1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/dbms/ustor/US_TABLE.CPP Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,945 @@
1.4 +// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +//
1.18 +
1.19 +#include "US_STD.H"
1.20 +
1.21 +//#define __READBIT_CLASS
1.22 +//#define __WRITEBIT_CLASS
1.23 +
1.24 +#ifdef __READBIT_CLASS
1.25 +class TReadBitSequence
1.26 + {
1.27 +public:
1.28 + inline TReadBitSequence();
1.29 + inline TBool HasBits() const;
1.30 + TUint Read(const TUint8*& aPtr);
1.31 +private:
1.32 + TUint iBits;
1.33 + };
1.34 +inline TReadBitSequence::TReadBitSequence()
1.35 + :iBits(0) {}
1.36 +inline TBool TReadBitSequence::HasBits() const
1.37 + {return (iBits&0x2000000);}
1.38 +TUint TReadBitSequence::Read(const TUint8*& aPtr)
1.39 + {
1.40 + iBits>>=1;
1.41 + if ((iBits&0x1000000)==0)
1.42 + iBits=*aPtr++ | 0xff000000u;
1.43 + return iBits&1;
1.44 + }
1.45 +#define READBITINIT(This) TReadBitSequence This
1.46 +#define READHASBITS(This) This.HasBits()
1.47 +#define READBIT(This,ptr) This.Read(ptr)
1.48 +#define SKIPBIT(This,ptr) READBIT(This,ptr)
1.49 +#else
1.50 +#define READBITINIT(This) TUint This##_bits=0
1.51 +#define READHASBITS(This) (This##_bits&0x2000000)
1.52 +#define SKIPBIT(This,ptr) (This##_bits>>=1,(This##_bits&0x1000000 ? void(0) : void(This##_bits=*ptr++|0xff000000u)))
1.53 +#define READBIT(This,ptr) (SKIPBIT(This,ptr),This##_bits&1)
1.54 +#endif
1.55 +
1.56 +#ifdef __WRITEBIT_CLASS
1.57 +class TWriteBitSequence
1.58 + {
1.59 +public:
1.60 + inline TWriteBitSequence();
1.61 + TUint8* Write(TUint8* aPtr,TUint aBit);
1.62 + void Flush();
1.63 +private:
1.64 + TUint iBits;
1.65 + TUint8* iPtr;
1.66 + };
1.67 +inline TWriteBitSequence::TWriteBitSequence()
1.68 + :iBits(0),iPtr(0) {}
1.69 +TUint8* TWriteBitSequence::Write(TUint8* aPtr,TUint aBit)
1.70 + {
1.71 + TUint bits=iBits>>1;
1.72 + if ((bits&0x1000000)==0)
1.73 + {
1.74 + if (iPtr)
1.75 + *iPtr=TUint8(bits);
1.76 + iPtr=aPtr++;
1.77 + bits=0xff000000;
1.78 + }
1.79 + if (aBit)
1.80 + bits|=0x100;
1.81 + iBits=bits;
1.82 + return aPtr;
1.83 + }
1.84 +void TWriteBitSequence::Flush()
1.85 + {
1.86 + TUint8* ptr=iPtr;
1.87 + if (ptr)
1.88 + {
1.89 + TUint bits=iBits;
1.90 + do bits>>=1; while (bits&0x1000000);
1.91 + *ptr=TUint8(bits);
1.92 + }
1.93 + }
1.94 +#define WRITEBITINIT(This) TWriteBitSequence This
1.95 +#define WRITEBIT(This,ptr,bit) ptr=This.Write(ptr,bit)
1.96 +#define WRITEZEROBIT(This,ptr) ptr=This.Write(ptr,0)
1.97 +#define FLUSHBITS(This) This.Flush()
1.98 +#else
1.99 +#define WRITEBITINIT(This) TUint32 This##_bits=0; TUint8* This##_ptr=0
1.100 +#define NEXTBIT(This,ptr) This##_bits>>=1;if ((This##_bits&0x1000000)==0){if (This##_ptr) *This##_ptr=TUint8(This##_bits);This##_ptr=ptr++;This##_bits=0xff000000;}
1.101 +#define WRITEZEROBIT(This,ptr) {NEXTBIT(This,ptr)}
1.102 +#define WRITEBIT(This,ptr,bit) {NEXTBIT(This,ptr) if (bit) This##_bits|=0x100;}
1.103 +#define FLUSHBITS(This) {if (This##_ptr){do This##_bits>>=1; while (This##_bits&0x1000000);*This##_ptr=TUint8(This##_bits);}}
1.104 +#endif
1.105 +
1.106 +LOCAL_C const TUint8* Read32(const TUint8* aPtr,TUint32* aDest)
1.107 +// fast read for non-aligned little-endian 32-bit data
1.108 + {
1.109 + TUint32 x=*aPtr++;
1.110 + x|=*aPtr++<<8;
1.111 + x|=*aPtr++<<16;
1.112 + x|=*aPtr++<<24;
1.113 + *aDest=x;
1.114 + return aPtr;
1.115 + }
1.116 +
1.117 +LOCAL_C TUint8* Write32(TUint8* aPtr,TUint32 aVal)
1.118 +// fast transfer for non-aligned little-endian 32-bit data
1.119 + {
1.120 + *aPtr++=TUint8(aVal);
1.121 + *aPtr++=TUint8(aVal>>8);
1.122 + *aPtr++=TUint8(aVal>>16);
1.123 + *aPtr++=TUint8(aVal>>24);
1.124 + return aPtr;
1.125 + }
1.126 +
1.127 +inline const TUint8* Read16(const TUint8* aPtr,TUint32* aDest)
1.128 +// Read unsigned 16-bit value into aDest storage
1.129 + {
1.130 + TUint x=*aPtr++;
1.131 + x|=*aPtr++<<8;
1.132 + *aDest=TUint16(x);
1.133 + return aPtr;
1.134 + }
1.135 +
1.136 +inline const TUint8* Read16s(const TUint8* aPtr,TUint32* aDest)
1.137 +// Read signed 16-bit value into aDest storage
1.138 + {
1.139 + TInt x=*aPtr++<<16;
1.140 + x|=*aPtr++<<24;
1.141 + *aDest=x>>16;
1.142 + return aPtr;
1.143 + }
1.144 +
1.145 +inline TUint8* Write16(TUint8* aPtr,TUint aVal)
1.146 +// Write little-endian rep of the low 16 bits of aVal
1.147 + {
1.148 + *aPtr++=TUint8(aVal);
1.149 + *aPtr++=TUint8(aVal>>8);
1.150 + return aPtr;
1.151 + }
1.152 +
1.153 +LOCAL_C TUint8* WriteCardinality(TUint8* aPtr,TUint aVal)
1.154 +// compress cardinality into the data stream
1.155 + {
1.156 + __ASSERT(aVal<(1u<<30));
1.157 + if ((aVal>>7)==0)
1.158 + {
1.159 + *aPtr++=TUint8(aVal<<1);
1.160 + return aPtr;
1.161 + }
1.162 + aVal=(aVal<<2)|1;
1.163 + if ((aVal>>16)==0)
1.164 + {
1.165 + *aPtr++=TUint8(aVal);
1.166 + *aPtr++=TUint8(aVal>>8);
1.167 + return aPtr;
1.168 + }
1.169 + return Write32(aPtr,aVal|2);
1.170 + }
1.171 +
1.172 +LOCAL_C TUint ReadCardinality(const TUint8* aPtr)
1.173 +// extract cardinality from the data stream
1.174 + {
1.175 + TUint x=aPtr[0];
1.176 + if ((x&1)==0)
1.177 + return x>>1;
1.178 + x|=aPtr[1]<<8;
1.179 + if (x&2)
1.180 + {
1.181 + x|=aPtr[2]<<16;
1.182 + x|=aPtr[3]<<24;
1.183 + }
1.184 + return x>>2;
1.185 + }
1.186 +
1.187 +LOCAL_C const TUint8* ReadCardinality(const TUint8* aPtr,TInt& aVal)
1.188 +// extract cardinality from the data stream
1.189 + {
1.190 + TUint x=*aPtr++;
1.191 + if ((x&1)==0)
1.192 + x>>=1;
1.193 + else
1.194 + {
1.195 + x|=*aPtr++<<8;
1.196 + if (x&2)
1.197 + {
1.198 + x|=*aPtr++<<16;
1.199 + x|=*aPtr++<<24;
1.200 + }
1.201 + x>>=2;
1.202 + }
1.203 + aVal=x;
1.204 + return aPtr;
1.205 + }
1.206 +
1.207 +LOCAL_C TInt SizeOfCardinality(TUint aVal)
1.208 +// report the externalized size of the Compressed value in bytes
1.209 + {
1.210 + if ((aVal>>7)==0)
1.211 + return 1;
1.212 + return (aVal>>14)==0 ? 2 : 4;
1.213 + }
1.214 +
1.215 +LOCAL_C TUint8* WriteBlobId(TUint8* aPtr,TDbBlobId aId)
1.216 + {
1.217 + return WriteCardinality(aPtr,(aId>>24)|(aId<<8>>4));
1.218 + }
1.219 +
1.220 +LOCAL_C const TUint8* ReadBlobId(const TUint8* aPtr,TDbBlobId& aId)
1.221 + {
1.222 + aPtr=ReadCardinality(aPtr,*reinterpret_cast<TInt*>(&aId));
1.223 + aId=(aId>>4)|(aId<<28>>4);
1.224 + return aPtr;
1.225 + }
1.226 +
1.227 +LOCAL_C TInt SizeOfBlobId(TDbBlobId aId)
1.228 + {
1.229 + return SizeOfCardinality((aId>>24)|(aId<<8>>4));
1.230 + }
1.231 +
1.232 +// Class CDbStoreTable
1.233 +
1.234 +CDbStoreTable::CDbStoreTable(CDbStoreDatabase& aDatabase,const CDbTableDef& aDef)
1.235 + : CDbTable(aDatabase,aDef)
1.236 + {}
1.237 +
1.238 +CDbRecordSpace* CDbStoreTable::RecordSpaceL()
1.239 +//
1.240 +// open records handler
1.241 +//
1.242 + {
1.243 + return CDbStoreRecords::NewL(Database().ClusterCacheL(),Def());
1.244 + }
1.245 +
1.246 +CDbBlobSpace* CDbStoreTable::BlobSpaceL()
1.247 +//
1.248 +// Open a blobs accessor for the table
1.249 +//
1.250 + {
1.251 + return new(ELeave) CDbStoreBlobs(Database(),Def().InlineLimit());
1.252 + }
1.253 +
1.254 +CDbRecordIndex* CDbStoreTable::RecordIndexL(const CDbTableIndexDef& anIndex)
1.255 +//
1.256 +// Open an index
1.257 +//
1.258 + {
1.259 + return CDbStoreIndex::NewL(Database(),(const CDbStoreIndexDef&)anIndex,Def());
1.260 + }
1.261 +
1.262 +static TUint8* CompressUnicode(TUint8* aRec,const TAny* aData,TInt aSize)
1.263 +//
1.264 +// initially assume the compressed data requires 1 byte for the length data
1.265 +// Copy it if more is necessary. This avoids having to run the compressor twice
1.266 +//
1.267 + {
1.268 + TMemoryUnicodeSource source(reinterpret_cast<const TUint16*>(aData));
1.269 + TUnicodeCompressor compressor;
1.270 + TInt output;
1.271 + compressor.CompressL(aRec+1,source,KMaxTInt,aSize>>1,&output);
1.272 + TInt lenSize=SizeOfCardinality(output);
1.273 + if (lenSize!=1)
1.274 + Mem::Copy(aRec+lenSize,aRec+1,output); // needs more space for length
1.275 + return WriteCardinality(aRec,output)+output;
1.276 + }
1.277 +
1.278 +static TInt SizeOfCompressedUnicode(const TAny* aData,TInt aSize)
1.279 +//
1.280 +// bytes required to store the unicode data
1.281 +//
1.282 + {
1.283 + TMemoryUnicodeSource source(reinterpret_cast<const TUint16*>(aData));
1.284 + TInt size=TUnicodeCompressor::CompressedSizeL(source,aSize>>1);
1.285 + return SizeOfCardinality(size)+size;
1.286 + }
1.287 +
1.288 +static const TUint8* ExpandUnicodeL(const TUint8* aRec,TAny* aTarget,const TAny* aLimit,TInt& aChars)
1.289 +//
1.290 +// Read compressed unicode from the record
1.291 +//
1.292 + {
1.293 + TInt bytes;
1.294 + aRec=ReadCardinality(aRec,bytes);
1.295 + TMemoryUnicodeSink unicode(reinterpret_cast<TUint16*>(aTarget));
1.296 + TUnicodeExpander expander;
1.297 + TInt used;
1.298 + expander.ExpandL(unicode,aRec,(TUint16*)aLimit-(TUint16*)aTarget,bytes,&aChars,&used);
1.299 + return bytes==used ? aRec+bytes : 0; // signal corruption in data, could not fit text in space
1.300 + }
1.301 +
1.302 +static TInt SizeOfExpandedUnicodeL(const TUint8* aData,TInt aSize)
1.303 +//
1.304 +// bytes required to store the unicode data
1.305 +//
1.306 + {
1.307 + return TUnicodeExpander::ExpandedSizeL(aData,aSize)<<1;
1.308 + }
1.309 +
1.310 +TInt CDbStoreTable::RecordLength(const RDbRow& aRow)
1.311 +//
1.312 +// Calculate the size of a record
1.313 +//
1.314 + {
1.315 + TInt bits=SizeOfCardinality(OptimizedRowLength(aRow))<<3; // record buffer size
1.316 + HDbColumnSet::TIteratorC col=Def().Columns().Begin();
1.317 + const TDbCell* const last=aRow.Last();
1.318 + for (const TDbCell* column=aRow.First();column<last;++col,column=column->Next())
1.319 + {
1.320 + __ASSERT(col<Def().Columns().End()); // columns off end
1.321 + TInt size=column->Length();
1.322 + if ((col->iAttributes&TDbCol::ENotNull)==0)
1.323 + { //nullable
1.324 + ++bits;
1.325 + if (size==0)
1.326 + continue; // no data
1.327 + }
1.328 + __ASSERT(size>0); // must be non-null to reach here
1.329 + TDbColType type=col->Type();
1.330 + __ASSERT(type>=EDbColBit&&type<=EDbColLongBinary);
1.331 + if (type==EDbColBit)
1.332 + ++bits;
1.333 + else if (type<=EDbColDateTime)
1.334 + bits+=TRecordSize::FixedFieldSize(type)<<3;
1.335 + else if (type==EDbColText16)
1.336 + bits+=SizeOfCompressedUnicode(column->Data(),size)<<3;
1.337 + else if (type<=EDbColBinary)
1.338 + bits+=8+(size<<3);
1.339 + else
1.340 + {
1.341 + __ASSERT(type<=EDbColLongBinary);
1.342 + const TDbBlob& blob=*(const TDbBlob*)column->Data();
1.343 + if (!blob.IsInline())
1.344 + bits+=1+((SizeOfBlobId(blob.Id())+SizeOfCardinality(blob.Size()))<<3);
1.345 + else if (type!=EDbColLongText16)
1.346 + bits+=9+(blob.Size()<<3);
1.347 + else
1.348 + bits+=1+(SizeOfCompressedUnicode(blob.Data(),blob.Size())<<3);
1.349 + }
1.350 + }
1.351 + __ASSERT(bits<=(KDbStoreMaxRecordLength<<3));
1.352 + return (bits+7)>>3;
1.353 + }
1.354 +
1.355 +TInt CDbStoreTable::OptimizedRowLength(const RDbRow& aRow)
1.356 +//
1.357 +// Calculate the minimal row buffer size (in words) to store the row data
1.358 +//
1.359 + {
1.360 + HDbColumnSet::TIteratorC col=Def().Columns().Begin();
1.361 + const TDbCell* const last=aRow.Last();
1.362 + TInt cellHead=0;
1.363 + TInt words=0;
1.364 + for (const TDbCell* column=aRow.First();column<last;++col,column=column->Next())
1.365 + {
1.366 + ++cellHead;
1.367 + __ASSERT(col<Def().Columns().End()); // columns off end
1.368 + TInt size=column->Length();
1.369 + if (size==0)
1.370 + continue;
1.371 + words+=cellHead;
1.372 + cellHead=0;
1.373 + TDbColType type=col->Type();
1.374 + __ASSERT(type>=EDbColBit&&type<=EDbColLongBinary);
1.375 + if (type<=EDbColDateTime)
1.376 + __ASSERT(size==(size>>2<<2));
1.377 + else if (type<=EDbColBinary)
1.378 + ;
1.379 + else
1.380 + size=((const TDbBlob*)column->Data())->CellSize();
1.381 + words+=(size+3)>>2;
1.382 + }
1.383 + return words;
1.384 + }
1.385 +
1.386 +void CDbStoreTable::CopyFromRow(TUint8* aRecord,const RDbRow& aRow)
1.387 +//
1.388 +// translate the row buffer into its persistent format in the record buffer
1.389 +//
1.390 + {
1.391 + aRecord=WriteCardinality(aRecord,OptimizedRowLength(aRow)); // internal size
1.392 +//
1.393 + WRITEBITINIT(bits);
1.394 + HDbColumnSet::TIteratorC iter=Def().Columns().Begin();
1.395 + const TDbCell* const last=aRow.Last();
1.396 + for (const TDbCell* column=aRow.First();column<last;++iter,column=column->Next())
1.397 + {
1.398 + __ASSERT(iter<Def().Columns().End()); // columns off end
1.399 + TInt size=column->Length();
1.400 + if ((iter->iAttributes&TDbCol::ENotNull)==0)
1.401 + { // nullable
1.402 + WRITEBIT(bits,aRecord,size!=0);
1.403 + if (size==0)
1.404 + continue; // no data
1.405 + }
1.406 + __ASSERT(size>0); // must be non-null to reach here
1.407 + const TUint32* data=(const TUint32*)column->Data();
1.408 + TDbColType type=iter->Type();
1.409 + switch (type)
1.410 + {
1.411 + default:
1.412 + __ASSERT(0);
1.413 + case EDbColBit:
1.414 + WRITEBIT(bits,aRecord,*data);
1.415 + break;
1.416 + case EDbColInt8:
1.417 + case EDbColUint8:
1.418 + *aRecord++=TUint8(*data);
1.419 + break;
1.420 + case EDbColInt16:
1.421 + case EDbColUint16:
1.422 + aRecord=Write16(aRecord,*data);
1.423 + break;
1.424 +#if defined(__DOUBLE_WORDS_SWAPPED__)
1.425 + case EDbColReal64:
1.426 + aRecord=Write32(aRecord,data[1]); // write low word out first
1.427 + // drop through to write high word next
1.428 +#endif
1.429 + case EDbColInt32:
1.430 + case EDbColUint32:
1.431 + case EDbColReal32:
1.432 + aRecord=Write32(aRecord,*data);
1.433 + break;
1.434 +#if !defined(__DOUBLE_WORDS_SWAPPED__)
1.435 + case EDbColReal64:
1.436 +#endif
1.437 + case EDbColInt64:
1.438 + case EDbColDateTime:
1.439 + aRecord=Write32(aRecord,data[0]);
1.440 + aRecord=Write32(aRecord,data[1]);
1.441 + break;
1.442 + case EDbColText16:
1.443 + aRecord=CompressUnicode(aRecord,data,size);
1.444 + break;
1.445 + case EDbColText8:
1.446 + case EDbColBinary:
1.447 + *aRecord++=TUint8(size);
1.448 + aRecord=Mem::Copy(aRecord,data,size);
1.449 + break;
1.450 + case EDbColLongText8:
1.451 + case EDbColLongText16:
1.452 + case EDbColLongBinary:
1.453 + {
1.454 + const TDbBlob& blob=*reinterpret_cast<const TDbBlob*>(data);
1.455 + size=blob.Size();
1.456 + WRITEBIT(bits,aRecord,blob.IsInline());
1.457 + if (blob.IsInline())
1.458 + {
1.459 + if (type==EDbColLongText16)
1.460 + aRecord=CompressUnicode(aRecord,blob.Data(),size);
1.461 + else
1.462 + {
1.463 + *aRecord++=TUint8(size);
1.464 + aRecord=Mem::Copy(aRecord,blob.Data(),size);
1.465 + }
1.466 + }
1.467 + else
1.468 + {
1.469 + aRecord=WriteBlobId(aRecord,blob.Id());
1.470 + aRecord=WriteCardinality(aRecord,size);
1.471 + }
1.472 + }
1.473 + break;
1.474 + }
1.475 + }
1.476 + FLUSHBITS(bits);
1.477 + }
1.478 +
1.479 +const TUint8* CDbStoreTable::CopyToRowL(TDbCell* aCell,TInt aSize,const TUint8* aRec)
1.480 +//
1.481 +// translate persistent record into the row buffer
1.482 +//
1.483 + {
1.484 + __ASSERT(aSize>0);
1.485 +//
1.486 + const TDbCell* const end=PtrAdd(aCell,aSize);
1.487 + READBITINIT(bits);
1.488 + HDbColumnSet::TIteratorC col=Def().Columns().Begin();
1.489 + HDbColumnSet::TIteratorC const cend=Def().Columns().End();
1.490 + for (;;)
1.491 + {
1.492 + TInt size=0; //null data
1.493 + if (col->iAttributes&TDbCol::ENotNull || READBIT(bits,aRec)) // have data
1.494 + {
1.495 + if (TInt(end)-TInt(aCell)<=(TInt)sizeof(TUint32))
1.496 + return 0;
1.497 + size=sizeof(TUint32); // for most types
1.498 + TDbColType type=col->Type();
1.499 + switch (type)
1.500 + {
1.501 + default:
1.502 + __ASSERT(0);
1.503 + case EDbColBit:
1.504 + *(TUint32*)aCell->Data()=READBIT(bits,aRec);
1.505 + break;
1.506 + case EDbColInt8:
1.507 + *(TInt32*)aCell->Data()=*(const TInt8*)aRec;
1.508 + aRec+=sizeof(TInt8);
1.509 + break;
1.510 + case EDbColUint8:
1.511 + *(TUint32*)aCell->Data()=*aRec;
1.512 + aRec+=sizeof(TUint8);
1.513 + break;
1.514 + case EDbColInt16:
1.515 + aRec=Read16s(aRec,(TUint32*)aCell->Data());
1.516 + break;
1.517 + case EDbColUint16:
1.518 + aRec=Read16(aRec,(TUint32*)aCell->Data());
1.519 + break;
1.520 + #if defined(__DOUBLE_WORDS_SWAPPED__)
1.521 + case EDbColReal64:
1.522 + if (TInt(end)-TInt(aCell)<=(TInt)sizeof(TReal64))
1.523 + return 0;
1.524 + size=sizeof(TReal64);
1.525 + aRec=Read32(aRec,(TUint32*)aCell->Data()+1); // transfer low word first, to high address
1.526 + // drop through to transfer high word to low address!
1.527 + #endif
1.528 + case EDbColInt32:
1.529 + case EDbColUint32:
1.530 + case EDbColReal32:
1.531 + aRec=Read32(aRec,(TUint32*)aCell->Data());
1.532 + break;
1.533 + #if !defined(__DOUBLE_WORDS_SWAPPED__)
1.534 + case EDbColReal64:
1.535 + #endif
1.536 + case EDbColInt64:
1.537 + case EDbColDateTime:
1.538 + if (TInt(end)-TInt(aCell)<=(TInt)sizeof(TInt64))
1.539 + return 0;
1.540 + size=sizeof(TInt64);
1.541 + aRec=Read32(aRec,(TUint32*)aCell->Data());
1.542 + aRec=Read32(aRec,(TUint32*)aCell->Data()+1);
1.543 + break;
1.544 + case EDbColText16:
1.545 + {
1.546 + TInt len;
1.547 + aRec=ExpandUnicodeL(aRec,aCell->Data(),end,len);
1.548 + if (!aRec)
1.549 + return 0;
1.550 + size=len<<1;
1.551 + }
1.552 + break;
1.553 + case EDbColText8:
1.554 + case EDbColBinary:
1.555 + size=*aRec++;
1.556 + if (TInt(end)-TInt(aCell)<TInt(size+sizeof(TUint32)))
1.557 + return 0;
1.558 + Mem::Copy(aCell->Data(),aRec,size);
1.559 + aRec+=size;
1.560 + break;
1.561 + case EDbColLongText8:
1.562 + case EDbColLongText16:
1.563 + case EDbColLongBinary:
1.564 + if (READBIT(bits,aRec)==0)
1.565 + { // out of line Long column
1.566 + if (TInt(end)-TInt(aCell)<=TDbBlob::RefSize())
1.567 + return 0;
1.568 + TDbBlobId id;
1.569 + aRec=ReadBlobId(aRec,id);
1.570 + TInt sz;
1.571 + aRec=ReadCardinality(aRec,sz);
1.572 + new(aCell->Data()) TDbBlob(id,sz);
1.573 + size=TDbBlob::RefSize();
1.574 + }
1.575 + else if (type!=EDbColLongText16)
1.576 + { // inline
1.577 + size=*aRec++;
1.578 + if (TInt(end)-TInt(aCell)<TInt(TDbBlob::InlineSize(size)+sizeof(TUint32)))
1.579 + return 0;
1.580 + new(aCell->Data()) TDbBlob(aRec,size);
1.581 + aRec+=size;
1.582 + size=TDbBlob::InlineSize(size);
1.583 + }
1.584 + else
1.585 + {
1.586 + TDbBlob* blob=new(aCell->Data()) TDbBlob;
1.587 + TInt len;
1.588 + aRec=ExpandUnicodeL(aRec,blob->InlineBuffer(),end,len);
1.589 + if (!aRec)
1.590 + return 0;
1.591 + size=len<<1;
1.592 + blob->SetSize(size);
1.593 + size=TDbBlob::InlineSize(size);
1.594 + }
1.595 + break;
1.596 + }
1.597 + }
1.598 + aCell->SetLength(size);
1.599 + aCell=aCell->Next();
1.600 + if (aCell==end)
1.601 + return aRec;
1.602 + if (++col==cend)
1.603 + return 0;
1.604 + }
1.605 + }
1.606 +
1.607 +void CDbStoreTable::CopyToRowL(RDbRow& aRow,const TDesC8& aRecord)
1.608 +//
1.609 +// translate persistent record into the row buffer
1.610 +//
1.611 + {
1.612 + const TUint8* rec=aRecord.Ptr();
1.613 + const TUint8* end=rec+aRecord.Length();
1.614 + TInt size;
1.615 + rec=ReadCardinality(rec,size);
1.616 + size<<=2;
1.617 +
1.618 + //If such huge allocation is requested(KMaxTInt/2), it is highly likely the file is corrupt
1.619 + if((size < 0) || (size >= KMaxTInt/2))
1.620 + {
1.621 + aRow.SetSize(0);
1.622 + __LEAVE(KErrCorrupt);
1.623 + }
1.624 +
1.625 + if (size)
1.626 + {
1.627 + aRow.GrowL(size);
1.628 + rec=CopyToRowL(aRow.First(),size,rec);
1.629 + }
1.630 + if (rec)
1.631 + {
1.632 + do
1.633 + {
1.634 + if (rec==end)
1.635 + {
1.636 + aRow.SetSize(size);
1.637 + return;
1.638 + }
1.639 + } while (*rec++==0);
1.640 + }
1.641 + aRow.SetSize(0);
1.642 + __LEAVE(KErrCorrupt);
1.643 + }
1.644 +
1.645 +TUint8* CDbStoreTable::AlterRecordL(TUint8* aWPtr,const TUint8* aRPtr,TInt aLength,TInt aInlineLimit)
1.646 +//
1.647 +// Rewrite the record in the buffer by removing the data from the delete-list
1.648 +// any changes are recorded in the iAltered member
1.649 +//
1.650 + {
1.651 + // initially assume that the length count will be the same size after alteration
1.652 + TInt lenSize=SizeOfCardinality(ReadCardinality(aRPtr));
1.653 + const TUint8* const rEnd=aRPtr+aLength;
1.654 + aRPtr+=lenSize;
1.655 + TUint8* wptr=aWPtr+lenSize;
1.656 + TInt wRowSize=0;
1.657 + TInt headers=0;
1.658 +//
1.659 + READBITINIT(rbits);
1.660 + WRITEBITINIT(wbits);
1.661 + const HDbColumnSet::TIteratorC cEnd=Def().Columns().End();
1.662 + HDbColumnSet::TIteratorC col=Def().Columns().Begin();
1.663 + do
1.664 + {
1.665 + if (aRPtr==rEnd && !READHASBITS(rbits))
1.666 + break; // no more data
1.667 + TUint flg=col->iFlags;
1.668 + if ((flg&TDbColumnDef::EDropped)==0)
1.669 + ++headers;
1.670 + if ((col->iAttributes&TDbCol::ENotNull)==0)
1.671 + { // nullable
1.672 + TUint notnull=READBIT(rbits,aRPtr);
1.673 + if ((flg&TDbColumnDef::EDropped)==0)
1.674 + WRITEBIT(wbits,wptr,notnull);
1.675 + if (notnull==0) // null data
1.676 + continue;
1.677 + }
1.678 + wRowSize+=headers;
1.679 + headers=0;
1.680 + TInt size;
1.681 + TDbColType type=col->Type();
1.682 + switch (type)
1.683 + {
1.684 + default:
1.685 + __ASSERT(0);
1.686 + case EDbColBit:
1.687 + size=READBIT(rbits,aRPtr);
1.688 + if ((flg&TDbColumnDef::EDropped)==0)
1.689 + {
1.690 + WRITEBIT(wbits,wptr,size);
1.691 + ++wRowSize;
1.692 + }
1.693 + continue;
1.694 + case EDbColInt8:
1.695 + case EDbColUint8:
1.696 + case EDbColInt16:
1.697 + case EDbColUint16:
1.698 + case EDbColInt32:
1.699 + case EDbColUint32:
1.700 + case EDbColReal32:
1.701 + case EDbColReal64:
1.702 + case EDbColInt64:
1.703 + case EDbColDateTime:
1.704 + size=TRecordSize::FixedFieldSize(type);
1.705 + if ((flg&TDbColumnDef::EDropped)==0)
1.706 + {
1.707 + wptr=Mem::Copy(wptr,aRPtr,size);
1.708 + wRowSize+=(size+3)>>2; // # words
1.709 + }
1.710 + break;
1.711 + case EDbColText8:
1.712 + case EDbColBinary:
1.713 + size=*aRPtr++;
1.714 + if ((flg&(TDbColumnDef::EChangedType|TDbColumnDef::EDropped))==0)
1.715 + {
1.716 + wptr=Mem::Copy(wptr,aRPtr-1,size+1); // no change, copy the column
1.717 + wRowSize+=(size+3)>>2; // # words
1.718 + }
1.719 + else if (flg&TDbColumnDef::EChangedType)
1.720 + goto alterBlob8; // type change, into a LongColumn
1.721 + else
1.722 + __ASSERT(flg&TDbColumnDef::EDropped); // drop the column
1.723 + break;
1.724 + case EDbColText16:
1.725 + {
1.726 + TInt sz;
1.727 + aRPtr=ReadCardinality(aRPtr,sz);
1.728 + size=sz;
1.729 + if ((flg&(TDbColumnDef::EChangedType|TDbColumnDef::EDropped))==0)
1.730 + {
1.731 + wptr=WriteCardinality(wptr,size);
1.732 + wptr=Mem::Copy(wptr,aRPtr,size); // no change, copy the column
1.733 + wRowSize+=(SizeOfExpandedUnicodeL(aRPtr,size)+3)>>2;
1.734 + }
1.735 + else if (flg&TDbColumnDef::EChangedType)
1.736 + goto alterBlob16; // type change, into a LongColumn
1.737 + else
1.738 + __ASSERT(flg&TDbColumnDef::EDropped); // drop the column
1.739 + }
1.740 + break;
1.741 + case EDbColLongText8:
1.742 + case EDbColLongBinary:
1.743 + case EDbColLongText16:
1.744 + if (!READBIT(rbits,aRPtr))
1.745 + { // out-of-line
1.746 + TDbBlobId id;
1.747 + aRPtr=ReadBlobId(aRPtr,id);
1.748 + TInt sz;
1.749 + aRPtr=ReadCardinality(aRPtr,sz);
1.750 + if (flg&TDbColumnDef::EDropped)
1.751 + BlobsL()->DeleteL(id); // delete the stream
1.752 + else
1.753 + {
1.754 + WRITEZEROBIT(wbits,wptr); // out-of-line
1.755 + wptr=WriteBlobId(wptr,id);
1.756 + wptr=WriteCardinality(wptr,sz);
1.757 + wRowSize+=TDbBlob::RefSize()>>2;
1.758 + }
1.759 + size=0;
1.760 + }
1.761 + else if (type!=EDbColLongText16)
1.762 + { // currently inline
1.763 + size=*aRPtr++;
1.764 + if (flg&TDbColumnDef::EDropped)
1.765 + break;
1.766 + // write long-column data, check inline status
1.767 +alterBlob8: WRITEBIT(wbits,wptr,size<=aInlineLimit);
1.768 + if (size<=aInlineLimit)
1.769 + { // inlined
1.770 + *wptr++=TUint8(size); // blob size
1.771 + wptr=Mem::Copy(wptr,aRPtr,size); // blob data
1.772 + wRowSize+=(TDbBlob::InlineSize(size)+3)>>2;
1.773 + }
1.774 + else
1.775 + {
1.776 + TDbBlobId id=BlobsL()->CreateL(type,aRPtr,size);
1.777 + wptr=WriteBlobId(wptr,id);
1.778 + wptr=WriteCardinality(wptr,size);
1.779 + wRowSize+=TDbBlob::RefSize()>>2;
1.780 + }
1.781 + }
1.782 + else
1.783 + { // currently inline
1.784 + TInt sz;
1.785 + aRPtr=ReadCardinality(aRPtr,sz);
1.786 + size=sz;
1.787 + if (flg&TDbColumnDef::EDropped)
1.788 + break;
1.789 + // write long-column data, check inline status
1.790 +alterBlob16: TInt len=SizeOfExpandedUnicodeL(aRPtr,size);
1.791 + WRITEBIT(wbits,wptr,len<=aInlineLimit);
1.792 + if (len<=aInlineLimit)
1.793 + { // inlined
1.794 + wptr=WriteCardinality(wptr,size);
1.795 + wptr=Mem::Copy(wptr,aRPtr,size); // blob data
1.796 + wRowSize+=(TDbBlob::InlineSize(len)+3)>>2;
1.797 + }
1.798 + else
1.799 + {
1.800 + TDbBlobId id=BlobsL()->CreateL(EDbColLongText8,aRPtr,size); // no unicode compressor!
1.801 + wptr=WriteBlobId(wptr,id);
1.802 + wptr=WriteCardinality(wptr,len);
1.803 + wRowSize+=TDbBlob::RefSize()>>2;
1.804 + }
1.805 + }
1.806 + break;
1.807 + }
1.808 + aRPtr+=size;
1.809 + } while (++col<cEnd);
1.810 + FLUSHBITS(wbits);
1.811 + TInt lsz=SizeOfCardinality(wRowSize);
1.812 + if (lenSize!=lsz)
1.813 + wptr=Mem::Copy(aWPtr+lsz,aWPtr+lenSize,wptr-(aWPtr+lenSize));
1.814 + WriteCardinality(aWPtr,wRowSize);
1.815 + return wptr;
1.816 + }
1.817 +
1.818 +TInt CDbStoreTable::IndexSpanL(const CDbTableIndexDef& aIndex,TUint aInclusion,const TDbLookupKey* aLower,const TDbLookupKey* aUpper)
1.819 +//
1.820 +// Guess the size of the index set contained in the given restriction
1.821 +// First check the cached values in the defintion, and only load the index if necessary
1.822 +//
1.823 + {
1.824 + const TDbStoreIndexStats& stats=static_cast<const CDbStoreIndexDef&>(aIndex).iStats;
1.825 + if (!stats.IsValid())
1.826 + IndexL(aIndex); // ensure that the index is loaded
1.827 + return stats.Span(aInclusion,aLower,aUpper,TTextOps::Ops(aIndex.Key().Comparison()));
1.828 + }
1.829 +
1.830 +// Class CDbStoreTable::CDiscarder
1.831 +
1.832 +CDbStoreTable::CDiscarder::CDiscarder()
1.833 + {}
1.834 +
1.835 +CDbStoreTable::CDiscarder::~CDiscarder()
1.836 + {
1.837 + if (iTable)
1.838 + iTable->Close();
1.839 + iRow.Close();
1.840 + }
1.841 +
1.842 +TInt CDbStoreTable::CDiscarder::OpenL(CDbStoreTable* aTable)
1.843 + {
1.844 + __ASSERT(!iTable);
1.845 + iTable=aTable;
1.846 + iRecords=&aTable->StoreRecordsL();
1.847 + iCluster=iRecords->Head();
1.848 + return iRecords->Count()+1;
1.849 + }
1.850 +
1.851 +TInt CDbStoreTable::CDiscarder::StepL(TInt aStep)
1.852 + {
1.853 + __ASSERT(iTable);
1.854 + TInt limit=iTable->Def().Columns().HasLongColumns() ? EBlobDiscardClusters : EDiscardClusters;
1.855 + for (TInt inc=0;inc<limit;++inc)
1.856 + {
1.857 + if (iCluster==KNullClusterId)
1.858 + {
1.859 + iRecords->DestroyL();
1.860 + return 0;
1.861 + }
1.862 + if (limit==EBlobDiscardClusters)
1.863 + iRecords->AlterL(iCluster,*this);
1.864 + aStep-=iRecords->DiscardL(iCluster);
1.865 + }
1.866 + return Max(aStep,1);
1.867 + }
1.868 +
1.869 +TUint8* CDbStoreTable::CDiscarder::AlterRecordL(TUint8* aWPtr,const TUint8* aRPtr,TInt aLength)
1.870 +//
1.871 +// Scan for and discard all known BLOBs
1.872 +//
1.873 + {
1.874 + iTable->CopyToRowL(iRow,TPtrC8(aRPtr,aLength));
1.875 + iTable->DiscardBlobsL(iRow);
1.876 + return aWPtr;
1.877 + }
1.878 +
1.879 +// class CDbStoreTable::CAlter
1.880 +
1.881 +CDbStoreTable::CAlter::CAlter()
1.882 + {}
1.883 +
1.884 +CDbStoreTable::CAlter::~CAlter()
1.885 + {
1.886 + if (iTable)
1.887 + iTable->Close();
1.888 + }
1.889 +
1.890 +void CDbStoreTable::CAlter::OpenL(CDbStoreTable* aTable,const HDbColumnSet& aNewSet)
1.891 +//
1.892 +// Prepare for alteration of the table data
1.893 +//
1.894 + {
1.895 + __ASSERT(!iTable);
1.896 + iTable=aTable;
1.897 + iInlineLimit=TRecordSize::InlineLimit(aNewSet);
1.898 + iRecords=&iTable->StoreRecordsL();
1.899 + iCluster=iRecords->Head();
1.900 +//
1.901 +// Calculate the maximum possible expansion, based on the changes to the column set
1.902 +// Currently the only alloed change which affects this is Text->LongText type changes
1.903 +// these all add a single bit
1.904 +//
1.905 + TInt expand=0;
1.906 + const HDbColumnSet& columns=iTable->Def().Columns();
1.907 + const HDbColumnSet::TIteratorC end=columns.End();
1.908 + HDbColumnSet::TIteratorC col=columns.Begin();
1.909 + do
1.910 + {
1.911 + if (col->iFlags&TDbColumnDef::EChangedType)
1.912 + {
1.913 + __ASSERT(col->iType>=EDbColText8&&col->iType<=EDbColBinary);
1.914 + ++expand;
1.915 + }
1.916 + } while (++col<end);
1.917 + iExpansion=(expand+7)>>3;
1.918 + }
1.919 +
1.920 +TInt CDbStoreTable::CAlter::StepL(TInt aStep)
1.921 +//
1.922 +// Do some steps to alter the table data
1.923 +//
1.924 + {
1.925 + __ASSERT(iTable);
1.926 + iStep=aStep;
1.927 + iCluster=iRecords->AlterL(iCluster,*this);
1.928 + return iCluster==KNullClusterId ? 0 : Max(iStep,1);
1.929 + }
1.930 +
1.931 +TUint8* CDbStoreTable::CAlter::AlterRecordL(TUint8* aWPtr,const TUint8* aRPtr,TInt aLength)
1.932 +//
1.933 +// providing for CClusterCache::MAlter
1.934 +// re-write the record
1.935 +//
1.936 + {
1.937 + --iStep;
1.938 + return iTable->AlterRecordL(aWPtr,aRPtr,aLength,iInlineLimit);
1.939 + }
1.940 +
1.941 +TInt CDbStoreTable::CAlter::RecordExpansion(const TUint8*,TInt)
1.942 +//
1.943 +// providing for CClusterCache::MAlter
1.944 +// just return the maximum possible expansion, rather than a record-specific one
1.945 +//
1.946 + {
1.947 + return iExpansion;
1.948 + }