MySQL 8.0.31
Source Code Documentation
rem0rec.h
Go to the documentation of this file.
1/*****************************************************************************
2
3Copyright (c) 1994, 2022, Oracle and/or its affiliates.
4
5This program is free software; you can redistribute it and/or modify it under
6the terms of the GNU General Public License, version 2.0, as published by the
7Free Software Foundation.
8
9This program is also distributed with certain software (including but not
10limited to OpenSSL) that is licensed under separate terms, as designated in a
11particular file or component or in included license documentation. The authors
12of MySQL hereby grant you an additional permission to link the program and
13your derivative works with the separately licensed software that they have
14included with MySQL.
15
16This program is distributed in the hope that it will be useful, but WITHOUT
17ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
18FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0,
19for more details.
20
21You should have received a copy of the GNU General Public License along with
22this program; if not, write to the Free Software Foundation, Inc.,
2351 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
24
25*****************************************************************************/
26
27/** @file include/rem0rec.h
28 Record manager
29
30 Created 5/30/1994 Heikki Tuuri
31 *************************************************************************/
32
33#ifndef rem0rec_h
34#define rem0rec_h
35
36#include <ostream>
37#include <sstream>
38
39#include "univ.i"
40
41#include "data0data.h"
42#include "mtr0types.h"
43#include "page0types.h"
44#include "rem/rec.h"
45#include "rem0types.h"
46#include "trx0types.h"
47#include "ut0class_life_cycle.h"
48
49#include "rem0wrec.h"
50
51/** The following function is used to get the pointer of the next chained record
52on the same page.
53@param[in] rec Physical record.
54@param[in] comp Nonzero=compact page format.
55@return pointer to the next chained record, or nullptr if none */
56[[nodiscard]] static inline const rec_t *rec_get_next_ptr_const(
57 const rec_t *rec, ulint comp);
58/** The following function is used to get the pointer of the next chained record
59on the same page.
60@param[in] rec Physical record.
61@param[in] comp Nonzero=compact page format.
62@return pointer to the next chained record, or nullptr if none */
63[[nodiscard]] static inline rec_t *rec_get_next_ptr(rec_t *rec, ulint comp);
64/** The following function is used to get the offset of the
65next chained record on the same page.
66@param[in] rec Physical record.
67@param[in] comp Nonzero=compact page format.
68@return the page offset of the next chained record, or 0 if none */
69[[nodiscard]] static inline ulint rec_get_next_offs(const rec_t *rec,
70 ulint comp);
71
72/** The following function is used to set the next record offset field of an
73old-style record.
74@param[in] rec old-style physical record
75@param[in] next offset of the next record */
76static inline void rec_set_next_offs_old(rec_t *rec, ulint next);
77
78/** The following function is used to set the next record offset field of a
79new-style record. */
80static inline void rec_set_next_offs_new(rec_t *rec, ulint next);
81
82/** The following function is used to get the number of records owned by the
83 previous directory record.
84 @return number of owned records */
85[[nodiscard]] static inline ulint rec_get_n_owned_old(
86 const rec_t *rec); /*!< in: old-style physical record */
87
88/** The following function is used to set the number of owned records.
89@param[in] rec old-style physical record
90@param[in] n_owned the number of owned */
91static inline void rec_set_n_owned_old(rec_t *rec, ulint n_owned);
92
93/** The following function is used to get the number of records owned by the
94 previous directory record.
95 @return number of owned records */
96[[nodiscard]] static inline ulint rec_get_n_owned_new(
97 const rec_t *rec); /*!< in: new-style physical record */
98
99/** The following function is used to set the number of owned records.
100@param[in,out] rec new-style physical record
101@param[in,out] page_zip compressed page, or NULL
102@param[in] n_owned the number of owned */
103static inline void rec_set_n_owned_new(rec_t *rec, page_zip_des_t *page_zip,
104 ulint n_owned);
105
106/** The following function is used to set the info bits of a record.
107@param[in] rec old-style physical record
108@param[in] bits info bits */
109static inline void rec_set_info_bits_old(rec_t *rec, ulint bits);
110
111/** The following function is used to set the info bits of a record.
112@param[in,out] rec new-style physical record
113@param[in] bits info bits */
114static inline void rec_set_info_bits_new(rec_t *rec, ulint bits);
115
116/** The following function is used to set the status bits of a new-style record.
117@param[in,out] rec physical record
118@param[in] bits info bits */
119static inline void rec_set_status(rec_t *rec, ulint bits);
120
121/** The following function is used to retrieve the info and status
122bits of a record. (Only compact records have status bits.)
123@param[in] rec Physical record.
124@param[in] comp Nonzero=compact page format.
125@return info bits */
126[[nodiscard]] static inline ulint rec_get_info_and_status_bits(const rec_t *rec,
127 bool comp);
128
129/** The following function is used to set the info and status bits of a record.
130(Only compact records have status bits.)
131@param[in,out] rec compact physical record
132@param[in] bits info bits */
133static inline void rec_set_info_and_status_bits(rec_t *rec, ulint bits);
134
135/** The following function tells if record is delete marked.
136@param[in] rec Physical record.
137@param[in] comp Nonzero=compact page format.
138@return nonzero if delete marked */
139[[nodiscard]] static inline bool rec_get_deleted_flag(const rec_t *rec,
140 bool comp);
141
142/** The following function is used to set the deleted bit.
143@param[in] rec old-style physical record
144@param[in] flag true if delete marked */
145static inline void rec_set_deleted_flag_old(rec_t *rec, bool flag);
146
147/** The following function is used to set the deleted bit.
148@param[in,out] rec new-style physical record
149@param[in,out] page_zip compressed page, or NULL
150@param[in] flag true if delete marked */
151static inline void rec_set_deleted_flag_new(rec_t *rec,
152 page_zip_des_t *page_zip,
153 bool flag);
154
155/** The following function is used to set the instant bit.
156@param[in,out] rec new-style physical record
157@param[in] flag set the bit to this flag */
158static inline void rec_set_instant_flag_new(rec_t *rec, bool flag);
159
160/** The following function is used to set the row version bit.
161@param[in,out] rec new-style (COMPACT/DYNAMIC) physical record
162@param[in] flag set the bit to this flag */
163static inline void rec_new_set_versioned(rec_t *rec, bool flag);
164
165/** The following function is used to set the instant bit.
166@param[in,out] rec old-style (REDUNDANT) physical record
167@param[in] flag set the bit to this flag */
168static inline void rec_old_set_versioned(rec_t *rec, bool flag);
169
170/** The following function tells if a new-style record is a node pointer.
171 @return true if node pointer */
172[[nodiscard]] static inline bool rec_get_node_ptr_flag(
173 const rec_t *rec); /*!< in: physical record */
174
175/** The following function is used to get the order number of an old-style
176record in the heap of the index page.
177@param[in] rec physical record
178@return heap order number */
179[[nodiscard]] static inline ulint rec_get_heap_no_old(const rec_t *rec);
180
181/** The following function is used to set the heap number field in an old-style
182record.
183@param[in] rec physical record
184@param[in] heap_no the heap number */
185static inline void rec_set_heap_no_old(rec_t *rec, ulint heap_no);
186
187/** The following function is used to get the order number of a new-style
188record in the heap of the index page.
189@param[in] rec physical record
190@return heap order number */
191[[nodiscard]] static inline ulint rec_get_heap_no_new(const rec_t *rec);
192
193/** The following function is used to set the heap number field in a new-style
194record.
195@param[in,out] rec physical record
196@param[in] heap_no the heap number */
197static inline void rec_set_heap_no_new(rec_t *rec, ulint heap_no);
198
199/** The following function is used to set the 1-byte offsets flag.
200@param[in] rec physical record
201@param[in] flag true if 1byte form */
202static inline void rec_set_1byte_offs_flag(rec_t *rec, bool flag);
203
204/** Determine how many of the first n columns in a compact
205physical record are stored externally.
206@param[in] rec compact physical record
207@param[in] index record descriptor
208@param[in] n number of columns to scan
209@return number of externally stored columns */
210[[nodiscard]] ulint rec_get_n_extern_new(const rec_t *rec,
211 const dict_index_t *index, ulint n);
212
213/** Gets the value of the specified field in the record in old style.
214This is only used for record from instant index, which is clustered
215index and has some instantly added columns.
216@param[in] rec physical record
217@param[in] n index of the field
218@param[in] index clustered index where the record resides
219@param[out] len length of the field, UNIV_SQL if SQL null
220@return value of the field, could be either pointer to rec or default value */
221static inline const byte *rec_get_nth_field_old_instant(
222 const rec_t *rec, uint16_t n, const dict_index_t *index, ulint *len);
223
224/** Gets the value of the specified field in the record.
225This is only used when there is possibility that the record comes from the
226clustered index, which has some instantly added columns.
227@param[in] rec physical record
228@param[in] offsets array returned by rec_get_offsets()
229@param[in] n index of the field
230@param[in] index clustered index where the record resides, or nullptr
231 if the record doesn't have instantly added columns
232 for sure
233@param[out] len length of the field, UNIV_SQL_NULL if SQL null
234@return value of the field, could be either pointer to rec or default value */
235static inline const byte *rec_get_nth_field_instant(const rec_t *rec,
236 const ulint *offsets,
237 ulint n,
238 const dict_index_t *index,
239 ulint *len);
240
241/** Determine if the field is not NULL and not having default value
242after instant ADD COLUMN
243@param[in] len length of a field
244@return true if not NULL and not having default value */
246
247/** Determine if the offsets are for a record in the new compact format.
248@param[in] offsets array returned by rec_get_offsets()
249@return nonzero if compact format */
250[[nodiscard]] static inline bool rec_offs_comp(const ulint *offsets);
251
252/** Determine if the offsets are for a record containing externally stored
253columns.
254@param[in] offsets array returned by rec_get_offsets()
255@return nonzero if externally stored */
256[[nodiscard]] static inline bool rec_offs_any_extern(const ulint *offsets);
257
258/** Determine if the offsets are for a record containing null BLOB pointers.
259@param[in] index record descriptor
260@param[in] rec record
261@param[in] offsets array returned by rec_get_offsets()
262@return first field containing a null BLOB pointer, or NULL if none found */
263[[nodiscard]] static inline const byte *rec_offs_any_null_extern(
264 const dict_index_t *index, const rec_t *rec, const ulint *offsets);
265
266/** Returns the number of extern bits set in a record.
267@param[in] index record descriptor
268@param[in] offsets array returned by rec_get_offsets()
269@return number of externally stored fields */
270[[nodiscard]] static inline ulint rec_offs_n_extern(const dict_index_t *index,
271 const ulint *offsets);
272
273#define rec_offs_init(offsets) \
274 rec_offs_set_n_alloc(offsets, (sizeof offsets) / sizeof *offsets)
275
276/**
277A helper RAII wrapper for otherwise difficult to use sequence of:
278
279 ulint offsets_[REC_OFFS_NORMAL_SIZE];
280 rec_offs_init(offsets_);
281 mem_heap_t *heap = nullptr;
282
283 const ulint *offsets =
284 rec_get_offsets(rec, index, offsets_, ULINT_UNDEFINED, &heap);
285
286 DO_SOMETHING(offsets);
287
288 if (heap != nullptr) {
289 mem_heap_free(heap);
290 }
291
292With this helper you can simply do:
293
294 DO_SOMETHING(Rec_offsets().compute(rec,index));
295
296And if you need to reuse the memory allocated offsets several times you can:
297 Rec_offsets offsets;
298 for(rec: recs) DO_SOMTHING(offsets.compute(rec,index))
299*/
301 public:
302 /** Prepares offsets to initially point to the fixed-size buffer, and marks
303 the memory as allocated, but uninitialized. You first need to call compute()
304 to use it */
306
307 /** Computes offsets for given record. Returned array is owned by this
308 instance. You can use its value as long as this object does not go out of
309 scope (which can free the buffer), and you don't call compute() again (which
310 can overwrite the offsets).
311 @param[in] rec The record for which you want to compute the offsets
312 @param[in] index The index which contains the record
313 @param[in] n_fields Number of columns to scan
314 @return A pointer to offsets array owned by this instance. Valid till next
315 call to compute() or end of this instance lifetime.
316 */
317 const ulint *compute(const rec_t *rec, const dict_index_t *index,
318 const ulint n_fields = ULINT_UNDEFINED) {
319 m_offsets = rec_get_offsets(rec, index, m_offsets, n_fields,
321 return m_offsets;
322 }
323 /** Deallocated dynamically allocated memory, if any. */
325 if (m_heap) {
327 m_heap = nullptr;
328 }
329 }
330
331 private:
332 /** Pointer to heap used by rec_get_offsets(). Initially nullptr. If row is
333 really big, rec_get_offsets() may need to allocate new buffer for offsets.
334 At, first, when heap is null, rec_get_offsets() will create new heap, and pass
335 it back via reference. On subsequent calls, we will pass this heap, so it
336 is reused if needed. Therefore all allocated buffers are in this heap, if it
337 is not nullptr */
339
340 /** Buffer with size large enough to handle common cases without having to use
341 heap. This is the initial value of m_offsets.*/
343
344 /* Initially points to m_preallocated_buffer (which is uninitialized memory).
345 After each call to compute() contains the pointer to the most recently
346 computed offsets.
347 We pass it back to rec_get_offsets() on subsequent calls to compute() to reuse
348 the same memory if possible. */
350};
351
352/** The following function returns the data size of a physical
353record, that is the sum of field lengths. SQL null fields
354are counted as length 0 fields. The value returned by the function
355is the distance from record origin to record end in bytes.
356@param[in] offsets array returned by rec_get_offsets()
357@return size */
358[[nodiscard]] static inline ulint rec_offs_data_size(const ulint *offsets);
359
360/** Returns the total size of record minus data size of record.
361The value returned by the function is the distance from record
362start to record origin in bytes.
363@param[in] offsets array returned by rec_get_offsets()
364@return size */
365[[nodiscard]] static inline ulint rec_offs_extra_size(const ulint *offsets);
366
367/** Returns the total size of a physical record.
368@param[in] offsets array returned by rec_get_offsets()
369@return size */
370[[nodiscard]] static inline ulint rec_offs_size(const ulint *offsets);
371
372#ifdef UNIV_DEBUG
373/** Returns a pointer to the start of the record.
374@param[in] rec pointer to record
375@param[in] offsets array returned by rec_get_offsets()
376@return pointer to start */
377[[nodiscard]] static inline byte *rec_get_start(const rec_t *rec,
378 const ulint *offsets);
379
380/** Returns a pointer to the end of the record.
381@param[in] rec pointer to record
382@param[in] offsets array returned by rec_get_offsets()
383@return pointer to end */
384[[nodiscard]] static inline byte *rec_get_end(const rec_t *rec,
385 const ulint *offsets);
386#else /* UNIV_DEBUG */
387#define rec_get_start(rec, offsets) ((rec)-rec_offs_extra_size(offsets))
388#define rec_get_end(rec, offsets) ((rec) + rec_offs_data_size(offsets))
389#endif /* UNIV_DEBUG */
390
391/** Copy a physical record to a buffer.
392@param[in] buf buffer
393@param[in] rec physical record
394@param[in] offsets array returned by rec_get_offsets()
395@return pointer to the origin of the copy */
396static inline rec_t *rec_copy(void *buf, const rec_t *rec,
397 const ulint *offsets);
398
399#ifndef UNIV_HOTBACKUP
400/** Determines the size of a data tuple prefix in a temporary file.
401@param[in] index record descriptor
402@param[in] fields array of data fields
403@param[in] n_fields number of data fields
404@param[in] v_entry dtuple contains virtual column data
405@param[out] extra extra size
406@param[in] rec_version row version of record
407@return total size */
408[[nodiscard]] ulint rec_get_serialize_size(const dict_index_t *index,
409 const dfield_t *fields,
410 ulint n_fields,
411 const dtuple_t *v_entry,
412 ulint *extra, uint8_t rec_version);
413
414/** Determine the offset to each field in temporary file.
415@param[in] rec temporary file record
416@param[in] index record descriptor
417@param[in,out] offsets array of offsets
418 @see rec_serialize_dtuple() */
419void rec_deserialize_init_offsets(const rec_t *rec, const dict_index_t *index,
420 ulint *offsets);
421
422/** Builds a temporary file record out of a data tuple.
423@param[out] rec record
424@param[in] index record descriptor
425@param[in] fields array of data fields
426@param[in] n_fields number of fields
427@param[in] v_entry dtuple contains virtual column data
428@param[in] rec_version rec version
429@see rec_deserialize_init_offsets() */
430void rec_serialize_dtuple(rec_t *rec, const dict_index_t *index,
431 const dfield_t *fields, ulint n_fields,
432 const dtuple_t *v_entry,
433 uint8_t rec_version = MAX_ROW_VERSION);
434
435/** Copies the first n fields of a physical record to a new physical record in
436a buffer.
437@param[in] rec physical record
438@param[in] index record descriptor
439@param[in] n_fields number of fields to copy
440@param[in,out] buf memory buffer for the copied prefix, or NULL
441@param[in,out] buf_size buffer size
442@return own: copied record */
443rec_t *rec_copy_prefix_to_buf(const rec_t *rec, const dict_index_t *index,
444 ulint n_fields, byte **buf, size_t *buf_size);
445
446/** Compute a hash value of a prefix of a leaf page record.
447@param[in] rec leaf page record
448@param[in] offsets rec_get_offsets(rec)
449@param[in] n_fields number of complete fields to hash
450@param[in] n_bytes number of bytes to hash in the last field
451@param[in] hashed_value hash value of the index identifier
452@param[in] index index where the record resides
453@return the hashed value */
454[[nodiscard]] static inline uint64_t rec_hash(const rec_t *rec,
455 const ulint *offsets,
456 ulint n_fields, ulint n_bytes,
457 uint64_t hashed_value,
458 const dict_index_t *index);
459#endif /* !UNIV_HOTBACKUP */
460
461/** Builds a physical record out of a data tuple and stores it into the given
462buffer.
463@param[in] buf start address of the physical record
464@param[in] index record descriptor
465@param[in] dtuple data tuple
466@return pointer to the origin of physical record */
467[[nodiscard]] rec_t *rec_convert_dtuple_to_rec(byte *buf,
468 const dict_index_t *index,
469 const dtuple_t *dtuple);
470
471/** Returns the extra size of an old-style physical record if we know its
472 data size and number of fields.
473 @param[in] data_size data size
474 @param[in] n_fields number of fields
475 @param[in] has_ext true if tuple has ext fields
476 @return extra size */
478 ulint n_fields, bool has_ext);
479
480/** Determines the size of a data tuple prefix in ROW_FORMAT=COMPACT.
481@param[in] index record descriptor
482@param[in] fields array of data fields
483@param[in] n_fields number of data fields
484@param[out] extra extra size
485@return total size */
487 const dict_index_t *index, const dfield_t *fields, ulint n_fields,
488 ulint *extra);
489
490/** Determines the size of a data tuple in ROW_FORMAT=COMPACT.
491@param[in] index record descriptor; dict_table_is_comp() is
492 assumed to hold, even if it does not
493@param[in] status status bits of the record
494@param[in] fields array of data fields
495@param[in] n_fields number of data fields
496@param[out] extra extra size
497@return total size */
499 const dfield_t *fields, ulint n_fields,
500 ulint *extra);
501
502/** The following function returns the size of a data tuple when converted to
503a physical record.
504@param[in] index record descriptor
505@param[in] dtuple data tuple
506@return size */
507[[nodiscard]] static inline ulint rec_get_converted_size(
508 const dict_index_t *index, const dtuple_t *dtuple);
509
510#ifndef UNIV_HOTBACKUP
511/** Copies the first n fields of a physical record to a data tuple.
512The fields are copied to the memory heap.
513@param[out] tuple data tuple
514@param[in] rec physical record
515@param[in] index record descriptor
516@param[in] n_fields number of fields to copy
517@param[in] heap memory heap */
518void rec_copy_prefix_to_dtuple(dtuple_t *tuple, const rec_t *rec,
519 const dict_index_t *index, ulint n_fields,
520 mem_heap_t *heap);
521#endif /* !UNIV_HOTBACKUP */
522
523/** Get the length of the number of fields for any new style record.
524@param[in] n_fields number of fields in the record
525@return length of specified number of fields */
526static inline uint8_t rec_get_n_fields_length(ulint n_fields);
527
528/** Set the row version on one new style leaf page record.
529This is only needed for table after instant ADD/DROP COLUMN.
530@param[in,out] rec leaf page record
531@param[in] version row version */
532static inline void rec_set_instant_row_version_new(rec_t *rec, uint8_t version);
533
534/** Set the row version on one old style leaf page record.
535This is only needed for table after instant ADD/DROP COLUMN.
536@param[in,out] rec leaf page record
537@param[in] version row version */
538static inline void rec_set_instant_row_version_old(rec_t *rec, uint8_t version);
539
540/** Validates the consistency of a physical record.
541@param[in] rec physical record
542@param[in] offsets array returned by rec_get_offsets()
543@return true if ok */
544bool rec_validate(const rec_t *rec, const ulint *offsets);
545
546/** Prints an old-style physical record.
547@param[in] file File where to print
548@param[in] rec Physical record */
549void rec_print_old(FILE *file, const rec_t *rec);
550
551#ifndef UNIV_HOTBACKUP
552
553/** Prints a spatial index record.
554@param[in] file File where to print
555@param[in] rec Physical record
556@param[in] offsets Array returned by rec_get_offsets() */
557void rec_print_mbr_rec(FILE *file, const rec_t *rec, const ulint *offsets);
558
559/** Prints a physical record.
560@param[in] file file where to print
561@param[in] rec physical record
562@param[in] offsets array returned by rec_get_offsets() */
563void rec_print_new(FILE *file, const rec_t *rec, const ulint *offsets);
564
565/** Prints a physical record.
566@param[in] file File where to print
567@param[in] rec Physical record
568@param[in] index Record descriptor */
569void rec_print(FILE *file, const rec_t *rec, const dict_index_t *index);
570
571/** Pretty-print a record.
572@param[in,out] o output stream
573@param[in] rec physical record
574@param[in] info rec_get_info_bits(rec)
575@param[in] offsets rec_get_offsets(rec) */
576void rec_print(std::ostream &o, const rec_t *rec, ulint info,
577 const ulint *offsets);
578
579/** Wrapper for pretty-printing a record */
581 /** Constructor */
582 rec_index_print(const rec_t *rec, const dict_index_t *index)
583 : m_rec(rec), m_index(index) {}
584
585 /** Record */
586 const rec_t *m_rec;
587 /** Index */
589};
590
591/** Display a record.
592@param[in,out] o output stream
593@param[in] r record to display
594@return the output stream */
595std::ostream &operator<<(std::ostream &o, const rec_index_print &r);
596
597/** Wrapper for pretty-printing a record */
599 /** Constructor */
600 rec_offsets_print(const rec_t *rec, const ulint *offsets)
601 : m_rec(rec), m_offsets(offsets) {}
602
603 /** Record */
604 const rec_t *m_rec;
605 /** Offsets to each field */
607};
608
609/** Display a record.
610@param[in,out] o output stream
611@param[in] r record to display
612@return the output stream */
613std::ostream &operator<<(std::ostream &o, const rec_offsets_print &r);
614
615#ifdef UNIV_DEBUG
616/** Pretty-printer of records and tuples */
618 public:
619 /** Construct a pretty-printed record.
620 @param rec record with header
621 @param offsets rec_get_offsets(rec, ...) */
622 rec_printer(const rec_t *rec, const ulint *offsets) : std::ostringstream() {
623 rec_print(*this, rec, rec_get_info_bits(rec, rec_offs_comp(offsets)),
624 offsets);
625 }
626
627 /** Construct a pretty-printed record.
628 @param rec record, possibly lacking header
629 @param info rec_get_info_bits(rec)
630 @param offsets rec_get_offsets(rec, ...) */
631 rec_printer(const rec_t *rec, ulint info, const ulint *offsets)
632 : std::ostringstream() {
633 rec_print(*this, rec, info, offsets);
634 }
635
636 /** Construct a pretty-printed tuple.
637 @param tuple data tuple */
639 dtuple_print(*this, tuple);
640 }
641
642 /** Construct a pretty-printed tuple.
643 @param field array of data tuple fields
644 @param n number of fields */
646 dfield_print(*this, field, n);
647 }
648
649 /** Destructor */
650 virtual ~rec_printer() = default;
651
652 private:
653 /** Copy constructor */
655 /** Assignment operator */
657};
658#endif /* UNIV_DEBUG */
659
660/** Reads the DB_TRX_ID of a clustered index record.
661@param[in] rec record
662@param[in] index clustered index
663@return the value of DB_TRX_ID */
664[[nodiscard]] trx_id_t rec_get_trx_id(const rec_t *rec,
665 const dict_index_t *index);
666#endif /* UNIV_HOTBACKUP */
667
668/* Maximum lengths for the data in a physical record if the offsets
669are given in one byte (resp. two byte) format. */
670constexpr ulint REC_1BYTE_OFFS_LIMIT = 0x7FUL;
671constexpr ulint REC_2BYTE_OFFS_LIMIT = 0x7FFFUL;
672
673/* The data size of record must be smaller than this because we reserve
674two upmost bits in a two byte offset for special purposes */
675constexpr ulint REC_MAX_DATA_SIZE = 16384;
676
677/** For a given clustered index, version is to be stored on physical record.
678@param[in] index clustered index
679@param[in] n_tuple_fields number of fields in tuple
680@return true, if version is to be stored */
681bool is_store_version(const dict_index_t *index, size_t n_tuple_fields);
682
683#include "rem0rec.ic"
684
685#endif
A helper RAII wrapper for otherwise difficult to use sequence of:
Definition: rem0rec.h:300
ulint m_preallocated_buffer[REC_OFFS_NORMAL_SIZE]
Buffer with size large enough to handle common cases without having to use heap.
Definition: rem0rec.h:342
~Rec_offsets()
Deallocated dynamically allocated memory, if any.
Definition: rem0rec.h:324
Rec_offsets()
Prepares offsets to initially point to the fixed-size buffer, and marks the memory as allocated,...
Definition: rem0rec.h:305
ulint * m_offsets
Definition: rem0rec.h:349
mem_heap_t * m_heap
Pointer to heap used by rec_get_offsets().
Definition: rem0rec.h:338
const ulint * compute(const rec_t *rec, const dict_index_t *index, const ulint n_fields=ULINT_UNDEFINED)
Computes offsets for given record.
Definition: rem0rec.h:317
Pretty-printer of records and tuples.
Definition: rem0rec.h:617
rec_printer(const dfield_t *field, ulint n)
Construct a pretty-printed tuple.
Definition: rem0rec.h:645
rec_printer(const rec_printer &other)
Copy constructor.
rec_printer & operator=(const rec_printer &other)
Assignment operator.
rec_printer(const rec_t *rec, const ulint *offsets)
Construct a pretty-printed record.
Definition: rem0rec.h:622
rec_printer(const rec_t *rec, ulint info, const ulint *offsets)
Construct a pretty-printed record.
Definition: rem0rec.h:631
rec_printer(const dtuple_t *tuple)
Construct a pretty-printed tuple.
Definition: rem0rec.h:638
virtual ~rec_printer()=default
Destructor.
A utility class which, if inherited from, prevents the descendant class from being copied,...
Definition: ut0class_life_cycle.h:40
constexpr DWORD buf_size
Definition: create_def.cc:227
void dtuple_print(FILE *f, const dtuple_t *tuple)
The following function prints the contents of a tuple.
Definition: data0data.cc:367
void dfield_print(std::ostream &o, const dfield_t *field, ulint n)
Print the contents of a tuple.
Definition: data0data.cc:384
SQL data field and tuple.
const uint8_t MAX_ROW_VERSION
Maximum number of rows version allowed when columns are added/dropped INSTANTly.
Definition: dict0mem.h:318
static int flag
Definition: hp_test1.cc:39
static void mem_heap_free(mem_heap_t *heap)
Frees the space occupied by a memory heap.
Mini-transaction buffer global types.
Log info(cout, "NOTE")
Definition: buf0block_hint.cc:29
const std::string FILE("FILE")
Definition: os0file.h:85
Definition: varlen_sort.h:183
std::basic_ostringstream< char, std::char_traits< char >, ut::allocator< char > > ostringstream
Specialization of basic_ostringstream which uses ut::allocator.
Definition: ut0new.h:2851
Index page routines.
const mysql_service_registry_t * r
Definition: pfs_example_plugin_employee.cc:85
ulint * rec_get_offsets(const rec_t *rec, const dict_index_t *index, ulint *offsets, ulint n_fields, ut::Location location, mem_heap_t **heap)
The following function determines the offsets to each field in the record.
Definition: rec.cc:358
Record manager.
static ulint rec_get_info_bits(const rec_t *rec, ulint comp)
The following function is used to retrieve the info bits of a record.
Definition: rec.h:277
constexpr uint32_t REC_OFFS_NORMAL_SIZE
Definition: rec.h:169
static const byte * rec_get_nth_field_instant(const rec_t *rec, const ulint *offsets, ulint n, const dict_index_t *index, ulint *len)
Gets the value of the specified field in the record.
void rec_print(FILE *file, const rec_t *rec, const dict_index_t *index)
Prints a physical record.
Definition: rem0rec.cc:1708
ulint rec_get_n_extern_new(const rec_t *rec, const dict_index_t *index, ulint n)
Determine how many of the first n columns in a compact physical record are stored externally.
Definition: rem0rec.cc:173
ulint rec_get_serialize_size(const dict_index_t *index, const dfield_t *fields, ulint n_fields, const dtuple_t *v_entry, ulint *extra, uint8_t rec_version)
Determines the size of a data tuple prefix in a temporary file.
Definition: rem0rec.cc:1093
static void rec_set_n_owned_old(rec_t *rec, ulint n_owned)
The following function is used to set the number of owned records.
static bool rec_get_node_ptr_flag(const rec_t *rec)
The following function tells if a new-style record is a node pointer.
void rec_deserialize_init_offsets(const rec_t *rec, const dict_index_t *index, ulint *offsets)
Determine the offset to each field in temporary file.
Definition: rem0rec.cc:1102
ulint rec_get_converted_size_comp_prefix(const dict_index_t *index, const dfield_t *fields, ulint n_fields, ulint *extra)
Determines the size of a data tuple prefix in ROW_FORMAT=COMPACT.
Definition: rem0rec.cc:469
void rec_print_new(FILE *file, const rec_t *rec, const ulint *offsets)
Prints a physical record.
Definition: rem0rec.cc:1672
static void rec_set_instant_flag_new(rec_t *rec, bool flag)
The following function is used to set the instant bit.
static void rec_set_info_bits_old(rec_t *rec, ulint bits)
The following function is used to set the info bits of a record.
static void rec_set_next_offs_old(rec_t *rec, ulint next)
The following function is used to set the next record offset field of an old-style record.
bool is_store_version(const dict_index_t *index, size_t n_tuple_fields)
For a given clustered index, version is to be stored on physical record.
Definition: rem0rec.cc:245
ulint rec_get_converted_size_comp(const dict_index_t *index, ulint status, const dfield_t *fields, ulint n_fields, ulint *extra)
Determines the size of a data tuple in ROW_FORMAT=COMPACT.
Definition: rem0rec.cc:483
static void rec_set_status(rec_t *rec, ulint bits)
The following function is used to set the status bits of a new-style record.
#define rec_offs_init(offsets)
Definition: rem0rec.h:273
static ulint rec_get_converted_size(const dict_index_t *index, const dtuple_t *dtuple)
The following function returns the size of a data tuple when converted to a physical record.
trx_id_t rec_get_trx_id(const rec_t *rec, const dict_index_t *index)
Reads the DB_TRX_ID of a clustered index record.
Definition: rem0rec.cc:1808
static const byte * rec_offs_any_null_extern(const dict_index_t *index, const rec_t *rec, const ulint *offsets)
Determine if the offsets are for a record containing null BLOB pointers.
static void rec_set_n_owned_new(rec_t *rec, page_zip_des_t *page_zip, ulint n_owned)
The following function is used to set the number of owned records.
constexpr ulint REC_MAX_DATA_SIZE
Definition: rem0rec.h:675
static ulint rec_offs_size(const ulint *offsets)
Returns the total size of a physical record.
static const rec_t * rec_get_next_ptr_const(const rec_t *rec, ulint comp)
The following function is used to get the pointer of the next chained record on the same page.
static bool rec_get_deleted_flag(const rec_t *rec, bool comp)
The following function tells if record is delete marked.
static ulint rec_get_n_owned_new(const rec_t *rec)
The following function is used to get the number of records owned by the previous directory record.
static ulint rec_get_heap_no_old(const rec_t *rec)
The following function is used to get the order number of an old-style record in the heap of the inde...
static void rec_set_heap_no_new(rec_t *rec, ulint heap_no)
The following function is used to set the heap number field in a new-style record.
static void rec_old_set_versioned(rec_t *rec, bool flag)
The following function is used to set the instant bit.
static byte * rec_get_start(const rec_t *rec, const ulint *offsets)
Returns a pointer to the start of the record.
static rec_t * rec_get_next_ptr(rec_t *rec, ulint comp)
The following function is used to get the pointer of the next chained record on the same page.
static ulint rec_get_converted_extra_size(ulint data_size, ulint n_fields, bool has_ext)
Returns the extra size of an old-style physical record if we know its data size and number of fields.
void rec_copy_prefix_to_dtuple(dtuple_t *tuple, const rec_t *rec, const dict_index_t *index, ulint n_fields, mem_heap_t *heap)
Copies the first n fields of a physical record to a data tuple.
Definition: rem0rec.cc:1128
static bool rec_offs_any_extern(const ulint *offsets)
Determine if the offsets are for a record containing externally stored columns.
static void rec_set_instant_row_version_new(rec_t *rec, uint8_t version)
Set the row version on one new style leaf page record.
static ulint rec_get_info_and_status_bits(const rec_t *rec, bool comp)
The following function is used to retrieve the info and status bits of a record.
void rec_print_mbr_rec(FILE *file, const rec_t *rec, const ulint *offsets)
Prints a spatial index record.
Definition: rem0rec.cc:1612
static ulint rec_offs_data_size(const ulint *offsets)
The following function returns the data size of a physical record, that is the sum of field lengths.
static bool rec_field_not_null_not_add_col_def(ulint len)
Determine if the field is not NULL and not having default value after instant ADD COLUMN.
static void rec_set_next_offs_new(rec_t *rec, ulint next)
The following function is used to set the next record offset field of a new-style record.
static bool rec_offs_comp(const ulint *offsets)
Determine if the offsets are for a record in the new compact format.
static void rec_set_info_and_status_bits(rec_t *rec, ulint bits)
The following function is used to set the info and status bits of a record.
static ulint rec_get_n_owned_old(const rec_t *rec)
The following function is used to get the number of records owned by the previous directory record.
void rec_serialize_dtuple(rec_t *rec, const dict_index_t *index, const dfield_t *fields, ulint n_fields, const dtuple_t *v_entry, uint8_t rec_version=MAX_ROW_VERSION)
Builds a temporary file record out of a data tuple.
Definition: rem0rec.cc:1119
static void rec_new_set_versioned(rec_t *rec, bool flag)
The following function is used to set the row version bit.
static ulint rec_get_next_offs(const rec_t *rec, ulint comp)
The following function is used to get the offset of the next chained record on the same page.
std::ostream & operator<<(std::ostream &o, const rec_index_print &r)
Display a record.
Definition: rem0rec.cc:1786
static void rec_set_deleted_flag_old(rec_t *rec, bool flag)
The following function is used to set the deleted bit.
static ulint rec_offs_n_extern(const dict_index_t *index, const ulint *offsets)
Returns the number of extern bits set in a record.
static ulint rec_get_heap_no_new(const rec_t *rec)
The following function is used to get the order number of a new-style record in the heap of the index...
static const byte * rec_get_nth_field_old_instant(const rec_t *rec, uint16_t n, const dict_index_t *index, ulint *len)
Gets the value of the specified field in the record in old style.
void rec_print_old(FILE *file, const rec_t *rec)
Prints an old-style physical record.
Definition: rem0rec.cc:1450
bool rec_validate(const rec_t *rec, const ulint *offsets)
Validates the consistency of a physical record.
Definition: rem0rec.cc:1375
static uint64_t rec_hash(const rec_t *rec, const ulint *offsets, ulint n_fields, ulint n_bytes, uint64_t hashed_value, const dict_index_t *index)
Compute a hash value of a prefix of a leaf page record.
static void rec_set_heap_no_old(rec_t *rec, ulint heap_no)
The following function is used to set the heap number field in an old-style record.
static ulint rec_offs_extra_size(const ulint *offsets)
Returns the total size of record minus data size of record.
constexpr ulint REC_2BYTE_OFFS_LIMIT
Definition: rem0rec.h:671
rec_t * rec_copy_prefix_to_buf(const rec_t *rec, const dict_index_t *index, ulint n_fields, byte **buf, size_t *buf_size)
Copies the first n fields of a physical record to a new physical record in a buffer.
Definition: rem0rec.cc:1208
static rec_t * rec_copy(void *buf, const rec_t *rec, const ulint *offsets)
Copy a physical record to a buffer.
static void rec_set_info_bits_new(rec_t *rec, ulint bits)
The following function is used to set the info bits of a record.
static void rec_set_instant_row_version_old(rec_t *rec, uint8_t version)
Set the row version on one old style leaf page record.
rec_t * rec_convert_dtuple_to_rec(byte *buf, const dict_index_t *index, const dtuple_t *dtuple)
Builds a physical record out of a data tuple and stores it into the given buffer.
Definition: rem0rec.cc:1041
constexpr ulint REC_1BYTE_OFFS_LIMIT
Definition: rem0rec.h:670
static byte * rec_get_end(const rec_t *rec, const ulint *offsets)
Returns a pointer to the end of the record.
static uint8_t rec_get_n_fields_length(ulint n_fields)
Get the length of the number of fields for any new style record.
static void rec_set_deleted_flag_new(rec_t *rec, page_zip_des_t *page_zip, bool flag)
The following function is used to set the deleted bit.
static void rec_set_1byte_offs_flag(rec_t *rec, bool flag)
The following function is used to set the 1-byte offsets flag.
Record manager.
Record manager global types.
byte rec_t
Definition: rem0types.h:40
Record manager wrapper declaration.
required uint32 status
Definition: replication_asynchronous_connection_failover.proto:60
required uint64 version
Definition: replication_group_member_actions.proto:40
Structure for an SQL data field.
Definition: data0data.h:604
Data structure for an index.
Definition: dict0mem.h:1021
Structure for an SQL data tuple of fields (logical record)
Definition: data0data.h:681
The info structure stored at the beginning of a heap block.
Definition: mem0mem.h:299
Compressed page descriptor.
Definition: page0types.h:199
Part of traditional "extra" column or related hierarchical property.
Definition: opt_explain_format.h:264
Wrapper for pretty-printing a record.
Definition: rem0rec.h:580
const dict_index_t * m_index
Index.
Definition: rem0rec.h:588
const rec_t * m_rec
Record.
Definition: rem0rec.h:586
rec_index_print(const rec_t *rec, const dict_index_t *index)
Constructor.
Definition: rem0rec.h:582
Wrapper for pretty-printing a record.
Definition: rem0rec.h:598
const rec_t * m_rec
Record.
Definition: rem0rec.h:604
const ulint * m_offsets
Offsets to each field.
Definition: rem0rec.h:606
rec_offsets_print(const rec_t *rec, const ulint *offsets)
Constructor.
Definition: rem0rec.h:600
Transaction system global type definitions.
ib_id_t trx_id_t
Transaction identifier (DB_TRX_ID, DATA_TRX_ID)
Definition: trx0types.h:137
Version control for database, common definitions, and include files.
unsigned long int ulint
Definition: univ.i:407
constexpr ulint ULINT_UNDEFINED
The 'undefined' value for a ulint.
Definition: univ.i:421
Utilities related to class lifecycle.
#define UT_LOCATION_HERE
Definition: ut0core.h:46
int n
Definition: xcom_base.cc:505