--- /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__