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); }