Impressum ma_dyncol.c
Interaktion und
/* Copyright (c) 2011, 2017, MariaDB Corporation. Copyright ( c ) 2011 , 2012 , Oleksandr Byelkin Redistribution and use in source and binary forms , with or without modification , are permitted provided that the following conditions are met : 1 . Redistributions of source code must retain the above copyright notice , this list of conditions and the following disclaimer . 2 . Redistributions in binary form must the following disclaimer in the documentation and / or other materials provided with the distribution . THIS SOFTWARE IS PROVIDED BY < COPYRIGHT HOLDER > ` ` AS IS ' ' AND ANY EXPRESS OR IMPLIED WARRANTIES , INCLUDING , BUT NOT LIMITED TO , THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED . IN NO EVENT SHALL < COPYRIGHT HOLDER > OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT , INDIRECT , INCIDENTAL , SPECIAL , EXEMPLARY , OR CONSEQUENTIAL DAMAGES ( INCLUDING , BUT NOT LIMITED TO , PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES ; LOSS OF USE , DATA , OR PROFITS ; OR BUSINESS INTERRUPTION ) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY , WHETHER IN CONTRACT , STRICT LIABILITY , OR TORT ( INCLUDING NEGLIGENCE OR OTHERWISE ) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE , EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE . /* Numeric format : = = = = = = = = = = = = = = = * Fixed header part 1 byte flags : 0 , 1 bits - < offset size > - 1 2 - 7 bits - 0 2 bytes column counter * Columns directory sorted by column number , each entry contains of : 2 bytes column number < offset size > bytes ( 1 - 4 ) combined offset from beginning of the data segment + 3 bit type * Data of above columns size of data and length depend on type Columns with names : = = = = = = = = = = = = = = = = = = = * Fixed header part 1 byte flags : 0 , 1 bits - < offset size > - 2 2 bit - 1 ( means format with names ) 3 , 4 bits - 00 ( means < names offset size > - 2 , now 2 is the only supported size ) 5 - 7 bits - 0 2 bytes column counter * Variable header part ( now it is actually fixed part ) < names offset size > ( 2 ) bytes size of stored names pool * Column directory sorted by names , each consists of < names offset size > ( 2 ) bytes offset of name < offset size > bytes ( 2 - 5 ) bytes combined offset from beginning of the data segment + 4 bit type * Names stored one after another * Data of above columns size of data and length depend on type #include "mysys_priv.h" #include <m_string.h>#include <ma_dyncol.h>#include <my_time.h>char *to, uint32 to_length, CHARSET_INFO *to_cs,const char *from, uint32 from_length,/* Flag byte bits 2 bits which determinate size of offset in the header - 1 /* mask to get above bits */ #define DYNCOL_FLG_OFFSET (1 U|2 U)#define DYNCOL_FLG_NAMES 4 U#define DYNCOL_FLG_NMOFFSET (8 U|16 U)/** All known flags mask that could be set . @ note DYNCOL_FLG_NMOFFSET should be 0 for now . #define DYNCOL_FLG_KNOWN (1 U|2 U|4 U)/* formats */ enum enum_dyncol_format0 ,1 /* dynamic column size reserve */ #define DYNCOL_SYZERESERVE 80 #define DYNCOL_OFFSET_ERROR 0 xffffffff/* length of fixed string header 1 byte - flags, 2 bytes - columns counter */ #define FIXED_HEADER_SIZE 3 /* length of fixed string header with names 1 byte - flags , 2 bytes - columns counter , 2 bytes - name pool size #define FIXED_HEADER_SIZE_NM 5 #define COLUMN_NUMBER_SIZE 2 /* 2 bytes offset from the name pool */ #define COLUMN_NAMEPTR_SIZE 2 #define MAX_OFFSET_LENGTH 4 #define MAX_OFFSET_LENGTH_NM 5 #define DYNCOL_NUM_CHAR 6 if (str->length < 1 )return FALSE ;return MY_TEST(str->str[0 ] & DYNCOL_FLG_NAMES);static enum enum_dyncol_func_resultenum enum_dyncol_format format);static enum enum_dyncol_func_resultstatic enum enum_dyncol_func_resultstatic enum enum_dyncol_func_resultstatic enum enum_dyncol_func_resultstatic enum enum_dyncol_func_resultstatic enum enum_dyncol_func_resultvoid *column_keys,static int plan_sort_num(const void *a, const void *b);static int plan_sort_named(const void *a, const void *b);/* Structure to hold information about dynamic columns record and iterate through it . struct st_dyn_header/* dyncol_fmt_num - numeric columns, dyncol_fmt_str - column names */ enum enum_dyncol_format format;enum enum_dynamic_column_type type;typedef struct st_dyn_header DYN_HEADER;static inline my_bool read_fixed_header(DYN_HEADER *hdr,static void set_fixed_header(DYNAMIC_COLUMN *str,/* Calculate entry size ( E ) and header size ( H ) by offset size ( O ) and column count ( C ) and fixed part of entry size ( F ) . #define calc_param(E,H,F,O,C) do { \while (0 );/** Name pool size functions , for numeric format it is 0 static size_t name_size_num(void *keys __attribute__((unused)),return 0 ;/** Name pool size functions . static size_t name_size_named(void *keys, uint i)return ((LEX_STRING *) keys)[i].length;/** Comparator function for references on column numbers for qsort ( numeric format ) static int column_sort_num(const void *a, const void *b)return **((uint **)a) - **((uint **)b);/** Comparator function for references on column numbers for qsort ( names format ) int mariadb_dyncol_column_cmp_named(const LEX_STRING *s1, const LEX_STRING *s2)/* We compare instead of subtraction to avoid data loss in case of huge length difference ( more then fit in int ) . int rc= (s1->length > s2->length ? 1 :1 : 0 ));if (rc == 0 )void *)s1->str, (void *)s2->str,return rc;/** Comparator function for references on column numbers for qsort ( names format ) static int column_sort_named(const void *a, const void *b)return mariadb_dyncol_column_cmp_named(*((LEX_STRING **)a),/** Check limit function ( numeric format ) static my_bool check_limit_num(const void *val)return **((uint **)val) > UINT_MAX16;/** Check limit function ( names format ) static my_bool check_limit_named(const void *val)return (*((LEX_STRING **)val))->length > MAX_NAME_LENGTH;/** Write numeric format static header part . static void set_fixed_header_num(DYNAMIC_COLUMN *str, DYN_HEADER *hdr)/** Write names format static header part . static void set_fixed_header_named(DYNAMIC_COLUMN *str, DYN_HEADER *hdr)0 xffff);/* size of data offset, named format flag, size of names offset (0 means 2) */ 0 ]=char ) (((uchar)str->str[0 ] & ~(DYNCOL_FLG_OFFSET | DYNCOL_FLG_NMOFFSET)) |2 ) | DYNCOL_FLG_NAMES);1 , hdr->column_count); /* columns number */ 3 , hdr->nmpool_size);/** Store offset and type information in the given place @ param place Beginning of the index entry @ param offset_size Size of offset field in bytes @ param type Type to be written @ param offset Offset to be written static my_bool type_and_offset_store_num(uchar *place, size_t offset_size,3 ) | (type - 1 );1 ) & (~7 U)) == 0 ); /* fit in 3 bits */ 1 && offset_size <= 4 );/* Index entry starts with column number; jump over it */ switch (offset_size) {case 1 :if (offset >= 0 x1f) /* all 1 value is reserved */ return TRUE ;0 ]= (uchar)val;break ;case 2 :if (offset >= 0 x1fff) /* all 1 value is reserved */ return TRUE ;break ;case 3 :if (offset >= 0 x1fffff) /* all 1 value is reserved */ return TRUE ;break ;case 4 :if (offset >= 0 x1fffffff) /* all 1 value is reserved */ return TRUE ;break ;default :return TRUE ;return FALSE ;static my_bool type_and_offset_store_named(uchar *place, size_t offset_size,4 ) | (type - 1 );1 ) & (~0 xfU)) == 0 ); /* fit in 4 bits */ 2 && offset_size <= 5 );/* Index entry starts with name offset; jump over it */ switch (offset_size) {case 2 :if (offset >= 0 xfff) /* all 1 value is reserved */ return TRUE ;break ;case 3 :if (offset >= 0 xfffff) /* all 1 value is reserved */ return TRUE ;break ;case 4 :if (offset >= 0 xfffffff) /* all 1 value is reserved */ return TRUE ;break ;case 5 :#if SIZEOF_SIZE_T > 4 if (offset >= 0 xfffffffffull) /* all 1 value is reserved */ return TRUE ;#endif break ;case 1 :default :return TRUE ;return FALSE ;/** Write numeric format header entry 2 bytes - column number 1 - 4 bytes - data offset combined with type @ param hdr descriptor of dynamic column record @ param column_key pointer to uint ( column number ) @ param value value which will be written ( only type used ) @ param offset offset of the data static my_bool put_header_entry_num(DYN_HEADER *hdr,void *column_key,0 );if (type_and_offset_store_num(hdr->entry, hdr->offset_size,return TRUE ;return FALSE ;/** Write names format header entry 1 byte - name length 2 bytes - name offset in the name pool 1 - 4 bytes - data offset combined with type @ param hdr descriptor of dynamic column record @ param column_key pointer to LEX_STRING ( column name ) @ param value value which will be written ( only type used ) @ param offset offset of the data static my_bool put_header_entry_named(DYN_HEADER *hdr,void *column_key,long ) 0 x10000L);0 || column_name->length == 0 );if (type_and_offset_store_named(hdr->entry, hdr->offset_size,return TRUE ;return FALSE ;/** Calculate length of offset field for given data length @ param data_length Length of the data segment @ return number of bytes static size_t dynamic_column_offset_bytes_num(size_t data_length)if (data_length < 0 x1f) /* all 1 value is reserved */ return 1 ;if (data_length < 0 x1fff) /* all 1 value is reserved */ return 2 ;if (data_length < 0 x1fffff) /* all 1 value is reserved */ return 3 ;if (data_length < 0 x1fffffff) /* all 1 value is reserved */ return 4 ;return MAX_OFFSET_LENGTH + 1 ; /* For an error generation*/ static size_t dynamic_column_offset_bytes_named(size_t data_length)if (data_length < 0 xfff) /* all 1 value is reserved */ return 2 ;if (data_length < 0 xfffff) /* all 1 value is reserved */ return 3 ;if (data_length < 0 xfffffff) /* all 1 value is reserved */ return 4 ;#if SIZEOF_SIZE_T > 4 if (data_length < 0 xfffffffffull) /* all 1 value is reserved */ #endif return 5 ;return MAX_OFFSET_LENGTH_NM + 1 ; /* For an error generation */ /** Read offset and type information from index entry @ param type Where to put type info @ param offset Where to put offset info @ param place beginning of the type and offset @ param offset_size Size of offset field in bytes static my_bool type_and_offset_read_num(DYNAMIC_COLUMN_TYPE *type,1 && offset_size <= 4 );switch (offset_size) {case 1 :0 ];0 x1f;break ;case 2 :0 x1fff;break ;case 3 :0 x1fffff;break ;case 4 :0 x1fffffff;break ;default :0 ); /* impossible */ return 1 ;0 x7) + 1 ;3 ;return (*offset >= lim);static my_bool type_and_offset_read_named(DYNAMIC_COLUMN_TYPE *type,2 && offset_size <= 5 );switch (offset_size) {case 2 :0 xfff;break ;case 3 :0 xfffff;break ;case 4 :0 xfffffff;break ;case 5 :0 xfffffffffull;break ;case 1 :default :0 ); /* impossible */ return 1 ;0 xf) + 1 ;4 );return (*offset >= lim);/** Format descriptor , contain constants and function references for format processing struct st_service_funcs/* size of fixed header */ /* size of fixed part of header entry */ /*size of array element which stores keys */ /* Maximum data offset size in bytes */ void *, uint);int (*column_sort)const void *a, const void *b);const void *val);void (*set_fixed_hdr)void *column_key,int (*plan_sort)(const void *a, const void *b);/** Actual our 2 format descriptors static struct st_service_funcs fmt_data[2 ]=sizeof (uint),sizeof (LEX_STRING),/** Read dynamic column record header and fill the descriptor @ param hdr dynamic columns record descriptor to fill @ param str dynamic columns record @ return ER_DYNCOL_ * return code static enum enum_dyncol_func_resultif (read_fixed_header(hdr, str))return ER_DYNCOL_FORMAT;if (str->length < nodata_size)return ER_DYNCOL_FORMAT;return ER_DYNCOL_OK;/** Initialize dynamic column string with ( make it empty but correct format ) @ param str The string to initialize @ param size Amount of preallocated memory for the string . @ retval FALSE OK @ retval TRUE error static my_bool dynamic_column_init_named(DYNAMIC_COLUMN *str, size_t size)0 );/* Make string with no fields ( empty header ) - First \ 0 is flags - other 2 \ 0 is number of fields if (init_dynamic_string(str, NULL, size, DYNCOL_SYZERESERVE))return TRUE ;return FALSE ;/** Calculate how many bytes needed to store val as variable length integer where first bit indicate continuation of the sequence . @ param val The value for which we are calculating length @ return number of bytes static size_t dynamic_column_var_uint_bytes(ulonglong val)0 ;do 7 ;while (val);return len;/** Stores variable length unsigned integer value to a string @ param str The string where to append the value @ param val The value to put in the string @ return ER_DYNCOL_ * return code @ notes This is used to store a number together with other data in the same object . ( Like decimals , length of string etc ) ( As we don ' t know the length of this object , we can ' t store 0 in 0 bytes ) static enum enum_dyncol_func_resultif (dynstr_realloc(str, 10 )) /* max what we can use */ return ER_DYNCOL_RESOURCE;do 7 ;0 x7f) | (rest ? 0 x80 : 0 x00));while (val);return ER_DYNCOL_OK;/** Reads variable length unsigned integer value from a string @ param data The string from which the int should be read @ param data_length Max length of data @ param len Where to put length of the string read in bytes @ return value of the unsigned integer read from the string In case of error , * len is set to 0 static ulonglong0 ;/* A 64-bit value needs at most 10 groups; stop before the shift reaches 64 */ for (length=0 ; data < end && length < 10 ; data++)0 x7f)) << (length * 7 ));if (!((*data) & 0 x80))/* End of data */ return val;/* Something was wrong with data */ 0 ; /* Mark error */ return 0 ;/** Calculate how many bytes needed to store val as unsigned . @ param val The value for which we are calculating length @ return number of bytes ( 0 - 8 ) static size_t dynamic_column_uint_bytes(ulonglong val)for (len= 0 ; val ; val>>= 8 , len++)return len;/** Append the string with given unsigned int value . @ param str The string where to put the value @ param val The value to put in the string @ return ER_DYNCOL_ * return code static enum enum_dyncol_func_resultif (dynstr_realloc(str, 8 )) /* max what we can use */ return ER_DYNCOL_RESOURCE;for (; val; val>>= 8 )char ) (val & 0 xff);return ER_DYNCOL_OK;/** Read unsigned int value of given length from the string @ param store_it_here The structure to store the value @ param data The string which should be read @ param length The length ( in bytes ) of the value in nthe string @ return ER_DYNCOL_ * return code static enum enum_dyncol_func_result0 ;/* an unsigned value occupies at most 8 bytes; reject the rest to keep i*8 < 64 */ if (length > 8 )return ER_DYNCOL_FORMAT;for (i= 0 ; i < length; i++)8 );return ER_DYNCOL_OK;/** Calculate how many bytes needed to store val as signed in following encoding : 0 - > 0 - 1 - > 1 1 - > 2 - 2 - > 3 2 - > 4 . . . @ param val The value for which we are calculating length @ return number of bytes static size_t dynamic_column_sint_bytes(longlong val)return dynamic_column_uint_bytes((((ulonglong) val) << 1 ) ^0 ? 0 xffffffffffffffffull : 0 ));/** Append the string with given signed int value . @ param str the string where to put the value @ param val the value to put in the string @ return ER_DYNCOL_ * return code static enum enum_dyncol_func_resultreturn dynamic_column_uint_store(str,1 ) ^0 ? 0 xffffffffffffffffULL : 0 ));/** Read signed int value of given length from the string @ param store_it_here The structure to store the value @ param data The string which should be read @ param length The length ( in bytes ) of the value in the string @ return ER_DYNCOL_ * return code static enum enum_dyncol_func_resultenum enum_dyncol_func_result rc;if ((rc= dynamic_column_uint_read(store_it_here, data, length)))return rc;if (val & 1 )1 ) ^ 0 xffffffffffffffffULL;else 1 ;return ER_DYNCOL_OK;/** Calculate how many bytes needed to store the value . @ param value The value for which we are calculating length @ return Error : ( size_t ) ~ 0 ok number of bytes static size_tenum enum_dyncol_format format)switch (value->type) {case DYN_COL_NULL:return 0 ;case DYN_COL_INT:return dynamic_column_sint_bytes(value->x.long_value);case DYN_COL_UINT:return dynamic_column_uint_bytes(value->x.ulong_value);case DYN_COL_DOUBLE:return 8 ;case DYN_COL_STRING:return (dynamic_column_var_uint_bytes(value->x.string.charset->number) +case DYN_COL_DECIMAL:int precision= value->x.decimal.value.intg + value->x.decimal.value.frac;int scale= value->x.decimal.value.frac;if (precision == 0 || decimal_is_zero(&value->x.decimal.value))/* This is here to simplify dynamic_column_decimal_store() */ 0 ;return 0 ;/* Check if legal decimal ; This is needed to not get an assert in decimal_bin_size ( ) . However this should be impossible as all decimals entered here should be valid and we have the special check above to handle the unlikely but possible case that decimal . value . intg and decimal . frac is 0 . if (scale < 0 || precision <= 0 )0 ); /* Impossible */ return (size_t) ~0 ;return (dynamic_column_var_uint_bytes(value->x.decimal.value.intg) +case DYN_COL_DATETIME:if (format == dyncol_fmt_num || value->x.time_value.second_part)/* date+time in bits: 14 + 4 + 5 + 10 + 6 + 6 + 20 + 1 66bits ~= 9 bytes*/ return 9 ;else return 6 ;case DYN_COL_DATE:/* date in dits: 14 + 4 + 5 = 23bits ~= 3bytes*/ return 3 ;case DYN_COL_TIME:if (format == dyncol_fmt_num || value->x.time_value.second_part)/* time in bits: 10 + 6 + 6 + 20 + 1 = 43bits ~= 6bytes*/ return 6 ;else return 3 ;case DYN_COL_DYNCOL:return value->x.string.value.length;0 );return 0 ;/** Append double value to a string @ param str the string where to put the value @ param val the value to put in the string @ return ER_DYNCOL_ * return code static enum enum_dyncol_func_resultdouble val)if (dynstr_realloc(str, 8 ))return ER_DYNCOL_RESOURCE;8 ;return ER_DYNCOL_OK;/** Read double value of given length from the string @ param store_it_here The structure to store the value @ param data The string which should be read @ param length The length ( in bytes ) of the value in nthe string @ return ER_DYNCOL_ * return code static enum enum_dyncol_func_resultif (length != 8 )return ER_DYNCOL_FORMAT;return ER_DYNCOL_OK;/** Append the string with given string value . @ param str the string where to put the value @ param val the value to put in the string @ return ER_DYNCOL_ * return code static enum enum_dyncol_func_resultenum enum_dyncol_func_result rc;if ((rc= dynamic_column_var_uint_store(str, charset->number)))return rc;if (dynstr_append_mem(str, string->str, string->length))return ER_DYNCOL_RESOURCE;return ER_DYNCOL_OK;/** Append the string with given string value . @ param str the string where to put the value @ param val the value to put in the string @ return ER_DYNCOL_ * return code static enum enum_dyncol_func_resultif (dynstr_append_mem(str, string->str, string->length))return ER_DYNCOL_RESOURCE;return ER_DYNCOL_OK;/** Read string value of given length from the packed string @ param store_it_here The structure to store the value @ param data The packed string which should be read @ param length The length ( in bytes ) of the value in nthe string @ return ER_DYNCOL_ * return code static enum enum_dyncol_func_resultif (len == 0 ) /* Wrong packed number */ return ER_DYNCOL_FORMAT;if (store_it_here->x.string.charset == NULL)return ER_DYNCOL_UNKNOWN_CHARSET;char *) data;return ER_DYNCOL_OK;/** Read Dynamic columns packet string value of given length from the packed string @ param store_it_here The structure to store the value @ param data The packed string which should be read @ param length The length ( in bytes ) of the value in nthe string @ return ER_DYNCOL_ * return code static enum enum_dyncol_func_resultchar *) data;return ER_DYNCOL_OK;/** Append the string with given decimal value . @ param str the string where to put the value @ param val the value to put in the string @ return ER_DYNCOL_ * return code static enum enum_dyncol_func_resultint precision= value->intg + value->frac;/* Store decimal zero as empty string */ if (precision == 0 )return ER_DYNCOL_OK;if (dynstr_realloc(str, bin_size + 20 ))return ER_DYNCOL_RESOURCE;/* The following can't fail as memory is already allocated */ void ) dynamic_column_var_uint_store(str, value->intg);void ) dynamic_column_var_uint_store(str, value->frac);return ER_DYNCOL_OK;/** Prepare the value to be used as decimal . @ param value The value structure which sould be setup . void mariadb_dyncol_prepare_decimal(DYNAMIC_COLUMN_VALUE *value)/* just to be safe */ void dynamic_column_prepare_decimal(DYNAMIC_COLUMN_VALUE *value)/** Read decimal value of given length from the string @ param store_it_here The structure to store the value @ param data The string which should be read @ param length The length ( in bytes ) of the value in nthe string @ return ER_DYNCOL_ * return code static enum enum_dyncol_func_resultint intg, frac, precision, scale;/* Decimals 0.0 is stored as a zero length string */ if (length == 0 )return ER_DYNCOL_OK; /* value contains zero */ int )dynamic_column_var_uint_get(data, length, &intg_len);int )dynamic_column_var_uint_get(data, length - intg_len, &frac_len);/* Check the size of data is correct */ if (scale < 0 || precision <= 0 || scale > precision ||sizeof (decimal_digit_t)) ||return ER_DYNCOL_FORMAT;if (bin2decimal(data, &store_it_here->x.decimal.value, precision, scale) !=return ER_DYNCOL_FORMAT;return ER_DYNCOL_OK;/** Append the string with given datetime value . @ param str the string where to put the value @ param value the value to put in the string @ return ER_DYNCOL_ * return code static enum enum_dyncol_func_resultenum enum_dyncol_format format)enum enum_dyncol_func_result rc;/* 0 < - - - - year - - - - > < mn > < day > 00000 ! < - hours - - > < min - > < sec - > < - - - microseconds - - - > 12345678901234123412345 1123456789012345612345612345678901234567890 < 123456 > < 123456 > < 123456 > < 123456 > < 123456 > < 123456 > < 123456 > < 123456 > < 123456 > if ((rc= dynamic_column_date_store(str, value)) ||return rc;return ER_DYNCOL_OK;/** Read datetime value of given length from the packed string @ param store_it_here The structure to store the value @ param data The packed string which should be read @ param length The length ( in bytes ) of the value in nthe string @ return ER_DYNCOL_ * return code static enum enum_dyncol_func_resultenum enum_dyncol_func_result rc= ER_DYNCOL_FORMAT;/* 0 < - - - - year - - - - > < mn > < day > 00000 ! < - hours - - > < min - > < sec - > < - - - microseconds - - - > 12345678901234123412345 1123456789012345612345612345678901234567890 < 123456 > < 123456 > < 123456 > < 123456 > < 123456 > < 123456 > < 123456 > < 123456 > < 123456 > if (length != 9 && length != 6 )goto err;if ((rc= dynamic_column_date_read_internal(store_it_here, data, 3 )) ||3 ,3 )))goto err;return ER_DYNCOL_OK;return rc;/** Append the string with given time value . @ param str the string where to put the value @ param value the value to put in the string @ return ER_DYNCOL_ * return code static enum enum_dyncol_func_resultenum enum_dyncol_format format)if (dynstr_realloc(str, 6 ))return ER_DYNCOL_RESOURCE;if (value->time_type == MYSQL_TIMESTAMP_NONE ||0 ;0 ;0 ;0 ;0 ;838 );59 );59 );999999 );if (format == dyncol_fmt_num || value->second_part)/* 00000 ! < - hours - - > < min - > < sec - > < - - - microseconds - - - > 1123456789012345612345612345678901234567890 < 123456 > < 123456 > < 123456 > < 123456 > < 123456 > < 123456 > 0 ]= (value->second_part & 0 xff);1 ]= ((value->second_part & 0 xff00) >> 8 );2 ]= (uchar)(((value->second & 0 xf) << 4 ) |0 xf0000) >> 16 ));3 ]= ((value->minute << 2 ) | ((value->second & 0 x30) >> 4 ));4 ]= (value->hour & 0 xff);5 ]= ((value->neg ? 0 x4 : 0 ) | (value->hour >> 8 ));6 ;else /* ! < - hours - - > < min - > < sec - > 11234567890123456123456 < 123456 > < 123456 > < 123456 > 0 ]= (value->second) | ((value->minute & 0 x3) << 6 );1 ]= (value->minute >> 2 ) | ((value->hour & 0 xf) << 4 );2 ]= (value->hour >> 4 ) | (value->neg ? 0 x80 : 0 );3 ;return ER_DYNCOL_OK;/** Read time value of given length from the packed string @ param store_it_here The structure to store the value @ param data The packed string which should be read @ param length The length ( in bytes ) of the value in nthe string @ return ER_DYNCOL_ * return code static enum enum_dyncol_func_result0 ;return dynamic_column_time_read_internal(store_it_here, data, length);/** Internal function for reading time part from the string . @ param store_it_here The structure to store the value @ param data The packed string which should be read @ param length The length ( in bytes ) of the value in nthe string @ return ER_DYNCOL_ * return code static enum enum_dyncol_func_resultif (length != 6 && length != 3 )goto err;if (length == 6 )/* 00000 ! < - hours - - > < min - > < sec - > < - - - microseconds - - - > 1123456789012345612345612345678901234567890 < 123456 > < 123456 > < 123456 > < 123456 > < 123456 > < 123456 > 0 ] |1 ] << 8 ) |2 ] & 0 xf) << 16 ));2 ] >> 4 ) |3 ] & 0 x3) << 4 ));3 ] >> 2 );5 ]) & 0 x3 ) << 8 ) | data[4 ]);5 ] & 0 x4) ? 1 : 0 );else /* ! < - hours - - > < min - > < sec - > 11234567890123456123456 < 123456 > < 123456 > < 123456 > 0 ;0 ] & 0 x3f);0 ] >> 6 ) | ((data[1 ] & 0 xf) << 2 );1 ] >> 4 ) | ((data[2 ] & 0 x3f) << 4 );2 ] & 0 x80) ? 1 : 0 );if (store_it_here->x.time_value.second > 59 ||59 ||838 ||999999 )goto err;return ER_DYNCOL_OK;return ER_DYNCOL_FORMAT;/** Append the string with given date value . @ param str the string where to put the value @ param value the value to put in the string @ return ER_DYNCOL_ * return code static enum enum_dyncol_func_resultif (dynstr_realloc(str, 3 ))return ER_DYNCOL_RESOURCE;if (value->time_type == MYSQL_TIMESTAMP_NONE ||0 ;9999 );12 );31 );/* 0 < - - - - year - - - - > < mn > < day > 012345678901234123412345 < 123456 > < 123456 > < 123456 > 0 ]= (value->day |0 x7) << 5 ));1 ]= ((value->month >> 3 ) | ((value->year & 0 x7F) << 1 ));2 ]= (value->year >> 7 );3 ;return ER_DYNCOL_OK;/** Read date value of given length from the packed string @ param store_it_here The structure to store the value @ param data The packed string which should be read @ param length The length ( in bytes ) of the value in nthe string @ return ER_DYNCOL_ * return code static enum enum_dyncol_func_result0 ;0 ;0 ;0 ;0 ;return dynamic_column_date_read_internal(store_it_here, data, length);/** Internal function for reading date part from the string . @ param store_it_here The structure to store the value @ param data The packed string which should be read @ param length The length ( in bytes ) of the value in nthe string @ return ER_DYNCOL_ * return code static enum enum_dyncol_func_resultif (length != 3 )goto err;/* 0 < - - - - year - - - - > < mn > < day > 12345678901234123412345 < 123456 > < 123456 > < 123456 > 0 ] & 0 x1f);1 ] & 0 x1) << 3 ) |0 ] >> 5 ));2 ]) << 7 ) |1 ] >> 1 ));if (store_it_here->x.time_value.day > 31 ||12 ||9999 )goto err;return ER_DYNCOL_OK;return ER_DYNCOL_FORMAT;/** Append the string with given value . @ param str the string where to put the value @ param value the value to put in the string @ return ER_DYNCOL_ * return code static enum enum_dyncol_func_resultenum enum_dyncol_format format)switch (value->type) {case DYN_COL_INT:return dynamic_column_sint_store(str, value->x.long_value);case DYN_COL_UINT:return dynamic_column_uint_store(str, value->x.ulong_value);case DYN_COL_DOUBLE:return dynamic_column_double_store(str, value->x.double_value);case DYN_COL_STRING:return dynamic_column_string_store(str, &value->x.string.value,case DYN_COL_DECIMAL:return dynamic_column_decimal_store(str, &value->x.decimal.value);case DYN_COL_DATETIME:/* date+time in bits: 14 + 4 + 5 + 5 + 6 + 6 40bits = 5 bytes */ return dynamic_column_date_time_store(str, &value->x.time_value, format);case DYN_COL_DATE:/* date in dits: 14 + 4 + 5 = 23bits ~= 3bytes*/ return dynamic_column_date_store(str, &value->x.time_value);case DYN_COL_TIME:/* time in bits: 5 + 6 + 6 = 17bits ~= 3bytes*/ return dynamic_column_time_store(str, &value->x.time_value, format);case DYN_COL_DYNCOL:return dynamic_column_dyncol_store(str, &value->x.string.value);case DYN_COL_NULL:break ; /* Impossible */ 0 );return ER_DYNCOL_OK; /* Impossible */ /** Write information to the fixed header @ param str String where to write the header @ param offset_size Size of offset field in bytes @ param column_count Number of columns static void set_fixed_header(DYNAMIC_COLUMN *str,0 xffff);0 ]= ((str->str[0 ] & ~DYNCOL_FLG_OFFSET) |1 )); /* size of offset */ 1 , column_count); /* columns number */ 0 ] & (~DYNCOL_FLG_KNOWN)) == 0 );/** Adds columns into the empty string @ param str String where to write the data ( the record ) @ param hdr Dynamic columns record descriptor @ param column_count Number of columns in the arrays @ param column_keys Array of columns keys ( uint or LEX_STRING ) @ param values Array of columns values @ param new_str True if we need to allocate new string @ return ER_DYNCOL_ * return code static enum enum_dyncol_func_resultvoid *column_keys,struct st_service_funcs *fmt= fmt_data + hdr->format;void **UNINIT_VAR(columns_order);enum enum_dyncol_func_result rc= ER_DYNCOL_RESOURCE;if (column_count && !(columns_order= malloc(sizeof (void *)*column_count)))return ER_DYNCOL_RESOURCE;if (new_str || str->str == 0 )if (column_count)if (dynamic_column_init_named(str,goto err;else else 0 ;if (dynstr_realloc(str,goto err;if (!column_count)return ER_DYNCOL_OK;/* sort columns for the header */ for (i= 0 , element= (uchar *) column_keys;void *)element;sizeof (void *), fmt->column_sort);/* For now we don ' t allow creating two columns with the same number at the time of create . This can be fixed later to just use the later by comparing the pointers . for (i= 0 ; i < column_count - 1 ; i++)if ((*fmt->check_limit)(&columns_order[i]) ||1 ]) == 0 )goto err;if ((*fmt->check_limit)(&columns_order[i]))goto err;/* reserve place for header and name pool */ for (i= 0 ; i < column_count; i++)if (values[ord].type != DYN_COL_NULL)/* Store header first in the str */ if ((*fmt->put_header_entry)(hdr, columns_order[i], values + ord,goto err;/* Store value in 'str + str->length' and increase str->length */ if ((rc= data_store(str, values + ord, hdr->format)))goto err;return rc;/** Calculate size of header , name pool and data pool @ param hdr descriptor of dynamic column record @ param column_count number of elements in arrays @ param column_count Number of columns in the arrays @ param column_keys Array of columns keys ( uint or LEX_STRING ) @ param values Array of columns values @ return ER_DYNCOL_ * return code static enum enum_dyncol_func_resultvoid *column_keys,struct st_service_funcs *fmt= fmt_data + hdr->format;0 ;0 ;for (i= 0 ; i < column_count; i++)if (values[i].type != DYN_COL_NULL)if (tmp == (size_t) ~0 )return ER_DYNCOL_DATA;/* We can handle data up to 0 x1fffffff ( old format ) and 0 xfffffffff ( new format ) bytes now . if ((hdr->offset_size= fmt->dynamic_column_offset_bytes(hdr->data_size)) >=return ER_DYNCOL_LIMIT;/* header entry is column number or string pointer + offset & type */ return ER_DYNCOL_OK;/** Create packed string which contains given columns ( internal multi format ) @ param str String where to write the data @ param column_count Number of columns in the arrays @ param column_keys Array of columns keys ( format dependent ) @ param values Array of columns values @ param new_str True if we need allocate new string @ param string_keys keys are strings @ return ER_DYNCOL_ * return code static enum enum_dyncol_func_resultvoid *column_keys,enum enum_dyncol_func_result rc;sizeof (header));1 : 0 );if (new_str)/* to make dynstr_free() working in case of errors */ if ((rc= calc_var_sizes(&header, column_count, column_keys, values)) < 0 )return rc;return dynamic_new_column_store(str, &header,/** Create packed string which contains given columns @ param str String where to write the data @ param column_count Number of columns in the arrays @ param column_numbers Array of columns numbers @ param values Array of columns values @ return ER_DYNCOL_ * return code enum enum_dyncol_func_result"dynamic_column_create_many" );TRUE , FALSE ));/** Create packed string which contains given columns @ param str String where to write the data @ param column_count Number of columns in the arrays @ param column_numbers Array of columns numbers @ param values Array of columns values @ param new_string True if we need allocate new string @ return ER_DYNCOL_ * return code enum enum_dyncol_func_result"mariadb_dyncol_create_many_num" );FALSE ));/** Create packed string which contains given columns @ param str String where to write the data @ param column_count Number of columns in the arrays @ param column_keys Array of columns keys @ param values Array of columns value @ param new_string True if we need allocate new string @ return ER_DYNCOL_ * return code enum enum_dyncol_func_result"mariadb_dyncol_create_many_named" );TRUE ));/** Create packed string which contains given column @ param str String where to write the data @ param column_number Column number @ param value The columns value @ return ER_DYNCOL_ * return code enum enum_dyncol_func_result"dynamic_column_create" );1 , &column_nr, value));/** Calculate length of data between given two header entries @ param entry Pointer to the first entry @ param entry_next Pointer to the last entry @ param header_end Pointer to the header end @ param offset_size Size of offset field in bytes @ param last_offset Size of the data segment @ return number of bytes static size_t get_length_interval(uchar *entry, uchar *entry_next,if (type_and_offset_read_num(&type, &offset, entry + COLUMN_NUMBER_SIZE,return DYNCOL_OFFSET_ERROR;if (entry_next >= header_end)return (last_offset - offset);if (type_and_offset_read_num(&type_next, &offset_next,return DYNCOL_OFFSET_ERROR;return (offset_next - offset);/** Calculate length of data between given hdr - > entry and next_entry @ param hdr descriptor of dynamic column record @ param next_entry next header entry ( can point just after last header entry ) @ return number of bytes static size_t hdr_interval_length(DYN_HEADER *hdr, uchar *next_entry)struct st_service_funcs *fmt= fmt_data + hdr->format;if ((*fmt->type_and_offset_read)(&hdr->type, &hdr->offset,return DYNCOL_OFFSET_ERROR;if (next_entry == hdr->header + hdr->header_size)return hdr->data_size - hdr->offset;if ((*fmt->type_and_offset_read)(&next_entry_type, &next_entry_offset,return DYNCOL_OFFSET_ERROR;return (next_entry_offset - hdr->offset);/** Comparator function for references to header entries for qsort static int header_compar_num(const void *a, const void *b)return (va > vb ? 1 : (va < vb ? -1 : 0 ));/** Find entry in the numeric format header by the column number @ param hdr descriptor of dynamic column record @ param key number to find @ return pointer to the entry or NULL static uchar *find_entry_num(DYN_HEADER *hdr, uint key)2 +4 ];return hdr->entry= bsearch(header_entry, hdr->header,/** Read name from header entry @ param hdr descriptor of dynamic column record @ param entry pointer to the header entry @ param name where to put name @ return 0 ok @ return 1 error in data static my_bool read_name(DYN_HEADER *hdr, uchar *entry, LEX_STRING *name)if (nmoffset > hdr->nmpool_size)return 1 ;char *)hdr->nmpool + nmoffset;if (next_entry == hdr->header + hdr->header_size)else if (next_nmoffset > hdr->nmpool_size || next_nmoffset < nmoffset)return 1 ;return 0 ;/** Find entry in the names format header by the column number @ param hdr descriptor of dynamic column record @ param key name to find @ return pointer to the entry or NULL static uchar *find_entry_named(DYN_HEADER *hdr, LEX_STRING *key)1 ) * hdr->entry_size;while (max >= min)int cmp;2 /if (read_name(hdr, mid, &name))return NULL;if (cmp < 0 )else if (cmp > 0 )else return mid;return NULL;/** Write number in the buffer ( backward direction - starts from the buffer end ) @ return pointer on the number beginning static char *backwritenum(char *chr, uint numkey)if (numkey == 0 )'0' ;else while (numkey > 0 )'0' + numkey % 10 ;10 ;return chr;/** Find column and fill information about it @ param hdr descriptor of dynamic column record @ param numkey Number of the column to fetch ( if strkey is NULL ) @ param strkey Name of the column to fetch ( or NULL ) @ return 0 ok @ return 1 error in data static my_boolchar nmkeybuff[DYNCOL_NUM_CHAR]; /* to fit max 2 bytes number */ if (hdr->header + hdr->header_size > hdr->data_end)return TRUE ;/* fix key */ if (hdr->format == dyncol_fmt_num && strkey != NULL)char *end;10 );if (end != strkey->str + strkey->length)/* we can't find non-numeric key among numeric ones */ return 0 ;else if (hdr->format == dyncol_fmt_str && strkey == NULL)sizeof (nmkeybuff), numkey);sizeof (nmkeybuff)) - nmkey.str;if (hdr->format == dyncol_fmt_num)else if (!hdr->entry)/* Column not found */ return 0 ;/* Check that the found data is within the ranges . This can happen if we get data with wrong offsets . if (hdr->length == DYNCOL_OFFSET_ERROR ||return 1 ;return 0 ;/** Read and check the header of the dynamic string @ param hdr descriptor of dynamic column record @ param str Dynamic string @ retval FALSE OK @ retval TRUE error Note We don ' t check for str - > length = = 0 as all code that calls this already have handled this case . static inline my_bool read_fixed_header(DYN_HEADER *hdr,0 );if ((str->length < 1 ) ||0 ] & (~DYNCOL_FLG_KNOWN)))return 1 ;0 ] & DYNCOL_FLG_NAMES) ?if ((str->length < fmt_data[hdr->format].fixed_hdr))return 1 ; /* Wrong header */ 0 ] & DYNCOL_FLG_OFFSET) + 1 +1 : 0 );1 );if (hdr->format == dyncol_fmt_str)3 ); // only 2 bytes supported for now else 0 ;return 0 ;/** Get dynamic column value by column number @ param str The packed string to extract the column @ param column_nr Number of column to fetch @ param store_it_here Where to store the extracted value @ return ER_DYNCOL_ * return code enum enum_dyncol_func_resultreturn dynamic_column_get_internal(str, store_it_here, column_nr, NULL);enum enum_dyncol_func_resultreturn dynamic_column_get_internal(str, store_it_here, column_nr, NULL);/** Get dynamic column value by name @ param str The packed string to extract the column @ param name Name of column to fetch @ param store_it_here Where to store the extracted value @ return ER_DYNCOL_ * return code enum enum_dyncol_func_resultreturn dynamic_column_get_internal(str, store_it_here, 0 , name);static enum enum_dyncol_func_resultstatic enum enum_dyncol_func_result rc;switch ((store_it_here->type= hdr->type)) {case DYN_COL_INT:break ;case DYN_COL_UINT:break ;case DYN_COL_DOUBLE:break ;case DYN_COL_STRING:break ;case DYN_COL_DECIMAL:break ;case DYN_COL_DATETIME:break ;case DYN_COL_DATE:break ;case DYN_COL_TIME:break ;case DYN_COL_NULL:break ;case DYN_COL_DYNCOL:break ;default :break ;return rc;/** Get dynamic column value by number or name @ param str The packed string to extract the column @ param store_it_here Where to store the extracted value @ param numkey Number of the column to fetch ( if strkey is NULL ) @ param strkey Name of the column to fetch ( or NULL ) @ return ER_DYNCOL_ * return code static enum enum_dyncol_func_resultenum enum_dyncol_func_result rc= ER_DYNCOL_FORMAT;sizeof (header));if (str->length == 0 )goto null;if ((rc= init_read_hdr(&header, str)) < 0 )goto err;if (header.column_count == 0 )goto null;if (find_column(&header, num_key, str_key))goto err;return rc;return rc;/** Check existence of the column in the packed string ( by number ) @ param str The packed string to check the column @ param column_nr Number of column to check @ return ER_DYNCOL_ * return code enum enum_dyncol_func_resultreturn dynamic_column_exists_internal(str, column_nr, NULL);enum enum_dyncol_func_resultreturn dynamic_column_exists_internal(str, column_nr, NULL);/** Check existence of the column in the packed string ( by name ) @ param str The packed string to check the column @ param name Name of column to check @ return ER_DYNCOL_ * return code enum enum_dyncol_func_resultreturn dynamic_column_exists_internal(str, 0 , name);/** Check existence of the column in the packed string ( by name of number ) @ param str The packed string to check the column @ param num_key Number of the column to fetch ( if strkey is NULL ) @ param str_key Name of the column to fetch ( or NULL ) @ return ER_DYNCOL_ * return code static enum enum_dyncol_func_resultenum enum_dyncol_func_result rc;sizeof (header));if (str->length == 0 )return ER_DYNCOL_NO; /* no columns */ if ((rc= init_read_hdr(&header, str)) < 0 )return rc;if (header.column_count == 0 )return ER_DYNCOL_NO; /* no columns */ if (find_column(&header, num_key, str_key))return ER_DYNCOL_FORMAT;return (header.type != DYN_COL_NULL ? ER_DYNCOL_YES : ER_DYNCOL_NO);/** List not - null columns in the packed string ( only numeric format ) @ param str The packed string @ param array_of_uint Where to put reference on created array @ return ER_DYNCOL_ * return code enum enum_dyncol_func_resultenum enum_dyncol_func_result rc;sizeof (*array_of_uint)); /* In case of errors */ if (str->length == 0 )return ER_DYNCOL_OK; /* no columns */ if ((rc= init_read_hdr(&header, str)) < 0 )return rc;if (header.format != dyncol_fmt_num)return ER_DYNCOL_FORMAT;if (header.entry_size * header.column_count + FIXED_HEADER_SIZE >return ER_DYNCOL_FORMAT;if (my_init_dynamic_array(PSI_INSTRUMENT_ME, array_of_uint,sizeof (uint), header.column_count, 0 , MYF(0 )))return ER_DYNCOL_RESOURCE;for (i= 0 , read= header.header;/* Insert can't never fail as it's pre-allocated above */ void ) insert_dynamic(array_of_uint, (uchar *)&nm);return ER_DYNCOL_OK;/** List not - null columns in the packed string ( only numeric format ) @ param str The packed string @ param array_of_uint Where to put reference on created array @ return ER_DYNCOL_ * return code enum enum_dyncol_func_resultenum enum_dyncol_func_result rc;0 ; (*count)= 0 ; /* In case of errors */ if (str->length == 0 )return ER_DYNCOL_OK; /* no columns */ if ((rc= init_read_hdr(&header, str)) < 0 )return rc;if (header.format != dyncol_fmt_num)return ER_DYNCOL_FORMAT;if (header.entry_size * header.column_count + FIXED_HEADER_SIZE >return ER_DYNCOL_FORMAT;if (!((*nums)= my_malloc(PSI_INSTRUMENT_ME, sizeof (uint) * header.column_count, MYF(0 ))))return ER_DYNCOL_RESOURCE;for (i= 0 , read= header.header;return ER_DYNCOL_OK;/** List not - null columns in the packed string ( any format ) @ param str The packed string @ param count Number of names in the list @ param names Where to put names list ( should be freed ) @ return ER_DYNCOL_ * return code enum enum_dyncol_func_resultchar *pool;struct st_service_funcs *fmt;enum enum_dyncol_func_result rc;0 ; (*count)= 0 ;if (str->length == 0 )return ER_DYNCOL_OK; /* no columns */ if ((rc= init_read_hdr(&header, str)) < 0 )return rc;if (header.entry_size * header.column_count + fmt->fixed_hdr >return ER_DYNCOL_FORMAT;if (header.format == dyncol_fmt_num)else sizeof (LEX_STRING) * header.column_count + size, MYF(0 ));if (!(*names))return ER_DYNCOL_RESOURCE;char *)(*names)) + sizeof (LEX_STRING) * header.column_count;for (i= 0 , read= header.header;if (header.format == dyncol_fmt_num)10 ) - (*names)[i].str;else if (read_name(&header, read, &tmp))return ER_DYNCOL_FORMAT;1 ;const void *)tmp.str, tmp.length);'\0' ; // just for safety return ER_DYNCOL_OK;/** Find the place of the column in the header or place where it should be put @ param hdr descriptor of dynamic column record @ param key Name or number of column to fetch ( depends on string_key ) @ param string_key True if we gave pointer to LEX_STRING . @ retval TRUE found @ retval FALSE pointer set to the next row static my_boolvoid *key, my_bool string_keys)int UNINIT_VAR(flag);char buff[DYNCOL_NUM_CHAR];/* new format can't be numeric if the old one is names */ 0 ;1 ;1 ;while (start != end)2 ;if (!string_keys)else if (need_conversion)sizeof (buff), uint2korr(hdr->entry));sizeof (buff)) - str.str;else if (read_name(hdr, hdr->entry, &str))return 0 ;if (flag <= 0 )else 1 ;if (start != mid)if (!string_keys)else if (need_conversion)sizeof (buff), uint2korr(hdr->entry));sizeof (buff)) - str.str;else if (read_name(hdr, hdr->entry, &str))return 0 ;if (flag > 0 )/* Point at next bigger key */ return flag == 0 ;/* It is internal structure which describes a plan of changing the record of dynamic columns typedef enum {PLAN_REPLACE, PLAN_ADD, PLAN_DELETE, PLAN_NOP} PLAN_ACT;struct st_plan {void *key;long long hdelta, ddelta, ndelta;long long mv_offset, mv_length;typedef struct st_plan PLAN;/** Sort function for plan by column number static int plan_sort_num(const void *a, const void *b)return *((uint *)((PLAN *)a)->key) - *((uint *)((PLAN *)b)->key);/** Sort function for plan by column name static int plan_sort_named(const void *a, const void *b)return mariadb_dyncol_column_cmp_named((LEX_STRING *)((PLAN *)a)->key,#define DELTA_CHECK(S, D, C) \if ((S) == 0 ) \else if (((S) > 0 && (D) < 0 ) || \0 && (D) > 0 )) \TRUE ; \/** Update dynamic column by copying in a new record ( string ) . @ param str Dynamic column record to change @ param plan Plan of changing the record @ param add_column_count number of records in the plan array . @ param hdr descriptor of old dynamic column record @ param new_hdr descriptor of new dynamic column record @ param convert need conversion from numeric to names format @ return ER_DYNCOL_ * return code static enum enum_dyncol_func_resultstruct st_service_funcs *fmt= fmt_data + hdr->format,if (dynamic_column_init_named(&tmp,return ER_DYNCOL_RESOURCE;/* Adjust tmp to contain whole the future header */ /* Copy data to the new string i = index in array of changes j = index in packed string header index for (i= 0 , j= 0 ; i < add_column_count || j < hdr->column_count; i++)/* Search in i and j for the next column to add from i and where to add . while (i < add_column_count && plan[i].act == PLAN_NOP)/* skip NOP */ if (i == add_column_count)else /* old data portion . We don ' t need to check that j < column_count as plan [ i ] . place is guaranteed to have a pointer inside the data . while (hdr->header + j * hdr->entry_size < plan[i].place)if ((plan[i].act == PLAN_REPLACE || plan[i].act == PLAN_DELETE))/* data at 'j' will be removed */ /* Adjust all headers since last loop . We have to do this as the offset for data has moved for (k= start; k < end; k++)void *key;char buff[DYNCOL_NUM_CHAR];if (hdr->format == dyncol_fmt_num)if (convert)sizeof (buff), uint2korr(read));sizeof (buff)) - name.str;else /* Column nummber */ else if (read_name(hdr, read, &name))goto err;if (fmt->type_and_offset_read(&tp, &offs,goto err;if (k == start)else if (offs < first_offset)goto err;// only the type used in the header if ((*new_fmt->put_header_entry)(new_hdr, key, &val, offs))goto err;/* copy first the data that was not replaced in original packed data */ if (start < end)/* Add old data last in 'tmp' */ if (data_size == DYNCOL_OFFSET_ERROR ||long ) data_size < 0 ||goto err;char *)hdr->dtpool + first_offset,/* new data adding */ if (i < add_column_count)if ( plan[i].act == PLAN_ADD || plan[i].act == PLAN_REPLACE)if ((*new_fmt->put_header_entry)(new_hdr, plan[i].key,goto err;/* Append new data */ return ER_DYNCOL_OK;return ER_DYNCOL_FORMAT;static enum enum_dyncol_func_resultif (!new_column_count)// No records left 0 );return ER_DYNCOL_OK;/* Move headers first . i = index in array of changes j = index in packed string header index for (curr_offset= 0 , i= 0 , j= 0 ;/* Search in i and j for the next column to add from i and where to add . while (i < add_column_count && plan[i].act == PLAN_NOP)/* skip NOP */ if (i == add_column_count)else /* old data portion . We don ' t need to check that j < column_count as plan [ i ] . place is guaranteed to have a pointer inside the data . while (header_base + j * entry_size < plan[i].place)if ((plan[i].act == PLAN_REPLACE || plan[i].act == PLAN_DELETE))/* data at 'j' will be removed */ if (type_and_offset_read_num(&tp, &first_offset,return ER_DYNCOL_FORMAT;/* find data to be moved */ if (start < end)if (data_size == DYNCOL_OFFSET_ERROR ||long ) data_size < 0 ||0 ; // just something valid return ER_DYNCOL_FORMAT;else 0 ;if (plan[i].ddelta == 0 && offset_size == new_offset_size &&else /* Adjust all headers since last loop . We have to do this as the offset for data has moved for (k= start; k < end; k++)/* Column nummber */ if (type_and_offset_read_num(&tp, &offs, read + COLUMN_NUMBER_SIZE,return ER_DYNCOL_FORMAT;if (k > start && offs < first_offset)0 ; // just something valid return ER_DYNCOL_FORMAT;/* write rest of data at write + COLUMN_NUMBER_SIZE */ /* new data adding */ if (i < add_column_count)if ( plan[i].act == PLAN_ADD || plan[i].act == PLAN_REPLACE)0 ].type,/* Move data . i = index in array of changes j = index in packed string header index for (i= 0 , j= 0 ;/* Search in i and j for the next column to add from i and where to add . while (i < add_column_count && plan[i].act == PLAN_NOP)/* skip NOP */ if (i != add_column_count &&/* copy first the data that was not replaced in original packed data */ if (start < end && plan[i].mv_length)/* new data adding */ if (i < add_column_count)if ( plan[i].act == PLAN_ADD || plan[i].act == PLAN_REPLACE)/* Append new data */ return ER_DYNCOL_OK;#ifdef UNUSEDstatic enum enum_dyncol_func_result/* Move data first . i = index in array of changes j = index in packed string header index for (curr_offset= 0 , i= 0 , j= 0 ;/* Search in i and j for the next column to add from i and where to add . while (i < add_column_count && plan[i].act == PLAN_NOP)/* skip NOP */ if (i == add_column_count)else /* old data portion . We don ' t need to check that j < column_count as plan [ i ] . place is guaranteed to have a pointer inside the data . while (header_base + j * entry_size < plan[i].place)if ((plan[i].act == PLAN_REPLACE || plan[i].act == PLAN_DELETE))/* data at 'j' will be removed */ /* find data to be moved */ if (start < end)if (data_size == DYNCOL_OFFSET_ERROR ||long ) data_size < 0 ||0 ; // just something valid return ER_DYNCOL_FORMAT;else 0 ;if (plan[i].ddelta == 0 && offset_size == new_offset_size &&else /* Adjust all headers since last loop . We have to do this as the offset for data has moved for (k= start; k < end; k++)/* Column nummber */ if (k > start && offs < first_offset)0 ; // just something valid return ER_DYNCOL_FORMAT;/* write rest of data at write + COLUMN_NUMBER_SIZE */ if (type_and_offset_store_num(write, new_offset_size, tp, offs))0 ; // just something valid return ER_DYNCOL_FORMAT;/* new data adding */ if (i < add_column_count)if ( plan[i].act == PLAN_ADD || plan[i].act == PLAN_REPLACE)if (type_and_offset_store_num(write, new_offset_size,0 ].type,0 ; // just something valid return ER_DYNCOL_FORMAT;/* Move headers . i = index in array of changes j = index in packed string header index for (i= 0 , j= 0 ;/* Search in i and j for the next column to add from i and where to add . while (i < add_column_count && plan[i].act == PLAN_NOP)/* skip NOP */ if (i != add_column_count &&/* copy first the data that was not replaced in original packed data */ if (start < end && plan[i].mv_length)/* new data adding */ if (i < add_column_count)if ( plan[i].act == PLAN_ADD || plan[i].act == PLAN_REPLACE)/* Append new data */ return ER_DYNCOL_OK;#endif /** Update the packed string with the given columns @ param str String where to write the data @ param add_column_count Number of columns in the arrays @ param column_numbers Array of columns numbers @ param values Array of columns values @ return ER_DYNCOL_ * return code /* plan allocated on the stack */ #define IN_PLACE_PLAN 4 enum enum_dyncol_func_resultreturn dynamic_column_update_many_fmt(str, add_column_count, column_numbers,FALSE );enum enum_dyncol_func_resultreturn dynamic_column_update_many_fmt(str, add_column_count, column_numbers,FALSE );enum enum_dyncol_func_resultreturn dynamic_column_update_many_fmt(str, add_column_count, column_names,TRUE );static uint numlen(uint val)if (val == 0 )return 1 ;0 ;while (val)10 ;return res;static enum enum_dyncol_func_resultvoid *column_keys,struct st_service_funcs *fmt, *new_fmt;long long data_delta= 0 , name_delta= 0 ;long long header_delta= 0 ;long long header_delta_sign, data_delta_sign;int copy= FALSE ;enum enum_dyncol_func_result rc;if (add_column_count == 0 )return ER_DYNCOL_OK;sizeof (header));sizeof (new_header));/* Get columns in column order . As the data in ' str ' is already in column order this allows to replace all columns in one loop . if (IN_PLACE_PLAN > add_column_count)else if (!(alloc_plan= plan=sizeof (PLAN) * (add_column_count + 1 ), MYF(0 ))))return ER_DYNCOL_RESOURCE;for (i= 0 , element= (uchar *) column_keys;if ((*new_fmt->check_limit)(&element))goto end;if (values[i].type == DYN_COL_NULL)if (str->length == 0 )/* Just add new columns . If there was no columns to add we return an empty string . goto create_new_string;/* Check that header is ok */ if ((rc= init_read_hdr(&header, str)) < 0 )goto end;/* new format can't be numeric if the old one is names */ if (header.column_count == 0 )goto create_new_string;sizeof (PLAN), new_fmt->plan_sort);if ((convert= (new_header.format == dyncol_fmt_str &&0 );for (i= 0 , header.entry= header.header;if (fmt->fixed_hdr + header.header_size + header.nmpool_size > str->length)goto end;/* Calculate how many columns and data is added / deleted and make a ' plan ' for each of them . for (i= 0 ; i < add_column_count; i++)/* For now we don ' t allow creating two columns with the same number at the time of create . This can be fixed later to just use the later by comparing the pointers . if (i < add_column_count - 1 &&1 ].key) == 0 )goto end;/* Set common variables for all plans */ /* get header delta in entries */ 0 ; /* Length if NULL */ if (find_place(&header, plan[i].key, string_keys))0 ;/* Data existed; We have to replace or delete it */ if (entry_data_size == DYNCOL_OFFSET_ERROR ||long ) entry_data_size < 0 )goto end;if (new_header.format == dyncol_fmt_str)if (header.format == dyncol_fmt_str)if (read_name(&header, header.entry, &name))goto end;else if (plan[i].val->type == DYN_COL_NULL)/* Inserting a NULL means delete the old data */ /* Remove old value */ /* One row less in header */ /* Less data to store */ else /* Replace the value */ /* get data delta in bytes */ if ((plan[i].length= dynamic_column_value_len(plan[i].val,0 )goto end;if (new_header.format == dyncol_fmt_str)else /* Data did not exists. Add if it it's not NULL */ if (plan[i].val->type == DYN_COL_NULL)/* Mark entry to be skipped */ else /* Add new value */ /* One more row in header */ /* get data delta in bytes */ if ((plan[i].length= dynamic_column_value_len(plan[i].val,0 )goto end;if (new_header.format == dyncol_fmt_str)/* Check if it is only " increasing " or only " decreasing " plan for ( header and data separately ) . 0 );if ((new_header.offset_size=goto end;/* if (new_header.offset_size!=offset_size) then we have to rewrite header */ int )new_header.offset_size + new_fmt->fixed_hdr_entry) -int )header.offset_size + fmt->fixed_hdr_entry);0 ;// plan[add_column_count] contains last deltas. for (i= 0 ; i <= add_column_count && !copy; i++)/* This is the check for increasing/decreasing */ /* Need copy because : 1 , Header / data parts moved in different directions . 2 . There is no enough allocated space in the string . 3 . Header and data moved in different directions . if (copy || /*1.*/ /*2.*/ 0 && data_delta_sign > 0 ) ||0 && data_delta_sign < 0 ))) /*3.*/ else if (header_delta_sign < 0 )else /* rc = dynamic_column_update_move_right ( str , plan , offset_size , entry_size , header_size , new_header . offset_size , new_header . entry_size , new_header . header_size , column_count , new_header . column_count , add_column_count , header_end , header . data_size ) ; return rc;/* There is no columns from before, so let's just add the new ones */ if (not_null != 0 )goto end;/** Update the packed string with the given column @ param str String where to write the data @ param column_number Array of columns number @ param values Array of columns values @ return ER_DYNCOL_ * return code enum enum_dyncol_func_resultreturn dynamic_column_update_many(str, 1 , &column_nr, value);enum enum_dyncol_func_resultstruct st_service_funcs *fmt;enum enum_dyncol_func_result rc= ER_DYNCOL_FORMAT;0 , name_offset= 0 ;0 , prev_name_offset= 0 ;0 ,0 }, prev_name= {0 ,0 };0 , prev_num= 0 ;void *key, *prev_key;enum enum_dynamic_column_type type= DYN_COL_NULL, prev_type= DYN_COL_NULL;"dynamic_column_check" );if (str->length == 0 )"info" , ("empty string is OK" ));sizeof (header));/* Check that header is OK */ if (read_fixed_header(&header, str))"info" , ("Reading fixed string header failed" ));goto end;/* headers are out of string length (no space for data and part of headers) */ if (fmt->fixed_hdr + header.header_size + header.nmpool_size > str->length)"info" , ("Fixed header: %u Header size: %u " "Name pool size: %u but String length: %u" ,goto end;/* read and check headers */ if (header.format == dyncol_fmt_num)else for (i= 0 , header.entry= header.header;if (header.format == dyncol_fmt_num)else if (read_name(&header, header.entry, &name))"info" , ("Reading name failed: Field order: %u" " Name offset: %u" " Name pool size: %u" ,goto end;char *)header.nmpool;if ((*fmt->type_and_offset_read)(&type, &data_offset,goto end;if (data_offset > header.data_size)"info" , ("Field order: %u Data offset: %u" " > Data pool size: %u" ,goto end;if (prev_type != DYN_COL_NULL)/* It is not first entry */ if (prev_data_offset > data_offset ||"info" , ("Field order: %u Previous data offset: %u" " >(=) Current data offset: %u" ,goto end;if (prev_name_offset > name_offset)"info" , ("Field order: %u Previous name offset: %u" " > Current name offset: %u" ,goto end;if ((*fmt->column_sort)(&prev_key, &key) >= 0 )"info" , ("Field order: %u Previous key >= Current key" ,goto end;/* check data, which we can */ for (i= 0 , header.entry= header.header;// already checked by previous pass switch ((header.type)) {case DYN_COL_INT:break ;case DYN_COL_UINT:break ;case DYN_COL_DOUBLE:break ;case DYN_COL_STRING:break ;case DYN_COL_DECIMAL:break ;case DYN_COL_DATETIME:break ;case DYN_COL_DATE:break ;case DYN_COL_TIME:break ;case DYN_COL_DYNCOL:break ;case DYN_COL_NULL:default :goto end;if (rc != ER_DYNCOL_OK)0 );"info" , ("Field order: %u Can't read data: %i" ,int ) rc));goto end;static const char *append, size_t len)6 ) ?10 );if (dynstr_realloc(str, len + additional + 2 ))return TRUE ;'"' ;for (i= 0 ; i < len; i++)register char c= append[i];if (unlikely(((uchar)c) <= 0 x1F))if (lim < 6 )if (dynstr_realloc(str, additional))return TRUE ;6 ;'\\' ;'u' ;'0' ;'0' ;0 x10 ? '0' : '1' );0 x10;0 xA ? '0' + c : 'A' + (c - 0 xA));else if (lim < 2 )if (dynstr_realloc(str, additional))return TRUE ;if (c == '"' || c == '\\' )'\\' ;'"' ;return FALSE ;enum enum_dyncol_func_resultchar quote)char buff[40 ];switch (val->type) {case DYN_COL_INT:sizeof (buff), "%lld" , val->x.long_value);if (dynstr_append_mem(str, buff, len))return ER_DYNCOL_RESOURCE;break ;case DYN_COL_UINT:sizeof (buff), "%llu" , val->x.ulong_value);if (dynstr_append_mem(str, buff, len))return ER_DYNCOL_RESOURCE;break ;case DYN_COL_DOUBLE:sizeof (buff) - 1 , buff, NULL);if (dynstr_realloc(str, len + (quote ? 2 : 0 )))return ER_DYNCOL_RESOURCE;break ;case DYN_COL_DYNCOL:case DYN_COL_STRING:char *alloc= NULL;char *from= val->x.string.value.str;1 ));if (dynstr_realloc(str, bufflen))return ER_DYNCOL_RESOURCE;// guaranty UTF-8 string for value if (!my_charset_same(val->x.string.charset, cs))if (!quote)/* convert to the destination */ return ER_DYNCOL_OK;if ((alloc= (char *)my_malloc(PSI_INSTRUMENT_ME, bufflen, MYF(0 ))))else return ER_DYNCOL_RESOURCE;if (quote)if (quote == DYNCOL_JSON_ESC)else else if (alloc)if (rc)return ER_DYNCOL_RESOURCE;break ;case DYN_COL_DECIMAL:int tmp_len= sizeof (buff);0 , val->x.decimal.value.frac,'0' );if (dynstr_append_mem(str, buff, tmp_len))return ER_DYNCOL_RESOURCE;break ;case DYN_COL_DATETIME:case DYN_COL_DATE:case DYN_COL_TIME:if (dynstr_realloc(str, len + (quote ? 2 : 0 )))return ER_DYNCOL_RESOURCE;if (quote)'"' ;if (quote)'"' ;break ;case DYN_COL_NULL:if (dynstr_append_mem(str, "null" , 4 ))return ER_DYNCOL_RESOURCE;break ;default :return (ER_DYNCOL_FORMAT);return (ER_DYNCOL_OK);enum enum_dyncol_func_resultenum enum_dyncol_func_result rc= ER_DYNCOL_OK;0 ;switch (val->type) {case DYN_COL_INT:break ;case DYN_COL_UINT:if (val->x.ulong_value > ULONGLONG_MAX)break ;case DYN_COL_DOUBLE:if (((double ) *ll) != val->x.double_value)break ;case DYN_COL_STRING:char *src= val->x.string.value.str;0 , sign= 1 ;while (len && my_isspace(&my_charset_latin1, *src)) src++,len--;if (len)if (*src == '-' )1 ;else if (*src == '+' )while (len && my_isdigit(&my_charset_latin1, *src))10 + (*src - '0' );else if (len)break ;case DYN_COL_DECIMAL:if (decimal2longlong(&val->x.decimal.value, ll,TRUNCATE) != E_DEC_OK)break ;case DYN_COL_DATETIME:10000000000 ull +100000000 L +1000000 +10000 +100 +1 : 1 );break ;case DYN_COL_DATE:10000 +100 +1 : 1 );break ;case DYN_COL_TIME:10000 +100 +1 : 1 );break ;case DYN_COL_DYNCOL:case DYN_COL_NULL:break ;default :return (ER_DYNCOL_FORMAT);return (rc);enum enum_dyncol_func_resultdouble *dbl, DYNAMIC_COLUMN_VALUE *val)enum enum_dyncol_func_result rc= ER_DYNCOL_OK;0 ;switch (val->type) {case DYN_COL_INT:double )val->x.long_value;if (((longlong) *dbl) != val->x.long_value)break ;case DYN_COL_UINT:double )val->x.ulong_value;if (((ulonglong) *dbl) != val->x.ulong_value)break ;case DYN_COL_DOUBLE:break ;case DYN_COL_STRING:char *str, *end;if (!(str= malloc(val->x.string.value.length + 1 )))return ER_DYNCOL_RESOURCE;'\0' ;if (*end != '\0' )break ;case DYN_COL_DECIMAL:if (decimal2double(&val->x.decimal.value, dbl) != E_DEC_OK)break ;case DYN_COL_DATETIME:double )(val->x.time_value.year * 10000000000 ull +100000000 L +1000000 +10000 +100 +1 : 1 );break ;case DYN_COL_DATE:double )(val->x.time_value.year * 10000 +100 +1 : 1 );break ;case DYN_COL_TIME:double )(val->x.time_value.hour * 10000 +100 +1 : 1 );break ;case DYN_COL_DYNCOL:case DYN_COL_NULL:break ;default :return (ER_DYNCOL_FORMAT);return (rc);/** Convert to JSON @ param str The packed string @ param json Where to put json result @ return ER_DYNCOL_ * return code #define JSON_STACK_PROTECTION 10 static enum enum_dyncol_func_resultenum enum_dyncol_func_result rc;if (lvl >= JSON_STACK_PROTECTION)goto err;if (str->length == 0 )return ER_DYNCOL_OK; /* no columns */ if ((rc= init_read_hdr(&header, str)) < 0 )goto err;if (header.entry_size * header.column_count + FIXED_HEADER_SIZE >goto err;if (dynstr_append_mem(json, "{" , 1 ))goto err;for (i= 0 , header.entry= header.header;if (i != 0 && dynstr_append_mem(json, "," , 1 ))goto err;/* Check that the found data is within the ranges . This can happen if we get data with wrong offsets . if (header.length == DYNCOL_OFFSET_ERROR ||goto err;if ((rc= dynamic_column_get_value(&header, &val)) < 0 )goto err;if (header.format == dyncol_fmt_num)if (dynstr_realloc(json, DYNCOL_NUM_CHAR + 3 ))goto err;'"' ;"%u" , nm));else if (read_name(&header, header.entry, &name))goto err;if (dynstr_realloc(json, name.length + 3 ))goto err;'"' ;'"' ;':' ;if (val.type == DYN_COL_DYNCOL)/* here we use it only for read so can cheat a bit */ sizeof (dc));if (mariadb_dyncol_json_internal(&dc, json, lvl + 1 ) < 0 )0 ;goto err;0 ;else if ((rc= mariadb_dyncol_val_str(json, &val, DYNCOL_UTF, DYNCOL_JSON_ESC))0 )goto err;if (dynstr_append_mem(json, "}" , 1 ))goto err;return ER_DYNCOL_OK;0 ;return rc;enum enum_dyncol_func_resultif (init_dynamic_string(json, NULL, str->length * 2 , 100 ))return ER_DYNCOL_RESOURCE;return mariadb_dyncol_json_internal(str, json, 1 );/** Convert to DYNAMIC_COLUMN_VALUE values and names ( LEX_STING ) dynamic array @ param str The packed string @ param count number of elements in the arrays @ param names Where to put names ( should be free by user ) @ param vals Where to put values ( should be free by user ) @ return ER_DYNCOL_ * return code enum enum_dyncol_func_resultchar *nm;enum enum_dyncol_func_result rc;0 ; *names= 0 ; *vals= 0 ;if (str->length == 0 )return ER_DYNCOL_OK; /* no columns */ if ((rc= init_read_hdr(&header, str)) < 0 )return rc;if (header.entry_size * header.column_count + FIXED_HEADER_SIZE >return ER_DYNCOL_FORMAT;sizeof (DYNAMIC_COLUMN_VALUE)* header.column_count, MYF(0 ));if (header.format == dyncol_fmt_num)sizeof (LEX_STRING) * header.column_count +0 ));char *)((*names) + header.column_count);else sizeof (LEX_STRING) * header.column_count, MYF(0 ));0 ;if (!(*vals) || !(*names))goto err;for (i= 0 , header.entry= header.header;/* Check that the found data is within the ranges . This can happen if we get data with wrong offsets . if (header.length == DYNCOL_OFFSET_ERROR ||goto err;if ((rc= dynamic_column_get_value(&header, (*vals) + i)) < 0 )goto err;if (header.format == dyncol_fmt_num)"%u" , num);1 ;else if (read_name(&header, header.entry, (*names) + i))goto err;return ER_DYNCOL_OK;if (*vals)0 ;if (*names)0 ;return rc;/** Free arrays allocated by mariadb_dyncol_unpack ( ) @ param names Where to put names ( should be free by user ) @ param vals Where to put values ( should be free by user ) void mariadb_dyncol_unpack_free(LEX_STRING *names, DYNAMIC_COLUMN_VALUE *vals)/** Get not NULL column count @ param str The packed string @ param column_count Where to put column count @ return ER_DYNCOL_ * return code enum enum_dyncol_func_resultenum enum_dyncol_func_result rc;0 ;if (str->length == 0 )return ER_DYNCOL_OK;if ((rc= init_read_hdr(&header, str)) < 0 )return rc;return rc;/** Free dynamic column @ param str The packed string void mariadb_dyncol_free(DYNAMIC_COLUMN *str)
Messung V0.5 in Prozent C=94 H=83 G=88
¤ Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.0.112Bemerkung:
(Wie Sie bei der Firma Beratungs- und Dienstleistungen beauftragen können 2026-10-08)
¤ *Eine klare Vorstellung vom Zielzustand
2026-10-09
Neuigkeiten Aktuelles Motto des Tages Open Source Software
Jenseits des Üblichen ....
Besucherstatistik
Statistik #Sources=1126438 #Domains=1867298
