mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-01-31 11:01:52 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge joreland@bk-internal.mysql.com:/home/bk/mysql-5.1-new-ndb

Browse source 
into  perch.ndb.mysql.com:/home/jonas/src/mysql-5.1-new-ndb
This commit is contained in:
jonas@perch.ndb.mysql.com 2007-04-25 23:49:37 +02:00
commit 35b65dbf14
10 changed files with 93 additions and 157 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
storage/ndb/src/kernel/blocks/dbdict/Dbdict.cpp
View file

@ -2819,8 +2819,10 @@ void Dbdict::checkSchemaStatus(Signal* signal)
continue;
case SchemaFile::ADD_STARTED: jam();
case SchemaFile::DROP_TABLE_STARTED: jam();
ndbrequire(false);
return;
ndbrequire(DictTabInfo::isTable(newEntry->m_tableType) ||
DictTabInfo::isIndex(newEntry->m_tableType));
newEntry->m_tableState = SchemaFile::INIT;
continue;
case SchemaFile::TABLE_ADD_COMMITTED: jam();
case SchemaFile::ALTER_TABLE_COMMITTED: jam();
if (DictTabInfo::isIndex(newEntry->m_tableType) ||

35
storage/ndb/src/kernel/blocks/dbtup/Dbtup.hpp
View file

@ -1021,18 +1021,12 @@ ArrayPool<TupTriggerData> c_triggerPool;
Uint8 m_null_words;
Uint8 m_null_offset;
Uint16 m_disk_ref_offset; // In words relative m_data
union {
Uint16 m_varpart_offset; // In words relative m_data
Uint16 m_fix_header_size; // For fix size tuples= total rec size(part)
};
Uint16 m_fix_header_size; // For fix size tuples= total rec size(part)
Uint16 m_max_var_offset; // In bytes relative m_var_data.m_data_ptr
} m_offsets[2];
Uint32 get_check_offset(Uint32 mm) const {
Uint32 cnt= m_attributes[mm].m_no_of_varsize;
Uint32 off= m_offsets[mm].m_varpart_offset;
return off - (cnt ? 0 : Tuple_header::HeaderSize);
return m_offsets[mm].m_fix_header_size;
}
struct {
@ -1321,6 +1315,11 @@ typedef Ptr<HostBuffer> HostBufferPtr;
#endif
};
struct Disk_part_ref
{
STATIC_CONST( SZ32 = 2 );
};
struct Tuple_header
{
union {
@ -1370,14 +1369,24 @@ typedef Ptr<HostBuffer> HostBufferPtr;
return m_null_bits+tabPtrP->m_offsets[mm].m_null_offset;
}
Uint32* get_var_part_ptr(const Tablerec* tabPtrP) {
return m_data + tabPtrP->m_offsets[MM].m_varpart_offset;
Var_part_ref* get_var_part_ref_ptr(const Tablerec* tabPtrP) {
return (Var_part_ref*)(get_disk_ref_ptr(tabPtrP) + Disk_part_ref::SZ32);
}
const Uint32* get_var_part_ptr(const Tablerec* tabPtrP) const {
return m_data + tabPtrP->m_offsets[MM].m_varpart_offset;
const Var_part_ref* get_var_part_ref_ptr(const Tablerec* tabPtrP) const {
return (Var_part_ref*)(get_disk_ref_ptr(tabPtrP) + Disk_part_ref::SZ32);
}
Uint32* get_end_of_fix_part_ptr(const Tablerec* tabPtrP) {
return m_data + tabPtrP->m_offsets[MM].m_fix_header_size -
Tuple_header::HeaderSize;
}
const Uint32* get_end_of_fix_part_ptr(const Tablerec* tabPtrP) const {
return m_data + tabPtrP->m_offsets[MM].m_fix_header_size -
Tuple_header::HeaderSize;
}
Uint32* get_disk_ref_ptr(const Tablerec* tabPtrP) {
return m_data + tabPtrP->m_offsets[MM].m_disk_ref_offset;
}

3
storage/ndb/src/kernel/blocks/dbtup/DbtupAbort.cpp
View file

@ -152,8 +152,7 @@ void Dbtup::do_tup_abortreq(Signal* signal, Uint32 flags)
ndbassert(tuple_ptr->m_header_bits & Tuple_header::CHAINED_ROW);
Var_part_ref *ref =
(Var_part_ref*)tuple_ptr->get_var_part_ptr(regTabPtr.p);
Var_part_ref *ref = tuple_ptr->get_var_part_ref_ptr(regTabPtr.p);
Local_key tmp;
ref->copyout(&tmp);

19
storage/ndb/src/kernel/blocks/dbtup/DbtupCommit.cpp
View file

@ -233,16 +233,22 @@ Dbtup::commit_operation(Signal* signal,
}
else
{
Var_part_ref *ref= (Var_part_ref*)tuple_ptr->get_var_part_ptr(regTabPtr);
memcpy(tuple_ptr, copy, 4*(Tuple_header::HeaderSize+fixsize));
/**
* Var_part_ref is only stored in *allocated* tuple
* so memcpy from copy, will over write it...
* hence subtle copyout/assign...
*/
Local_key tmp;
Var_part_ref *ref= tuple_ptr->get_var_part_ref_ptr(regTabPtr);
ref->copyout(&tmp);
memcpy(tuple_ptr, copy, 4*fixsize);
ref->assign(&tmp);
PagePtr vpagePtr;
Uint32 *dst= get_ptr(&vpagePtr, *ref);
Var_page* vpagePtrP = (Var_page*)vpagePtr.p;
Uint32 *src= copy->get_var_part_ptr(regTabPtr);
Uint32 *src= copy->get_end_of_fix_part_ptr(regTabPtr);
Uint32 sz= ((mm_vars + 1) << 1) + (((Uint16*)src)[mm_vars]);
ndbassert(4*vpagePtrP->get_entry_len(tmp.m_page_idx) >= sz);
memcpy(dst, src, sz);
@ -255,9 +261,8 @@ Dbtup::commit_operation(Signal* signal,
update_free_page_list(regFragPtr, vpagePtr);
}
disk_ptr = (Tuple_header*)
(((Uint32*)copy)+Tuple_header::HeaderSize+fixsize+((sz + 3) >> 2));
}
disk_ptr = (Tuple_header*)(((Uint32*)copy)+fixsize+((sz + 3) >> 2));
}
if (regTabPtr->m_no_of_disk_attributes &&
(copy_bits & Tuple_header::DISK_INLINE))

2
storage/ndb/src/kernel/blocks/dbtup/DbtupDebug.cpp
View file

@ -366,7 +366,7 @@ operator<<(NdbOut& out, const Dbtup::Tablerec::Tuple_offsets& off)
out << "[ null_words: " << (Uint32)off.m_null_words
<< " null off: " << (Uint32)off.m_null_offset
<< " disk_off: " << off.m_disk_ref_offset
<< " var_off: " << off.m_varpart_offset
<< " fixheadsz: " << off.m_fix_header_size
<< " max_var_off: " << off.m_max_var_offset
<< " ]";

129
storage/ndb/src/kernel/blocks/dbtup/DbtupExecQuery.cpp
View file

@ -222,9 +222,6 @@ Dbtup::calculateChecksum(Tuple_header* tuple_ptr,
// includes tupVersion
//printf("%p - ", tuple_ptr);
if (regTabPtr->m_attributes[MM].m_no_of_varsize)
rec_size += Tuple_header::HeaderSize;
for (i= 0; i < rec_size-2; i++) {
checksum ^= tuple_header[i];
//printf("%.8x ", tuple_header[i]);
@ -1107,7 +1104,7 @@ Dbtup::prepare_initial_insert(KeyReqStruct *req_struct,
const Uint32 cnt1= regTabPtr->m_attributes[MM].m_no_of_varsize;
const Uint32 cnt2= regTabPtr->m_attributes[DD].m_no_of_varsize;
Uint32 *ptr= req_struct->m_tuple_ptr->get_var_part_ptr(regTabPtr);
Uint32 *ptr= req_struct->m_tuple_ptr->get_end_of_fix_part_ptr(regTabPtr);
if(cnt1)
{
@ -1129,22 +1126,10 @@ Dbtup::prepare_initial_insert(KeyReqStruct *req_struct,
pos += AttributeDescriptor::getSizeInBytes(tab_descr[*order++].tabDescr);
}
}
else
{
ptr -= Tuple_header::HeaderSize;
}
req_struct->m_disk_ptr= (Tuple_header*)ptr;
if(cnt2)
{
KeyReqStruct::Var_data *dst= &req_struct->m_var_data[DD];
ptr=((Tuple_header*)ptr)->m_data+regTabPtr->m_offsets[DD].m_varpart_offset;
dst->m_data_ptr= (char*)(((Uint16*)ptr)+cnt2+1);
dst->m_offset_array_ptr= req_struct->var_pos_array + (cnt1 << 1);
dst->m_var_len_offset= cnt2;
dst->m_max_var_offset= regTabPtr->m_offsets[DD].m_max_var_offset;
}
ndbrequire(cnt2 == 0);
// Set all null bits
memset(req_struct->m_tuple_ptr->m_null_bits+
@ -2524,13 +2509,14 @@ Dbtup::expand_tuple(KeyReqStruct* req_struct,
Uint16 dd_tot= tabPtrP->m_no_of_disk_attributes;
Uint16 mm_vars= tabPtrP->m_attributes[MM].m_no_of_varsize;
Uint32 fix_size= tabPtrP->m_offsets[MM].m_varpart_offset;
Uint32 fix_size= tabPtrP->m_offsets[MM].m_fix_header_size;
Uint32 order_desc= tabPtrP->m_real_order_descriptor;
Uint32 *dst_ptr= ptr->get_var_part_ptr(tabPtrP);
Uint32 *dst_ptr= ptr->get_end_of_fix_part_ptr(tabPtrP);
const Uint32 *disk_ref= src->get_disk_ref_ptr(tabPtrP);
const Uint32 *src_ptr= src->get_var_part_ptr(tabPtrP);
const Uint32 * desc= (Uint32*)req_struct->attr_descr;
const Uint32 *src_ptr= src->get_end_of_fix_part_ptr(tabPtrP);
const Var_part_ref* var_ref = src->get_var_part_ref_ptr(tabPtrP);
const Uint32 *desc= (Uint32*)req_struct->attr_descr;
const Uint16 *order = (Uint16*)(&tableDescriptor[order_desc]);
order += tabPtrP->m_attributes[MM].m_no_of_fixsize;
@ -2543,7 +2529,7 @@ Dbtup::expand_tuple(KeyReqStruct* req_struct,
if(bits & Tuple_header::CHAINED_ROW)
{
Ptr<Page> var_page;
src_data= get_ptr(&var_page, * (Var_part_ref*)src_ptr);
src_data= get_ptr(&var_page, *var_ref);
step= 4;
sizes[MM]= (2 + (mm_vars << 1) + ((Uint16*)src_data)[mm_vars] + 3) >> 2;
req_struct->m_varpart_page_ptr = var_page;
@ -2564,14 +2550,12 @@ Dbtup::expand_tuple(KeyReqStruct* req_struct,
ndbassert((UintPtr(src_ptr) & 3) == 0);
src_ptr = ALIGN_WORD(((char*)src_ptr)+step);
sizes[MM] += fix_size + Tuple_header::HeaderSize;
memcpy(ptr, src, 4*(fix_size + Tuple_header::HeaderSize));
sizes[MM] += fix_size;
memcpy(ptr, src, 4*fix_size);
}
else
{
sizes[MM]= 1;
dst_ptr -= Tuple_header::HeaderSize;
src_ptr -= Tuple_header::HeaderSize;
memcpy(ptr, src, 4*fix_size);
}
@ -2605,20 +2589,7 @@ Dbtup::expand_tuple(KeyReqStruct* req_struct,
ndbassert(! (req_struct->m_disk_ptr->m_header_bits & Tuple_header::FREE));
if(dd_vars)
{
KeyReqStruct::Var_data* dst= &req_struct->m_var_data[DD];
dst_ptr += tabPtrP->m_offsets[DD].m_varpart_offset;
src_ptr += tabPtrP->m_offsets[DD].m_varpart_offset;
order += tabPtrP->m_attributes[DD].m_no_of_fixsize;
dst->m_data_ptr= (char*)(char*)(((Uint16*)dst_ptr)+dd_vars+1);
dst->m_offset_array_ptr= req_struct->var_pos_array + (mm_vars << 1);
dst->m_var_len_offset= dd_vars;
dst->m_max_var_offset= tabPtrP->m_offsets[DD].m_max_var_offset;
expand_var_part(dst, src_ptr, desc, order);
}
ndbrequire(dd_vars == 0);
}
ptr->m_header_bits= (bits & ~(Uint32)(Tuple_header::CHAINED_ROW));
@ -2634,9 +2605,9 @@ Dbtup::prepare_read(KeyReqStruct* req_struct,
Uint16 dd_tot= tabPtrP->m_no_of_disk_attributes;
Uint16 mm_vars= tabPtrP->m_attributes[MM].m_no_of_varsize;
const Uint32 *src_ptr= ptr->get_var_part_ptr(tabPtrP);
const Uint32 *src_ptr= ptr->get_end_of_fix_part_ptr(tabPtrP);
const Uint32 *disk_ref= ptr->get_disk_ref_ptr(tabPtrP);
const Var_part_ref* var_ref = ptr->get_var_part_ref_ptr(tabPtrP);
if(mm_vars)
{
const Uint32 *src_data= src_ptr;
@ -2646,7 +2617,7 @@ Dbtup::prepare_read(KeyReqStruct* req_struct,
#if VM_TRACE
#endif
src_data= get_ptr(* (Var_part_ref*)src_ptr);
src_data= get_ptr(* var_ref);
}
dst->m_data_ptr= (char*)(((Uint16*)src_data)+mm_vars+1);
dst->m_offset_array_ptr= (Uint16*)src_data;
@ -2656,11 +2627,6 @@ Dbtup::prepare_read(KeyReqStruct* req_struct,
// disk part start after varsize (aligned)
src_ptr = ALIGN_WORD(dst->m_data_ptr + dst->m_max_var_offset);
}
else
{
// disk part if after fixsize part...
src_ptr -= Tuple_header::HeaderSize;
}
if(disk && dd_tot)
{
@ -2682,16 +2648,7 @@ Dbtup::prepare_read(KeyReqStruct* req_struct,
// Fix diskpart
req_struct->m_disk_ptr= (Tuple_header*)src_ptr;
ndbassert(! (req_struct->m_disk_ptr->m_header_bits & Tuple_header::FREE));
if(dd_vars)
{
KeyReqStruct::Var_data* dst= &req_struct->m_var_data[DD];
src_ptr += tabPtrP->m_offsets[DD].m_varpart_offset;
dst->m_data_ptr= (char*)(char*)(((Uint16*)src_ptr)+dd_vars+1);
dst->m_offset_array_ptr= (Uint16*)src_ptr;
dst->m_var_len_offset= 1;
dst->m_max_var_offset= ((Uint16*)src_ptr)[dd_vars];
}
ndbrequire(dd_vars == 0);
}
}
@ -2706,10 +2663,11 @@ Dbtup::shrink_tuple(KeyReqStruct* req_struct, Uint32 sizes[2],
Uint16 mm_vars= tabPtrP->m_attributes[MM].m_no_of_varsize;
Uint16 dd_vars= tabPtrP->m_attributes[DD].m_no_of_varsize;
Uint32 *dst_ptr= ptr->get_var_part_ptr(tabPtrP);
Uint32 *dst_ptr= ptr->get_end_of_fix_part_ptr(tabPtrP);
Uint16* src_off_ptr= req_struct->var_pos_array;
sizes[MM]= sizes[DD]= 0;
sizes[MM] = 1;
sizes[DD] = 0;
if(mm_vars)
{
Uint16* dst_off_ptr= (Uint16*)dst_ptr;
@ -2733,25 +2691,14 @@ Dbtup::shrink_tuple(KeyReqStruct* req_struct, Uint32 sizes[2],
dst_ptr = ALIGN_WORD(dst_data_ptr);
}
else
{
sizes[MM] = 1;
dst_ptr -= Tuple_header::HeaderSize;
}
if(disk && dd_tot)
{
Uint32 * src_ptr = (Uint32*)req_struct->m_disk_ptr;
req_struct->m_disk_ptr = (Tuple_header*)dst_ptr;
if (unlikely(dd_vars))
{
abort();
}
else
{
sizes[DD] = tabPtrP->m_offsets[DD].m_fix_header_size;
memmove(dst_ptr, src_ptr, 4*tabPtrP->m_offsets[DD].m_fix_header_size);
}
ndbrequire(dd_vars == 0);
sizes[DD] = tabPtrP->m_offsets[DD].m_fix_header_size;
memmove(dst_ptr, src_ptr, 4*tabPtrP->m_offsets[DD].m_fix_header_size);
}
}
@ -2785,7 +2732,7 @@ Dbtup::validate_page(Tablerec* regTabPtr, Var_page* p)
if(!(idx & Var_page::FREE) && !(idx & Var_page::CHAIN))
{
Tuple_header *ptr= (Tuple_header*)page->get_ptr(i);
Uint32 *part= ptr->get_var_part_ptr(regTabPtr);
Uint32 *part= ptr->get_end_of_fix_part_ptr(regTabPtr);
if(ptr->m_header_bits & Tuple_header::CHAINED_ROW)
{
ndbassert(len == fix_sz + 1);
@ -2849,8 +2796,7 @@ Dbtup::handle_size_change_after_update(KeyReqStruct* req_struct,
Uint32 bits= org->m_header_bits;
Uint32 copy_bits= req_struct->m_tuple_ptr->m_header_bits;
Uint32 fix_sz = Tuple_header::HeaderSize +
regTabPtr->m_offsets[MM].m_fix_header_size;
Uint32 fix_sz = regTabPtr->m_offsets[MM].m_fix_header_size;
if(sizes[MM] == sizes[2+MM])
;
@ -2865,7 +2811,7 @@ Dbtup::handle_size_change_after_update(KeyReqStruct* req_struct,
Ptr<Page> pagePtr = req_struct->m_varpart_page_ptr;
Var_page* pageP= (Var_page*)pagePtr.p;
Uint32 idx, alloc, needed;
Var_part_ref *refptr = (Var_part_ref*)org->get_var_part_ptr(regTabPtr);
Var_part_ref *refptr = org->get_var_part_ref_ptr(regTabPtr);
ndbassert(bits & Tuple_header::CHAINED_ROW);
Local_key ref;
@ -2914,18 +2860,7 @@ Dbtup::nr_update_gci(Uint32 fragPtrI, const Local_key* key, Uint32 gci)
Local_key tmp = *key;
PagePtr page_ptr;
int ret;
if (tablePtr.p->m_attributes[MM].m_no_of_varsize)
{
const Uint32 XXX = Tuple_header::HeaderSize+Var_part_ref::SZ32;
tablePtr.p->m_offsets[MM].m_fix_header_size += XXX;
ret = alloc_page(tablePtr.p, fragPtr.p, &page_ptr, tmp.m_page_no);
tablePtr.p->m_offsets[MM].m_fix_header_size -= XXX;
}
else
{
ret = alloc_page(tablePtr.p, fragPtr.p, &page_ptr, tmp.m_page_no);
}
int ret = alloc_page(tablePtr.p, fragPtr.p, &page_ptr, tmp.m_page_no);
if (ret)
return -1;
@ -2953,19 +2888,9 @@ Dbtup::nr_read_pk(Uint32 fragPtrI,
Local_key tmp = *key;
int ret;
PagePtr page_ptr;
if (tablePtr.p->m_attributes[MM].m_no_of_varsize)
{
const Uint32 XXX = Tuple_header::HeaderSize+Var_part_ref::SZ32;
tablePtr.p->m_offsets[MM].m_fix_header_size += XXX;
ret = alloc_page(tablePtr.p, fragPtr.p, &page_ptr, tmp.m_page_no);
tablePtr.p->m_offsets[MM].m_fix_header_size -= XXX;
}
else
{
ret = alloc_page(tablePtr.p, fragPtr.p, &page_ptr, tmp.m_page_no);
}
int ret = alloc_page(tablePtr.p, fragPtr.p, &page_ptr, tmp.m_page_no);
if (ret)
return -1;

3
storage/ndb/src/kernel/blocks/dbtup/DbtupIndex.cpp
View file

@ -476,8 +476,7 @@ Dbtup::buildIndex(Signal* signal, Uint32 buildPtrI)
ptrCheckGuard(tablePtr, cnoOfTablerec, tablerec);
const Uint32 firstTupleNo = 0;
const Uint32 tupheadsize = tablePtr.p->m_offsets[MM].m_fix_header_size +
(buildPtr.p->m_build_vs? Tuple_header::HeaderSize + Var_part_ref::SZ32: 0);
const Uint32 tupheadsize = tablePtr.p->m_offsets[MM].m_fix_header_size;
#ifdef TIME_MEASUREMENT
MicroSecondTimer start;

26
storage/ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp
View file

@ -175,12 +175,12 @@ void Dbtup::execTUPFRAGREQ(Signal* signal)
regTabPtr.p->m_offsets[MM].m_disk_ref_offset= 0;
regTabPtr.p->m_offsets[MM].m_null_words= 0;
regTabPtr.p->m_offsets[MM].m_varpart_offset= 0;
regTabPtr.p->m_offsets[MM].m_fix_header_size= 0;
regTabPtr.p->m_offsets[MM].m_max_var_offset= 0;
regTabPtr.p->m_offsets[DD].m_disk_ref_offset= 0;
regTabPtr.p->m_offsets[DD].m_null_words= 0;
regTabPtr.p->m_offsets[DD].m_varpart_offset= 0;
regTabPtr.p->m_offsets[DD].m_fix_header_size= 0;
regTabPtr.p->m_offsets[DD].m_max_var_offset= 0;
regTabPtr.p->m_attributes[MM].m_no_of_fixsize= 0;
@ -463,7 +463,19 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal)
if(regTabPtr.p->m_no_of_disk_attributes > 0)
{
regTabPtr.p->m_offsets[MM].m_disk_ref_offset= pos[MM];
pos[MM] += 2; // 8 bytes
pos[MM] += Disk_part_ref::SZ32; // 8 bytes
}
else
{
/**
* var part ref is stored at m_disk_ref_offset + Disk_part_ref::SZ32
*/
regTabPtr.p->m_offsets[MM].m_disk_ref_offset= pos[MM]-Disk_part_ref::SZ32;
}
if (regTabPtr.p->m_attributes[MM].m_no_of_varsize)
{
pos[MM] += Var_part_ref::SZ32;
}
regTabPtr.p->m_offsets[MM].m_null_offset= pos[MM];
@ -489,16 +501,14 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal)
}
regTabPtr.p->m_offsets[MM].m_fix_header_size=
Tuple_header::HeaderSize +
fragOperPtr.p->m_fix_attributes_size[MM] +
pos[MM];
regTabPtr.p->m_offsets[DD].m_fix_header_size=
fragOperPtr.p->m_fix_attributes_size[DD] +
pos[DD];
if(regTabPtr.p->m_attributes[MM].m_no_of_varsize == 0)
regTabPtr.p->m_offsets[MM].m_fix_header_size += Tuple_header::HeaderSize;
if(regTabPtr.p->m_attributes[DD].m_no_of_varsize == 0 &&
regTabPtr.p->m_attributes[DD].m_no_of_fixsize > 0)
regTabPtr.p->m_offsets[DD].m_fix_header_size += Tuple_header::HeaderSize;
@ -538,8 +548,6 @@ void Dbtup::execTUP_ADD_ATTRREQ(Signal* signal)
{
Uint32 fix_tupheader = regTabPtr.p->m_offsets[MM].m_fix_header_size;
if(regTabPtr.p->m_attributes[MM].m_no_of_varsize != 0)
fix_tupheader += Tuple_header::HeaderSize + Var_part_ref::SZ32;
ndbassert(fix_tupheader > 0);
Uint32 noRowsPerPage = ZWORDS_ON_PAGE / fix_tupheader;
Uint32 noAllocatedPages =

3
storage/ndb/src/kernel/blocks/dbtup/DbtupScan.cpp
View file

@ -600,8 +600,7 @@ Dbtup::scanNext(Signal* signal, ScanOpPtr scanPtr)
const bool lcp = (bits & ScanOp::SCAN_LCP);
Uint32 lcp_list = fragPtr.p->m_lcp_keep_list;
Uint32 size = table.m_offsets[mm].m_fix_header_size +
(bits&ScanOp::SCAN_VS ? Tuple_header::HeaderSize + Var_part_ref::SZ32 : 0);
Uint32 size = table.m_offsets[mm].m_fix_header_size;
if (lcp && lcp_list != RNIL)
goto found_lcp_keep;

24
storage/ndb/src/kernel/blocks/dbtup/DbtupVarAlloc.cpp
View file

@ -68,27 +68,22 @@ Uint32* Dbtup::alloc_var_rec(Fragrecord* fragPtr,
/**
* TODO alloc fix+var part
*/
const Uint32 XXX = Tuple_header::HeaderSize + Var_part_ref::SZ32;
tabPtr->m_offsets[MM].m_fix_header_size += XXX;
Uint32 *ptr = alloc_fix_rec(fragPtr, tabPtr, key, out_frag_page_id);
tabPtr->m_offsets[MM].m_fix_header_size -= XXX;
if (unlikely(ptr == 0))
{
return 0;
}
ndbassert(alloc_size >= tabPtr->m_offsets[MM].m_fix_header_size +
Tuple_header::HeaderSize);
ndbassert(alloc_size >= tabPtr->m_offsets[MM].m_fix_header_size);
alloc_size -= tabPtr->m_offsets[MM].m_fix_header_size +
Tuple_header::HeaderSize;
alloc_size -= tabPtr->m_offsets[MM].m_fix_header_size;
Local_key varref;
if (likely(alloc_var_part(fragPtr, tabPtr, alloc_size, &varref) != 0))
{
Tuple_header* tuple = (Tuple_header*)ptr;
Var_part_ref* dst = (Var_part_ref*)tuple->get_var_part_ptr(tabPtr);
Var_part_ref* dst = tuple->get_var_part_ref_ptr(tabPtr);
dst->assign(&varref);
return ptr;
}
@ -166,7 +161,7 @@ void Dbtup::free_var_rec(Fragrecord* fragPtr,
Tuple_header* tuple = (Tuple_header*)ptr;
Local_key ref;
Var_part_ref * varref = (Var_part_ref*)tuple->get_var_part_ptr(tabPtr);
Var_part_ref * varref = tuple->get_var_part_ref_ptr(tabPtr);
varref->copyout(&ref);
free_fix_rec(fragPtr, tabPtr, key, (Fix_page*)pagePtr.p);
@ -398,26 +393,21 @@ Dbtup::alloc_var_rowid(Fragrecord* fragPtr,
Local_key* key,
Uint32 * out_frag_page_id)
{
const Uint32 XXX = Tuple_header::HeaderSize + Var_part_ref::SZ32;
tabPtr->m_offsets[MM].m_fix_header_size += XXX;
Uint32 *ptr = alloc_fix_rowid(fragPtr, tabPtr, key, out_frag_page_id);
tabPtr->m_offsets[MM].m_fix_header_size -= XXX;
if (unlikely(ptr == 0))
{
return 0;
}
ndbassert(alloc_size >= tabPtr->m_offsets[MM].m_fix_header_size +
Tuple_header::HeaderSize);
ndbassert(alloc_size >= tabPtr->m_offsets[MM].m_fix_header_size);
alloc_size -= tabPtr->m_offsets[MM].m_fix_header_size +
Tuple_header::HeaderSize;
alloc_size -= tabPtr->m_offsets[MM].m_fix_header_size;
Local_key varref;
if (likely(alloc_var_part(fragPtr, tabPtr, alloc_size, &varref) != 0))
{
Tuple_header* tuple = (Tuple_header*)ptr;
Var_part_ref* dst = (Var_part_ref*)tuple->get_var_part_ptr(tabPtr);
Var_part_ref* dst = (Var_part_ref*)tuple->get_var_part_ref_ptr(tabPtr);
dst->assign(&varref);
return ptr;
}