int CLogEvent::tune(uint8_t* data, size_t size, const CFormatDescriptionLogEvent& fmt)
{
_when = uint4korr(data);
_server_id = uint4korr(data + SERVER_ID_OFFSET);
_data_written = uint4korr(data + EVENT_LEN_OFFSET);
_log_pos= uint4korr(data + LOG_POS_OFFSET);
_flags = uint2korr(data + FLAGS_OFFSET);
return 0;
}
/* Taken from original MySQL sources, some versions of libmysqlclient does not export this function. */
static ulong __net_field_length(uchar **packet)
{
reg1 uchar *pos= (uchar *)*packet;
if (*pos < 251)
{
(*packet)++;
return (ulong) *pos;
}
if (*pos == 251)
{
(*packet)++;
return NULL_LENGTH;
}
if (*pos == 252)
{
(*packet)+=3;
return (ulong) uint2korr(pos+1);
}
if (*pos == 253)
{
(*packet)+=4;
return (ulong) uint3korr(pos+1);
}
(*packet)+=9; /* Must be 254 when here */
return (ulong) uint4korr(pos+1);
}
/* The same as above but returns longlong */
my_ulonglong net_field_length_ll(uchar **packet)
{
reg1 uchar *pos= *packet;
if (*pos < 251)
{
(*packet)++;
return (my_ulonglong) *pos;
}
if (*pos == 251)
{
(*packet)++;
return (my_ulonglong) NULL_LENGTH;
}
if (*pos == 252)
{
(*packet)+=3;
return (my_ulonglong) uint2korr(pos+1);
}
if (*pos == 253)
{
(*packet)+=4;
return (my_ulonglong) uint3korr(pos+1);
}
(*packet)+=9; /* Must be 254 when here */
#ifdef NO_CLIENT_LONGLONG
return (my_ulonglong) uint4korr(pos+1);
#else
return (my_ulonglong) uint8korr(pos+1);
#endif
}
const char* Field_set::unpack(const char* from) {
ulonglong tmp;
switch(pack_length()) {
case 1:
tmp = ulonglong(*((unsigned char*)(from)));
break;
case 2:
tmp = ulonglong(uint2korr(from));
break;
case 3:
tmp = ulonglong(uint3korr(from));
break;
case 4:
tmp = ulonglong(uint4korr(from));
break;
case 8:
tmp = uint8korr(from);
break;
default:
tmp = uint8korr(from);
break;
}
field_data = tmp;
LOG_TRACE(log, " set: " << tmp << " // " << pack_length());
return from + pack_length();
}
static void
update_record(char *record)
{
char *pos = record + 1;
if (recinfo[1].type == FIELD_BLOB) {
char *column, *ptr;
int length;
length = uint4korr(pos); /* Long blob */
memcpy_fixed(&column, pos + 4, sizeof(char *));
memcpy(blob_key, column, length); /* Move old key */
ptr = blob_key;
memcpy_fixed(pos + 4, &ptr, sizeof(char *)); /* Store pointer to new
* key */
if (keyinfo[0].seg[0].type != HA_KEYTYPE_NUM)
casedn(blob_key, length);
pos += recinfo[1].length;
} else if (recinfo[1].type == FIELD_VARCHAR) {
uint length = uint2korr(pos);
casedn(pos + 2, length);
pos += recinfo[1].length;
} else {
if (keyinfo[0].seg[0].type != HA_KEYTYPE_NUM)
casedn(pos, keyinfo[0].seg[0].length);
pos += recinfo[1].length;
}
if (recinfo[2].type == FIELD_BLOB) {
char *column;
int length;
length = uint4korr(pos);
memcpy_fixed(&column, pos + 4, sizeof(char *));
memcpy(blob_record, column, length);
bfill(blob_record + length, 20, '.'); /* Make it larger */
length += 20;
int4store(pos, length);
column = blob_record;
memcpy_fixed(pos + 4, &column, sizeof(char *));
} else if (recinfo[2].type == FIELD_VARCHAR) {
/* Second field is longer than 10 characters */
uint length = uint2korr(pos);
bfill(pos + 2 + length, recinfo[2].length - length - 2, '.');
length = recinfo[2].length - 2;
int2store(pos, length);
} else {
bfill(pos + recinfo[2].length - 10, 10, '.');
}
}
const char* Field_long::unpack(const char* from) {
uint32 tmp = uint4korr(from);
field_data = tmp;
LOG_TRACE(log, " long: " << tmp << " // " << pack_length());
return from + pack_length();
}
bool BackupRestore::map_in_frm(char *new_data, const char *data,
uint data_len, uint *new_data_len)
{
const char *end_data= data + data_len;
const char *end_part_data;
const char *part_data;
char *extra_ptr;
uint start_key_definition_len = uint2korr(data + 6);
uint key_definition_len = uint4korr(data + 47);
uint part_info_len;
DBUG_ENTER("map_in_frm");
if (data_len < 4096) goto error;
extra_ptr = (char*)data + start_key_definition_len + key_definition_len;
if ((int)data_len < ((extra_ptr - data) + 2)) goto error;
extra_ptr = extra_ptr + 2 + uint2korr(extra_ptr);
if ((int)data_len < ((extra_ptr - data) + 2)) goto error;
extra_ptr = extra_ptr + 2 + uint2korr(extra_ptr);
if ((int)data_len < ((extra_ptr - data) + 4)) goto error;
part_info_len = uint4korr(extra_ptr);
part_data = extra_ptr + 4;
if ((int)data_len < ((part_data + part_info_len) - data)) goto error;
do
{
copy_byte(&data, &new_data, new_data_len);
} while (data < part_data);
end_part_data = part_data + part_info_len;
do
{
if (search_replace((char*)" NODEGROUP = ", &new_data, &data,
end_part_data, new_data_len))
goto error;
} while (data != end_part_data);
do
{
copy_byte(&data, &new_data, new_data_len);
} while (data < end_data);
DBUG_RETURN(FALSE);
error:
DBUG_RETURN(TRUE);
}
static my_bool is_slave_stmt(MYSQL *mysql, const char *buffer)
{
unsigned long stmt_id= uint4korr(buffer);
LIST *stmt_list= mysql->stmts;
for (; stmt_list; stmt_list= stmt_list->next)
{
MYSQL_STMT *stmt= (MYSQL_STMT *)stmt_list->data;
if (stmt->stmt_id == stmt_id)
return 1;
}
return 0;
}
static int sp_get_polygon_mbr(uchar *(*wkb), uchar *end, uint n_dims,
uchar byte_order, double *mbr)
{
uint n_linear_rings;
uint n_points;
n_linear_rings = uint4korr((*wkb));
(*wkb) += 4;
for (; n_linear_rings > 0; --n_linear_rings)
{
n_points = uint4korr((*wkb));
(*wkb) += 4;
for (; n_points > 0; --n_points)
{
/* Add next point to mbr */
if (sp_add_point_to_mbr(wkb, end, n_dims, byte_order, mbr))
return -1;
}
}
return 0;
}
uint64_t CRowLogEvent::build_column_mask(const uint8_t** ptr, size_t* len, uint64_t n)
{
uint64_t column_mask;
uint8_t l = uint8_t((n+7)/8);
switch( l )
{
case 1: // [1..8] columns
{
column_mask = 0xFFFFFFFFFFFFFFFFLL & (uint64_t)*(*ptr);
break;
}
case 2: // [9..16] columns
{
column_mask = 0xFFFFFFFFFFFFFFFFLL & (uint64_t)uint2korr(*ptr);
break;
}
case 3: // [17..24] columns
{
column_mask = 0xFFFFFFFFFFFFFFFFLL & (uint64_t)uint3korr(*ptr);
break;
}
case 4: // [25..32] columns
{
column_mask = 0xFFFFFFFFFFFFFFFFLL & (uint64_t)uint4korr(*ptr);
break;
}
case 5: // [33..40] columns
{
column_mask = 0xFFFFFFFFFFFFFFFFLL & (uint64_t)uint5korr(*ptr);
break;
}
case 6: // [41..48] columns
{
column_mask = 0xFFFFFFFFFFFFFFFFLL & (uint64_t)uint6korr(*ptr);
break;
}
default:
{
// wrong column number
return (uint64_t) - 1;
}
}
if (ptr && *ptr) (*ptr) += l;
if (len) *len -= l;
return column_mask;
}
int _nisam_write_static_record(N_INFO *info, const byte *record)
{
uchar temp[4]; /* Not sizeof(long) */
if (info->s->state.dellink != NI_POS_ERROR)
{
ulong filepos=info->s->state.dellink;
info->rec_cache.seek_not_done=1; /* We have done a seek */
VOID(my_seek(info->dfile,info->s->state.dellink+1,MY_SEEK_SET,MYF(0)));
if (my_read(info->dfile,(char*) &temp[0],sizeof(temp), MYF(MY_NABP)))
goto err;
info->s->state.dellink=uint4korr(temp);
if (info->s->state.dellink == (uint32) ~0) /* Fix for 64 bit long */
info->s->state.dellink=NI_POS_ERROR;
info->s->state.del--;
info->s->state.empty-=info->s->base.reclength;
VOID(my_seek(info->dfile,filepos,MY_SEEK_SET,MYF(0)));
if (my_write(info->dfile, (char*) record, info->s->base.reclength,
MYF(MY_NABP)))
goto err;
}
else
{
if (info->s->state.data_file_length > info->s->base.max_data_file_length)
{
my_errno=HA_ERR_RECORD_FILE_FULL;
return(2);
}
if (info->opt_flag & WRITE_CACHE_USED)
{ /* Cash in use */
if (my_b_write(&info->rec_cache, (byte*) record, info->s->base.reclength))
goto err;
}
else
{
info->rec_cache.seek_not_done=1; /* We have done a seek */
VOID(my_seek(info->dfile,info->s->state.data_file_length,
MY_SEEK_SET,MYF(0)));
if (my_write(info->dfile,(char*) record,info->s->base.reclength,
MYF(MY_NABP | MY_WAIT_IF_FULL)))
goto err;
}
info->s->state.data_file_length+=info->s->base.reclength;
info->s->state.splitt++;
}
return 0;
err:
return 1;
}
ssize_t pvio_shm_read(MARIADB_PVIO *pvio, uchar *buffer, size_t length)
{
PVIO_SHM *pvio_shm= (PVIO_SHM *)pvio->data;
size_t copy_size= length;
HANDLE events[2];
if (!pvio_shm)
return -1;
/* we need to wait for write and close events */
if (!pvio_shm->buffer_size)
{
events[0]= pvio_shm->event[PVIO_SHM_CONNECTION_CLOSED];
events[1]= pvio_shm->event[PVIO_SHM_SERVER_WROTE];
switch(WaitForMultipleObjects(2, events, 0, pvio->timeout[PVIO_READ_TIMEOUT]))
{
case WAIT_OBJECT_0: /* server closed connection */
SetLastError(ERROR_GRACEFUL_DISCONNECT);
return -1;
case WAIT_OBJECT_0 +1: /* server_wrote event */
break;
case WAIT_TIMEOUT:
SetLastError(ETIMEDOUT);
default:
return -1;
}
/* server sent data */
pvio_shm->read_pos= (char *)pvio_shm->map;
pvio_shm->buffer_size= uint4korr(pvio_shm->read_pos);
pvio_shm->read_pos+= 4;
}
if (pvio_shm->buffer_size < copy_size)
copy_size= pvio_shm->buffer_size;
if (copy_size)
{
memcpy(buffer, (uchar *)pvio_shm->read_pos, pvio_shm->buffer_size);
pvio_shm->read_pos+= copy_size;
pvio_shm->buffer_size-= copy_size;
}
/* we need to read again */
if (!pvio_shm->buffer_size)
if (!SetEvent(pvio_shm->event[PVIO_SHM_CLIENT_READ]))
return -1;
return (ssize_t)copy_size;
}
// numeric
template<class T> T as_int() const
{
if (is_null() || !is_valid() || sizeof(T)>8) return (T)0;
switch (_size)
{
case 1: return (T)*_storage;
case 2: return (T)uint2korr(_storage);
case 3: return (T)uint3korr(_storage);
case 4: return (T)uint4korr(_storage);
case 8: return (T)uint8korr(_storage);
}
return (T)0;
}
int unpackfrm(uchar **unpack_data, size_t *unpack_len,
const uchar *pack_data)
{
uchar *data;
size_t complen, orglen;
ulong ver;
DBUG_ENTER("unpackfrm");
DBUG_PRINT("enter", ("pack_data: 0x%lx", (long) pack_data));
ver= uint4korr(pack_data);
orglen= uint4korr(pack_data+4);
complen= uint4korr(pack_data+8);
DBUG_PRINT("blob",("ver: %lu complen: %lu orglen: %lu",
ver, (ulong) complen, (ulong) orglen));
DBUG_DUMP("blob->data", pack_data + BLOB_HEADER, complen);
if (ver != 1)
DBUG_RETURN(1);
if (!(data= my_malloc(max(orglen, complen), MYF(MY_WME))))
DBUG_RETURN(2);
memcpy(data, pack_data + BLOB_HEADER, complen);
if (my_uncompress(data, complen, &orglen))
{
my_free(data);
DBUG_RETURN(3);
}
*unpack_data= data;
*unpack_len= orglen;
DBUG_PRINT("exit", ("frmdata: 0x%lx len: %lu", (long) *unpack_data,
(ulong) *unpack_len));
DBUG_RETURN(0);
}
uint hp_calc_blob_length(uint bytes, const uchar *pos)
{
switch (bytes) {
case 1:
return (uint) *pos;
case 2:
return uint2korr(pos);
case 3:
return uint3korr(pos);
case 4:
return uint4korr(pos);
default:
break;
}
return 0; /* Impossible */
}
int CQueryLogEvent::tune(uint8_t* data, size_t size, const CFormatDescriptionLogEvent& fmt)
{
uint8_t common_header_len, post_header_len;
uint64_t data_len;
_query[0] = '\0';
int rc = CLogEvent::tune(data,size,fmt);
if (rc == 0)
{
common_header_len = fmt._common_header_len;
post_header_len = fmt._post_header_len[QUERY_EVENT - 1];
data_len = size - (common_header_len + post_header_len);
data += common_header_len;
_q_exec_time = uint4korr(data + Q_EXEC_TIME_OFFSET);
_db_len = (uint32_t)data[Q_DB_LEN_OFFSET];
_error_code = uint2korr(data + Q_ERR_CODE_OFFSET);
if (post_header_len - QUERY_HEADER_MINIMAL_LEN)
{
_status_vars_len= uint2korr(data + Q_STATUS_VARS_LEN_OFFSET);
if (_status_vars_len > data_len || _status_vars_len > MAX_SIZE_LOG_EVENT_STATUS) return -1;
data_len -= _status_vars_len;
}
else
{
return -1;
}
// смещаемся к query
data += post_header_len + _status_vars_len + _db_len + 1;
data_len -= (_db_len + 1);
_q_len = data_len;
memcpy(_query, data, _q_len);
_query[_q_len] = '\0';
}
return rc;
}
unsigned int Field_blob::get_length(const char *pos) {
switch (packlength)
{
case 1:
return (unsigned int) (unsigned char) pos[0];
case 2:
{
unsigned short tmp = 0;
/*
if (db_low_byte_first) {
tmp = sint2korr(pos);
} else {
shortget(tmp,pos);
}
*/
tmp = sint2korr(pos);
return (unsigned int) tmp;
}
case 3:
return (unsigned int) uint3korr(pos);
case 4:
{
unsigned int tmp;
/*
if (db_low_byte_first)
tmp = uint4korr(pos);
else
longget(tmp,pos);
*/
tmp = uint4korr(pos);
return (unsigned int) tmp;
}
}
throw std::runtime_error("Oops, wrong packlength in Field_blob::get_length(): wanted 1, 2, 3 or 4.");
}
void put_rec(uchar *buff, uint end, uint len, uint tag)
{
uint i;
uint num;
num= uint4korr(buff);
if (!len)
len= 1;
if (end + 4*2 + len > TEST_PAGE_SIZE)
return;
int4store(buff + end, len);
end+= 4;
int4store(buff + end, tag);
end+= 4;
num++;
int4store(buff, num);
for (i= end; i < (len + end); i++)
{
buff[i]= (uchar) num % 256;
}
}
const char* Field_timestamp::unpack(const char* from) {
uint32 tmp;
if (is_old_storage)
{
tmp = uint4korr(from);
}
else
{
// !! we ignore fractional part
// 4 bytes + fractional-seconds storage, big endian
// same as before 5.6.4, except big endian rather than little endian
tmp = 0;
for (unsigned int i = 0; i < 4; ++i)
*((unsigned char *)&tmp + 3 - i) = *(from + i);
}
field_data = tmp;
LOG_TRACE(log, " timestamp: " << tmp << " // " << pack_length());
return from + pack_length();
}
my_bool _nisam_read_pack_info(N_INFO *info, pbool fix_keys)
{
File file;
int diff_length;
uint i,trees,huff_tree_bits,rec_reflength,length;
uint16 *decode_table,*tmp_buff;
ulong elements,intervall_length;
char *disk_cache,*intervall_buff;
uchar header[32];
ISAM_SHARE *share=info->s;
BIT_BUFF bit_buff;
DBUG_ENTER("_nisam_read_pack_info");
if (nisam_quick_table_bits < 4)
nisam_quick_table_bits=4;
else if (nisam_quick_table_bits > MAX_QUICK_TABLE_BITS)
nisam_quick_table_bits=MAX_QUICK_TABLE_BITS;
file=info->dfile;
my_errno=0;
if (my_read(file,(byte*) header,sizeof(header),MYF(MY_NABP)))
{
if (!my_errno)
my_errno=HA_ERR_END_OF_FILE;
DBUG_RETURN(1);
}
if (memcmp((byte*) header,(byte*) nisam_pack_file_magic,4))
{
my_errno=HA_ERR_WRONG_IN_RECORD;
DBUG_RETURN(1);
}
share->pack.header_length=uint4korr(header+4);
share->min_pack_length=(uint) uint4korr(header+8);
share->max_pack_length=(uint) uint4korr(header+12);
set_if_bigger(share->base.pack_reclength,share->max_pack_length);
elements=uint4korr(header+16);
intervall_length=uint4korr(header+20);
trees=uint2korr(header+24);
share->pack.ref_length=header[26];
rec_reflength=header[27];
diff_length=(int) rec_reflength - (int) share->base.rec_reflength;
if (fix_keys)
share->rec_reflength=rec_reflength;
share->base.min_block_length=share->min_pack_length+share->pack.ref_length;
if (!(share->decode_trees=(DECODE_TREE*)
my_malloc((uint) (trees*sizeof(DECODE_TREE)+
intervall_length*sizeof(byte)),
MYF(MY_WME))))
DBUG_RETURN(1);
intervall_buff=(byte*) (share->decode_trees+trees);
length=(uint) (elements*2+trees*(1 << nisam_quick_table_bits));
if (!(share->decode_tables=(uint16*)
my_malloc((length+512)*sizeof(uint16)+
(uint) (share->pack.header_length+7),
MYF(MY_WME | MY_ZEROFILL))))
{
my_free((gptr) share->decode_trees,MYF(0));
DBUG_RETURN(1);
}
tmp_buff=share->decode_tables+length;
disk_cache=(byte*) (tmp_buff+512);
if (my_read(file,disk_cache,
(uint) (share->pack.header_length-sizeof(header)),
MYF(MY_NABP)))
{
my_free((gptr) share->decode_trees,MYF(0));
my_free((gptr) share->decode_tables,MYF(0));
DBUG_RETURN(1);
}
huff_tree_bits=max_bit(trees ? trees-1 : 0);
init_bit_buffer(&bit_buff,disk_cache,
(uint) (share->pack.header_length-sizeof(header)));
/* Read new info for each field */
for (i=0 ; i < share->base.fields ; i++)
{
share->rec[i].base_type=(enum en_fieldtype) get_bits(&bit_buff,4);
share->rec[i].pack_type=(uint) get_bits(&bit_buff,4);
share->rec[i].space_length_bits=get_bits(&bit_buff,4);
share->rec[i].huff_tree=share->decode_trees+(uint) get_bits(&bit_buff,
huff_tree_bits);
share->rec[i].unpack=get_unpack_function(share->rec+i);
}
skipp_to_next_byte(&bit_buff);
decode_table=share->decode_tables;
for (i=0 ; i < trees ; i++)
read_huff_table(&bit_buff,share->decode_trees+i,&decode_table,
&intervall_buff,tmp_buff);
decode_table=(uint16*)
my_realloc((gptr) share->decode_tables,
(uint) ((byte*) decode_table - (byte*) share->decode_tables),
MYF(MY_HOLD_ON_ERROR));
{
my_ptrdiff_t diff=PTR_BYTE_DIFF(decode_table,share->decode_tables);
share->decode_tables=decode_table;
for (i=0 ; i < trees ; i++)
share->decode_trees[i].table=ADD_TO_PTR(share->decode_trees[i].table,
diff, uint16*);
}
/* Fix record-ref-length for keys */
if (fix_keys)
{
for (i=0 ; i < share->base.keys ; i++)
{
share->keyinfo[i].base.keylength+=(uint16) diff_length;
share->keyinfo[i].base.minlength+=(uint16) diff_length;
share->keyinfo[i].base.maxlength+=(uint16) diff_length;
share->keyinfo[i].seg[share->keyinfo[i].base.keysegs].base.length=
(uint16) rec_reflength;
}
}
if (bit_buff.error || bit_buff.pos < bit_buff.end)
{ /* info_length was wrong */
my_errno=HA_ERR_WRONG_IN_RECORD;
my_free((gptr) share->decode_trees,MYF(0));
my_free((gptr) share->decode_tables,MYF(0));
DBUG_RETURN(1);
}
DBUG_RETURN(0);
}
size_t vio_read_shared_memory(Vio *vio, uchar *buf, size_t size)
{
size_t length;
size_t remain_local;
char *current_position;
HANDLE events[2];
DWORD timeout;
DBUG_ENTER("vio_read_shared_memory");
remain_local= size;
current_position= buf;
timeout= vio->read_timeout >= 0 ? vio->read_timeout : INFINITE;
events[0]= vio->event_server_wrote;
events[1]= vio->event_conn_closed;
do
{
if (vio->shared_memory_remain == 0)
{
DWORD wait_status;
wait_status= WaitForMultipleObjects(array_elements(events), events,
FALSE, timeout);
/*
WaitForMultipleObjects can return next values:
WAIT_OBJECT_0+0 - event from vio->event_server_wrote
WAIT_OBJECT_0+1 - event from vio->event_conn_closed.
We can't read anything
WAIT_ABANDONED_0 and WAIT_TIMEOUT - fail. We can't read anything
*/
if (wait_status != WAIT_OBJECT_0)
{
/*
If wait_status is WAIT_TIMEOUT, set error code to indicate a
timeout error. If vio->event_conn_closed was set, use an EOF
condition (return value of zero) to indicate that the operation
has been aborted.
*/
if (wait_status == WAIT_TIMEOUT)
SetLastError(SOCKET_ETIMEDOUT);
else if (wait_status == (WAIT_OBJECT_0 + 1))
DBUG_RETURN(0);
DBUG_RETURN(-1);
}
vio->shared_memory_pos= vio->handle_map;
vio->shared_memory_remain= uint4korr((ulong*)vio->shared_memory_pos);
vio->shared_memory_pos+= 4;
}
length= size;
if (vio->shared_memory_remain < length)
length= vio->shared_memory_remain;
if (length > remain_local)
length= remain_local;
memcpy(current_position, vio->shared_memory_pos, length);
vio->shared_memory_remain-= length;
vio->shared_memory_pos+= length;
current_position+= length;
remain_local-= length;
if (!vio->shared_memory_remain)
{
if (!SetEvent(vio->event_client_read))
DBUG_RETURN(-1);
}
} while (remain_local);
length= size;
DBUG_RETURN(length);
}
/* {{{ ps_fetch_from_1_to_8_bytes */
void ps_fetch_from_1_to_8_bytes(zval *zv, const MYSQLND_FIELD * const field,
unsigned int pack_len, zend_uchar **row, zend_bool as_unicode,
unsigned int byte_count TSRMLS_DC)
{
char tmp[22];
size_t tmp_len = 0;
zend_bool is_bit = field->type == MYSQL_TYPE_BIT;
DBG_ENTER("ps_fetch_from_1_to_8_bytes");
DBG_INF_FMT("zv=%p byte_count=%d", zv, byte_count);
if (field->flags & UNSIGNED_FLAG) {
uint64_t uval = 0;
switch (byte_count) {
case 8:uval = is_bit? (uint64_t) bit_uint8korr(*row):(uint64_t) uint8korr(*row);break;
case 7:uval = bit_uint7korr(*row);break;
case 6:uval = bit_uint6korr(*row);break;
case 5:uval = bit_uint5korr(*row);break;
case 4:uval = is_bit? (uint64_t) bit_uint4korr(*row):(uint64_t) uint4korr(*row);break;
case 3:uval = is_bit? (uint64_t) bit_uint3korr(*row):(uint64_t) uint3korr(*row);break;
case 2:uval = is_bit? (uint64_t) bit_uint2korr(*row):(uint64_t) uint2korr(*row);break;
case 1:uval = (uint64_t) uint1korr(*row);break;
}
#if SIZEOF_LONG==4
if (uval > INT_MAX) {
DBG_INF("stringify");
tmp_len = sprintf((char *)&tmp, MYSQLND_LLU_SPEC, uval);
} else
#endif /* #if SIZEOF_LONG==4 */
{
if (byte_count < 8 || uval <= L64(9223372036854775807)) {
ZVAL_LONG(zv, uval);
} else {
DBG_INF("stringify");
tmp_len = sprintf((char *)&tmp, MYSQLND_LLU_SPEC, uval);
}
}
} else {
/* SIGNED */
int64_t lval = 0;
switch (byte_count) {
case 8:lval = (int64_t) sint8korr(*row);break;
/*
7, 6 and 5 are not possible.
BIT is only unsigned, thus only uint5|6|7 macroses exist
*/
case 4:lval = (int64_t) sint4korr(*row);break;
case 3:lval = (int64_t) sint3korr(*row);break;
case 2:lval = (int64_t) sint2korr(*row);break;
case 1:lval = (int64_t) *(int8_t*)*row;break;
}
#if SIZEOF_LONG==4
if ((L64(2147483647) < (int64_t) lval) || (L64(-2147483648) > (int64_t) lval)) {
DBG_INF("stringify");
tmp_len = sprintf((char *)&tmp, MYSQLND_LL_SPEC, lval);
} else
#endif /* SIZEOF */
{
ZVAL_LONG(zv, lval);
}
}
if (tmp_len) {
#if PHP_MAJOR_VERSION >= 6
if (as_unicode) {
DBG_INF("stringify");
ZVAL_UTF8_STRINGL(zv, tmp, tmp_len, ZSTR_DUPLICATE);
} else
#endif
{
DBG_INF("stringify");
ZVAL_STRINGL(zv, tmp, tmp_len, 1);
}
}
(*row)+= byte_count;
DBG_VOID_RETURN;
}
int main(int argc, char *argv[])
{
uint i;
int j,n1,n2,n3,error,k;
uint write_count,update,dupp_keys,opt_delete,start,length,blob_pos,
reclength,ant,found_parts;
my_off_t lastpos;
ha_rows range_records,records;
MARIA_HA *file;
MARIA_KEYDEF keyinfo[10];
MARIA_COLUMNDEF recinfo[10];
MARIA_INFO info;
char *blob_buffer;
MARIA_CREATE_INFO create_info;
char filename[FN_REFLEN];
#ifdef SAFE_MUTEX
safe_mutex_deadlock_detector= 1;
#endif
MY_INIT(argv[0]);
maria_data_root= (char *)".";
get_options(argc,argv);
fn_format(filename, "test2", maria_data_root, "", MYF(0));
if (! async_io)
my_disable_async_io=1;
/* If we sync or not have no affect on this test */
my_disable_sync= 1;
/* Maria requires that we always have a page cache */
if (maria_init() ||
(init_pagecache(maria_pagecache, pagecache_size, 0, 0,
maria_block_size, MY_WME) == 0) ||
ma_control_file_open(TRUE, TRUE) ||
(init_pagecache(maria_log_pagecache,
TRANSLOG_PAGECACHE_SIZE, 0, 0,
TRANSLOG_PAGE_SIZE, MY_WME) == 0) ||
translog_init(maria_data_root, TRANSLOG_FILE_SIZE,
0, 0, maria_log_pagecache,
TRANSLOG_DEFAULT_FLAGS, 0) ||
(transactional && (trnman_init(0) || ma_checkpoint_init(0))))
{
fprintf(stderr, "Error in initialization");
exit(1);
}
if (opt_versioning)
init_thr_lock();
reclength=STANDARD_LENGTH+60+(use_blob ? 8 : 0);
blob_pos=STANDARD_LENGTH+60;
keyinfo[0].seg= &glob_keyseg[0][0];
keyinfo[0].seg[0].start=0;
keyinfo[0].seg[0].length=6;
keyinfo[0].seg[0].type=HA_KEYTYPE_TEXT;
keyinfo[0].seg[0].language= default_charset_info->number;
keyinfo[0].seg[0].flag=(uint8) pack_seg;
keyinfo[0].seg[0].null_bit=0;
keyinfo[0].seg[0].null_pos=0;
keyinfo[0].key_alg=HA_KEY_ALG_BTREE;
keyinfo[0].keysegs=1;
keyinfo[0].flag = pack_type;
keyinfo[0].block_length= 0; /* Default block length */
keyinfo[1].seg= &glob_keyseg[1][0];
keyinfo[1].seg[0].start=7;
keyinfo[1].seg[0].length=6;
keyinfo[1].seg[0].type=HA_KEYTYPE_BINARY;
keyinfo[1].seg[0].flag=0;
keyinfo[1].seg[0].null_bit=0;
keyinfo[1].seg[0].null_pos=0;
keyinfo[1].seg[1].start=0; /* two part key */
keyinfo[1].seg[1].length=6;
keyinfo[1].seg[1].type=HA_KEYTYPE_NUM;
keyinfo[1].seg[1].flag=HA_REVERSE_SORT;
keyinfo[1].seg[1].null_bit=0;
keyinfo[1].seg[1].null_pos=0;
keyinfo[1].key_alg=HA_KEY_ALG_BTREE;
keyinfo[1].keysegs=2;
keyinfo[1].flag =0;
keyinfo[1].block_length= MARIA_MIN_KEY_BLOCK_LENGTH; /* Diff blocklength */
keyinfo[2].seg= &glob_keyseg[2][0];
keyinfo[2].seg[0].start=12;
keyinfo[2].seg[0].length=8;
keyinfo[2].seg[0].type=HA_KEYTYPE_BINARY;
keyinfo[2].seg[0].flag=HA_REVERSE_SORT;
keyinfo[2].seg[0].null_bit=0;
keyinfo[2].seg[0].null_pos=0;
keyinfo[2].key_alg=HA_KEY_ALG_BTREE;
keyinfo[2].keysegs=1;
keyinfo[2].flag =HA_NOSAME;
keyinfo[2].block_length= 0; /* Default block length */
keyinfo[3].seg= &glob_keyseg[3][0];
keyinfo[3].seg[0].start=0;
keyinfo[3].seg[0].length=reclength-(use_blob ? 8 : 0);
keyinfo[3].seg[0].type=HA_KEYTYPE_TEXT;
keyinfo[3].seg[0].language=default_charset_info->number;
keyinfo[3].seg[0].flag=(uint8) pack_seg;
keyinfo[3].seg[0].null_bit=0;
keyinfo[3].seg[0].null_pos=0;
keyinfo[3].key_alg=HA_KEY_ALG_BTREE;
keyinfo[3].keysegs=1;
keyinfo[3].flag = pack_type;
keyinfo[3].block_length= 0; /* Default block length */
keyinfo[4].seg= &glob_keyseg[4][0];
keyinfo[4].seg[0].start=0;
keyinfo[4].seg[0].length=5;
keyinfo[4].seg[0].type=HA_KEYTYPE_TEXT;
keyinfo[4].seg[0].language=default_charset_info->number;
keyinfo[4].seg[0].flag=0;
keyinfo[4].seg[0].null_bit=0;
keyinfo[4].seg[0].null_pos=0;
keyinfo[4].key_alg=HA_KEY_ALG_BTREE;
keyinfo[4].keysegs=1;
keyinfo[4].flag = pack_type;
keyinfo[4].block_length= 0; /* Default block length */
keyinfo[5].seg= &glob_keyseg[5][0];
keyinfo[5].seg[0].start=0;
keyinfo[5].seg[0].length=4;
keyinfo[5].seg[0].type=HA_KEYTYPE_TEXT;
keyinfo[5].seg[0].language=default_charset_info->number;
keyinfo[5].seg[0].flag=pack_seg;
keyinfo[5].seg[0].null_bit=0;
keyinfo[5].seg[0].null_pos=0;
keyinfo[5].key_alg=HA_KEY_ALG_BTREE;
keyinfo[5].keysegs=1;
keyinfo[5].flag = pack_type;
keyinfo[5].block_length= 0; /* Default block length */
recinfo[0].type=pack_fields ? FIELD_SKIP_PRESPACE : 0;
recinfo[0].length=7;
recinfo[0].null_bit=0;
recinfo[0].null_pos=0;
recinfo[1].type=pack_fields ? FIELD_SKIP_PRESPACE : 0;
recinfo[1].length=5;
recinfo[1].null_bit=0;
recinfo[1].null_pos=0;
recinfo[2].type=pack_fields ? FIELD_SKIP_PRESPACE : 0;
recinfo[2].length=9;
recinfo[2].null_bit=0;
recinfo[2].null_pos=0;
recinfo[3].type=FIELD_NORMAL;
recinfo[3].length=STANDARD_LENGTH-7-5-9-4;
recinfo[3].null_bit=0;
recinfo[3].null_pos=0;
recinfo[4].type=pack_fields ? FIELD_SKIP_ZERO : 0;
recinfo[4].length=4;
recinfo[4].null_bit=0;
recinfo[4].null_pos=0;
recinfo[5].type=pack_fields ? FIELD_SKIP_ENDSPACE : 0;
recinfo[5].length=60;
recinfo[5].null_bit=0;
recinfo[5].null_pos=0;
if (use_blob)
{
recinfo[6].type=FIELD_BLOB;
recinfo[6].length=4+portable_sizeof_char_ptr;
recinfo[6].null_bit=0;
recinfo[6].null_pos=0;
}
write_count=update=dupp_keys=opt_delete=0;
blob_buffer=0;
for (i=1000 ; i>0 ; i--) key1[i]=0;
for (i=5000 ; i>0 ; i--) key3[i]=0;
if (!silent)
printf("- Creating maria-file\n");
file= 0;
bzero((char*) &create_info,sizeof(create_info));
create_info.max_rows=(ha_rows) (rec_pointer_size ?
(1L << (rec_pointer_size*8))/
reclength : 0);
create_info.reloc_rows=(ha_rows) 100;
create_info.transactional= transactional;
if (maria_create(filename, record_type, keys,&keyinfo[first_key],
use_blob ? 7 : 6, &recinfo[0],
0,(MARIA_UNIQUEDEF*) 0,
&create_info,create_flag))
goto err;
if (!(file=maria_open(filename,2,HA_OPEN_ABORT_IF_LOCKED)))
goto err;
maria_begin(file);
if (opt_versioning)
maria_versioning(file, 1);
if (testflag == 1)
goto end;
if (checkpoint == 1 && ma_checkpoint_execute(CHECKPOINT_MEDIUM, FALSE))
goto err;
if (!silent)
printf("- Writing key:s\n");
if (do_locking)
maria_lock_database(file,F_WRLCK);
if (write_cacheing)
maria_extra(file,HA_EXTRA_WRITE_CACHE,0);
if (opt_quick_mode)
maria_extra(file,HA_EXTRA_QUICK,0);
for (i=0 ; i < recant ; i++)
{
ulong blob_length;
n1=rnd(1000); n2=rnd(100); n3=rnd(5000);
sprintf((char*) record,"%6d:%4d:%8d:Pos: %4d ",n1,n2,n3,write_count);
int4store(record+STANDARD_LENGTH-4,(long) i);
fix_length(record,(uint) STANDARD_LENGTH+rnd(60));
put_blob_in_record(record+blob_pos,&blob_buffer, &blob_length);
DBUG_PRINT("test",("record: %d blob_length: %lu", i, blob_length));
if (maria_write(file,record))
{
if (my_errno != HA_ERR_FOUND_DUPP_KEY || key3[n3] == 0)
{
printf("Error: %d in write at record: %d\n",my_errno,i);
goto err;
}
if (verbose) printf(" Double key: %d at record# %d\n", n3, i);
}
else
{
if (key3[n3] == 1 && first_key <3 && first_key+keys >= 3)
{
printf("Error: Didn't get error when writing second key: '%8d'\n",n3);
goto err2;
}
write_count++; key1[n1]++; key3[n3]=1;
}
/* Check if we can find key without flushing database */
if (i % 10 == 0)
{
for (j=rnd(1000)+1 ; j>0 && key1[j] == 0 ; j--) ;
if (!j)
for (j=999 ; j>0 && key1[j] == 0 ; j--) ;
sprintf((char*) key,"%6d",j);
if (maria_rkey(file,read_record,0,key,HA_WHOLE_KEY,HA_READ_KEY_EXACT))
{
printf("Test in loop: Can't find key: \"%s\"\n",key);
goto err;
}
}
}
if (checkpoint == 2 && ma_checkpoint_execute(CHECKPOINT_MEDIUM, FALSE))
goto err;
if (write_cacheing)
{
if (maria_extra(file,HA_EXTRA_NO_CACHE,0))
{
puts("got error from maria_extra(HA_EXTRA_NO_CACHE)");
goto err;
}
}
if (testflag == 2)
goto end;
#ifdef REMOVE_WHEN_WE_HAVE_RESIZE
if (pagecacheing)
resize_pagecache(maria_pagecache, maria_block_size,
pagecache_size * 2, 0, 0);
#endif
if (!silent)
printf("- Delete\n");
if (srand_arg)
srand(srand_arg);
if (!update_count)
update_count= recant/10;
for (i=0 ; i < update_count ; i++)
{
for (j=rnd(1000)+1 ; j>0 && key1[j] == 0 ; j--) ;
if (j != 0)
{
sprintf((char*) key,"%6d",j);
if (maria_rkey(file,read_record,0,key,HA_WHOLE_KEY,HA_READ_KEY_EXACT))
{
printf("can't find key1: \"%s\"\n",key);
goto err;
}
if (bcmp(read_record+keyinfo[0].seg[0].start,
key, keyinfo[0].seg[0].length))
{
printf("Found wrong record when searching for key: \"%s\"\n",key);
goto err2;
}
if (opt_delete == (uint) remove_count) /* While testing */
goto end;
if (maria_delete(file,read_record))
{
printf("error: %d; can't delete record: \"%s\"\n", my_errno,read_record);
goto err;
}
opt_delete++;
key1[atoi((char*) read_record+keyinfo[0].seg[0].start)]--;
key3[atoi((char*) read_record+keyinfo[2].seg[0].start)]=0;
}
else
{
puts("Warning: Skipping delete test because no dupplicate keys");
break;
}
}
if (testflag == 3)
goto end;
if (checkpoint == 3 && ma_checkpoint_execute(CHECKPOINT_MEDIUM, FALSE))
goto err;
if (!silent)
printf("- Update\n");
if (srand_arg)
srand(srand_arg);
if (!update_count)
update_count= recant/10;
for (i=0 ; i < update_count ; i++)
{
n1=rnd(1000); n2=rnd(100); n3=rnd(5000);
sprintf((char*) record2,"%6d:%4d:%8d:XXX: %4d ",n1,n2,n3,update);
int4store(record2+STANDARD_LENGTH-4,(long) i);
fix_length(record2,(uint) STANDARD_LENGTH+rnd(60));
for (j=rnd(1000)+1 ; j>0 && key1[j] == 0 ; j--) ;
if (j != 0)
{
sprintf((char*) key,"%6d",j);
if (maria_rkey(file,read_record,0,key,HA_WHOLE_KEY,HA_READ_KEY_EXACT))
{
printf("can't find key1: \"%s\"\n", (char*) key);
goto err;
}
if (bcmp(read_record+keyinfo[0].seg[0].start,
key, keyinfo[0].seg[0].length))
{
printf("Found wrong record when searching for key: \"%s\"; Found \"%.*s\"\n",
key, keyinfo[0].seg[0].length,
read_record+keyinfo[0].seg[0].start);
goto err2;
}
if (use_blob)
{
ulong blob_length;
if (i & 1)
put_blob_in_record(record2+blob_pos,&blob_buffer, &blob_length);
else
bmove(record2+blob_pos, read_record+blob_pos, 4 + sizeof(char*));
}
if (skip_update)
continue;
if (maria_update(file,read_record,record2))
{
if (my_errno != HA_ERR_FOUND_DUPP_KEY || key3[n3] == 0)
{
printf("error: %d; can't update:\nFrom: \"%s\"\nTo: \"%s\"\n",
my_errno,read_record,record2);
goto err;
}
if (verbose)
printf("Double key when tried to update:\nFrom: \"%s\"\nTo: \"%s\"\n",record,record2);
}
else
{
key1[atoi((char*) read_record+keyinfo[0].seg[0].start)]--;
key3[atoi((char*) read_record+keyinfo[2].seg[0].start)]=0;
key1[n1]++; key3[n3]=1;
update++;
}
}
}
if (testflag == 4)
goto end;
if (checkpoint == 4 && ma_checkpoint_execute(CHECKPOINT_MEDIUM, FALSE))
goto err;
for (i=999, dupp_keys=j=0 ; i>0 ; i--)
{
if (key1[i] > dupp_keys)
{
dupp_keys=key1[i]; j=i;
}
}
sprintf((char*) key,"%6d",j);
start=keyinfo[0].seg[0].start;
length=keyinfo[0].seg[0].length;
if (dupp_keys)
{
if (!silent)
printf("- Same key: first - next -> last - prev -> first\n");
DBUG_PRINT("progpos",("first - next -> last - prev -> first"));
if (verbose) printf(" Using key: \"%s\" Keys: %d\n",key,dupp_keys);
if (maria_rkey(file,read_record,0,key,HA_WHOLE_KEY,HA_READ_KEY_EXACT))
goto err;
if (maria_rsame(file,read_record2,-1))
goto err;
if (memcmp(read_record,read_record2,reclength) != 0)
{
printf("maria_rsame didn't find same record\n");
goto err2;
}
info.recpos=maria_position(file);
if (maria_rfirst(file,read_record2,0) ||
maria_rsame_with_pos(file,read_record2,0,info.recpos) ||
memcmp(read_record,read_record2,reclength) != 0)
{
printf("maria_rsame_with_pos didn't find same record\n");
goto err2;
}
{
int skr;
info.recpos= maria_position(file);
skr= maria_rnext(file,read_record2,0);
if ((skr && my_errno != HA_ERR_END_OF_FILE) ||
maria_rprev(file,read_record2,0) ||
memcmp(read_record,read_record2,reclength) != 0 ||
info.recpos != maria_position(file))
{
printf("maria_rsame_with_pos lost position\n");
goto err;
}
}
ant=1;
while (maria_rnext(file,read_record2,0) == 0 &&
memcmp(read_record2+start,key,length) == 0) ant++;
if (ant != dupp_keys)
{
printf("next: Found: %d keys of %d\n",ant,dupp_keys);
goto err2;
}
ant=0;
while (maria_rprev(file,read_record3,0) == 0 &&
bcmp(read_record3+start,key,length) == 0) ant++;
if (ant != dupp_keys)
{
printf("prev: Found: %d records of %d\n",ant,dupp_keys);
goto err2;
}
/* Check of maria_rnext_same */
if (maria_rkey(file,read_record,0,key,HA_WHOLE_KEY,HA_READ_KEY_EXACT))
goto err;
ant=1;
while (!maria_rnext_same(file,read_record3) && ant < dupp_keys+10)
ant++;
if (ant != dupp_keys || my_errno != HA_ERR_END_OF_FILE)
{
printf("maria_rnext_same: Found: %d records of %d\n",ant,dupp_keys);
goto err2;
}
}
if (!silent)
printf("- All keys: first - next -> last - prev -> first\n");
DBUG_PRINT("progpos",("All keys: first - next -> last - prev -> first"));
ant=1;
if (maria_rfirst(file,read_record,0))
{
printf("Can't find first record\n");
goto err;
}
while ((error=maria_rnext(file,read_record3,0)) == 0 && ant < write_count+10)
ant++;
if (ant != write_count - opt_delete || error != HA_ERR_END_OF_FILE)
{
printf("next: I found: %d records of %d (error: %d)\n",
ant, write_count - opt_delete, error);
goto err;
}
if (maria_rlast(file,read_record2,0) ||
bcmp(read_record2,read_record3,reclength))
{
printf("Can't find last record\n");
DBUG_DUMP("record2", read_record2, reclength);
DBUG_DUMP("record3", read_record3, reclength);
goto err2;
}
ant=1;
while (maria_rprev(file,read_record3,0) == 0 && ant < write_count+10)
ant++;
if (ant != write_count - opt_delete)
{
printf("prev: I found: %d records of %d\n",ant,write_count);
goto err2;
}
if (bcmp(read_record,read_record3,reclength))
{
printf("Can't find first record\n");
goto err2;
}
if (!silent)
printf("- Test if: Read first - next - prev - prev - next == first\n");
DBUG_PRINT("progpos",("- Read first - next - prev - prev - next == first"));
if (maria_rfirst(file,read_record,0) ||
maria_rnext(file,read_record3,0) ||
maria_rprev(file,read_record3,0) ||
maria_rprev(file,read_record3,0) == 0 ||
maria_rnext(file,read_record3,0))
goto err;
if (bcmp(read_record,read_record3,reclength) != 0)
printf("Can't find first record\n");
if (!silent)
printf("- Test if: Read last - prev - next - next - prev == last\n");
DBUG_PRINT("progpos",("Read last - prev - next - next - prev == last"));
if (maria_rlast(file,read_record2,0) ||
maria_rprev(file,read_record3,0) ||
maria_rnext(file,read_record3,0) ||
maria_rnext(file,read_record3,0) == 0 ||
maria_rprev(file,read_record3,0))
goto err;
if (bcmp(read_record2,read_record3,reclength))
printf("Can't find last record\n");
#ifdef NOT_ANYMORE
if (!silent)
puts("- Test read key-part");
strmov(key2,key);
for(i=strlen(key2) ; i-- > 1 ;)
{
key2[i]=0;
/* The following row is just to catch some bugs in the key code */
bzero((char*) file->lastkey,file->s->base.max_key_length*2);
if (maria_rkey(file,read_record,0,key2,(uint) i,HA_READ_PREFIX))
goto err;
if (bcmp(read_record+start,key,(uint) i))
{
puts("Didn't find right record");
goto err2;
}
}
#endif
if (dupp_keys > 2)
{
if (!silent)
printf("- Read key (first) - next - delete - next -> last\n");
DBUG_PRINT("progpos",("first - next - delete - next -> last"));
if (maria_rkey(file,read_record,0,key,HA_WHOLE_KEY,HA_READ_KEY_EXACT))
goto err;
if (maria_rnext(file,read_record3,0)) goto err;
if (maria_delete(file,read_record3)) goto err;
opt_delete++;
ant=1;
while (maria_rnext(file,read_record3,0) == 0 &&
bcmp(read_record3+start,key,length) == 0) ant++;
if (ant != dupp_keys-1)
{
printf("next: I can only find: %d keys of %d\n",ant,dupp_keys-1);
goto err2;
}
}
if (dupp_keys>4)
{
if (!silent)
printf("- Read last of key - prev - delete - prev -> first\n");
DBUG_PRINT("progpos",("last - prev - delete - prev -> first"));
if (maria_rprev(file,read_record3,0)) goto err;
if (maria_rprev(file,read_record3,0)) goto err;
if (maria_delete(file,read_record3)) goto err;
opt_delete++;
ant=1;
while (maria_rprev(file,read_record3,0) == 0 &&
bcmp(read_record3+start,key,length) == 0) ant++;
if (ant != dupp_keys-2)
{
printf("next: I can only find: %d keys of %d\n",ant,dupp_keys-2);
goto err2;
}
}
if (dupp_keys > 6)
{
if (!silent)
printf("- Read first - delete - next -> last\n");
DBUG_PRINT("progpos",("first - delete - next -> last"));
if (maria_rkey(file,read_record3,0,key,HA_WHOLE_KEY,HA_READ_KEY_EXACT))
goto err;
if (maria_delete(file,read_record3)) goto err;
opt_delete++;
ant=1;
if (maria_rnext(file,read_record,0))
goto err; /* Skall finnas poster */
while (maria_rnext(file,read_record3,0) == 0 &&
bcmp(read_record3+start,key,length) == 0) ant++;
if (ant != dupp_keys-3)
{
printf("next: I can only find: %d keys of %d\n",ant,dupp_keys-3);
goto err2;
}
if (!silent)
printf("- Read last - delete - prev -> first\n");
DBUG_PRINT("progpos",("last - delete - prev -> first"));
if (maria_rprev(file,read_record3,0)) goto err;
if (maria_delete(file,read_record3)) goto err;
opt_delete++;
ant=0;
while (maria_rprev(file,read_record3,0) == 0 &&
bcmp(read_record3+start,key,length) == 0) ant++;
if (ant != dupp_keys-4)
{
printf("next: I can only find: %d keys of %d\n",ant,dupp_keys-4);
goto err2;
}
}
if (!silent)
puts("- Test if: Read rrnd - same");
DBUG_PRINT("progpos",("Read rrnd - same"));
assert(maria_scan_init(file) == 0);
for (i=0 ; i < write_count ; i++)
{
int tmp;
if ((tmp= maria_scan(file,read_record)) &&
tmp != HA_ERR_END_OF_FILE &&
tmp != HA_ERR_RECORD_DELETED)
{
printf("Got error %d when scanning table\n", tmp);
break;
}
if (!tmp)
{
/* Remember position to last found row */
info.recpos= maria_position(file);
bmove(read_record2,read_record,reclength);
}
}
maria_scan_end(file);
if (i != write_count && i != write_count - opt_delete)
{
printf("Found wrong number of rows while scanning table\n");
goto err2;
}
if (maria_rsame_with_pos(file,read_record,0,info.recpos))
goto err;
if (bcmp(read_record,read_record2,reclength) != 0)
{
printf("maria_rsame_with_pos didn't find same record\n");
goto err2;
}
for (i=min(2,keys) ; i-- > 0 ;)
{
if (maria_rsame(file,read_record2,(int) i)) goto err;
if (bcmp(read_record,read_record2,reclength) != 0)
{
printf("maria_rsame didn't find same record\n");
goto err2;
}
}
if (!silent)
puts("- Test maria_records_in_range");
maria_status(file,&info,HA_STATUS_VARIABLE);
for (i=0 ; i < info.keys ; i++)
{
key_range min_key, max_key;
if (maria_rfirst(file,read_record,(int) i) ||
maria_rlast(file,read_record2,(int) i))
goto err;
copy_key(file,(uint) i, read_record, key);
copy_key(file,(uint) i, read_record2, key2);
min_key.key= key;
min_key.keypart_map= HA_WHOLE_KEY;
min_key.flag= HA_READ_KEY_EXACT;
max_key.key= key2;
max_key.keypart_map= HA_WHOLE_KEY;
max_key.flag= HA_READ_AFTER_KEY;
range_records= maria_records_in_range(file,(int) i, &min_key, &max_key);
if (range_records < info.records*8/10 ||
range_records > info.records*12/10)
{
printf("maria_records_range returned %ld; Should be about %ld\n",
(long) range_records,(long) info.records);
goto err2;
}
if (verbose)
{
printf("maria_records_range returned %ld; Exact is %ld (diff: %4.2g %%)\n",
(long) range_records, (long) info.records,
labs((long) range_records - (long) info.records)*100.0/
info.records);
}
}
for (i=0 ; i < 5 ; i++)
{
for (j=rnd(1000)+1 ; j>0 && key1[j] == 0 ; j--) ;
for (k=rnd(1000)+1 ; k>0 && key1[k] == 0 ; k--) ;
if (j != 0 && k != 0)
{
key_range min_key, max_key;
if (j > k)
swap_variables(int, j, k);
sprintf((char*) key,"%6d",j);
sprintf((char*) key2,"%6d",k);
min_key.key= key;
min_key.keypart_map= HA_WHOLE_KEY;
min_key.flag= HA_READ_AFTER_KEY;
max_key.key= key2;
max_key.keypart_map= HA_WHOLE_KEY;
max_key.flag= HA_READ_BEFORE_KEY;
range_records= maria_records_in_range(file, 0, &min_key, &max_key);
records=0;
for (j++ ; j < k ; j++)
records+=key1[j];
if ((long) range_records < (long) records*7/10-2 ||
(long) range_records > (long) records*14/10+2)
{
printf("maria_records_range for key: %d returned %lu; Should be about %lu\n",
i, (ulong) range_records, (ulong) records);
goto err2;
}
if (verbose && records)
{
printf("maria_records_range returned %lu; Exact is %lu (diff: %4.2g %%)\n",
(ulong) range_records, (ulong) records,
labs((long) range_records-(long) records)*100.0/records);
}
}
}
if (!silent)
printf("- maria_info\n");
maria_status(file,&info,HA_STATUS_VARIABLE | HA_STATUS_CONST);
if (info.records != write_count-opt_delete ||
info.deleted > opt_delete + update || info.keys != keys)
{
puts("Wrong info from maria_info");
printf("Got: records: %lu delete: %lu i_keys: %d\n",
(ulong) info.records, (ulong) info.deleted, info.keys);
goto err2;
}
if (verbose)
{
char buff[80];
get_date(buff,3,info.create_time);
printf("info: Created %s\n",buff);
get_date(buff,3,info.check_time);
printf("info: checked %s\n",buff);
get_date(buff,3,info.update_time);
printf("info: Modified %s\n",buff);
}
maria_panic(HA_PANIC_WRITE);
maria_panic(HA_PANIC_READ);
if (maria_is_changed(file))
puts("Warning: maria_is_changed reported that datafile was changed");
if (!silent)
printf("- maria_extra(CACHE) + maria_rrnd.... + maria_extra(NO_CACHE)\n");
if (maria_reset(file) || maria_extra(file,HA_EXTRA_CACHE,0))
{
if (do_locking || (!use_blob && !pack_fields))
{
puts("got error from maria_extra(HA_EXTRA_CACHE)");
goto err;
}
}
ant=0;
assert(maria_scan_init(file) == 0);
while ((error= maria_scan(file,record)) != HA_ERR_END_OF_FILE &&
ant < write_count + 10)
ant+= error ? 0 : 1;
maria_scan_end(file);
if (ant != write_count-opt_delete)
{
printf("scan with cache: I can only find: %d records of %d\n",
ant,write_count-opt_delete);
maria_scan_end(file);
goto err2;
}
if (maria_extra(file,HA_EXTRA_NO_CACHE,0))
{
puts("got error from maria_extra(HA_EXTRA_NO_CACHE)");
maria_scan_end(file);
goto err;
}
maria_scan_end(file);
ant=0;
maria_scan_init(file);
while ((error=maria_scan(file,record)) != HA_ERR_END_OF_FILE &&
ant < write_count + 10)
ant+= error ? 0 : 1;
if (ant != write_count-opt_delete)
{
printf("scan with cache: I can only find: %d records of %d\n",
ant,write_count-opt_delete);
maria_scan_end(file);
goto err2;
}
maria_scan_end(file);
if (testflag == 5)
goto end;
if (checkpoint == 5 && ma_checkpoint_execute(CHECKPOINT_MEDIUM, FALSE))
goto err;
if (!silent)
printf("- Removing keys\n");
DBUG_PRINT("progpos",("Removing keys"));
lastpos = HA_OFFSET_ERROR;
/* DBUG_POP(); */
maria_reset(file);
found_parts=0;
maria_scan_init(file);
while ((error= maria_scan(file,read_record)) != HA_ERR_END_OF_FILE)
{
info.recpos=maria_position(file);
if (lastpos >= info.recpos && lastpos != HA_OFFSET_ERROR)
{
printf("maria_rrnd didn't advance filepointer; old: %ld, new: %ld\n",
(long) lastpos, (long) info.recpos);
goto err2;
}
lastpos=info.recpos;
if (error == 0)
{
if (opt_delete == (uint) remove_count) /* While testing */
goto end;
if (rnd(2) == 1 && maria_rsame(file,read_record,-1))
{
printf("can't find record %lx\n",(long) info.recpos);
goto err;
}
if (use_blob)
{
ulong blob_length,pos;
uchar *ptr;
memcpy(&ptr, read_record+blob_pos+4, sizeof(ptr));
blob_length= uint4korr(read_record+blob_pos);
for (pos=0 ; pos < blob_length ; pos++)
{
if (ptr[pos] != (uchar) (blob_length+pos))
{
printf("Found blob with wrong info at %ld\n",(long) lastpos);
maria_scan_end(file);
my_errno= 0;
goto err2;
}
}
}
if (maria_delete(file,read_record))
{
printf("can't delete record: %6.6s, delete_count: %d\n",
read_record, opt_delete);
maria_scan_end(file);
goto err;
}
opt_delete++;
}
else
found_parts++;
}
if (my_errno != HA_ERR_END_OF_FILE && my_errno != HA_ERR_RECORD_DELETED)
printf("error: %d from maria_rrnd\n",my_errno);
if (write_count != opt_delete)
{
printf("Deleted only %d of %d records (%d parts)\n",opt_delete,write_count,
found_parts);
maria_scan_end(file);
goto err2;
}
if (testflag == 6)
goto end;
if (checkpoint == 6 && ma_checkpoint_execute(CHECKPOINT_MEDIUM, FALSE))
goto err;
end:
maria_scan_end(file);
if (die_in_middle_of_transaction)
{
/* As commit record is not done, UNDO entries needs to be rolled back */
switch (die_in_middle_of_transaction) {
case 1:
/*
Flush changed data and index pages go to disk
That will also flush log. Recovery will skip REDOs and apply UNDOs.
*/
_ma_flush_table_files(file, MARIA_FLUSH_DATA | MARIA_FLUSH_INDEX,
FLUSH_RELEASE, FLUSH_RELEASE);
break;
case 2:
/*
Just flush log. Pages are likely to not be on disk. Recovery will
then execute REDOs and UNDOs.
*/
if (translog_flush(file->trn->undo_lsn))
goto err;
break;
case 3:
/*
Flush nothing. Pages and log are likely to not be on disk. Recovery
will then do nothing.
*/
break;
case 4:
/*
Flush changed data pages go to disk. Changed index pages are not
flushed. Recovery will skip some REDOs and apply UNDOs.
*/
_ma_flush_table_files(file, MARIA_FLUSH_DATA, FLUSH_RELEASE,
FLUSH_RELEASE);
/*
We have to flush log separately as the redo for the last key page
may not be flushed
*/
if (translog_flush(file->trn->undo_lsn))
goto err;
break;
}
printf("Dying on request without maria_commit()/maria_close()\n");
sf_leaking_memory= 1; /* no memory leak reports here */
exit(0);
}
if (maria_commit(file))
goto err;
if (maria_close(file))
{
file= 0;
goto err;
}
file= 0;
maria_panic(HA_PANIC_CLOSE); /* Should close log */
if (!silent)
{
printf("\nFollowing test have been made:\n");
printf("Write records: %d\nUpdate records: %d\nSame-key-read: %d\nDelete records: %d\n", write_count,update,dupp_keys,opt_delete);
if (rec_pointer_size)
printf("Record pointer size: %d\n",rec_pointer_size);
printf("maria_block_size: %lu\n", maria_block_size);
if (write_cacheing)
puts("Key cache resized");
if (write_cacheing)
puts("Write cacheing used");
if (write_cacheing)
puts("quick mode");
if (async_io && do_locking)
puts("Asyncron io with locking used");
else if (do_locking)
puts("Locking used");
if (use_blob)
puts("blobs used");
printf("key cache status: \n\
blocks used:%10lu\n\
not flushed:%10lu\n\
w_requests: %10lu\n\
writes: %10lu\n\
r_requests: %10lu\n\
reads: %10lu\n",
maria_pagecache->blocks_used,
maria_pagecache->global_blocks_changed,
(ulong) maria_pagecache->global_cache_w_requests,
(ulong) maria_pagecache->global_cache_write,
(ulong) maria_pagecache->global_cache_r_requests,
(ulong) maria_pagecache->global_cache_read);
}
static my_bool maria_page_crc_check(uchar *page,
pgcache_page_no_t page_no,
MARIA_SHARE *share,
uint32 no_crc_val,
int data_length)
{
uint32 crc= uint4korr(page + share->block_size - CRC_SIZE), new_crc;
my_bool res;
DBUG_ENTER("maria_page_crc_check");
DBUG_ASSERT((uint)data_length <= share->block_size - CRC_SIZE);
/* we need this assert to get following comparison working */
compile_time_assert(MARIA_NO_CRC_BITMAP_PAGE ==
MARIA_NO_CRC_NORMAL_PAGE - 1 &&
MARIA_NO_CRC_NORMAL_PAGE == 0xffffffff);
/*
If crc is no_crc_val then
the page has no crc, so there is nothing to check.
*/
if (crc >= MARIA_NO_CRC_BITMAP_PAGE)
{
DBUG_PRINT("info", ("No crc: %lu crc: %lu page: %lu ",
(ulong) no_crc_val, (ulong) crc, (ulong) page_no));
if (crc != no_crc_val)
{
my_errno= HA_ERR_WRONG_CRC;
DBUG_PRINT("error", ("Wrong no CRC value"));
DBUG_RETURN(1);
}
DBUG_RETURN(0);
}
new_crc= maria_page_crc((uint32) page_no, page, data_length);
DBUG_ASSERT(new_crc != no_crc_val);
res= MY_TEST(new_crc != crc);
if (res)
{
/*
Bitmap pages may be totally zero filled in some cases.
This happens when we get a crash after the pagecache has written
out a page that is on a newly created bitmap page and we get
a crash before the bitmap page is written out.
We handle this case with the following logic:
When reading, approve of bitmap pages where all bytes are zero
(This is after all a bitmap pages where no data is reserved and
the CRC will be corrected at next write)
*/
if (no_crc_val == MARIA_NO_CRC_BITMAP_PAGE &&
crc == 0 && _ma_check_if_zero(page, data_length))
{
DBUG_PRINT("warning", ("Found bitmap page that was not initialized"));
DBUG_RETURN(0);
}
DBUG_PRINT("error", ("Page: %lu crc: %lu calculated crc: %lu",
(ulong) page_no, (ulong) crc, (ulong) new_crc));
my_errno= HA_ERR_WRONG_CRC;
}
DBUG_RETURN(res);
}
my_bool pvio_shm_connect(MARIADB_PVIO *pvio, MA_PVIO_CINFO *cinfo)
{
const char *base_memory_name;
char *prefixes[]= {"", "Global\\", NULL};
char *shm_name, *shm_suffix, *shm_prefix;
uchar i= 0;
int len;
int cid;
DWORD dwDesiredAccess= EVENT_MODIFY_STATE | SYNCHRONIZE;
HANDLE hdlConnectRequest= NULL,
hdlConnectRequestAnswer= NULL,
file_map= NULL;
LPVOID map= NULL;
PVIO_SHM *pvio_shm= (PVIO_SHM*)LocalAlloc(LMEM_ZEROINIT, sizeof(PVIO_SHM));
if (!pvio_shm)
{
PVIO_SET_ERROR(cinfo->mysql, CR_OUT_OF_MEMORY, "HY000", 0, "");
return 0;
}
/* MariaDB server constructs the event name as follows:
"Global\\base_memory_name" or
"\\base_memory_name"
*/
base_memory_name= (cinfo->host) ? cinfo->host : SHM_DEFAULT_NAME;
if (!(shm_name= (char *)LocalAlloc(LMEM_ZEROINIT, strlen(base_memory_name) + 40)))
{
PVIO_SET_ERROR(cinfo->mysql, CR_OUT_OF_MEMORY, "HY000", 0, "");
goto error;
}
/* iterate through prefixes */
while (prefixes[i])
{
len= sprintf(shm_name, "%s%s_", prefixes[i], base_memory_name);
shm_suffix= shm_name + len;
strcpy(shm_suffix, "CONNECT_REQUEST");
if ((hdlConnectRequest= OpenEvent(dwDesiredAccess, 0, shm_name)))
{
/* save prefix to prevent further loop */
shm_prefix= prefixes[i];
break;
}
i++;
}
if (!hdlConnectRequest)
{
PVIO_SET_ERROR(cinfo->mysql, CR_SHARED_MEMORY_CONNECT_ERROR, "HY000", 0, "Opening CONNECT_REQUEST event failed", GetLastError());
goto error;
}
strcpy(shm_suffix, "CONNECT_ANSWER");
if (!(hdlConnectRequestAnswer= OpenEvent(dwDesiredAccess, 0, shm_name)))
{
PVIO_SET_ERROR(cinfo->mysql, CR_SHARED_MEMORY_CONNECT_ERROR, "HY000", 0, "Opening CONNECT_ANSWER event failed", GetLastError());
goto error;
}
/* get connection id, so we can build the filename used for connection */
strcpy(shm_suffix, "CONNECT_DATA");
if (!(file_map= OpenFileMapping(FILE_MAP_WRITE, 0, shm_name)))
{
PVIO_SET_ERROR(cinfo->mysql, CR_SHARED_MEMORY_CONNECT_ERROR, "HY000", 0, "OpenFileMapping failed", GetLastError());
goto error;
}
/* try to get first 4 bytes, which represents connection_id */
if (!(map= MapViewOfFile(file_map, FILE_MAP_WRITE, 0, 0, sizeof(cid))))
{
PVIO_SET_ERROR(cinfo->mysql, CR_SHARED_MEMORY_CONNECT_ERROR, "HY000", 0, "Reading connection_id failed", GetLastError());
goto error;
}
/* notify server */
if (!SetEvent(hdlConnectRequest))
{
PVIO_SET_ERROR(cinfo->mysql, CR_SHARED_MEMORY_CONNECT_ERROR, "HY000", 0, "Failed sending connection request", GetLastError());
goto error;
}
/* Wait for server answer */
switch(WaitForSingleObject(hdlConnectRequestAnswer, pvio->timeout[PVIO_CONNECT_TIMEOUT])) {
case WAIT_ABANDONED:
PVIO_SET_ERROR(cinfo->mysql, CR_SHARED_MEMORY_CONNECT_ERROR, "HY000", 0, "Mutex was not released in time", GetLastError());
goto error;
break;
case WAIT_FAILED:
PVIO_SET_ERROR(cinfo->mysql, CR_SHARED_MEMORY_CONNECT_ERROR, "HY000", 0, "Operation wait failed", GetLastError());
goto error;
break;
case WAIT_TIMEOUT:
PVIO_SET_ERROR(cinfo->mysql, CR_SHARED_MEMORY_CONNECT_ERROR, "HY000", 0, "Operation timed out", GetLastError());
goto error;
break;
case WAIT_OBJECT_0:
break;
default:
PVIO_SET_ERROR(cinfo->mysql, CR_SHARED_MEMORY_CONNECT_ERROR, "HY000", 0, "Wait for server failed", GetLastError());
break;
}
cid= uint4korr(map);
len= sprintf(shm_name, "%s%s_%d_", shm_prefix, base_memory_name, cid);
shm_suffix= shm_name + len;
strcpy(shm_suffix, "DATA");
pvio_shm->file_map= OpenFileMapping(FILE_MAP_WRITE, 0, shm_name);
if (pvio_shm->file_map == NULL)
{
PVIO_SET_ERROR(cinfo->mysql, CR_SHARED_MEMORY_CONNECT_ERROR, "HY000", 0, "OpenFileMapping failed", GetLastError());
goto error;
}
if (!(pvio_shm->map= MapViewOfFile(pvio_shm->file_map, FILE_MAP_WRITE, 0, 0, PVIO_SHM_BUFFER_SIZE)))
{
PVIO_SET_ERROR(cinfo->mysql, CR_SHARED_MEMORY_CONNECT_ERROR, "HY000", 0, "MapViewOfFile failed", GetLastError());
goto error;
}
for (i=0; i < 5; i++)
{
strcpy(shm_suffix, StrEvent[i]);
if (!(pvio_shm->event[i]= OpenEvent(dwDesiredAccess, 0, shm_name)))
{
PVIO_SET_ERROR(cinfo->mysql, CR_SHARED_MEMORY_CONNECT_ERROR, "HY000", 0, "Couldn't create event", GetLastError());
goto error;
}
}
/* we will first read from server */
SetEvent(pvio_shm->event[PVIO_SHM_SERVER_READ]);
error:
if (hdlConnectRequest)
CloseHandle(hdlConnectRequest);
if (hdlConnectRequestAnswer)
CloseHandle(hdlConnectRequestAnswer);
if (shm_name)
LocalFree(shm_name);
if (map)
UnmapViewOfFile(map);
if (file_map)
CloseHandle(file_map);
if (pvio_shm)
{
/* check if all events are set */
if (pvio_shm->event[4])
{
pvio->data= (void *)pvio_shm;
pvio->mysql= cinfo->mysql;
pvio->type= cinfo->type;
pvio_shm->read_pos= (char *)pvio_shm->map;
pvio->mysql->net.pvio= pvio;
return 0;
}
for (i=0;i < 5; i++)
if (pvio_shm->event[i])
CloseHandle(pvio_shm->event[i]);
if (pvio_shm->map)
UnmapViewOfFile(pvio_shm->map);
if (pvio_shm->file_map)
CloseHandle(pvio_shm->file_map);
LocalFree(pvio_shm);
}
return 1;
}
int mysac_decode_field(char *buf, int len, MYSQL_FIELD *col) {
int i;
unsigned long size;
char nul;
char *wh;
int tmp_len;
/*
VERSION 4.0
Bytes Name
----- ----
n (Length Coded String) table
n (Length Coded String) name
4 (Length Coded Binary) length
2 (Length Coded Binary) type
2 (Length Coded Binary) flags
1 decimals
n (Length Coded Binary) default
-> VERSION 4.1
Bytes Name
----- ----
n (Length Coded String) catalog
n (Length Coded String) db
n (Length Coded String) table
n (Length Coded String) org_table
n (Length Coded String) name
n (Length Coded String) org_name
1 (filler)
2 charsetnr
4 length
1 type
2 flags
1 decimals
2 (filler), always 0x00
n (Length Coded Binary) default
*/
wh = buf;
i = 0;
/* n (Length Coded String) catalog */
tmp_len = my_lcb(&buf[i], &size, &nul, len-i);
if (tmp_len == -1)
return -MYERR_BAD_LCB;
i += tmp_len;
if (i + size > (unsigned int)len)
return -MYERR_LEN_OVER_BUFFER;
col->catalog_length = size;
memmove(wh, &buf[i], size);
col->catalog = wh;
col->catalog[size] = '\0';
wh += size + 1;
i += size;
/* n (Length Coded String) db */
tmp_len = my_lcb(&buf[i], &size, &nul, len-i);
if (tmp_len == -1)
return -MYERR_BAD_LCB;
i += tmp_len;
if (i + size > (unsigned int)len)
return -MYERR_LEN_OVER_BUFFER;
col->db_length = size;
memmove(wh, &buf[i], size);
col->db = wh;
col->db[size] = '\0';
wh += size + 1;
i += size;
/* n (Length Coded String) table */
tmp_len = my_lcb(&buf[i], &size, &nul, len-i);
if (tmp_len == -1)
return -MYERR_BAD_LCB;
i += tmp_len;
if (i + size > (unsigned int)len)
return -MYERR_LEN_OVER_BUFFER;
col->table_length = size;
memmove(wh, &buf[i], size);
col->table = wh;
col->table[size] = '\0';
wh += size + 1;
i += size;
/* n (Length Coded String) org_table */
tmp_len = my_lcb(&buf[i], &size, &nul, len-i);
if (tmp_len == -1)
return -MYERR_BAD_LCB;
i += tmp_len;
if (i + size > (unsigned int)len)
return -MYERR_LEN_OVER_BUFFER;
col->org_table_length = size;
memmove(wh, &buf[i], size);
col->org_table = wh;
col->org_table[size] = '\0';
wh += size + 1;
i += size;
/* n (Length Coded String) name */
tmp_len = my_lcb(&buf[i], &size, &nul, len-i);
if (tmp_len == -1)
return -MYERR_BAD_LCB;
i += tmp_len;
if (i + size > (unsigned int)len)
return -MYERR_LEN_OVER_BUFFER;
col->name_length = size;
memmove(wh, &buf[i], size);
col->name = wh;
col->name[size] = '\0';
wh += size + 1;
i += size;
/* n (Length Coded String) org_name */
tmp_len = my_lcb(&buf[i], &size, &nul, len-i);
if (tmp_len == -1)
return -MYERR_BAD_LCB;
i += tmp_len;
if (i + size > (unsigned int)len)
return -MYERR_LEN_OVER_BUFFER;
col->org_name_length = size;
memmove(wh, &buf[i], size);
col->org_name = wh;
col->org_name[size] = '\0';
wh += size + 1;
i += size;
/* check len */
if (i + 13 > len)
return -MYERR_LEN_OVER_BUFFER;
/* (filler) */
i += 1;
/* charset */
col->charsetnr = uint2korr(&buf[i]);
i += 2;
/* length */
col->length = uint4korr(&buf[i]);
i += 4;
/* type */
col->type = (unsigned char)buf[i];
i += 1;
/* flags */
col->flags = uint3korr(&buf[i]);
i += 2;
/* decimals */
col->decimals = buf[i];
i += 1;
/* filler */
i += 2;
/* default - a priori facultatif */
if (len-i > 0) {
tmp_len = my_lcb(&buf[i], &size, &nul, len-i);
if (tmp_len == -1)
return -MYERR_BAD_LCB;
i += tmp_len;
if (i + size > (unsigned int)len)
return -MYERR_LEN_OVER_BUFFER;
col->def_length = size;
memmove(wh, &buf[i], size);
col->def = wh;
col->def[size] = '\0';
wh += size + 1;
i += size;
}
else {
col->def = NULL;
col->def_length = 0;
}
/* set write pointer */
return wh - buf;
}
static int sp_get_geometry_mbr(uchar *(*wkb), uchar *end, uint n_dims,
double *mbr, int top)
{
int res;
uchar byte_order;
uint wkb_type;
byte_order = *(*wkb);
++(*wkb);
wkb_type = uint4korr((*wkb));
(*wkb) += 4;
switch ((enum wkbType) wkb_type)
{
case wkbPoint:
res = sp_get_point_mbr(wkb, end, n_dims, byte_order, mbr);
break;
case wkbLineString:
res = sp_get_linestring_mbr(wkb, end, n_dims, byte_order, mbr);
break;
case wkbPolygon:
res = sp_get_polygon_mbr(wkb, end, n_dims, byte_order, mbr);
break;
case wkbMultiPoint:
{
uint n_items;
n_items = uint4korr((*wkb));
(*wkb) += 4;
for (; n_items > 0; --n_items)
{
byte_order = *(*wkb);
++(*wkb);
(*wkb) += 4;
if (sp_get_point_mbr(wkb, end, n_dims, byte_order, mbr))
return -1;
}
res = 0;
break;
}
case wkbMultiLineString:
{
uint n_items;
n_items = uint4korr((*wkb));
(*wkb) += 4;
for (; n_items > 0; --n_items)
{
byte_order = *(*wkb);
++(*wkb);
(*wkb) += 4;
if (sp_get_linestring_mbr(wkb, end, n_dims, byte_order, mbr))
return -1;
}
res = 0;
break;
}
case wkbMultiPolygon:
{
uint n_items;
n_items = uint4korr((*wkb));
(*wkb) += 4;
for (; n_items > 0; --n_items)
{
byte_order = *(*wkb);
++(*wkb);
(*wkb) += 4;
if (sp_get_polygon_mbr(wkb, end, n_dims, byte_order, mbr))
return -1;
}
res = 0;
break;
}
case wkbGeometryCollection:
{
uint n_items;
if (!top)
return -1;
n_items = uint4korr((*wkb));
(*wkb) += 4;
for (; n_items > 0; --n_items)
{
if (sp_get_geometry_mbr(wkb, end, n_dims, mbr, 0))
return -1;
}
res = 0;
break;
}
default:
res = -1;
}
return res;
}
int main(int argc __attribute__((unused)), char *argv[])
{
uint pagen;
int rc= 1;
uchar long_tr_id[6];
PAGECACHE pagecache;
LSN first_lsn;
TRANSLOG_HEADER_BUFFER rec;
LEX_CUSTRING parts[TRANSLOG_INTERNAL_PARTS + 1];
translog_size_t len;
MY_INIT(argv[0]);
plan(1);
bzero(&pagecache, sizeof(pagecache));
maria_data_root= create_tmpdir(argv[0]);
if (maria_log_remove(0))
exit(1);
bzero(long_tr_id, 6);
#ifndef DBUG_OFF
#if defined(__WIN__)
default_dbug_option= "d:t:i:O,\\ma_test_loghandler.trace";
#else
default_dbug_option= "d:t:i:o,/tmp/ma_test_loghandler.trace";
#endif
if (argc > 1)
{
DBUG_SET(default_dbug_option);
DBUG_SET_INITIAL(default_dbug_option);
}
#endif
if (ma_control_file_open(TRUE, TRUE))
{
fprintf(stderr, "Can't init control file (%d)\n", errno);
exit(1);
}
if ((pagen= init_pagecache(&pagecache, PCACHE_SIZE, 0, 0,
PCACHE_PAGE, 0)) == 0)
{
fprintf(stderr, "Got error: init_pagecache() (errno: %d)\n", errno);
exit(1);
}
if (translog_init_with_table(maria_data_root, LOG_FILE_SIZE, 50112, 0, &pagecache,
LOG_FLAGS, 0, &translog_example_table_init,
0))
{
fprintf(stderr, "Can't init loghandler (%d)\n", errno);
exit(1);
}
/* Suppressing of automatic record writing */
dummy_transaction_object.first_undo_lsn|= TRANSACTION_LOGGED_LONG_ID;
int4store(long_tr_id, 0);
long_tr_id[5]= 0xff;
parts[TRANSLOG_INTERNAL_PARTS + 0].str= long_tr_id;
parts[TRANSLOG_INTERNAL_PARTS + 0].length= 6;
if (translog_write_record(&first_lsn,
LOGREC_FIXED_RECORD_0LSN_EXAMPLE,
&dummy_transaction_object, NULL, 6,
TRANSLOG_INTERNAL_PARTS + 1,
parts, NULL, NULL))
{
fprintf(stderr, "Can't write record #%lu\n", (ulong) 0);
translog_destroy();
exit(1);
}
len= translog_read_record_header(first_lsn, &rec);
if (len == 0)
{
fprintf(stderr, "translog_read_record_header failed (%d)\n", errno);
goto err;
}
if (rec.type !=LOGREC_FIXED_RECORD_0LSN_EXAMPLE || rec.short_trid != 0 ||
rec.record_length != 6 || uint4korr(rec.header) != 0 ||
((uchar)rec.header[4]) != 0 || ((uchar)rec.header[5]) != 0xFF ||
first_lsn != rec.lsn)
{
fprintf(stderr, "Incorrect LOGREC_FIXED_RECORD_0LSN_EXAMPLE "
"data read(0)\n"
"type: %u (%d) strid: %u (%d) len: %u (%d) i: %u (%d), "
"4: %u (%d) 5: %u (%d) "
"lsn(%lu,0x%lx) (%d)\n",
(uint) rec.type, (rec.type !=LOGREC_FIXED_RECORD_0LSN_EXAMPLE),
(uint) rec.short_trid, (rec.short_trid != 0),
(uint) rec.record_length, (rec.record_length != 6),
(uint) uint4korr(rec.header), (uint4korr(rec.header) != 0),
(uint) rec.header[4], (((uchar)rec.header[4]) != 0),
(uint) rec.header[5], (((uchar)rec.header[5]) != 0xFF),
LSN_IN_PARTS(rec.lsn), (first_lsn != rec.lsn));
goto err;
}
ok(1, "read OK");
rc= 0;
err:
translog_destroy();
end_pagecache(&pagecache, 1);
ma_control_file_end();
if (maria_log_remove(maria_data_root))
exit(1);
exit(rc);
}
static void update_record(uchar *record)
{
uchar *pos=record+1;
if (recinfo[1].type == FIELD_BLOB)
{
uchar *column,*ptr;
int length;
length=uint4korr(pos); /* Long blob */
memcpy_fixed(&column,pos+4,sizeof(char*));
memcpy(blob_key,column,length); /* Move old key */
ptr=blob_key;
memcpy_fixed(pos+4,&ptr,sizeof(char*)); /* Store pointer to new key */
if (keyinfo[0].seg[0].type != HA_KEYTYPE_NUM)
default_charset_info->cset->casedn(default_charset_info,
(char*) blob_key, length,
(char*) blob_key, length);
pos+=recinfo[1].length;
}
else if (recinfo[1].type == FIELD_VARCHAR)
{
uint pack_length= HA_VARCHAR_PACKLENGTH(recinfo[1].length-1);
uint length= pack_length == 1 ? (uint) *(uchar*) pos : uint2korr(pos);
default_charset_info->cset->casedn(default_charset_info,
(char*) pos + pack_length, length,
(char*) pos + pack_length, length);
pos+=recinfo[1].length;
}
else
{
if (keyinfo[0].seg[0].type != HA_KEYTYPE_NUM)
default_charset_info->cset->casedn(default_charset_info,
(char*) pos, keyinfo[0].seg[0].length,
(char*) pos, keyinfo[0].seg[0].length);
pos+=recinfo[1].length;
}
if (recinfo[2].type == FIELD_BLOB)
{
uchar *column;
int length;
length=uint4korr(pos);
memcpy_fixed(&column,pos+4,sizeof(char*));
memcpy(blob_record,column,length);
bfill(blob_record+length,20,'.'); /* Make it larger */
length+=20;
int4store(pos,length);
column= blob_record;
memcpy_fixed(pos+4,&column,sizeof(char*));
}
else if (recinfo[2].type == FIELD_VARCHAR)
{
/* Second field is longer than 10 characters */
uint pack_length= HA_VARCHAR_PACKLENGTH(recinfo[1].length-1);
uint length= pack_length == 1 ? (uint) *(uchar*) pos : uint2korr(pos);
bfill(pos+pack_length+length,recinfo[2].length-length-pack_length,'.');
length=recinfo[2].length-pack_length;
if (pack_length == 1)
*(uchar*) pos= (uchar) length;
else
int2store(pos,length);
}
else
{
bfill(pos+recinfo[2].length-10,10,'.');
}
}
/*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*/
uint64_t CTableMapLogEvent::get_table_id(uint8_t* data, size_t size, const CFormatDescriptionLogEvent& fmt)
{
uint8_t* post_start = data + fmt._common_header_len + TM_MAPID_OFFSET;
return fmt._post_header_len[TABLE_MAP_EVENT - 1] == 6 ? (uint64_t)uint4korr(post_start) : (uint64_t)uint6korr(post_start);
}
