// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#include "US_STD.H"

#include "U32STD_DBMS.H"

#include <d32dbmsconstants.h>

// class TRecordSize

TUint8 const TRecordSize::FieldSizes[]=

	{

	0,					// EDbColBit

	sizeof(TInt8),		// EDbColInt8

	sizeof(TUint8),		// EDbColUint8

	sizeof(TInt16),		// EDbColInt16

	sizeof(TUint16),	// EDbColUint16

	sizeof(TInt32),		// EDbColInt32

	sizeof(TUint32),	// EDbColUint32

	sizeof(TInt64),		// EDbColInt64

	sizeof(TReal32),	// EDbColReal32

	sizeof(TReal64),	// EDbColReal64

	sizeof(TTime)		// EDbColDateTime

	};

TBool TRecordSize::Set(const HDbColumnSet& aColumns)

//

// Calculate stats for the record size and shape from the definition

//

	{

	TInt fix=0,null=0,var=0,blob=0;

	HDbColumnSet::TIteratorC const end=aColumns.End();

	HDbColumnSet::TIteratorC col=aColumns.Begin();

	do

		{

		TBool notnull=col->iAttributes&TDbCol::ENotNull;

		if (notnull==0)

			++fix;

		TDbColType type=col->Type();

		__ASSERT(type>=EDbColBit&&type<=EDbColLongBinary);

		if (type==EDbColBit)

			++fix;

		else if (type<=EDbColDateTime)

			{

			TInt bits=FixedFieldSize(type)<<3;

			if (notnull)

				fix+=bits;

			else

				null+=bits;

			}

		else if (type<=EDbColBinary)

			{

			TInt size=col->iMaxLength;

			if (type==EDbColText16)

				size<<=1;

			var+=8+(size<<3);

			}

		else

			++blob;

		} while(++col<end);

//

// assuming Blobs take at least 16 bytes + 1 bit

	TInt max=(fix+null+var+blob*(1+(KMinInlineLimit<<3))+7)>>3;

	if (max>KDbStoreMaxRecordLength)

		return ETrue;

//

// Assuming a Maximally full record, how much excess space is available for Blobs?

//

	iInlineLimit=KDbMaxInlineBlobSize;

	if (blob)

		{	// use the spare space for extra inlining

		TInt spare=(KDbStoreMaxRecordLength-max);

		TInt inl=spare/blob+KMinInlineLimit-1;

		if (inl<KDbMaxInlineBlobSize)

			iInlineLimit=inl;

		}

//

// Calculate the average cluster size for a column set

// This assumes that the nullable columns are present 50%, Variable average 1/16

// Blobs achieve 16 bytes, or inline limit (if smaller)

//

	TInt average=(fix+(null>>1)+(var>>4)+blob*(1+(16<<3))+7)>>3;

	TInt clustering=KClusterLimit/average;

	if (clustering==0)

		clustering=1;

	else if (clustering>KMaxClustering)

		clustering=KMaxClustering;

	iClustering=clustering;

	return EFalse;

	}

void TRecordSize::CheckSizeL(const HDbColumnSet& aColumns)

//

// Check that the columns definition is a valid size

//

	{

	TRecordSize size;

	if (size.Set(aColumns))

		__LEAVE(KErrTooBig);

	}

TInt TRecordSize::InlineLimit(const HDbColumnSet& aColumns)

//

// Evaluate the inline limit for the column set. It is assumed to be valid

//

	{

	TRecordSize size;

	__DEBUG(TBool chk =)size.Set(aColumns);

	__ASSERT(!chk);

	return size.InlineLimit();

	}

// Streaming column definitions

LOCAL_C void ExternalizeL(const TDbColumnDef& aCol,RWriteStream& aStream)

	{

	aStream<<*aCol.iName;

	aStream.WriteUint8L(aCol.iType);

	aStream.WriteUint8L(aCol.iAttributes);

	switch (aCol.iType)

		{

	case EDbColBinary:

	case EDbColText8:

	case EDbColText16:

		aStream.WriteUint8L(aCol.iMaxLength);

		break;

	default:

		break;

		}

	}

LOCAL_C void InternalizeL(TDbColumnDef& aCol,RReadStream& aStream)

	{

	aCol.iName=HBufC::NewL(aStream,KDbMaxColName);

	TDbColType type=TDbColType(aStream.ReadUint8L());

	aCol.iType=TUint8(type);

	aCol.iAttributes=aStream.ReadUint8L();

	if (type>EDbColLongBinary || (aCol.iAttributes&~(TDbCol::ENotNull|TDbCol::EAutoIncrement))!=0)

		__LEAVE(KErrCorrupt);

	if (type>=EDbColText8 && type<=EDbColBinary)

		{

		aCol.iMaxLength=aStream.ReadUint8L();

		if (aCol.iMaxLength==0)

			__LEAVE(KErrCorrupt);

		}

	else

		aCol.iMaxLength=KDbUndefinedLength;

	}

inline RWriteStream& operator<<(RWriteStream& aStream,const TDbColumnDef& aCol)

	{ExternalizeL(aCol,aStream);return aStream;}

inline RReadStream& operator>>(RReadStream& aStream,TDbColumnDef& aCol)

	{InternalizeL(aCol,aStream);return aStream;}

// Streaming key columns

LOCAL_C void ExternalizeL(const TDbKeyCol& aKeyCol,RWriteStream& aStream)

	{

	aStream<<aKeyCol.iName;

	aStream.WriteUint8L(aKeyCol.iLength!=KDbUndefinedLength ? aKeyCol.iLength : 0);

	aStream.WriteUint8L(aKeyCol.iOrder);

	}

LOCAL_C void InternalizeL(TDbKeyCol& aKeyCol,RReadStream& aStream)

	{

	TPtr des=aKeyCol.iName.Des();

	aStream>>des;

	TUint len=aStream.ReadUint8L();

	aKeyCol.iLength=len!=0 ? TInt(len) : KDbUndefinedLength;

	aKeyCol.iOrder=TDbKeyCol::TOrder(aStream.ReadUint8L());

	if (aKeyCol.iOrder>TDbKeyCol::EDesc)

		__LEAVE(KErrCorrupt);

	}

inline RWriteStream& operator<<(RWriteStream& aStream,const TDbKeyCol& aCol)

	{ExternalizeL(aCol,aStream);return aStream;}

inline RReadStream& operator>>(RReadStream& aStream,TDbKeyCol& aCol)

	{InternalizeL(aCol,aStream);return aStream;}

// Class CDbStoreIndexDef

CDbStoreIndexDef::CDbStoreIndexDef()

	{}

CDbStoreIndexDef* CDbStoreIndexDef::NewLC(const TDesC& aName)

	{

	CDbStoreIndexDef* self=new(ELeave) CDbStoreIndexDef;

	CleanupStack::PushL(self);

	self->ConstructL(aName);

	return self;

	}

CDbStoreIndexDef* CDbStoreIndexDef::NewLC(const TDesC& aName,const CDbKey& aKey,const HDbColumnSet& aColumns)

	{

	CDbStoreIndexDef* self=NewLC(aName);

	CDbKey& key=self->Key();

	TInt max=aKey.Count();

	for (TInt ii=0;ii<max;++ii)

		{

		TDbKeyCol kCol=aKey[ii];

		const TDbColumnDef& col=*aColumns.ColumnL(kCol.iName);

		switch (col.iType)

			{

		default:

			break;

		case EDbColText8:

		case EDbColText16:

			if (kCol.iLength==KDbUndefinedLength)

				kCol.iLength=col.iMaxLength;

			break;

		case EDbColLongText8:

		case EDbColLongText16:

			if (kCol.iLength==KDbUndefinedLength)

				__LEAVE(KErrArgument);

			break;

		case EDbColBinary:

		case EDbColLongBinary:

			__LEAVE(KErrArgument);

			break;

			}

		key.AddL(kCol);

		}

	if (aKey.IsUnique())

		key.MakeUnique();

	if (aKey.IsPrimary())

		key.MakePrimary();

	key.SetComparison(aKey.Comparison());

	CheckSizeL(key,aColumns);

	return self;

	}

CDbStoreIndexDef* CDbStoreIndexDef::NewL(RReadStream& aStream)

//

// Construct an index definition from persistent storage

//

	{

	TDbName name;

	aStream>>name;

	CDbStoreIndexDef* self=NewLC(name);

	CDbKey& key=self->Key();

	TDbTextComparison comp=TDbTextComparison(aStream.ReadUint8L());

	if (comp>EDbCompareCollated)

		__LEAVE(KErrCorrupt);

	key.SetComparison(comp);

	if (aStream.ReadUint8L())

		key.MakeUnique();

	TCardinality count;

	aStream>>count;

	for (TInt ii=count;ii>0;--ii)

		{

		TDbKeyCol keycol;

		aStream>>keycol;

		key.AddL(keycol);

		}

	aStream>>self->iTokenId;

	CleanupStack::Pop();

	return self;

	}

void CDbStoreIndexDef::ExternalizeL(RWriteStream& aStream) const

	{

	aStream<<Name();

	const CDbKey& key=Key();

	aStream.WriteUint8L(TUint8(key.Comparison()));

	aStream.WriteUint8L(key.IsUnique());

	TInt max=key.Count();

	aStream<<TCardinality(max);

	for (TInt ii=0;ii<max;++ii)

		aStream<<key[ii];

	aStream<<iTokenId;

	}

TInt CDbStoreIndexDef::KeySize(const TDbKeyCol& aKeyCol,const TDbColumnDef& aColumn)

	{

	LOCAL_D const TUint8 KFixedSize[]=

		{

		sizeof(TUint32),

		sizeof(TInt32),

		sizeof(TUint32),

		sizeof(TInt32),

		sizeof(TUint32),

		sizeof(TInt32),

		sizeof(TUint32),

		sizeof(TInt64),

		sizeof(TReal32),

		sizeof(TReal64),

		sizeof(TTime)

		};

	TDbColType t=aColumn.Type();

	if (TUint(t)<sizeof(KFixedSize)/sizeof(KFixedSize[0]))

		return KFixedSize[t];

	switch (t)

		{

	default:

		__ASSERT(0);

	case EDbColText8:

	case EDbColLongText8:

		return aKeyCol.iLength;

	case EDbColText16:

	case EDbColLongText16:

		return aKeyCol.iLength<<1;

		}

	}

void CDbStoreIndexDef::CheckSizeL(const CDbKey& aKey,const HDbColumnSet& aColSet)

//

// Check the size of the key for the index definition

//

	{

	TInt len=aKey.IsUnique()?0:sizeof(TDbRecordId);

	for (TInt ii=aKey.Count();--ii>=0;)

		{

		const TDbKeyCol& keyCol=aKey[ii];

		len+=Align4(KeySize(keyCol,*aColSet.ColumnL(keyCol.iName)));

		}

	if (len>KMaxIndexKeySize)

		__LEAVE(KErrTooBig);

	}

// Class CDbStoreDef

LOCAL_C void SetColumnL(TDbColumnDef& aDef,const TDbCol& aCol,TUint aFlag=0)

	{

	aDef.SetL(aCol);

	if (aDef.iAttributes&TDbCol::EAutoIncrement)

		aDef.iAttributes|=TDbCol::ENotNull;	// auto-increment => not-null

	aDef.iFlags=TUint8(aFlag);

	TDbColType type=aCol.iType;

	if (type>=EDbColText8 && type<=EDbColBinary)

		{

		if (aCol.iMaxLength==KDbUndefinedLength)

			aDef.iMaxLength=KDbStoreMaxColumnLength;

		else if (aCol.iMaxLength>KDbStoreMaxColumnLength)

			__LEAVE(KErrNotSupported);

		}

	else

		aDef.iMaxLength=KDbUndefinedLength;

	}

LOCAL_C HDbColumnSet::TIterator CheckColumnsL(HDbColumnSet::TIterator anIter,const CDbColSet& aColSet,TInt aNotNull,TUint aFlag=0)

//

// Check the columns from aColset into anIter, according to ENotNull attribute

// Validate as we go

//

	{

	for (TDbColSetIter iter(aColSet);iter;++iter)

		{

		TInt att=iter->iAttributes;

		if (att&TDbCol::EAutoIncrement)

			att|=TDbCol::ENotNull;		// auto-increment => not-null

		if ((att&TDbCol::ENotNull)==aNotNull)

			{

			SetColumnL(*anIter,*iter,aFlag);

			++anIter;

			}

		}

	return anIter;

	}

CDbStoreDef::CDbStoreDef()

	{}

CDbStoreDef* CDbStoreDef::NewLC(const TDesC& aName,TInt aColumnCount)

	{

	CDbStoreDef* self=new(ELeave) CDbStoreDef;

	CleanupStack::PushL(self);

	self->ConstructL(aName,aColumnCount);

	return self;

	}

CDbStoreDef* CDbStoreDef::NewLC(const TDesC& aName,const CDbColSet& aColSet)

//

// Construct a table definition from the column set supplied

//

	{

	CDbStoreDef* self=NewLC(aName,aColSet.Count());

	HDbColumnSet& columns=self->Columns();

	HDbColumnSet::TIterator def=CheckColumnsL(columns.Begin(),aColSet,TDbCol::ENotNull);

	def=CheckColumnsL(def,aColSet,0);

	__ASSERT(def==columns.End());

	TRecordSize::CheckSizeL(columns);

	self->Changed();

	return self;

	}

CDbStoreDef* CDbStoreDef::NewL(RReadStream& aStream)

//

// Construct a table definition from persistent storage

//

	{

	TDbName name;

	aStream>>name;

	TCardinality count;

	aStream>>count;

	CDbStoreDef* self=NewLC(name,count);

	HDbColumnSet& columns=self->Columns();

	HDbColumnSet::TIterator iter=columns.Begin();

	const HDbColumnSet::TIteratorC end=columns.End();

	do

		{

		aStream>>*iter;

		} while (++iter<end);

	aStream>>count;

	TInt cluster=count;

	if (cluster==0 || cluster>KMaxClustering)

		__LEAVE(KErrCorrupt);

	aStream>>self->iTokenId;

	RDbIndexes& indexes=self->Indexes();

	aStream>>count;

	for (TInt ii=count;ii>0;--ii)

		indexes.Add(CDbStoreIndexDef::NewL(aStream));

	self->Changed();

	CleanupStack::Pop();

	return self;

	}

void CDbStoreDef::Changed()

//

// The definition has changed, following creation or alteration of the table

// Recalculate cached data for the definition.

//

	{

	CDbTableDef::Changed();

	__DEBUG(TBool dbg =)iInfo.Set(Columns());

	__ASSERT(!dbg);

	}

void CDbStoreDef::ExternalizeL(RWriteStream& aStream) const

	{

	aStream<<Name();

	const HDbColumnSet& columns=Columns();

	aStream<<TCardinality(columns.Count());

	HDbColumnSet::TIteratorC iter=columns.Begin();

	const HDbColumnSet::TIteratorC end=columns.End();

	do

		{

		aStream<<*iter;

		} while (++iter<end);

	aStream<<TCardinality(Clustering());	// old stuff, not needed

	aStream<<iTokenId;

	aStream<<TCardinality(Indexes().Count());

	TSglQueIterC<CDbStoreIndexDef> ixIter(Indexes().AsQue());

	for (const CDbStoreIndexDef* def;(def=ixIter++)!=0;)

		aStream<<*def;

	}

void CDbStoreDef::AlteredColumnSetL(HDbColumnSet& aSet,const CDbColSet& aChange,const CDbColSet& aAdd)

//

// Generate an altered column set

// We can hijack the non-user attribs of the column sets for marking changes

//

	{

	// add not-null columns to the front

	HDbColumnSet::TIterator newCol=CheckColumnsL(aSet.Begin(),aAdd,TDbCol::ENotNull,TDbColumnDef::EAdded);

	// copy current set, minus deleted ones, apply text column length changes

	TDbColSetIter change(aChange);

	HDbColumnSet::TIterator col=Columns().Begin();

	HDbColumnSet::TIteratorC const end=Columns().End();

	do

		{

		TUint flag=col->iFlags;

		if (flag&TDbColumnDef::EDropped)

			continue;

		if (flag&(TDbColumnDef::EChangedType|TDbColumnDef::EChangedLen))

			{

			// check allowed changes

			SetColumnL(*newCol,*change);

			++change;

			if (flag&TDbColumnDef::EChangedType)

				{	// validate type changes (only text->longtext etc)

				if (!TDbCol::IsLong(newCol->Type()) || newCol->iType-col->iType!=3)

					__LEAVE(KErrNotSupported);

				}

			else

				{

				col->iFlags=TUint8(flag&~TDbColumnDef::EChangedLen);	// no real changes req'd

				if (newCol->iMaxLength<col->iMaxLength)

					__LEAVE(KErrNotSupported);					// can only extend columns

				}

			}

		else

			newCol->SetL(*col);

		++newCol;

		} while (++col<end);

	// add nullable columns to the end

	newCol=CheckColumnsL(newCol,aAdd,0,TDbColumnDef::EAdded);

	__ASSERT(newCol==aSet.End());

	TRecordSize::CheckSizeL(aSet);

	}