@ -1,6 +1,7 @@
/*****************************************************************************
/*****************************************************************************
Copyright ( c ) 2000 , 2016 , Oracle and / or its affiliates . All Rights Reserved . Copyright ( c ) 2000 , 2016 , Oracle and / or its affiliates . All Rights Reserved .
Copyright ( c ) 2017 , MariaDB Corporation .
This program is free software ; you can redistribute it and / or modify it under This program is free software ; you can redistribute it and / or modify it under
the terms of the GNU General Public License as published by the Free Software the terms of the GNU General Public License as published by the Free Software
@ -69,48 +70,6 @@ Created 9/17/2000 Heikki Tuuri
/** Provide optional 4.x backwards compatibility for 5.0 and above */ /** Provide optional 4.x backwards compatibility for 5.0 and above */
UNIV_INTERN ibool row_rollback_on_timeout = FALSE ; UNIV_INTERN ibool row_rollback_on_timeout = FALSE ;
/**
Z_NO_COMPRESSION = 0
Z_BEST_SPEED = 1
Z_BEST_COMPRESSION = 9
Z_DEFAULT_COMPRESSION = - 1
Compression level to be used by zlib for compressed - blob columns .
Settable by user .
*/
UNIV_INTERN uint srv_compressed_columns_zip_level = DEFAULT_COMPRESSION_LEVEL ;
/**
( Z_FILTERED | Z_HUFFMAN_ONLY | Z_RLE | Z_FIXED | Z_DEFAULT_STRATEGY )
The strategy parameter is used to tune the compression algorithm . Use the
value Z_DEFAULT_STRATEGY for normal data , Z_FILTERED for data produced by a
filter ( or predictor ) , Z_HUFFMAN_ONLY to force Huffman encoding only
( no string match ) , or Z_RLE to limit match distances to one
( run - length encoding ) . Filtered data consists mostly of small values with a
somewhat random distribution . In this case , the compression algorithm is
tuned to compress them better .
The effect of Z_FILTERED is to force more Huffman coding and less string
matching ; it is somewhat intermediate between Z_DEFAULT_STRATEGY and
Z_HUFFMAN_ONLY . Z_RLE is designed to be almost as fast as Z_HUFFMAN_ONLY ,
but give better compression for PNG image data . The strategy parameter only
affects the compression ratio but not the correctness of the compressed
output even if it is not set appropriately . Z_FIXED prevents the use of
dynamic Huffman codes , allowing for a simpler decoder for special
applications .
*/
const uint srv_compressed_columns_zlib_strategy = Z_DEFAULT_STRATEGY ;
/** Compress the column if the data length exceeds this value. */
UNIV_INTERN ulong srv_compressed_columns_threshold = 96 ;
/**
Determine if zlib needs to compute adler32 value for the compressed data .
This variables is similar to page_zip_zlib_wrap , but only used by
compressed blob columns .
*/
const bool srv_compressed_columns_zlib_wrap = true ;
/**
Determine if zlib will use custom memory allocation functions based on
InnoDB memory heap routines ( mem_heap_t * ) .
*/
const bool srv_compressed_columns_zlib_use_heap = false ;
/** Chain node of the list of tables to drop in the background. */ /** Chain node of the list of tables to drop in the background. */
struct row_mysql_drop_t { struct row_mysql_drop_t {
char * table_name ; /*!< table name */ char * table_name ; /*!< table name */
@ -214,17 +173,6 @@ row_mysql_prebuilt_free_blob_heap(
prebuilt - > blob_heap = NULL ; prebuilt - > blob_heap = NULL ;
} }
/** Frees the compress heap in prebuilt when no longer needed. */
UNIV_INTERN
void
row_mysql_prebuilt_free_compress_heap (
row_prebuilt_t * prebuilt ) /*!< in: prebuilt struct of a
ha_innobase : : table handle */
{
mem_heap_free ( prebuilt - > compress_heap ) ;
prebuilt - > compress_heap = NULL ;
}
/*******************************************************************/ /**
/*******************************************************************/ /**
Stores a > = 5.0 .3 format true VARCHAR length to dest , in the MySQL row Stores a > = 5.0 .3 format true VARCHAR length to dest , in the MySQL row
format . format .
@ -281,425 +229,6 @@ row_mysql_read_true_varchar(
return ( field + 1 ) ; return ( field + 1 ) ;
} }
/**
Compressed BLOB header format :
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
| reserved | wrap | algorithm | len - len | compressed | unused |
| [ 1 ] | [ 1 ] | [ 5 ] | [ 3 ] | [ 1 ] | [ 5 ] |
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
| 0 0 | 1 1 | 2 6 | 7 9 | 10 10 | 11 15 |
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
* ' reserved ' bit is planned to be used in future versions of the BLOB
header . In this version it must always be
' default_zip_column_reserved_value ' ( 0 ) .
* ' wrap ' identifies if compression algorithm calculated a checksum
( adler32 in case of zlib ) and appended it to the compressed data .
* ' algorithm ' identifies which algoritm was used to compress this BLOB .
Currently , the only value ' default_zip_column_algorithm_value ' ( 0 ) is
supported .
* ' len - len ' field identifies the length of the column length data portion
followed by this header ( see below ) .
* If ' compressed ' bit is set to 1 , then this header is immediately followed
by 1. .8 bytes ( depending on the value of ' len - len ' bitfield ) which
determine original ( uncompressed ) block size . These ' len - len ' bytes are
followed by compressed representation of the original data .
* If ' compressed ' bit is set to 0 , every other bitfield ( ' wrap ' ,
' algorithm ' and ' le - len ' ) must be ignored . In this case the header is
immediately followed by uncompressed ( original ) data .
*/
/**
Currently the only supported value for the ' reserved ' field is
false ( 0 ) .
*/
static const bool default_zip_column_reserved_value = false ;
/**
Currently the only supported value for the ' algorithm ' field is 0 , which
means ' zlib ' .
*/
static const uint default_zip_column_algorithm_value = 0 ;
static const size_t zip_column_prefix_max_length =
ZIP_COLUMN_HEADER_LENGTH + 8 ;
static const size_t zip_column_header_length = ZIP_COLUMN_HEADER_LENGTH ;
/* 'reserved', bit 0 */
static const uint zip_column_reserved = 0 ;
/* 0000 0000 0000 0001 */
static const uint zip_column_reserved_mask = 0x0001 ;
/* 'wrap', bit 1 */
static const uint zip_column_wrap = 1 ;
/* 0000 0000 0000 0010 */
static const uint zip_column_wrap_mask = 0x0002 ;
/* 'algorithm', bit 2,3,4,5,6 */
static const uint zip_column_algorithm = 2 ;
/* 0000 0000 0111 1100 */
static const uint zip_column_algorithm_mask = 0x007C ;
/* 'len-len', bit 7,8,9 */
static const uint zip_column_data_length = 7 ;
/* 0000 0011 1000 0000 */
static const uint zip_column_data_length_mask = 0x0380 ;
/* 'compressed', bit 10 */
static const uint zip_column_compressed = 10 ;
/* 0000 0100 0000 0000 */
static const uint zip_column_compressed_mask = 0x0400 ;
/** Updates compressed block header with the given components */
static void
column_set_compress_header (
byte * data ,
bool compressed ,
ulint lenlen ,
uint alg ,
bool wrap ,
bool reserved )
{
ulint header = 0 ;
header | = ( compressed < < zip_column_compressed ) ;
header | = ( lenlen < < zip_column_data_length ) ;
header | = ( alg < < zip_column_algorithm ) ;
header | = ( wrap < < zip_column_wrap ) ;
header | = ( reserved < < zip_column_reserved ) ;
mach_write_to_2 ( data , header ) ;
}
/** Parse compressed block header into components */
static void
column_get_compress_header (
const byte * data ,
bool * compressed ,
ulint * lenlen ,
uint * alg ,
bool * wrap ,
bool * reserved
)
{
ulint header = mach_read_from_2 ( data ) ;
* compressed = ( ( header & zip_column_compressed_mask ) > >
zip_column_compressed ) ;
* lenlen = ( ( header & zip_column_data_length_mask ) > >
zip_column_data_length ) ;
* alg = ( ( header & zip_column_algorithm_mask ) > >
zip_column_algorithm ) ;
* wrap = ( ( header & zip_column_wrap_mask ) > >
zip_column_wrap ) ;
* reserved = ( ( header & zip_column_reserved_mask ) > >
zip_column_reserved ) ;
}
/** Allocate memory for zlib. */
static
void *
column_zip_zalloc (
void * opaque , /*!< in/out: memory heap */
uInt items , /*!< in: number of items to allocate */
uInt size ) /*!< in: size of an item in bytes */
{
return ( mem_heap_zalloc ( static_cast < mem_heap_t * > ( opaque ) ,
items * size ) ) ;
}
/** Deallocate memory for zlib. */
static
void
column_zip_free (
void * opaque MY_ATTRIBUTE ( ( unused ) ) , /*!< in: memory heap */
void * address MY_ATTRIBUTE ( ( unused ) ) ) /*!< in: object to free */
{
}
/** Configure the zlib allocator to use the given memory heap. */
UNIV_INTERN
void
column_zip_set_alloc (
void * stream , /*!< in/out: zlib stream */
mem_heap_t * heap ) /*!< in: memory heap to use */
{
z_stream * strm = static_cast < z_stream * > ( stream ) ;
if ( srv_compressed_columns_zlib_use_heap ) {
strm - > zalloc = column_zip_zalloc ;
strm - > zfree = column_zip_free ;
strm - > opaque = heap ;
} else {
strm - > zalloc = ( alloc_func ) 0 ;
strm - > zfree = ( free_func ) 0 ;
strm - > opaque = ( voidpf ) 0 ;
}
}
/** Compress blob/text/varchar column using zlib
@ return pointer to the compressed data */
byte *
row_compress_column (
const byte * data , /*!< in: data in mysql(uncompressed)
format */
ulint * len , /*!< in: data length; out: length of
compressed data */
ulint lenlen , /*!< in: bytes used to store the length of
data */
const byte * dict_data ,
/*!< in: optional dictionary data used for
compression */
ulint dict_data_len ,
/*!< in: optional dictionary data length */
row_prebuilt_t * prebuilt )
/*!< in: use prebuilt->compress_heap only
here */
{
int err = 0 ;
ulint comp_len = * len ;
ulint buf_len = * len + zip_column_prefix_max_length ;
byte * buf ;
byte * ptr ;
z_stream c_stream ;
bool wrap = srv_compressed_columns_zlib_wrap ;
int window_bits = wrap ? MAX_WBITS : - MAX_WBITS ;
if ( ! prebuilt - > compress_heap ) {
prebuilt - > compress_heap =
mem_heap_create ( max ( UNIV_PAGE_SIZE , buf_len ) ) ;
}
buf = static_cast < byte * > ( mem_heap_zalloc (
prebuilt - > compress_heap , buf_len ) ) ;
if ( * len < srv_compressed_columns_threshold | |
srv_compressed_columns_zip_level = = Z_NO_COMPRESSION )
goto do_not_compress ;
ptr = buf + zip_column_header_length + lenlen ;
/*init deflate object*/
c_stream . next_in = const_cast < Bytef * > ( data ) ;
c_stream . avail_in = * len ;
c_stream . next_out = ptr ;
c_stream . avail_out = comp_len ;
column_zip_set_alloc ( & c_stream , prebuilt - > compress_heap ) ;
err = deflateInit2 ( & c_stream , srv_compressed_columns_zip_level ,
Z_DEFLATED , window_bits , MAX_MEM_LEVEL ,
srv_compressed_columns_zlib_strategy ) ;
ut_a ( err = = Z_OK ) ;
if ( dict_data ! = 0 & & dict_data_len ! = 0 ) {
err = deflateSetDictionary ( & c_stream , dict_data ,
dict_data_len ) ;
ut_a ( err = = Z_OK ) ;
}
err = deflate ( & c_stream , Z_FINISH ) ;
if ( err ! = Z_STREAM_END ) {
deflateEnd ( & c_stream ) ;
if ( err = = Z_OK )
err = Z_BUF_ERROR ;
} else {
comp_len = c_stream . total_out ;
err = deflateEnd ( & c_stream ) ;
}
switch ( err ) {
case Z_OK :
break ;
case Z_BUF_ERROR :
/* data after compress is larger than uncompressed data*/
break ;
default :
ib_logf ( IB_LOG_LEVEL_ERROR ,
" failed to compress the column, error: %d \n " , err ) ;
}
/* make sure the compressed data size is smaller than
uncompressed data */
if ( err = = Z_OK & &
* len > ( comp_len + zip_column_header_length + lenlen ) ) {
column_set_compress_header ( buf , true , lenlen - 1 ,
default_zip_column_algorithm_value , wrap ,
default_zip_column_reserved_value ) ;
ptr = buf + zip_column_header_length ;
/*store the uncompressed data length*/
switch ( lenlen ) {
case 1 :
mach_write_to_1 ( ptr , * len ) ;
break ;
case 2 :
mach_write_to_2 ( ptr , * len ) ;
break ;
case 3 :
mach_write_to_3 ( ptr , * len ) ;
break ;
case 4 :
mach_write_to_4 ( ptr , * len ) ;
break ;
default :
ut_error ;
}
* len = comp_len + zip_column_header_length + lenlen ;
return buf ;
}
do_not_compress :
ptr = buf ;
column_set_compress_header ( ptr , false , 0 ,
default_zip_column_algorithm_value , false ,
default_zip_column_reserved_value ) ;
ptr + = zip_column_header_length ;
memcpy ( ptr , data , * len ) ;
* len + = zip_column_header_length ;
return buf ;
}
/** Uncompress blob/text/varchar column using zlib
@ return pointer to the uncompressed data */
const byte *
row_decompress_column (
const byte * data , /*!< in: data in innodb(compressed) format */
ulint * len , /*!< in: data length; out: length of
decompressed data */
const byte * dict_data ,
/*!< in: optional dictionary data used for
decompression */
ulint dict_data_len ,
/*!< in: optional dictionary data length */
row_prebuilt_t * prebuilt )
/*!< in: use prebuilt->compress_heap only
here */
{
ulint buf_len = 0 ;
byte * buf ;
int err = 0 ;
int window_bits = 0 ;
z_stream d_stream ;
bool is_compressed = false ;
bool wrap = false ;
bool reserved = false ;
ulint lenlen = 0 ;
uint alg = 0 ;
ut_ad ( * len ! = ULINT_UNDEFINED ) ;
ut_ad ( * len > = zip_column_header_length ) ;
column_get_compress_header ( data , & is_compressed , & lenlen , & alg ,
& wrap , & reserved ) ;
if ( reserved ! = default_zip_column_reserved_value ) {
ib_logf ( IB_LOG_LEVEL_FATAL ,
" unsupported compressed BLOB header format \n " ) ;
}
if ( alg ! = default_zip_column_algorithm_value ) {
ib_logf ( IB_LOG_LEVEL_FATAL ,
" unsupported 'algorithm' value in the "
" compressed BLOB header \n " ) ;
}
ut_a ( lenlen < 4 ) ;
data + = zip_column_header_length ;
if ( ! is_compressed ) { /* column not compressed */
* len - = zip_column_header_length ;
return data ;
}
lenlen + + ;
ulint comp_len = * len - zip_column_header_length - lenlen ;
ulint uncomp_len = 0 ;
switch ( lenlen ) {
case 1 :
uncomp_len = mach_read_from_1 ( data ) ;
break ;
case 2 :
uncomp_len = mach_read_from_2 ( data ) ;
break ;
case 3 :
uncomp_len = mach_read_from_3 ( data ) ;
break ;
case 4 :
uncomp_len = mach_read_from_4 ( data ) ;
break ;
default :
ut_error ;
}
data + = lenlen ;
/* data is compressed, decompress it*/
if ( ! prebuilt - > compress_heap ) {
prebuilt - > compress_heap =
mem_heap_create ( max ( UNIV_PAGE_SIZE , uncomp_len ) ) ;
}
buf_len = uncomp_len ;
buf = static_cast < byte * > ( mem_heap_zalloc (
prebuilt - > compress_heap , buf_len ) ) ;
/* init d_stream */
d_stream . next_in = const_cast < Bytef * > ( data ) ;
d_stream . avail_in = comp_len ;
d_stream . next_out = buf ;
d_stream . avail_out = buf_len ;
column_zip_set_alloc ( & d_stream , prebuilt - > compress_heap ) ;
window_bits = wrap ? MAX_WBITS : - MAX_WBITS ;
err = inflateInit2 ( & d_stream , window_bits ) ;
ut_a ( err = = Z_OK ) ;
err = inflate ( & d_stream , Z_FINISH ) ;
if ( err = = Z_NEED_DICT ) {
ut_a ( dict_data ! = 0 & & dict_data_len ! = 0 ) ;
err = inflateSetDictionary ( & d_stream , dict_data ,
dict_data_len ) ;
ut_a ( err = = Z_OK ) ;
err = inflate ( & d_stream , Z_FINISH ) ;
}
if ( err ! = Z_STREAM_END ) {
inflateEnd ( & d_stream ) ;
if ( err = = Z_BUF_ERROR & & d_stream . avail_in = = 0 )
err = Z_DATA_ERROR ;
} else {
buf_len = d_stream . total_out ;
err = inflateEnd ( & d_stream ) ;
}
switch ( err ) {
case Z_OK :
break ;
case Z_BUF_ERROR :
ib_logf ( IB_LOG_LEVEL_FATAL ,
" zlib buf error, this shouldn't happen \n " ) ;
break ;
default :
ib_logf ( IB_LOG_LEVEL_FATAL ,
" failed to decompress column, error: %d \n " , err ) ;
}
if ( err = = Z_OK ) {
if ( buf_len ! = uncomp_len ) {
ib_logf ( IB_LOG_LEVEL_FATAL ,
" failed to decompress blob column, may "
" be corrupted \n " ) ;
}
* len = buf_len ;
return buf ;
}
* len - = ( zip_column_header_length + lenlen ) ;
return data ;
}
/*******************************************************************/ /**
/*******************************************************************/ /**
Stores a reference to a BLOB in the MySQL format . */ Stores a reference to a BLOB in the MySQL format . */
UNIV_INTERN UNIV_INTERN
@ -713,21 +242,10 @@ row_mysql_store_blob_ref(
to 4 bytes */ to 4 bytes */
const void * data , /*!< in: BLOB data; if the value to store
const void * data , /*!< in: BLOB data; if the value to store
is SQL NULL this should be NULL pointer */ is SQL NULL this should be NULL pointer */
ulint len , /*!< in: BLOB length; if the value to store
ulint len ) /*!< in: BLOB length; if the value to store
is SQL NULL this should be 0 ; remember is SQL NULL this should be 0 ; remember
also to set the NULL bit in the MySQL record also to set the NULL bit in the MySQL record
header ! */ header ! */
bool need_decompression ,
/*!< in: if the data need to be compressed*/
const byte * dict_data ,
/*!< in: optional compression dictionary
data */
ulint dict_data_len ,
/*!< in: optional compression dictionary data
length */
row_prebuilt_t * prebuilt )
/*<! in: use prebuilt->compress_heap only
here */
{ {
/* MySQL might assume the field is set to zero except the length and
/* MySQL might assume the field is set to zero except the length and
the pointer fields */ the pointer fields */
@ -739,27 +257,11 @@ row_mysql_store_blob_ref(
In 32 - bit architectures we only use the first 4 bytes of the pointer In 32 - bit architectures we only use the first 4 bytes of the pointer
slot . */ slot . */
ut_a ( col_len - 8 > 1 | |
len < 256 +
( need_decompression ? ZIP_COLUMN_HEADER_LENGTH : 0 ) ) ;
ut_a ( col_len - 8 > 2 | |
len < 256 * 256 +
( need_decompression ? ZIP_COLUMN_HEADER_LENGTH : 0 ) ) ;
ut_a ( col_len - 8 > 3 | |
len < 256 * 256 * 256 +
( need_decompression ? ZIP_COLUMN_HEADER_LENGTH : 0 ) ) ;
const byte * ptr = NULL ;
if ( need_decompression )
ptr = row_decompress_column ( ( const byte * ) data , & len ,
dict_data , dict_data_len , prebuilt ) ;
if ( ptr )
memcpy ( dest + col_len - 8 , & ptr , sizeof ptr ) ;
else
memcpy ( dest + col_len - 8 , & data , sizeof data ) ;
ut_a ( col_len - 8 > 1 | | len < 256 ) ;
ut_a ( col_len - 8 > 2 | | len < 256 * 256 ) ;
ut_a ( col_len - 8 > 3 | | len < 256 * 256 * 256 ) ;
memcpy ( dest + col_len - 8 , & data , sizeof data ) ;
mach_write_to_n_little_endian ( dest , col_len - 8 , len ) ; mach_write_to_n_little_endian ( dest , col_len - 8 , len ) ;
} }
@ -773,32 +275,15 @@ row_mysql_read_blob_ref(
ulint * len , /*!< out: BLOB length */ ulint * len , /*!< out: BLOB length */
const byte * ref , /*!< in: BLOB reference in the
const byte * ref , /*!< in: BLOB reference in the
MySQL format */ MySQL format */
ulint col_len , /*!< in: BLOB reference length
ulint col_len ) /*!< in: BLOB reference length
( not BLOB length ) */ ( not BLOB length ) */
bool need_compression ,
/*!< in: if the data need to be
compressed */
const byte * dict_data , /*!< in: optional compression
dictionary data */
ulint dict_data_len , /*!< in: optional compression
dictionary data length */
row_prebuilt_t * prebuilt ) /*!< in: use prebuilt->compress_heap
only here */
{ {
byte * data = NULL ; byte * data = NULL ;
byte * ptr = NULL ;
* len = mach_read_from_n_little_endian ( ref , col_len - 8 ) ; * len = mach_read_from_n_little_endian ( ref , col_len - 8 ) ;
memcpy ( & data , ref + col_len - 8 , sizeof data ) ; memcpy ( & data , ref + col_len - 8 , sizeof data ) ;
if ( need_compression ) {
ptr = row_compress_column ( data , len , col_len - 8 , dict_data ,
dict_data_len , prebuilt ) ;
if ( ptr )
data = ptr ;
}
return ( data ) ; return ( data ) ;
} }
@ -881,16 +366,7 @@ row_mysql_store_col_in_innobase_format(
necessarily the length of the actual necessarily the length of the actual
payload data ; if the column is a true payload data ; if the column is a true
VARCHAR then this is irrelevant */ VARCHAR then this is irrelevant */
ulint comp , /*!< in: nonzero=compact format */
bool need_compression ,
/*!< in: if the data need to be
compressed */
const byte * dict_data , /*!< in: optional compression
dictionary data */
ulint dict_data_len , /*!< in: optional compression
dictionary data length */
row_prebuilt_t * prebuilt ) /*!< in: use prebuilt->compress_heap
only here */
ulint comp ) /*!< in: nonzero=compact format */
{ {
const byte * ptr = mysql_data ; const byte * ptr = mysql_data ;
const dtype_t * dtype ; const dtype_t * dtype ;
@ -943,14 +419,8 @@ row_mysql_store_col_in_innobase_format(
lenlen = 2 ; lenlen = 2 ;
} }
const byte * tmp_ ptr= row_mysql_read_true_varchar (
ptr = row_mysql_read_true_varchar (
& col_len , mysql_data , lenlen ) ; & col_len , mysql_data , lenlen ) ;
if ( need_compression )
ptr = row_compress_column ( tmp_ptr , & col_len ,
lenlen , dict_data , dict_data_len ,
prebuilt ) ;
else
ptr = tmp_ptr ;
} else { } else {
/* Remove trailing spaces from old style VARCHAR
/* Remove trailing spaces from old style VARCHAR
columns . */ columns . */
@ -1032,9 +502,7 @@ row_mysql_store_col_in_innobase_format(
} }
} else if ( type = = DATA_BLOB & & row_format_col ) { } else if ( type = = DATA_BLOB & & row_format_col ) {
ptr = row_mysql_read_blob_ref ( & col_len , mysql_data , col_len ,
need_compression , dict_data , dict_data_len ,
prebuilt ) ;
ptr = row_mysql_read_blob_ref ( & col_len , mysql_data , col_len ) ;
} }
dfield_set_data ( dfield , ptr , col_len ) ; dfield_set_data ( dfield , ptr , col_len ) ;
@ -1092,11 +560,7 @@ row_mysql_convert_row_to_innobase(
TRUE , /* MySQL row format data */ TRUE , /* MySQL row format data */
mysql_rec + templ - > mysql_col_offset , mysql_rec + templ - > mysql_col_offset ,
templ - > mysql_col_len , templ - > mysql_col_len ,
dict_table_is_comp ( prebuilt - > table ) ,
templ - > compressed ,
reinterpret_cast < const byte * > (
templ - > zip_dict_data . str ) ,
templ - > zip_dict_data . length , prebuilt ) ;
dict_table_is_comp ( prebuilt - > table ) ) ;
next_column : next_column :
; ;
} }
@ -1442,10 +906,6 @@ row_prebuilt_free(
mem_heap_free ( prebuilt - > blob_heap ) ; mem_heap_free ( prebuilt - > blob_heap ) ;
} }
if ( prebuilt - > compress_heap ) {
mem_heap_free ( prebuilt - > compress_heap ) ;
}
if ( prebuilt - > old_vers_heap ) { if ( prebuilt - > old_vers_heap ) {
mem_heap_free ( prebuilt - > old_vers_heap ) ; mem_heap_free ( prebuilt - > old_vers_heap ) ;
} }
@ -1875,9 +1335,6 @@ row_insert_for_mysql(
return ( DB_READ_ONLY ) ; return ( DB_READ_ONLY ) ;
} }
if ( UNIV_LIKELY_NULL ( prebuilt - > compress_heap ) )
mem_heap_empty ( prebuilt - > compress_heap ) ;
trx - > op_info = " inserting " ; trx - > op_info = " inserting " ;
row_mysql_delay_if_needed ( ) ; row_mysql_delay_if_needed ( ) ;
@ -3443,8 +2900,6 @@ row_mysql_table_id_reassign(
" WHERE TABLE_ID = :old_id; \n " " WHERE TABLE_ID = :old_id; \n "
" UPDATE SYS_INDEXES SET TABLE_ID = :new_id \n " " UPDATE SYS_INDEXES SET TABLE_ID = :new_id \n "
" WHERE TABLE_ID = :old_id; \n " " WHERE TABLE_ID = :old_id; \n "
" UPDATE SYS_ZIP_DICT_COLS SET TABLE_ID = :new_id_narrow \n "
" WHERE TABLE_ID = :old_id_narrow; \n "
" END; \n " , FALSE , trx ) ; " END; \n " , FALSE , trx ) ;
return ( err ) ; return ( err ) ;
@ -4228,9 +3683,6 @@ next_rec:
" UPDATE SYS_INDEXES " " UPDATE SYS_INDEXES "
" SET TABLE_ID = :new_id, SPACE = :new_space \n " " SET TABLE_ID = :new_id, SPACE = :new_space \n "
" WHERE TABLE_ID = :old_id; \n " " WHERE TABLE_ID = :old_id; \n "
" UPDATE SYS_ZIP_DICT_COLS \n "
" SET TABLE_ID = :new_id_narrow \n "
" WHERE TABLE_ID = :old_id_narrow; \n "
" END; \n " " END; \n "
, FALSE , trx ) ; , FALSE , trx ) ;
@ -4858,19 +4310,6 @@ row_drop_table_for_mysql(
filepath = fil_make_ibd_name ( tablename , false ) ; filepath = fil_make_ibd_name ( tablename , false ) ;
} }
/* Remove all compression dictionary references for the
table */
err = dict_create_remove_zip_dict_references_for_table (
table - > id , trx ) ;
if ( err ! = DB_SUCCESS ) {
ib_logf ( IB_LOG_LEVEL_ERROR , " Error: (%s) not "
" able to remove compression dictionary "
" references for table %s " , ut_strerr ( err ) ,
tablename ) ;
goto funct_exit ;
}
if ( dict_table_has_fts_index ( table ) if ( dict_table_has_fts_index ( table )
| | DICT_TF2_FLAG_IS_SET ( table , DICT_TF2_FTS_HAS_DOC_ID ) ) { | | DICT_TF2_FLAG_IS_SET ( table , DICT_TF2_FTS_HAS_DOC_ID ) ) {
ut_ad ( table - > n_ref_count = = 0 ) ; ut_ad ( table - > n_ref_count = = 0 ) ;
Marko Mäkelä
9 years ago