MySQL  8.0.27
Source Code Documentation
table_column_iterator.h
Go to the documentation of this file.
1 /*
2  Copyright (c) 2019, 2021, 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  */
107 template <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 * = 0);
153  /**
154  Constructor which takes a predicate used to filter this container iteration.
155 
156  @param filtering_predicate the predicate to filter this container iteration.
157  @param options optional parameter for filtering and iterating
158  options. Options should be combined with `|`. Available
159  options are `VFIELDS_ONLY`.
160  */
161  Table_columns_view(ExclusionFilter filtering_predicate,
162  unsigned long options = 0);
163  /**
164  Constructor which takes the TABLE object whose field set will be iterated
165  and a predicate used to filter this container iteration.
166 
167  @param table reference to the target TABLE object.
168  @param filtering_predicate the predicate to filter this container iteration.
169  @param options optional parameter for filtering and iterating
170  options. Options should be combined with `|`. Available
171  options are `VFIELDS_ONLY`.
172  */
173  Table_columns_view(TABLE const *table, ExclusionFilter filtering_predicate,
174  unsigned long options = 0);
175  /**
176  Destructor for the class.
177  */
178  virtual ~Table_columns_view();
179  /**
180  Setter which initializes the internal reference to the TABLE object whose
181  field set will be iterated over.
182 
183  @param rhs reference to the target TABLE object
184 
185  @return a reference to this object.
186  */
187  Table_columns_view &set_table(const TABLE *rhs);
188  /**
189  Setter which initializes the internal filtering predicate of type
190  `ExclusionFilter`.
191 
192  @param rhs reference to the target filtering predicate `ExclusionFilter`
193 
194  @return a reference to this object.
195  */
196  Table_columns_view &set_filter(ExclusionFilter rhs);
197 
198  // --> Deleted constructors and methods to remove default move/copy semantics
203  // <--
204 
205  /**
206  Iterator class to allow iterating over the replicatable fields in a TABLE
207  object field set. It implements the bidirectional iterator concept.
208 
209  In order to fully understand this class implementation, please, check the
210  documentation on the Iterator concept requirements within the C++ standard
211  and the STL definition.
212  */
213  class iterator {
214  public:
215  using difference_type = std::ptrdiff_t;
216  using value_type = Field *;
217  using pointer = Field *;
218  using reference = Field *;
219  using iterator_category = std::bidirectional_iterator_tag;
220  /**
221  Constructor for the iterator. It takes the parent Table_columns_view
222  object and the initial positions for the replicated table and for the
223  local table.
224 
225  @param parent reference to the target Table_columns_view object.
226  @param pos initial replicated table field set position.
227  @param col initial local table field set position.
228  */
229  explicit iterator(Table_columns_view &parent, long pos, long col);
230  /**
231  Copy constructor.
232 
233  @param rhs object instance we pretend to copy from.
234  */
235  iterator(const iterator &rhs);
236  /**
237  Default destructor
238  */
239  virtual ~iterator() = default;
240  // BASIC ITERATOR METHODS //
241  iterator &operator=(const iterator &rhs);
242  iterator &operator++();
243  reference operator*() const;
244  // END / BASIC ITERATOR METHODS //
245  // INPUT ITERATOR METHODS //
246  iterator operator++(int);
247  pointer operator->() const;
248  bool operator==(iterator rhs) const;
249  bool operator!=(iterator rhs) const;
250  // END / INPUT ITERATOR METHODS //
251 
252  // OUTPUT ITERATOR METHODS //
253  // reference operator*() const; <- already defined
254  // iterator operator++(int); <- already defined
255  // END / OUTPUT ITERATOR METHODS //
256  // FORWARD ITERATOR METHODS //
257  // Enable support for both input and output iterator <- already enabled
258  // END / FORWARD ITERATOR METHODS //
259 
260  // BIDIRECTIOANL ITERATOR METHODS //
261  iterator &operator--();
262  iterator operator--(int);
263  // END / BIDIRECTIOANL ITERATOR METHODS //
264  /**
265  Returns the position this iterator object is pointing to, within the
266  local table field set.
267 
268  @return the position this object is pointing to, within the local table
269  field set.
270  */
271  size_t absolute_pos();
272  /**
273  Returns the position this iterator object is pointing to, within the
274  replicated table field set.
275 
276  @return the position this object is pointing to, within the replicated
277  table field set.
278  */
279  size_t filtered_pos();
280 
281  friend struct TABLE;
282  friend class Table_columns_view;
283 
284  private:
285  /** A reference to the instance we wish to iterate over. */
287  /**
288  The position, relative to the TABLE object, this instance iterator is
289  pointing to.
290  */
292  /**
293  The position, relative to the set of included fields, this instance
294  iterator is pointing to.
295  */
297  };
298 
299  /**
300  Computes the total number of fields in the table.
301 
302  @return the number of fields in the table.
303  */
304  size_t absolute_size() const;
305  /**
306  Computes the total number of fields after filtering.
307 
308  @return the number of fields after filtering.
309  */
310  size_t filtered_size() const;
311  /**
312  Creates an iterator object, pointing at the beginning of the table field
313  set.
314 
315  @return an iterator pointing to the beginning of the field set.
316  */
317  iterator begin();
318  /**
319  Creates an iterator object, pointing at the end of the table field set.
320 
321  @return an iterator pointing to the end of the field set.
322  */
323  iterator end();
324  /**
325  Returns whether or not the field at `index` is to be excluded from the field
326  set iteration process.
327 
328  @param index the index of the field to test for exclusion from iteration.
329 
330  @return true if the field is to be excluded from the iteration, false
331  otherwise.
332  */
333  bool is_excluded(size_t index) const;
334  /**
335  Returns the bitmap for the columns from the local table set that are to be
336  included in the replicated row.
337 
338  @return a bitmap indicating which columns from the local table are to be
339  included in the replicated row.
340  */
342  /**
343  Returns the bitmap for the columns from the local table set that are to be
344  excluded from the replicated row.
345 
346  @return a bitmap indicating which columns from the local table are to be
347  excluded from the replicated row.
348  */
350  /**
351  Takes a bitmap object, as received from the replication channel and
352  translates it to a bitmap that matches the local TABLE object.
353 
354  @param[in] source the bitmap as received from the replication channel
355  @param[out] destination the bitmap that matches the local TABLE format
356 
357  @return this object reference (for chaining purposes).
358  */
360  MY_BITMAP &destination);
361  /**
362  Translates a position in the received replicated table into a position in
363  the local table.
364 
365  @param source the position in the received replicated table
366 
367  @return the relative position within the local table.
368  */
369  size_t translate_position(size_t source);
370 
371  protected:
372  /**
373  Initializes the internal included and excluded fields bitmaps. After each
374  member is set, this method should be invoked in order to remake the bitmaps.
375 
376  @return this object reference (for chaining purposes).
377  */
379 
380  private:
381  /**
382  The TABLE object reference which contains the field set to be iterated over.
383  */
384  TABLE const *m_table{nullptr};
385  /**
386  ExclusionFiltering predicate to be invoked when determining if a column is
387  to be included in the iteration.
388  */
389  ExclusionFilter m_filtering_predicate;
390  /** Number of columns to include in iteration. */
391  size_t m_filtered_size{0};
392  /**
393  Bitmap that holds the information about which columns from the local table
394  are to be included in the replicated row.
395  */
397  /**
398  Bitmap that holds the information about which columns from the local table
399  are to be excluded from the replicated row.
400  */
402  /**
403  Set of options to apply to view behaviour
404  */
405  unsigned long m_options{0};
406 
407  /**
408  Default filtering predicate.
409  */
410  static bool default_filter(TABLE const *table, size_t column_index);
411 };
412 
413 template <typename F>
414 template <typename U>
416  unsigned long options,
417  typename std::enable_if<std::is_same<
418  U, std::function<bool(TABLE const *, size_t)>>::value>::type *)
420  m_options{options} {
422 }
423 
424 template <typename F>
425 template <typename U>
427  TABLE const *table, unsigned long options,
428  typename std::enable_if<std::is_same<
429  U, std::function<bool(TABLE const *, size_t)>>::value>::type *)
431  m_options{options} {
433  .set_table(table);
434 }
435 
436 template <typename F>
438  unsigned long options)
439  : Table_columns_view{nullptr, filtering_predicate, options} {}
440 
441 template <typename F>
443  F filtering_predicate,
444  unsigned long options)
445  : m_filtering_predicate{filtering_predicate}, m_options{options} {
446  this->set_filter(filtering_predicate) //
447  .set_table(target);
448 }
449 
450 template <typename F>
454 }
455 
456 template <typename F>
458  this->m_table = rhs;
459  this->init_fields_bitmaps();
460  return (*this);
461 }
462 
463 template <typename F>
465  this->m_filtering_predicate = rhs;
466  this->init_fields_bitmaps();
467  return (*this);
468 }
469 
470 template <typename F>
472  if (this->m_table == nullptr) return 0;
473  return this->m_table->s->fields;
474 }
475 
476 template <typename F>
478  return this->m_filtered_size;
479 }
480 
481 template <typename F>
483  typename Table_columns_view<F>::iterator to_return{*this, -1, -1};
484  ++to_return;
485  return to_return;
486 }
487 
488 template <typename F>
490  typename Table_columns_view<F>::iterator to_return{
491  *this, static_cast<long>(this->absolute_size()),
492  static_cast<long>(this->filtered_size())};
493  return to_return;
494 }
495 
496 template <typename F>
497 bool Table_columns_view<F>::is_excluded(size_t index) const {
498  return bitmap_is_set(&this->m_excluded_fields_bitmap, index);
499 }
500 
501 template <typename F>
503  return this->m_included_fields_bitmap;
504 }
505 
506 template <typename F>
508  return this->m_excluded_fields_bitmap;
509 }
510 
511 template <typename F>
513  MY_BITMAP &source, MY_BITMAP &destination) {
514  if (this->m_table == nullptr) return (*this);
515  if (source.bitmap == nullptr) return (*this);
516 
517  bitmap_init(&destination, nullptr, this->m_table->s->fields);
518 
519  for (size_t d = 0, s = 0; d != destination.n_bits && s != source.n_bits;
520  ++d) {
521  if (!this->is_excluded(d)) {
522  if (bitmap_is_set(&source, static_cast<uint>(s))) {
523  bitmap_set_bit(&destination, static_cast<uint>(d));
524  }
525  ++s;
526  }
527  }
528 
529  return (*this);
530 }
531 
532 template <typename F>
534  if (this->m_table == nullptr) return source;
535  size_t d = 0;
536  for (size_t s = 0; s != source; ++d) {
537  if (!this->is_excluded(d)) {
538  ++s;
539  }
540  }
541  return d;
542 }
543 
544 template <typename F>
546  if (this->m_table == nullptr) return (*this);
547 
550  bitmap_init(&this->m_included_fields_bitmap, nullptr,
551  this->m_table->s->fields);
552  bitmap_init(&this->m_excluded_fields_bitmap, nullptr,
553  this->m_table->s->fields);
554 
555  this->m_filtered_size = 0;
556  if ((this->m_options & VFIELDS_ONLY) == VFIELDS_ONLY) {
558  for (auto fld = this->m_table->vfield; *fld != nullptr; ++fld) {
559  auto idx = (*fld)->field_index();
560  if (!this->m_filtering_predicate(this->m_table, idx)) {
563  ++this->m_filtered_size;
564  }
565  }
566  } else {
567  for (size_t idx = 0; idx != this->m_table->s->fields; ++idx) {
568  if (this->m_filtering_predicate(this->m_table, idx)) {
570  } else {
572  ++this->m_filtered_size;
573  }
574  }
575  }
576  return (*this);
577 }
578 
579 template <typename F>
581  return false;
582 }
583 
584 template <typename F>
586  long absolute_pos, long filtered_pos)
587  : m_parent{&parent},
588  m_absolute_pos{absolute_pos},
589  m_filtered_pos{filtered_pos} {}
590 
591 template <typename F>
593  (*this) = rhs;
594 }
595 
596 template <typename F>
599  const Table_columns_view<F>::iterator &rhs) {
600  this->m_parent = rhs.m_parent;
601  this->m_absolute_pos = rhs.m_absolute_pos;
602  this->m_filtered_pos = rhs.m_filtered_pos;
603  return (*this);
604 }
605 
606 template <typename F>
609  if (this->m_parent->m_table != nullptr &&
610  this->m_absolute_pos !=
611  static_cast<long>(this->m_parent->absolute_size())) {
612  do {
613  ++this->m_absolute_pos;
614  } while (this->m_absolute_pos !=
615  static_cast<long>(this->m_parent->absolute_size()) &&
616  this->m_parent->is_excluded(this->m_absolute_pos));
617  ++this->m_filtered_pos;
618  }
619  return (*this);
620 }
621 
622 template <typename F>
625  if (this->m_parent->m_table != nullptr &&
626  this->m_absolute_pos !=
627  static_cast<long>(this->m_parent->absolute_size())) {
628  return this->m_parent->m_table->field[this->m_absolute_pos];
629  }
630  return nullptr;
631 }
632 
633 template <typename F>
636  typename Table_columns_view<F>::iterator to_return = (*this);
637  ++(*this);
638  return to_return;
639 }
640 
641 template <typename F>
644  return this->operator*();
645 }
646 
647 template <typename F>
650  return this->m_absolute_pos == rhs.m_absolute_pos &&
651  this->m_parent->m_table == rhs.m_parent->m_table;
652 }
653 
654 template <typename F>
657  return !((*this) == rhs);
658 }
659 
660 template <typename F>
663  if (this->m_parent->m_table != nullptr && this->m_absolute_pos != 0) {
664  do {
665  --this->m_absolute_pos;
666  } while (this->m_absolute_pos != 0 &&
667  this->m_parent->is_excluded(this->m_absolute_pos));
668  --this->m_filtered_pos;
669  }
670  return (*this);
671 }
672 
673 template <typename F>
676  typename Table_columns_view<F>::iterator to_return = (*this);
677  --(*this);
678  return to_return;
679 }
680 
681 template <typename F>
683  return static_cast<size_t>(this->m_absolute_pos);
684 }
685 
686 template <typename F>
688  return static_cast<size_t>(this->m_filtered_pos);
689 }
690 
691 #endif // _table_column_iterator_h
Definition: field.h:590
Iterator class to allow iterating over the replicatable fields in a TABLE object field set.
Definition: table_column_iterator.h:213
iterator & operator--()
Definition: table_column_iterator.h:662
reference operator*() const
Definition: table_column_iterator.h:624
std::ptrdiff_t difference_type
Definition: table_column_iterator.h:215
long m_filtered_pos
The position, relative to the set of included fields, this instance iterator is pointing to.
Definition: table_column_iterator.h:296
iterator(Table_columns_view &parent, long pos, long col)
Constructor for the iterator.
Definition: table_column_iterator.h:585
bool operator!=(iterator rhs) const
Definition: table_column_iterator.h:655
size_t absolute_pos()
Returns the position this iterator object is pointing to, within the local table field set.
Definition: table_column_iterator.h:682
iterator & operator++()
Definition: table_column_iterator.h:608
bool operator==(iterator rhs) const
Definition: table_column_iterator.h:648
iterator & operator=(const iterator &rhs)
Definition: table_column_iterator.h:598
Table_columns_view const * m_parent
A reference to the instance we wish to iterate over.
Definition: table_column_iterator.h:286
std::bidirectional_iterator_tag iterator_category
Definition: table_column_iterator.h:219
pointer operator->() const
Definition: table_column_iterator.h:643
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:291
size_t filtered_pos()
Returns the position this iterator object is pointing to, within the replicated table field set.
Definition: table_column_iterator.h:687
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
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:502
Table_columns_view & operator=(const Table_columns_view &rhs)=delete
virtual ~Table_columns_view()
Destructor for the class.
Definition: table_column_iterator.h:451
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:457
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:497
iterator end()
Creates an iterator object, pointing at the end of the table field set.
Definition: table_column_iterator.h:489
size_t m_filtered_size
Number of columns to include in iteration.
Definition: table_column_iterator.h:391
iterator begin()
Creates an iterator object, pointing at the beginning of the table field set.
Definition: table_column_iterator.h:482
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:512
Table_columns_view & set_filter(ExclusionFilter rhs)
Setter which initializes the internal filtering predicate of type ExclusionFilter.
Definition: table_column_iterator.h:464
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:507
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:396
TABLE const * m_table
The TABLE object reference which contains the field set to be iterated over.
Definition: table_column_iterator.h:384
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:533
Table_columns_view & init_fields_bitmaps()
Initializes the internal included and excluded fields bitmaps.
Definition: table_column_iterator.h:545
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:415
static bool default_filter(TABLE const *table, size_t column_index)
Default filtering predicate.
Definition: table_column_iterator.h:580
size_t absolute_size() const
Computes the total number of fields in the table.
Definition: table_column_iterator.h:471
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:389
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:401
Table_columns_view & operator=(Table_columns_view &&rhs)=delete
unsigned long m_options
Set of options to apply to view behaviour.
Definition: table_column_iterator.h:405
size_t filtered_size() const
Computes the total number of fields after filtering.
Definition: table_column_iterator.h:477
Table_columns_view(const Table_columns_view &rhs)=delete
Dialog Client Authentication nullptr
Definition: dialog.cc:352
char * pos
Definition: do_ctype.cc:76
static void bitmap_set_all(MY_BITMAP *map)
Definition: my_bitmap.h:123
static bool bitmap_is_set(const MY_BITMAP *map, uint bit)
Definition: my_bitmap.h:90
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:85
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:75
Definition: options.cc:45
const string value("\"Value\"")
repeated Source source
Definition: replication_asynchronous_connection_failover.proto:41
required string type
Definition: replication_group_member_actions.proto:33
Definition: my_bitmap.h:41
my_bitmap_map * bitmap
Definition: my_bitmap.h:42
uint n_bits
Definition: my_bitmap.h:43
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