diff -r 000000000000 -r 08ec8eefde2f persistentstorage/dbms/inc/D32SQL.H
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/persistentstorage/dbms/inc/D32SQL.H	Fri Jan 22 11:06:30 2010 +0200
@@ -0,0 +1,446 @@
+// 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:
+// SQL parsing engine
+// 
+//
+
+#ifndef __D32SQL_H__
+#define __D32SQL_H__
+
+#ifndef __D32DBMS_H__
+#include <d32dbms.h>
+#endif
+
+// Other class referenced
+class MStreamBuf;
+class TDbBlob;
+class RDbTableRow;
+class TTextOps;
+class TSqlParser;
+class CDbTable;
+class CDbTableDatabase;
+class CDbDataSource;
+class CDbBlobSpace;
+template <class T,class D> class HMatcherPattern;
+
+// Classes defined
+class Sql;
+class RSqlLiteral;
+class CSqlValues;
+class RSqlColumnList;
+class CSqlSearchCondition;
+class CSqlMultiNode;
+class CSqlBoundNode;
+class CSqlNullPredicate;
+class CSqlLiteralNode;
+class CSqlCompPredicate;
+class CSqlLikePredicate;
+class CSqlQuery;
+class CSqlDDLStatement;
+class CSqlDMLStatement;
+class CSqlInsertStatement;
+class CSqlModifyStatement;
+
+/**
+@internalComponent
+*/
+typedef HMatcherPattern<TUint8,TDesC8> HMatcherPattern8;
+typedef HMatcherPattern<TUint16,TDesC16> HMatcherPattern16;
+
+/**
+@internalComponent
+*/
+class Sql
+	{
+public:
+	enum TStatementType { ENone, EDDL, EDML };
+public:
+	static CSqlDDLStatement* ParseDDLStatementLC( const TDesC& aSql );
+	static CSqlDMLStatement* ParseDMLStatementLC( const TDesC& aSql );
+	static CSqlQuery* ParseQueryLC( const TDesC& aSql );
+	static CSqlSearchCondition* ParseSearchConditionLC( const TDesC& aSql );
+	//
+	static TStatementType Type( const TDesC& aSql );
+	};
+
+// variant data classes
+
+/**
+@internalComponent
+*/
+class RSqlLiteral
+	{
+public:
+	inline RSqlLiteral();
+	void Close();
+// assignment
+	inline void SetText( const TText* aPtr, const TText* aEnd );
+	inline TInt64& SetInt();
+	inline TReal64& SetReal();
+	inline TTime& SetTime();
+// conversions
+	void ToInt32L();
+	void ToUint32L();
+	void ToInt64L();
+	void ToReal32L();
+	void ToReal64L();
+	void ToTimeL();
+	void ToText8L();
+	void ToText16L();
+	void ToPattern8L(TBool aEscape = EFalse);
+	void ToPattern16L(TBool aEscape = EFalse);
+	TInt CopyText();
+// accessors
+	inline TBool IsNull() const;
+	inline TInt32 Int32() const;
+	inline TUint32 Uint32() const;
+	inline const TInt64& Int64() const;
+	inline const TTime& Time() const;
+	inline const TReal32& Real32() const;
+	inline const TReal64& Real64() const;
+	inline const TText* Ptr() const;
+	inline const TText* End() const;
+	inline const TPtrC DesC() const;
+	inline const HBufC8& Text8() const;
+	inline const HBufC16& Text16() const;
+	inline const HMatcherPattern8& Pattern8() const;
+	inline const HMatcherPattern16& Pattern16() const;
+private:
+	inline TBool IsBasic() const;
+	inline TBool IsAlloc() const;
+private:
+	enum TType { EInt32, EUint32, EReal32, EInt64, ETime, EReal64, EPtr, ENull, EBuf8, EBuf16, EPattern8, EPattern16 };
+private:
+	union
+		{
+		TInt32 iInt32;
+		TUint32 iUint32;
+		TUnion<TInt64> iInt64;
+		TReal32 iReal32;
+		TReal64 iReal64;
+		TUnion<TTime> iTime;
+		struct { const TText* iPtr; const TText* iEnd; } iPtr;
+		TAny* iAlloc;
+		} iVal;
+	TType iType;
+	HBufC* iBuffer;
+	};
+
+/**
+@internalComponent
+*/
+NONSHARABLE_CLASS(CSqlValues) : public CBase
+	{
+public:
+	CSqlValues();
+	~CSqlValues();
+//
+	void AddL( const RSqlLiteral& aLiteral );
+	void BindL( const CDbDataSource& aSource );
+	void WriteL( CDbDataSource& aSource, CDbTable& aTable ) const;
+private:
+	enum { EGranularity = 8 };
+	class TEntry
+		{
+	public:
+		inline TEntry( const RSqlLiteral& aValue );
+	public:
+		RSqlLiteral iValue;
+		TDbColType iType;
+		};
+private:
+	RArray<TEntry> iValues;
+	};
+
+/**
+@internalComponent
+*/
+class RSqlColumnList : public RArray<TPtrC>
+	{
+	enum { EGranularity = 8 };
+public:
+	inline RSqlColumnList();
+	};
+
+// evaluation tree classes
+
+/**
+@internalComponent
+*/
+class CSqlSearchCondition : public CBase
+	{
+public:
+	enum TType
+		{
+		EAnd, EOr,
+		EIsNull, EIsNotNull,
+		ELike, ENotLike,
+		ELess, ELessEqual, EEqual, EGreaterEqual, EGreater, ENotEqual
+		};
+public:
+
+	TBool iIsEscape; 
+	
+	inline TType NodeType() const;
+	inline CSqlMultiNode* MultiNode();
+	inline CSqlNullPredicate* NullPredicate();
+	inline CSqlCompPredicate* CompPredicate();
+	inline CSqlLikePredicate* LikePredicate();
+//
+	virtual void BindL( const RDbTableRow& aSource ) = 0;
+	virtual TBool EvaluateL( const TTextOps& aTextOp ) const = 0;
+protected:
+	CSqlSearchCondition( TType aType );
+		
+private:
+	TType iType;
+	
+	};
+
+/**
+@internalComponent
+*/
+NONSHARABLE_CLASS(CSqlMultiNode) : public CSqlSearchCondition
+	{
+private:
+	typedef CSqlSearchCondition* TEntry;
+	enum { EGranularity = 4 * sizeof( TEntry ) };
+public:
+	static CSqlSearchCondition* New( TType aType, CSqlSearchCondition* aLeft, CSqlSearchCondition* aRight );
+//
+	inline TInt Count() const;
+	inline CSqlSearchCondition* SubNode( TInt aIndex ) const;
+	inline void SetSubNode( TInt aIndex, CSqlSearchCondition* aSearchCondition ); 
+	void Remove( CSqlSearchCondition* aSubNode );
+	static CSqlSearchCondition* Reduce( CSqlMultiNode* aNode );
+private:
+	inline CSqlMultiNode( TType aType );
+	~CSqlMultiNode();
+	static CSqlMultiNode* New( TType aType, TInt aSize );
+	static CSqlMultiNode* Grow( CSqlMultiNode* aNode, TInt aExtraSize );
+	static CSqlMultiNode* Concatenate( CSqlMultiNode* aLeft, CSqlMultiNode* aRight );
+//
+	inline TInt Size() const;
+	static inline TInt Size( TInt aLeaves );
+	inline TBool IsFull() const;
+private:
+// from CSqlSearchCondition
+	void BindL( const RDbTableRow& aSource );
+	TBool EvaluateL( const TTextOps& aTextOp ) const;
+private:
+	TEntry* iEnd;
+	TEntry iLeaves[1];
+	};
+
+/**
+@internalComponent
+*/
+NONSHARABLE_CLASS(CSqlBoundNode) : public CSqlSearchCondition
+	{
+public:
+	const TDesC& ColumnName() const;
+	inline TDbColNo ColNo() const;
+	inline TDbColType ColType() const;
+protected:
+	CSqlBoundNode( TType aType, const TDesC& aColumn );
+	inline TBool IsBound() const;
+	inline TDbColumnC Column() const;
+	MStreamBuf& StreamLC( const TDbBlob& aBlob ) const;
+// from CSqlSearchCondition
+	void BindL( const RDbTableRow& aSource );
+private:
+	const RDbTableRow* iSource;
+	union
+		{
+		TUnion<TPtrC> iName;
+		struct
+			{
+			TDbColNo iNumber;
+			TDbColType iType;
+			} iBound;
+		} iColumn;
+	};
+
+/**
+@internalComponent
+*/
+NONSHARABLE_CLASS(CSqlNullPredicate) : public CSqlBoundNode
+	{
+public:
+	CSqlNullPredicate( TType aType, const TDesC& aColumn );
+private:
+// from CSqlSearchCondition
+	TBool EvaluateL( const TTextOps& aTextOp ) const;
+	};
+
+/**
+@internalComponent
+*/
+NONSHARABLE_CLASS(CSqlLiteralNode) : public CSqlBoundNode
+	{
+public:
+	inline const RSqlLiteral& Value() const;
+	inline RSqlLiteral& Value();
+protected:
+	CSqlLiteralNode( TType aType, const TDesC& aColumn, const RSqlLiteral& aLiteral );
+	~CSqlLiteralNode();
+// from CSqlSearchCondition
+	void BindL( const RDbTableRow& aSource );
+private:
+	RSqlLiteral iLiteral;
+	};
+
+/**
+@internalComponent
+*/
+NONSHARABLE_CLASS(CSqlCompPredicate) : public CSqlLiteralNode
+	{
+public:
+	CSqlCompPredicate( TType aType, const TDesC& aColumn, const RSqlLiteral& aLiteral );
+private:
+	TInt CompareLongText8L( const TDbBlob& aBlob, const TTextOps& aTextOp ) const;
+	TInt CompareLongText16L( const TDbBlob& aBlob, const TTextOps& aTextOp ) const;
+// from CSqlSearchCondition
+	TBool EvaluateL( const TTextOps& aTextOp ) const;
+	};
+
+/**
+@internalComponent
+*/
+NONSHARABLE_CLASS(CSqlLikePredicate) : public CSqlLiteralNode 
+	{
+public:
+	CSqlLikePredicate( TType aType, const TDesC& aColumn, const RSqlLiteral& aPattern );
+private:
+// from CSqlSearchCondition
+	void BindL( const RDbTableRow& aSource );
+	TBool EvaluateL( const TTextOps& aTextOp ) const;
+private:
+	TInt iMatchSize;
+	};
+
+/**
+@internalComponent
+*/
+NONSHARABLE_CLASS(CSqlQuery) : public CBase
+	{
+	friend class TSqlParser;
+public:
+	CSqlQuery();
+	~CSqlQuery();
+//
+	inline const TDesC& Table() const;
+//
+	inline TBool HasColumnList() const;
+	inline const RSqlColumnList& ColumnList() const;
+//
+	inline TBool HasSearchCondition() const;
+	inline CSqlSearchCondition& SearchCondition();
+	void RemovePredicate( CSqlCompPredicate* aNode );
+	inline CSqlSearchCondition* AdoptSearchCondition();
+//
+	inline TBool HasSortSpecification() const;
+	inline CDbKey& SortSpecification();
+private:
+	CDbKey& SortSpecificationL();
+private:
+	TPtrC iTable;
+	RSqlColumnList iColumns;
+	CSqlSearchCondition* iSearchCondition;
+	CDbKey* iSortSpecification;
+	};
+
+/**
+@internalComponent
+*/
+class CSqlDDLStatement : public CBase
+	{
+protected:
+	inline CSqlDDLStatement() {}
+public:
+	virtual CDbIncremental* ExecuteL( CDbDatabase& aDatabase, TDbTextComparison aComparison, TInt& aStep ) = 0;
+	};
+
+/**
+@internalComponent
+*/
+NONSHARABLE_CLASS(CSqlDMLStatement) : public CBase
+	{
+	friend class TSqlParser;
+public:
+	~CSqlDMLStatement();
+//
+	inline CSqlQuery& Query();
+	inline CSqlValues& Values();
+	inline CSqlValues* AdoptValues();
+//
+	virtual CDbIncremental* ExecuteL( CDbTableDatabase& aDatabase, TDbTextComparison aComparison, TInt& aRows ) = 0;
+protected:
+	inline CSqlDMLStatement() {}
+	inline TBool HasValues() const;
+private:
+	CSqlValues& ValuesL();
+private:
+	CSqlQuery iQuery;
+	CSqlValues* iValues;
+	};
+
+/**
+@internalComponent
+*/
+NONSHARABLE_CLASS(CSqlInsertStatement) : public CSqlDMLStatement
+	{
+public:
+	static CSqlInsertStatement* NewLC();
+private:
+	inline CSqlInsertStatement() {}
+// from CSqlDMLStatement
+	CDbIncremental* ExecuteL( CDbTableDatabase& aDatabase, TDbTextComparison aComparison, TInt& aRows );
+	};
+
+/**
+@internalComponent
+*/
+NONSHARABLE_CLASS(CSqlModifyStatement) : public CSqlDMLStatement
+	{
+public:
+	static CSqlModifyStatement* NewLC();
+	inline TBool IsUpdate() const;
+private:
+	inline CSqlModifyStatement() {}
+// from CSqlDMLStatement
+	CDbIncremental* ExecuteL( CDbTableDatabase& aDatabase, TDbTextComparison aComparison, TInt& aRows );
+	};
+
+/**
+TSqlParser2 class uses TSqlParser class functionality only to parse particular SQL string
+and extract SQL type and table name.
+@internalComponent
+*/
+class TSqlParser2
+	{
+public:
+	void ParseL(const TDesC& aSql);
+	inline Sql::TStatementType StatementType() const;
+	inline const TDesC& TableName() const;
+
+private:
+	Sql::TStatementType	iStatementType;
+	TPtrC				iTableName;
+
+	};
+
+#include "D32SQL.INL"
+
+#endif//__D32SQL_H__