abssqlprocessor.hpp

Absolute Database 5.12 src. Absolute Database lets you forget the Borland Database Engine (BDE). Th

// Borland C++ Builder
// Copyright (c) 1995, 2005 by Borland Software Corporation
// All rights reserved

// (DO NOT EDIT: machine generated header) 'Abssqlprocessor.pas' rev: 10.00

#ifndef AbssqlprocessorHPP
#define AbssqlprocessorHPP

#pragma delphiheader begin
#pragma option push
#pragma option -w-      // All warnings off
#pragma option -Vx      // Zero-length empty class member functions
#pragma pack(push,8)
#include <System.hpp>	// Pascal unit
#include <Sysinit.hpp>	// Pascal unit
#include <Classes.hpp>	// Pascal unit
#include <Sysutils.hpp>	// Pascal unit
#include <Windows.hpp>	// Pascal unit
#include <Db.hpp>	// Pascal unit
#include <Abslexer.hpp>	// Pascal unit
#include <Absbase.hpp>	// Pascal unit
#include <Absrelationalalgebra.hpp>	// Pascal unit
#include <Abstypes.hpp>	// Pascal unit
#include <Absexpressions.hpp>	// Pascal unit
#include <Absvariant.hpp>	// Pascal unit
#include <Abscompression.hpp>	// Pascal unit
#include <Absconst.hpp>	// Pascal unit
#include <Absconverts.hpp>	// Pascal unit
#include <Absexcept.hpp>	// Pascal unit

//-- user supplied -----------------------------------------------------------

namespace Abssqlprocessor
{
//-- type declarations -------------------------------------------------------
class DELPHICLASS TABSTableReference;
class DELPHICLASS TABSSQLUnion;
class DELPHICLASS TABSSQLCursorCommand;
class DELPHICLASS TABSSQLCommand;
class PASCALIMPLEMENTATION TABSSQLCommand : public System::TObject 
{
	typedef System::TObject inherited;
	
protected:
	Abslexer::TABSLexer* LLex;
	Abslexer::TToken Token;
	Db::TDataSet* LQuery;
	int RowsAffected;
	bool IntoMemory;
	
private:
	void __fastcall ParseColumnList(Classes::TStringList* &Fields);
	void __fastcall ParseFieldList(Absrelationalalgebra::TABSFields* &Fields);
	bool __fastcall GetCurrentToken(void);
	bool __fastcall GetNextToken(void)/* overload */;
	bool __fastcall GetNextToken(Abslexer::TTokenTypes PermittedTypes, int NativeErrorCode, AnsiString ErrorText)/* overload */;
	
protected:
	void __fastcall ParseTableNameToken(AnsiString &DatabaseFileName, AnsiString &TableName, AnsiString &TableAlias, AnsiString &Password, bool &InMemory);
	void __fastcall CreateDbAndTableComponents(Db::TDataSet* Query, AnsiString DatabaseFileName, AnsiString TableName, AnsiString Password, bool InMemory, Db::TDataSet* &Table, System::TObject* &DB);
	void __fastcall FreeDbAndTableComponents(Db::TDataSet* Table, System::TObject* DB);
	
public:
	__fastcall TABSSQLCommand(Abslexer::TABSLexer* Lexer, Db::TDataSet* Query);
	virtual void __fastcall Parse(void) = 0 ;
	virtual void __fastcall ExecSQL(Db::TDataSet* query, bool IsRoot, bool RequestLive, bool &ReadOnly, Absrelationalalgebra::TABSAO* ParentQueryAO = (Absrelationalalgebra::TABSAO*)(0x0), Absbase::TABSCursor* ParentCursor = (Absbase::TABSCursor*)(0x0)) = 0 ;
	virtual Absbase::TABSCursor* __fastcall GetResultCursor(void);
	virtual Db::TDataSet* __fastcall GetResultDataset(void);
	bool __fastcall CheckPseudonym(AnsiString &Pseudonym);
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TABSSQLCommand(void) { }
	#pragma option pop
	
};


class PASCALIMPLEMENTATION TABSSQLCursorCommand : public TABSSQLCommand 
{
	typedef TABSSQLCommand inherited;
	
protected:
	Db::TDataSet* ResultDataset;
	AnsiString IntoDatabase;
	AnsiString IntoTable;
	bool IntoImmediate;
	DynamicArray<Abstypes::TABSSortSpecification >  OrderBySpecs;
	int OrderBySpecsCount;
	bool __fastcall OpenAndLockTablesBeforeSelect(void);
	bool __fastcall UnlockTablesAfterSelect(void);
	bool __fastcall ParseSortSpecification(void);
	bool __fastcall ParseOrderByClause(void);
	void __fastcall ApplyOrderBy(Absrelationalalgebra::TABSAO* AO);
	
public:
	Absrelationalalgebra::TABSAO* RootAO;
	__fastcall TABSSQLCursorCommand(Abslexer::TABSLexer* Lexer, Db::TDataSet* Query);
	__fastcall virtual ~TABSSQLCursorCommand(void);
	virtual void __fastcall ExecSQL(Db::TDataSet* query, bool IsRoot, bool RequestLive, bool &ReadOnly, Absrelationalalgebra::TABSAO* ParentQueryAO = (Absrelationalalgebra::TABSAO*)(0x0), Absbase::TABSCursor* ParentCursor = (Absbase::TABSCursor*)(0x0));
	virtual bool __fastcall AllConditionsApplied(void) = 0 ;
	virtual Absrelationalalgebra::TABSAO* __fastcall BuildAOTree(Db::TDataSet* query, bool RequestLive, Absrelationalalgebra::TABSAO* ParentQueryAO, Absbase::TABSCursor* ParentCursor, bool AllowNotAppliedConditions) = 0 ;
	virtual Absbase::TABSCursor* __fastcall GetResultCursor(void);
	virtual Db::TDataSet* __fastcall GetResultDataset(void);
};


class DELPHICLASS TABSQueryExprNode;
class DELPHICLASS TABSSQLSelect;
class PASCALIMPLEMENTATION TABSSQLSelect : public TABSSQLCursorCommand 
{
	typedef TABSSQLCursorCommand inherited;
	
protected:
	bool Distinct;
	int TopRowCount;
	int FirstRowNo;
	bool AllFields;
	DynamicArray<Absrelationalalgebra::TABSSelectListItem >  SelectList;
	int SelectListCount;
	DynamicArray<TABSTableReference* >  FromTables;
	int FromTablesCount;
	Absexpressions::TABSExpression* SearchCondition;
	Absrelationalalgebra::TABSFields* GroupByFields;
	Absexpressions::TABSExpression* HavingCondition;
	bool FSubqueryHasNotAppliedConditions;
	bool __fastcall ParseSelectToken(void);
	bool __fastcall ParseSetQuantifier(void);
	bool __fastcall ParseTopOperator(void);
	bool __fastcall DuplicatedFieldExists(const AnsiString TableName, const AnsiString FieldName);
	bool __fastcall FieldExists(const AnsiString TableName, const AnsiString FieldName);
	AnsiString __fastcall GetFieldNameForDuplicatedField(const AnsiString TableName, const AnsiString FieldName);
	bool __fastcall ParseSelectSubList(void);
	bool __fastcall ParseSelectList(void);
	bool __fastcall ParseInto(void);
	bool __fastcall ParseJoinCondition(Absexpressions::TABSExpression* &SearchCondition);
	bool __fastcall ParseNamedColumnsJoin(Classes::TStringList* &Fields);
	bool __fastcall ParseJoin(TABSTableReference* &tblRef);
	bool __fastcall ParseFromSubquery(TABSTableReference* tblRef);
	bool __fastcall ParseTableReference(TABSTableReference* tblRef = (TABSTableReference*)(0x0));
	bool __fastcall ParseFromClause(void);
	bool __fastcall ParseWhereClause(void);
	bool __fastcall ParseGroupByClause(void);
	bool __fastcall ParseHavingClause(void);
	AnsiString __fastcall GetDefaultDatabaseName();
	bool __fastcall GetDisableTempFiles(void);
	Absrelationalalgebra::TABSAO* __fastcall CreateTableAO(TABSTableReference* &TableRef);
	Absrelationalalgebra::TABSAO* __fastcall CreateJoinedTableAO(TABSTableReference* &TableRef, Absrelationalalgebra::TABSAO* ParentQueryAO, Absbase::TABSCursor* ParentCursor, bool AllowNotAppliedConditions);
	Absrelationalalgebra::TABSAO* __fastcall CreateSubQueryAO(TABSTableReference* &TableRef, bool RequestLive, Absrelationalalgebra::TABSAO* ParentQueryAO, Absbase::TABSCursor* ParentCursor, bool AllowNotAppliedConditions);
	Absrelationalalgebra::TABSAO* __fastcall CreateAO(TABSTableReference* &TableRef, bool RequestLive, Absrelationalalgebra::TABSAO* ParentQueryAO, Absbase::TABSCursor* ParentCursor, bool AllowNotAppliedConditions);
	Absrelationalalgebra::TABSAO* __fastcall BuildOneTableTree(bool RequestLive, Absrelationalalgebra::TABSAO* ParentQueryAO, Absbase::TABSCursor* ParentCursor, bool AllowNotAppliedConditions);
	Absrelationalalgebra::TABSAO* __fastcall BuildMultiTablesTree(bool RequestLive, Absrelationalalgebra::TABSAO* ParentQueryAO, Absbase::TABSCursor* ParentCursor, bool AllowNotAppliedConditions);
	
public:
	__fastcall TABSSQLSelect(Abslexer::TABSLexer* Lexer, Db::TDataSet* Query);
	__fastcall virtual ~TABSSQLSelect(void);
	virtual void __fastcall Parse(void);
	virtual bool __fastcall AllConditionsApplied(void);
	virtual Absrelationalalgebra::TABSAO* __fastcall BuildAOTree(Db::TDataSet* query, bool RequestLive, Absrelationalalgebra::TABSAO* ParentQueryAO, Absbase::TABSCursor* ParentCursor, bool AllowNotAppliedConditions);
};


class PASCALIMPLEMENTATION TABSQueryExprNode : public System::TObject 
{
	typedef System::TObject inherited;
	
public:
	Abstypes::TABSQueryExprType NodeType;
	TABSQueryExprNode* Left;
	TABSQueryExprNode* Right;
	bool All;
	bool Corresponding;
	Classes::TStringList* CorrespondingFields;
	TABSSQLSelect* SelectCommand;
	__fastcall TABSQueryExprNode(void)/* overload */;
	__fastcall TABSQueryExprNode(TABSQueryExprNode* Src)/* overload */;
	__fastcall virtual ~TABSQueryExprNode(void);
	void __fastcall AddNode(Abstypes::TABSQueryExprType NewType, TABSQueryExprNode* RightNode, bool bAll, bool bCorresponding, Classes::TStringList* ColumnList = (Classes::TStringList*)(0x0));
	bool __fastcall AllConditionsApplied(void);
	bool __fastcall HasInto(void);
};


class PASCALIMPLEMENTATION TABSSQLUnion : public TABSSQLCursorCommand 
{
	typedef TABSSQLCursorCommand inherited;
	
protected:
	TABSQueryExprNode* FRootNode;
	bool __fastcall ParseAll(void);
	bool __fastcall ParseCorrespondingSpec(Classes::TStringList* &ColumnsList);
	TABSQueryExprNode* __fastcall ParseQuerySpecification(void);
	TABSQueryExprNode* __fastcall ParseSimpleTable(void);
	TABSQueryExprNode* __fastcall ParseNonJoinQueryPrimary(void);
	TABSQueryExprNode* __fastcall ParseNonJoinQueryTerm(void);
	TABSQueryExprNode* __fastcall ParseNonJoinQueryExpression(void);
	TABSQueryExprNode* __fastcall ParseQueryExpression(void);
	Absrelationalalgebra::TABSAO* __fastcall BuildAO(TABSQueryExprNode* Node, bool RequestLive, Absrelationalalgebra::TABSAO* ParentQueryAO, Absbase::TABSCursor* ParentCursor, bool AllowNotAppliedConditions);
	
public:
	__fastcall TABSSQLUnion(Abslexer::TABSLexer* Lexer, Db::TDataSet* Query);
	__fastcall virtual ~TABSSQLUnion(void);
	virtual void __fastcall Parse(void);
	virtual bool __fastcall AllConditionsApplied(void);
	virtual Absrelationalalgebra::TABSAO* __fastcall BuildAOTree(Db::TDataSet* query, bool RequestLive, Absrelationalalgebra::TABSAO* ParentQueryAO, Absbase::TABSCursor* ParentCursor, bool AllowNotAppliedConditions);
};


class PASCALIMPLEMENTATION TABSTableReference : public System::TObject 
{
	typedef System::TObject inherited;
	
public:
	Abstypes::TABSTableType TableType;
	AnsiString DatabaseName;
	AnsiString TableName;
	AnsiString Pseudonym;
	AnsiString Password;
	bool InMemory;
	bool NaturalJoin;
	Abstypes::TABSJoinType JoinType;
	TABSTableReference* LeftTable;
	TABSTableReference* RightTable;
	Classes::TStringList* UsingFields;
	Absexpressions::TABSExpression* SearchCondition;
	TABSSQLUnion* SubQuery;
	System::TObject* ExternalDBToFree;
	__fastcall TABSTableReference(void);
	__fastcall virtual ~TABSTableReference(void);
	void __fastcall MakeJoin(TABSTableReference* RightNode, Abstypes::TABSJoinType JType, bool IsNatural, Classes::TStringList* Fields, Absexpressions::TABSExpression* OnCondition);
	void __fastcall MakeSubQuery(Abslexer::TABSLexer* Lexer, Db::TDataSet* Query);
};


typedef DynamicArray<Abstypes::TABSSortSpecification >  ABSSQLProcessor__4;

typedef DynamicArray<TABSSQLCommand* >  ABSSQLProcessor__6;

class DELPHICLASS TABSSQLProcessor;
class PASCALIMPLEMENTATION TABSSQLProcessor : public System::TObject 
{
	typedef System::TObject inherited;
	
private:
	Db::TDataSet* ABSQuery;
	bool FReadOnly;
	bool FRequestLive;
	bool FInMemory;
	__int64 FRowsAffected;
	Abslexer::TABSLexer* FLex;
	AnsiString FSqlText;
	Abslexer::TABSSQLParams* FSQLParams;
	Absbase::TABSCursor* FCursor;
	DynamicArray<TABSSQLCommand* >  Queries;
	bool __fastcall ParseNextCommand(Abslexer::TABSLexer* Lexer);
	void __fastcall AddSelectQuery(Abslexer::TABSLexer* Lexer);
	void __fastcall AddInsertQuery(Abslexer::TABSLexer* Lexer);
	void __fastcall AddUpdateQuery(Abslexer::TABSLexer* Lexer);
	void __fastcall AddDeleteQuery(Abslexer::TABSLexer* Lexer);
	void __fastcall AddTruncateTableQuery(Abslexer::TABSLexer* Lexer);
	void __fastcall AddCreateTableQuery(Abslexer::TABSLexer* Lexer);
	void __fastcall AddDropTableQuery(Abslexer::TABSLexer* Lexer);
	void __fastcall AddAlterTableQuery(Abslexer::TABSLexer* Lexer);
	void __fastcall AddRenameTableQuery(Abslexer::TABSLexer* Lexer);
	void __fastcall AddCreateIndex(Abslexer::TABSLexer* Lexer);
	void __fastcall AddDropIndexQuery(Abslexer::TABSLexer* Lexer);
	void __fastcall AddStartTransaction(Abslexer::TABSLexer* Lexer);
	void __fastcall AddCommit(Abslexer::TABSLexer* Lexer);
	void __fastcall AddRollback(Abslexer::TABSLexer* Lexer);
	void __fastcall ClearQueries(void);
	
public:
	__fastcall TABSSQLProcessor(Db::TDataSet* Query);
	__fastcall virtual ~TABSSQLProcessor(void);
	Absbase::TABSCursor* __fastcall OpenQuery(void);
	void __fastcall ExecuteQuery(void);
	void __fastcall PrepareStatement(char * SQLText);
	__property bool ReadOnly = {read=FReadOnly, write=FReadOnly, nodefault};
	__property bool RequestLive = {read=FRequestLive, write=FRequestLive, nodefault};
	__property bool InMemory = {read=FInMemory, write=FInMemory, nodefault};
	__property __int64 RowsAffected = {read=FRowsAffected};
	__property Abslexer::TABSSQLParams* SQLParams = {read=FSQLParams};
};


typedef DynamicArray<Absrelationalalgebra::TABSSelectListItem >  ABSSQLProcessor__8;

typedef DynamicArray<TABSTableReference* >  ABSSQLProcessor__9;

typedef DynamicArray<Classes::TList* >  ABSSQLProcessor__31;

class DELPHICLASS TABSSQLInsert;
class PASCALIMPLEMENTATION TABSSQLInsert : public TABSSQLCommand 
{
	typedef TABSSQLCommand inherited;
	
protected:
	AnsiString TableName;
	AnsiString DatabaseFileName;
	AnsiString Password;
	Classes::TStringList* FieldNames;
	DynamicArray<Classes::TList* >  FieldValues;
	TABSSQLSelect* InternalSelecter;
	void __fastcall ParseValuesList(void);
	
public:
	__fastcall TABSSQLInsert(Abslexer::TABSLexer* Lexer, Db::TDataSet* Query);
	__fastcall virtual ~TABSSQLInsert(void);
	virtual void __fastcall Parse(void);
	virtual void __fastcall ExecSQL(Db::TDataSet* query, bool IsRoot, bool RequestLive, bool &ReadOnly, Absrelationalalgebra::TABSAO* ParentQueryAO = (Absrelationalalgebra::TABSAO*)(0x0), Absbase::TABSCursor* ParentCursor = (Absbase::TABSCursor*)(0x0));
};


class DELPHICLASS TABSSQLUpdate;
class PASCALIMPLEMENTATION TABSSQLUpdate : public TABSSQLCommand 
{
	typedef TABSSQLCommand inherited;
	
protected:
	AnsiString DatabaseFileName;
	AnsiString TableName;
	AnsiString Password;
	Classes::TStringList* FieldNames;
	Classes::TList* FieldValues;
	bool IsFieldValuesSubquery;
	Absexpressions::TABSExpression* FieldValuesSubqueryExpr;
	TABSSQLSelect* InternalSelecter;
	Abslexer::TABSLexer* FSelectLexer;
	AnsiString FTablePseudonym;
	
public:
	__fastcall TABSSQLUpdate(Abslexer::TABSLexer* Lexer, Db::TDataSet* Query);
	__fastcall virtual ~TABSSQLUpdate(void);
	virtual void __fastcall Parse(void);
	virtual void __fastcall ExecSQL(Db::TDataSet* query, bool IsRoot, bool RequestLive, bool &ReadOnly, Absrelationalalgebra::TABSAO* ParentQueryAO = (Absrelationalalgebra::TABSAO*)(0x0), Absbase::TABSCursor* ParentCursor = (Absbase::TABSCursor*)(0x0));
};


class DELPHICLASS TABSSQLDelete;
class PASCALIMPLEMENTATION TABSSQLDelete : public TABSSQLCommand 
{
	typedef TABSSQLCommand inherited;
	
protected:
	TABSSQLSelect* InternalSelecter;
	AnsiString TableName;
	bool FullDelete;
	
public:
	__fastcall TABSSQLDelete(Abslexer::TABSLexer* Lexer, Db::TDataSet* Query);
	__fastcall virtual ~TABSSQLDelete(void);
	virtual void __fastcall Parse(void);
	virtual void __fastcall ExecSQL(Db::TDataSet* query, bool IsRoot, bool RequestLive, bool &ReadOnly, Absrelationalalgebra::TABSAO* ParentQueryAO = (Absrelationalalgebra::TABSAO*)(0x0), Absbase::TABSCursor* ParentCursor = (Absbase::TABSCursor*)(0x0));
};


class DELPHICLASS TSQLFieldDef;
class PASCALIMPLEMENTATION TSQLFieldDef : public System::TObject 
{
	typedef System::TObject inherited;
	
public:
	AnsiString FieldName;
	bool CreateIfNotExists;
	bool newFieldType;
	Abstypes::TABSAdvancedFieldType FieldType;
	bool newLength;
	int Length;
	bool newRequired;