MySQL 8.0.30
Source Code Documentation
table_column_iterator.h
Go to the documentation of this file.
1/*
2 Copyright (c) 2019, 2022, Oracle and/or its affiliates.
3
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License, version 2.0,
6 as published by the Free Software Foundation.
7
8 This program is also distributed with certain software (including
9 but not limited to OpenSSL) that is licensed under separate terms,
10 as designated in a particular file or component or in included license
11 documentation. The authors of MySQL hereby grant you an additional
12 permission to link the program and your derivative works with the
13 separately licensed software that they have included with MySQL.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License, version 2.0, for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
23*/
24#ifndef _table_column_iterator_h
25#define _table_column_iterator_h
26
27#include "my_bitmap.h" // MY_BITMAP
28#include "sql/field.h" // Field
29#include "sql/table.h" // TABLE
30
31/**
32 @class Table_columns_view
33
34 This template class acts as a container of table columns and encapsulates and
35 abstracts a `TABLE` object field set iteration logic, by providing an iterator
36 interface implementation.
37
38 The template parameter `ExclusionFilter` is a predicate that takes a `TABLE`
39 reference and a column index and returns whether or not the field should be
40 filtered out, more specifically, a signature compatible with:
41
42 std::function<bool (TABLE const*, size_t)>
43
44 This template class accepts an empty parameter set, which provides an
45 unfiltered container and iterates over all the table columns:
46
47 void print_all_fields(TABLE *table) {
48 Table_columns_view<> fields{table};
49
50 for (auto field : fields) {
51 std::cout << field->field_index << ". " << field << std::endl
52 << std::flush;
53 }
54 }
55
56 The template parameter predicate may take the form of a `operator()`:
57
58 class JSON_fields {
59 public:
60 bool operator()(TABLE const *table, size_t column_index) {
61 return table->field[column_index]->type() != MYSQL_TYPE_JSON;
62 }
63
64 void print_json_fields(TABLE *table) {
65 Table_columns_view<JSON_fields &> fields{table, *this};
66 for (auto field : fields) {
67 std::cout << field->field_index << ". " << field << std::endl
68 << std::flush;
69 }
70 }
71 };
72
73 The template parameter predicate may take the form of a lambda function:
74
75 void print_int_fields(TABLE *table) {
76 Table_columns_view<> fields{
77 table, [](TABLE const *table, size_t column_index) -> bool {
78 return table->field[column_index]->type() != MYSQL_TYPE_INT24;
79 }};
80
81 for (auto field : fields) {
82 std::cout << field->field_index << ". " << field << std::endl
83 << std::flush;
84 }
85 }
86
87 The list of generated columns is kept separately in the `TABLE` class, in
88 the `TABLE::vfield` member. Although we could achieve accurate filtering
89 using the above described methods, as a performance optimization, this
90 class allows applying the filter and iteration directly and exclusively
91 on the generated columns. For that we can use the `VFIELDS_ONLY` option:
92
93 void print_virtual_generated_columns(TABLE *table) {
94 Table_columns_view<> fields{
95 table, [](TABLE const *table, size_t column_index) -> bool {
96 return table->field[column_index]->is_virtual_gcol();
97 },
98 Table_columns_view<>::VFIELDS_ONLY
99 };
100
101 for (auto field : fields) {
102 std::cout << field->field_index << ". " << field << std::endl
103 << std::flush;
104 }
105 }
106 */
107template <typename ExclusionFilter = std::function<bool(TABLE const *, size_t)>>
109 public:
110 /**
111 Alias for the predicate type, for readability purposes.
112 */
113 using filter_fn_type = ExclusionFilter;
114
115 /**
116 Default set of options.
117 */
118 static constexpr unsigned long DEFAULTS = 0;
119 /**
120 Request the view excluding filter to operate `TABLE::vfields` instead
121 of the full set.
122 */
123 static constexpr unsigned long VFIELDS_ONLY = 1;
124
125 /**
126 Empty constructor, only available when the predicate type is a lambda
127 function.
128
129 @param options optional parameter for filtering and iterating
130 options. Options should be combined with `|`. Available
131 options are `VFIELDS_ONLY`.
132 */
133 template <typename U = ExclusionFilter>
135 unsigned long options = 0,
136 typename std::enable_if<std::is_same<
137 U, std::function<bool(TABLE const *, size_t)>>::value>::type * =
138 nullptr);
139 /**
140 Constructor that takes the target `TABLE` object, only available when the
141 predicate type is a lambda function.
142
143 @param table reference to the target TABLE object.
144 @param options optional parameter for filtering and iterating
145 options. Options should be combined with `|`. Available
146 options are `VFIELDS_ONLY`.
147 */
148 template <typename U = ExclusionFilter>
150 TABLE const *table, unsigned long options = 0,
151 typename std::enable_if<std::is_same<
152 U, std::function<bool(TABLE const *, size_t)>>::value>::type * =
153 nullptr);
154 /**
155 Constructor which takes a predicate used to filter this container iteration.
156
157 @param filtering_predicate the predicate to filter this container iteration.
158 @param options optional parameter for filtering and iterating
159 options. Options should be combined with `|`. Available
160 options are `VFIELDS_ONLY`.
161 */
162 Table_columns_view(ExclusionFilter filtering_predicate,
163 unsigned long options = 0);
164 /**
165 Constructor which takes the TABLE object whose field set will be iterated
166 and a predicate used to filter this container iteration.
167
168 @param table reference to the target TABLE object.
169 @param filtering_predicate the predicate to filter this container iteration.
170 @param options optional parameter for filtering and iterating
171 options. Options should be combined with `|`. Available
172 options are `VFIELDS_ONLY`.
173 */
174 Table_columns_view(TABLE const *table, ExclusionFilter filtering_predicate,
175 unsigned long options = 0);
176 /**
177 Destructor for the class.
178 */
179 virtual ~Table_columns_view();
180 /**
181 Setter which initializes the internal reference to the TABLE object whose
182 field set will be iterated over.
183
184 @param rhs reference to the target TABLE object
185
186 @return a reference to this object.
187 */
189 /**
190 Setter which initializes the internal filtering predicate of type
191 `ExclusionFilter`.
192
193 @param rhs reference to the target filtering predicate `ExclusionFilter`
194
195 @return a reference to this object.
196 */
197 Table_columns_view &set_filter(ExclusionFilter rhs);
198
199 // --> Deleted constructors and methods to remove default move/copy semantics
204 // <--
205
206 /**
207 Iterator class to allow iterating over the replicatable fields in a TABLE
208 object field set. It implements the bidirectional iterator concept.
209
210 In order to fully understand this class implementation, please, check the
211 documentation on the Iterator concept requirements within the C++ standard
212 and the STL definition.
213 */
214 class iterator {
215 public:
216 using difference_type = std::ptrdiff_t;
217 using value_type = Field *;
218 using pointer = Field *;
219 using reference = Field *;
220 using iterator_category = std::bidirectional_iterator_tag;
221 /**
222 Constructor for the iterator. It takes the parent Table_columns_view
223 object and the initial positions for the replicated table and for the
224 local table.
225
226 @param parent reference to the target Table_columns_view object.
227 @param pos initial replicated table field set position.
228 @param col initial local table field set position.
229 */
230 explicit iterator(Table_columns_view &parent, long pos, long col);
231 /**
232 Copy constructor.
233
234 @param rhs object instance we pretend to copy from.
235 */
236 iterator(const iterator &rhs);
237 /**
238 Default destructor
239 */
240 virtual ~iterator() = default;
241 // BASIC ITERATOR METHODS //
242 iterator &operator=(const iterator &rhs);
244 reference operator*() const;
245 // END / BASIC ITERATOR METHODS //
246 // INPUT ITERATOR METHODS //
247 iterator operator++(int);
248 pointer operator->() const;
249 bool operator==(iterator rhs) const;
250 bool operator!=(iterator rhs) const;
251 // END / INPUT ITERATOR METHODS //
252
253 // OUTPUT ITERATOR METHODS //
254 // reference operator*() const; <- already defined
255 // iterator operator++(int); <- already defined
256 // END / OUTPUT ITERATOR METHODS //
257 // FORWARD ITERATOR METHODS //
258 // Enable support for both input and output iterator <- already enabled
259 // END / FORWARD ITERATOR METHODS //
260
261 // BIDIRECTIOANL ITERATOR METHODS //
263 iterator operator--(int);
264 // END / BIDIRECTIOANL ITERATOR METHODS //
265 /**
266 Returns the position this iterator object is pointing to, within the
267 local table field set.
268
269 @return the position this object is pointing to, within the local table
270 field set.
271 */
272 size_t absolute_pos();
273 /**
274 Returns the position this iterator object is pointing to, within the
275 replicated table field set.
276
277 @return the position this object is pointing to, within the replicated
278 table field set.
279 */
280 size_t filtered_pos();
281
282 friend struct TABLE;
283 friend class Table_columns_view;
284
285 private:
286 /** A reference to the instance we wish to iterate over. */
288 /**
289 The position, relative to the TABLE object, this instance iterator is
290 pointing to.
291 */
293 /**
294 The position, relative to the set of included fields, this instance
295 iterator is pointing to.
296 */
298 };
299
300 /**
301 Computes the total number of fields in the table.
302
303 @return the number of fields in the table.
304 */
305 size_t absolute_size() const;
306 /**
307 Computes the total number of fields after filtering.
308
309 @return the number of fields after filtering.
310 */
311 size_t filtered_size() const;
312 /**
313 Creates an iterator object, pointing at the beginning of the table field
314 set.
315
316 @return an iterator pointing to the beginning of the field set.
317 */
318 iterator begin();
319 /**
320 Creates an iterator object, pointing at the end of the table field set.
321
322 @return an iterator pointing to the end of the field set.
323 */
324 iterator end();
325 /**
326 Returns whether or not the field at `index` is to be excluded from the field
327 set iteration process.
328
329 @param index the index of the field to test for exclusion from iteration.
330
331 @return true if the field is to be excluded from the iteration, false
332 otherwise.
333 */
334 bool is_excluded(size_t index) const;
335 /**
336 Returns the bitmap for the columns from the local table set that are to be
337 included in the replicated row.
338
339 @return a bitmap indicating which columns from the local table are to be
340 included in the replicated row.
341 */
343 /**
344 Returns the bitmap for the columns from the local table set that are to be
345 excluded from the replicated row.
346
347 @return a bitmap indicating which columns from the local table are to be
348 excluded from the replicated row.
349 */
351 /**
352 Takes a bitmap object, as received from the replication channel and
353 translates it to a bitmap that matches the local TABLE object.
354
355 @param[in] source the bitmap as received from the replication channel
356 @param[out] destination the bitmap that matches the local TABLE format
357
358 @return this object reference (for chaining purposes).
359 */
361 MY_BITMAP &destination);
362 /**
363 Translates a position in the received replicated table into a position in
364 the local table.
365
366 @param source the position in the received replicated table
367
368 @return the relative position within the local table.
369 */
370 size_t translate_position(size_t source);
371
372 protected:
373 /**
374 Initializes the internal included and excluded fields bitmaps. After each
375 member is set, this method should be invoked in order to remake the bitmaps.
376
377 @return this object reference (for chaining purposes).
378 */
380
381 private:
382 /**
383 The TABLE object reference which contains the field set to be iterated over.
384 */
385 TABLE const *m_table{nullptr};
386 /**
387 ExclusionFiltering predicate to be invoked when determining if a column is
388 to be included in the iteration.
389 */
390 ExclusionFilter m_filtering_predicate;
391 /** Number of columns to include in iteration. */
393 /**
394 Bitmap that holds the information about which columns from the local table
395 are to be included in the replicated row.
396 */
398 /**
399 Bitmap that holds the information about which columns from the local table
400 are to be excluded from the replicated row.
401 */
403 /**
404 Set of options to apply to view behaviour
405 */
406 unsigned long m_options{0};
407
408 /**
409 Default filtering predicate.
410 */
411 static bool default_filter(TABLE const *table, size_t column_index);
412};
413
414template <typename F>
415template <typename U>
417 unsigned long options,
418 typename std::enable_if<std::is_same<
419 U, std::function<bool(TABLE const *, size_t)>>::value>::type *)
423}
424
425template <typename F>
426template <typename U>
428 TABLE const *table, unsigned long options,
429 typename std::enable_if<std::is_same<
430 U, std::function<bool(TABLE const *, size_t)>>::value>::type *)
434 .set_table(table);
435}
436
437template <typename F>
439 unsigned long options)
440 : Table_columns_view{nullptr, filtering_predicate, options} {}
441
442template <typename F>
444 F filtering_predicate,
445 unsigned long options)
446 : m_filtering_predicate{filtering_predicate}, m_options{options} {
447 this->set_filter(filtering_predicate) //
448 .set_table(target);
449}
450
451template <typename F>
455}
456
457template <typename F>
459 this->m_table = rhs;
460 this->init_fields_bitmaps();
461 return (*this);
462}
463
464template <typename F>
466 this->m_filtering_predicate = rhs;
467 this->init_fields_bitmaps();
468 return (*this);
469}
470
471template <typename F>
473 if (this->m_table == nullptr) return 0;
474 return this->m_table->s->fields;
475}
476
477template <typename F>
479 return this->m_filtered_size;
480}
481
482template <typename F>
484 typename Table_columns_view<F>::iterator to_return{*this, -1, -1};
485 ++to_return;
486 return to_return;
487}
488
489template <typename F>
491 typename Table_columns_view<F>::iterator to_return{
492 *this, static_cast<long>(this->absolute_size()),
493 static_cast<long>(this->filtered_size())};
494 return to_return;
495}
496
497template <typename F>
498bool Table_columns_view<F>::is_excluded(size_t index) const {
499 return bitmap_is_set(&this->m_excluded_fields_bitmap, index);
500}
501
502template <typename F>
504 return this->m_included_fields_bitmap;
505}
506
507template <typename F>
509 return this->m_excluded_fields_bitmap;
510}
511
512template <typename F>
514 MY_BITMAP &source, MY_BITMAP &destination) {
515 if (this->m_table == nullptr) return (*this);
516 if (source.bitmap == nullptr) return (*this);
517
518 bitmap_init(&destination, nullptr, this->m_table->s->fields);
519
520 for (size_t d = 0, s = 0; d != destination.n_bits && s != source.n_bits;
521 ++d) {
522 if (!this->is_excluded(d)) {
523 if (bitmap_is_set(&source, static_cast<uint>(s))) {
524 bitmap_set_bit(&destination, static_cast<uint>(d));
525 }
526 ++s;
527 }
528 }
529
530 return (*this);
531}
532
533template <typename F>
535 if (this->m_table == nullptr) return source;
536 size_t d = 0;
537 for (size_t s = 0; s != source; ++d) {
538 if (!this->is_excluded(d)) {
539 ++s;
540 }
541 }
542 return d;
543}
544
545template <typename F>
547 if (this->m_table == nullptr) return (*this);
548
552 this->m_table->s->fields);
554 this->m_table->s->fields);
555
556 this->m_filtered_size = 0;
557 if ((this->m_options & VFIELDS_ONLY) == VFIELDS_ONLY) {
559 for (auto fld = this->m_table->vfield; *fld != nullptr; ++fld) {
560 auto idx = (*fld)->field_index();
561 if (!this->m_filtering_predicate(this->m_table, idx)) {
564 ++this->m_filtered_size;
565 }
566 }
567 } else {
568 for (size_t idx = 0; idx != this->m_table->s->fields; ++idx) {
569 if (this->m_filtering_predicate(this->m_table, idx)) {
571 } else {
573 ++this->m_filtered_size;
574 }
575 }
576 }
577 return (*this);
578}
579
580template <typename F>
582 return false;
583}
584
585template <typename F>
587 long absolute_pos, long filtered_pos)
588 : m_parent{&parent},
589 m_absolute_pos{absolute_pos},
590 m_filtered_pos{filtered_pos} {}
591
592template <typename F>
594 (*this) = rhs;
595}
596
597template <typename F>
601 this->m_parent = rhs.m_parent;
602 this->m_absolute_pos = rhs.m_absolute_pos;
603 this->m_filtered_pos = rhs.m_filtered_pos;
604 return (*this);
605}
606
607template <typename F>
610 if (this->m_parent->m_table != nullptr &&
611 this->m_absolute_pos !=
612 static_cast<long>(this->m_parent->absolute_size())) {
613 do {
614 ++this->m_absolute_pos;
615 } while (this->m_absolute_pos !=
616 static_cast<long>(this->m_parent->absolute_size()) &&
617 this->m_parent->is_excluded(this->m_absolute_pos));
618 ++this->m_filtered_pos;
619 }
620 return (*this);
621}
622
623template <typename F>
626 if (this->m_parent->m_table != nullptr &&
627 this->m_absolute_pos !=
628 static_cast<long>(this->m_parent->absolute_size())) {
629 return this->m_parent->m_table->field[this->m_absolute_pos];
630 }
631 return nullptr;
632}
633
634template <typename F>
637 typename Table_columns_view<F>::iterator to_return = (*this);
638 ++(*this);
639 return to_return;
640}
641
642template <typename F>
645 return this->operator*();
646}
647
648template <typename F>
651 return this->m_absolute_pos == rhs.m_absolute_pos &&
652 this->m_parent->m_table == rhs.m_parent->m_table;
653}
654
655template <typename F>
658 return !((*this) == rhs);
659}
660
661template <typename F>
664 if (this->m_parent->m_table != nullptr && this->m_absolute_pos != 0) {
665 do {
666 --this->m_absolute_pos;
667 } while (this->m_absolute_pos != 0 &&
668 this->m_parent->is_excluded(this->m_absolute_pos));
669 --this->m_filtered_pos;
670 }
671 return (*this);
672}
673
674template <typename F>
677 typename Table_columns_view<F>::iterator to_return = (*this);
678 --(*this);
679 return to_return;
680}
681
682template <typename F>
684 return static_cast<size_t>(this->m_absolute_pos);
685}
686
687template <typename F>
689 return static_cast<size_t>(this->m_filtered_pos);
690}
691
692#endif // _table_column_iterator_h
Definition: field.h:573
Iterator class to allow iterating over the replicatable fields in a TABLE object field set.
Definition: table_column_iterator.h:214
iterator & operator--()
Definition: table_column_iterator.h:663
reference operator*() const
Definition: table_column_iterator.h:625
std::ptrdiff_t difference_type
Definition: table_column_iterator.h:216
long m_filtered_pos
The position, relative to the set of included fields, this instance iterator is pointing to.
Definition: table_column_iterator.h:297
iterator(Table_columns_view &parent, long pos, long col)
Constructor for the iterator.
Definition: table_column_iterator.h:586
bool operator!=(iterator rhs) const
Definition: table_column_iterator.h:656
size_t absolute_pos()
Returns the position this iterator object is pointing to, within the local table field set.
Definition: table_column_iterator.h:683
iterator & operator++()
Definition: table_column_iterator.h:609
bool operator==(iterator rhs) const
Definition: table_column_iterator.h:649
iterator & operator=(const iterator &rhs)
Definition: table_column_iterator.h:599
Table_columns_view const * m_parent
A reference to the instance we wish to iterate over.
Definition: table_column_iterator.h:287
std::bidirectional_iterator_tag iterator_category
Definition: table_column_iterator.h:220
pointer operator->() const
Definition: table_column_iterator.h:644
virtual ~iterator()=default
Default destructor.
long m_absolute_pos
The position, relative to the TABLE object, this instance iterator is pointing to.
Definition: table_column_iterator.h:292
size_t filtered_pos()
Returns the position this iterator object is pointing to, within the replicated table field set.
Definition: table_column_iterator.h:688
This template class acts as a container of table columns and encapsulates and abstracts a TABLE objec...
Definition: table_column_iterator.h:108
static constexpr unsigned long VFIELDS_ONLY
Request the view excluding filter to operate TABLE::vfields instead of the full set.
Definition: table_column_iterator.h:123
Table_columns_view(unsigned long options=0, typename std::enable_if< std::is_same< U, std::function< bool(TABLE const *, size_t)> >::value >::type *=nullptr)
Empty constructor, only available when the predicate type is a lambda function.
Definition: table_column_iterator.h:416
MY_BITMAP & get_included_fields_bitmap()
Returns the bitmap for the columns from the local table set that are to be included in the replicated...
Definition: table_column_iterator.h:503
virtual ~Table_columns_view()
Destructor for the class.
Definition: table_column_iterator.h:452
Table_columns_view & set_table(const TABLE *rhs)
Setter which initializes the internal reference to the TABLE object whose field set will be iterated ...
Definition: table_column_iterator.h:458
ExclusionFilter filter_fn_type
Alias for the predicate type, for readability purposes.
Definition: table_column_iterator.h:113
bool is_excluded(size_t index) const
Returns whether or not the field at index is to be excluded from the field set iteration process.
Definition: table_column_iterator.h:498
iterator end()
Creates an iterator object, pointing at the end of the table field set.
Definition: table_column_iterator.h:490
size_t m_filtered_size
Number of columns to include in iteration.
Definition: table_column_iterator.h:392
iterator begin()
Creates an iterator object, pointing at the beginning of the table field set.
Definition: table_column_iterator.h:483
Table_columns_view & translate_bitmap(MY_BITMAP &source, MY_BITMAP &destination)
Takes a bitmap object, as received from the replication channel and translates it to a bitmap that ma...
Definition: table_column_iterator.h:513
Table_columns_view & set_filter(ExclusionFilter rhs)
Setter which initializes the internal filtering predicate of type ExclusionFilter.
Definition: table_column_iterator.h:465
Table_columns_view(Table_columns_view &&rhs)=delete
MY_BITMAP & get_excluded_fields_bitmap()
Returns the bitmap for the columns from the local table set that are to be excluded from the replicat...
Definition: table_column_iterator.h:508
Table_columns_view(ExclusionFilter filtering_predicate, unsigned long options=0)
Constructor which takes a predicate used to filter this container iteration.
MY_BITMAP m_included_fields_bitmap
Bitmap that holds the information about which columns from the local table are to be included in the ...
Definition: table_column_iterator.h:397
TABLE const * m_table
The TABLE object reference which contains the field set to be iterated over.
Definition: table_column_iterator.h:385
size_t translate_position(size_t source)
Translates a position in the received replicated table into a position in the local table.
Definition: table_column_iterator.h:534
Table_columns_view & operator=(Table_columns_view &&rhs)=delete
Table_columns_view & operator=(const Table_columns_view &rhs)=delete
Table_columns_view & init_fields_bitmaps()
Initializes the internal included and excluded fields bitmaps.
Definition: table_column_iterator.h:546
static bool default_filter(TABLE const *table, size_t column_index)
Default filtering predicate.
Definition: table_column_iterator.h:581
size_t absolute_size() const
Computes the total number of fields in the table.
Definition: table_column_iterator.h:472
static constexpr unsigned long DEFAULTS
Default set of options.
Definition: table_column_iterator.h:118
ExclusionFilter m_filtering_predicate
ExclusionFiltering predicate to be invoked when determining if a column is to be included in the iter...
Definition: table_column_iterator.h:390
Table_columns_view(TABLE const *table, ExclusionFilter filtering_predicate, unsigned long options=0)
Constructor which takes the TABLE object whose field set will be iterated and a predicate used to fil...
MY_BITMAP m_excluded_fields_bitmap
Bitmap that holds the information about which columns from the local table are to be excluded from th...
Definition: table_column_iterator.h:402
unsigned long m_options
Set of options to apply to view behaviour.
Definition: table_column_iterator.h:406
size_t filtered_size() const
Computes the total number of fields after filtering.
Definition: table_column_iterator.h:478
Table_columns_view(const Table_columns_view &rhs)=delete
char * pos
Definition: do_ctype.cc:76
Fido Client Authentication nullptr
Definition: fido_client_plugin.cc:221
static void bitmap_set_all(MY_BITMAP *map)
Definition: my_bitmap.h:127
static bool bitmap_is_set(const MY_BITMAP *map, uint bit)
Definition: my_bitmap.h:94
bool bitmap_init(MY_BITMAP *map, my_bitmap_map *buf, uint n_bits)
Definition: my_bitmap.cc:139
static void bitmap_clear_bit(MY_BITMAP *map, uint bit)
Definition: my_bitmap.h:89
void bitmap_free(MY_BITMAP *map)
Definition: my_bitmap.cc:157
static void bitmap_set_bit(MY_BITMAP *map, uint bit)
Definition: my_bitmap.h:79
Definition: options.cc:48
repeated Source source
Definition: replication_asynchronous_connection_failover.proto:41
required string type
Definition: replication_group_member_actions.proto:33
Definition: my_bitmap.h:42
my_bitmap_map * bitmap
Definition: my_bitmap.h:43
uint n_bits
Definition: my_bitmap.h:44
uint fields
Definition: table.h:837
Definition: table.h:1394
Field ** vfield
Pointer to generated columns.
Definition: table.h:1493
TABLE_SHARE * s
Definition: table.h:1395
unsigned int uint
Definition: uca-dump.cc:29
Definition: dtoa.cc:594