abssqlprocessor.hpp

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

	bool Required;
	bool newAutoincIncrement;
	__int64 AutoincIncrement;
	bool newAutoincLastValue;
	__int64 AutoincLastValue;
	bool newAutoincMinValue;
	__int64 AutoincMinValue;
	bool newAutoincMaxValue;
	__int64 AutoincMaxValue;
	bool newAutoincCycled;
	bool AutoincCycled;
	bool newBlobBlockSize;
	int BlobBlockSize;
	bool newBlobCompressionAlgorithm;
	Abscompression::TABSCompressionAlgorithm BlobCompressionAlgorithm;
	bool newBlobCompressionMode;
	Byte BlobCompressionMode;
	bool newDefaultValue;
	Absvariant::TABSVariant* DefaultValue;
	bool newMinValue;
	Absvariant::TABSVariant* MinValue;
	bool newMaxValue;
	Absvariant::TABSVariant* MaxValue;
	bool newPrimaryKey;
	bool PrimaryKey;
	bool newUnique;
	bool Unique;
	__fastcall TSQLFieldDef(void);
	__fastcall virtual ~TSQLFieldDef(void);
};


class DELPHICLASS TSQLFieldDefs;
class PASCALIMPLEMENTATION TSQLFieldDefs : public System::TObject 
{
	typedef System::TObject inherited;
	
public:
	TSQLFieldDef* operator[](int Index) { return Items[Index]; }
	
protected:
	Classes::TList* List;
	TSQLFieldDef* __fastcall GetDef(int Index);
	
public:
	__fastcall TSQLFieldDefs(void);
	__fastcall virtual ~TSQLFieldDefs(void);
	TSQLFieldDef* __fastcall AddCreated(void);
	int __fastcall GetCount(void);
	__property TSQLFieldDef* Items[int Index] = {read=GetDef/*, default*/};
	__property int Count = {read=GetCount, nodefault};
};


struct TABSIndexField
{
	
public:
	AnsiString FieldName;
	bool desc;
	bool nocase;
} ;

typedef DynamicArray<TABSIndexField >  ABSSQLProcessor__81;

struct TABSIndex
{
	
public:
	AnsiString IndexName;
	bool Unique;
	bool Primary;
	DynamicArray<TABSIndexField >  IndexFields;
} ;

typedef DynamicArray<TABSIndex >  ABSSQLProcessor__02;

class DELPHICLASS TABSDDLTableManipulation;
class PASCALIMPLEMENTATION TABSDDLTableManipulation : public TABSSQLCommand 
{
	typedef TABSSQLCommand inherited;
	
protected:
	AnsiString Password;
	AnsiString DatabaseName;
	AnsiString TableName;
	AnsiString TableAlias;
	TSQLFieldDefs* SQLFieldDefs;
	DynamicArray<TABSIndex >  Indexes;
	void __fastcall ParseTableElementList(void);
	HIDESBASE void __fastcall ParseTableNameToken(void);
	void __fastcall FillColumnType(TSQLFieldDef* &FieldDef);
	void __fastcall ParseColumnRequared(TSQLFieldDef* &FieldDef);
	void __fastcall ParsePassword(void);
	bool __fastcall ParseDefaultValue(TSQLFieldDef* &FieldDef);
	bool __fastcall ParseMinValue(TSQLFieldDef* &FieldDef);
	bool __fastcall ParseMaxValue(TSQLFieldDef* &FieldDef);
	bool __fastcall ParseFieldPrimaryKey(TSQLFieldDef* &FieldDef);
	bool __fastcall ParseFieldUnique(TSQLFieldDef* &FieldDef);
	bool __fastcall ParsePrimaryKey(void);
	bool __fastcall ParseIndex(void);
	void __fastcall ParseIndexField(int IndexNo);
	void __fastcall ParseIndexFields(int IndexNo);
	__int64 __fastcall ParseInteger(void);
	void __fastcall CreateInternalABSTable(Db::TDataSet* query, Db::TDataSet* &table, System::TObject* &db, bool FillAdvFieldDefs);
	void __fastcall FillAdvFieldDef(Db::TFieldDef* AdvFieldDef, TSQLFieldDef* SQLFieldDef);
	void __fastcall AddIndexes(Db::TDataSet* T);
	void __fastcall DeletePrimaryKey(Db::TDataSet* T);
	
public:
	__fastcall TABSDDLTableManipulation(Abslexer::TABSLexer* Lexer, Db::TDataSet* Query);
	__fastcall virtual ~TABSDDLTableManipulation(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)) = 0 ;
};


class DELPHICLASS TABSDDLCreateTable;
class PASCALIMPLEMENTATION TABSDDLCreateTable : public TABSDDLTableManipulation 
{
	typedef TABSDDLTableManipulation inherited;
	
private:
	bool FCreateIfNotExists;
	
protected:
	void __fastcall CreateTable(Db::TDataSet* query);
	
public:
	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));
public:
	#pragma option push -w-inl
	/* TABSDDLTableManipulation.Create */ inline __fastcall TABSDDLCreateTable(Abslexer::TABSLexer* Lexer, Db::TDataSet* Query) : TABSDDLTableManipulation(Lexer, Query) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TABSDDLTableManipulation.Destroy */ inline __fastcall virtual ~TABSDDLCreateTable(void) { }
	#pragma option pop
	
};


class DELPHICLASS TABSDDLDropTable;
class PASCALIMPLEMENTATION TABSDDLDropTable : public TABSDDLTableManipulation 
{
	typedef TABSDDLTableManipulation inherited;
	
protected:
	void __fastcall DropTable(Db::TDataSet* query);
	
public:
	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));
public:
	#pragma option push -w-inl
	/* TABSDDLTableManipulation.Create */ inline __fastcall TABSDDLDropTable(Abslexer::TABSLexer* Lexer, Db::TDataSet* Query) : TABSDDLTableManipulation(Lexer, Query) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TABSDDLTableManipulation.Destroy */ inline __fastcall virtual ~TABSDDLDropTable(void) { }
	#pragma option pop
	
};


class DELPHICLASS TABSDDLTruncateTable;
class PASCALIMPLEMENTATION TABSDDLTruncateTable : public TABSDDLTableManipulation 
{
	typedef TABSDDLTableManipulation inherited;
	
protected:
	void __fastcall TruncateTable(Db::TDataSet* query);
	
public:
	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));
public:
	#pragma option push -w-inl
	/* TABSDDLTableManipulation.Create */ inline __fastcall TABSDDLTruncateTable(Abslexer::TABSLexer* Lexer, Db::TDataSet* Query) : TABSDDLTableManipulation(Lexer, Query) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TABSDDLTableManipulation.Destroy */ inline __fastcall virtual ~TABSDDLTruncateTable(void) { }
	#pragma option pop
	
};


#pragma option push -b-
enum TAlterType { atAdd, atDrop, atModify, atRenameColumn, atRenameTable };
#pragma option pop

class DELPHICLASS TABSDDLAlterTable;
class PASCALIMPLEMENTATION TABSDDLAlterTable : public TABSDDLTableManipulation 
{
	typedef TABSDDLTableManipulation inherited;
	
protected:
	TAlterType AlterType;
	AnsiString NewPassword;
	bool NewEncrypted;
	Classes::TStringList* DropColumnNamesList;
	Classes::TStringList* RenameColumnOldNamesList;
	Classes::TStringList* RenameColumnNewNamesList;
	AnsiString NewTableName;
	void __fastcall ParseAlterTypeToken(void);
	void __fastcall ParseNewPasswordToken(void);
	void __fastcall ParseRenameColumnsList(void);
	void __fastcall DropColumn(Db::TDataSet* T);
	void __fastcall AddColumn(Db::TDataSet* T);
	void __fastcall Modify(Db::TDataSet* T);
	void __fastcall RenameColumn(Db::TDataSet* T);
	
public:
	__fastcall TABSDDLAlterTable(Abslexer::TABSLexer* Lexer, Db::TDataSet* Query);
	__fastcall virtual ~TABSDDLAlterTable(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 TABSDDLRenameTable;
class PASCALIMPLEMENTATION TABSDDLRenameTable : public TABSDDLAlterTable 
{
	typedef TABSDDLAlterTable inherited;
	
public:
	virtual void __fastcall Parse(void);
public:
	#pragma option push -w-inl
	/* TABSDDLAlterTable.Create */ inline __fastcall TABSDDLRenameTable(Abslexer::TABSLexer* Lexer, Db::TDataSet* Query) : TABSDDLAlterTable(Lexer, Query) { }
	#pragma option pop
	#pragma option push -w-inl
	/* TABSDDLAlterTable.Destroy */ inline __fastcall virtual ~TABSDDLRenameTable(void) { }
	#pragma option pop
	
};


typedef DynamicArray<TABSIndexField >  ABSSQLProcessor__72;

class DELPHICLASS TABSDDLCreateIndex;
class PASCALIMPLEMENTATION TABSDDLCreateIndex : public TABSSQLCommand 
{
	typedef TABSSQLCommand inherited;
	
protected:
	bool Unique;
	AnsiString IndexName;
	AnsiString DatabaseFileName;
	AnsiString TableName;
	AnsiString TableAlias;
	AnsiString Password;
	bool InMemory;
	DynamicArray<TABSIndexField >  ABSIndexFields;
	
public:
	__fastcall TABSDDLCreateIndex(Abslexer::TABSLexer* Lexer, Db::TDataSet* Query);
	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));
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TABSDDLCreateIndex(void) { }
	#pragma option pop
	
};


class DELPHICLASS TABSDDLDropIndex;
class PASCALIMPLEMENTATION TABSDDLDropIndex : public TABSSQLCommand 
{
	typedef TABSSQLCommand inherited;
	
protected:
	AnsiString IndexName;
	AnsiString DatabaseFileName;
	AnsiString TableName;
	AnsiString TableAlias;
	AnsiString Password;
	bool InMemory;
	
public:
	__fastcall TABSDDLDropIndex(Abslexer::TABSLexer* Lexer, Db::TDataSet* Query);
	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));
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TABSDDLDropIndex(void) { }
	#pragma option pop
	
};


class DELPHICLASS TABSSQLStartTransaction;
class PASCALIMPLEMENTATION TABSSQLStartTransaction : public TABSSQLCommand 
{
	typedef TABSSQLCommand inherited;
	
public:
	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));
public:
	#pragma option push -w-inl
	/* TABSSQLCommand.Create */ inline __fastcall TABSSQLStartTransaction(Abslexer::TABSLexer* Lexer, Db::TDataSet* Query) : TABSSQLCommand(Lexer, Query) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TABSSQLStartTransaction(void) { }
	#pragma option pop
	
};


class DELPHICLASS TABSSQLCommit;
class PASCALIMPLEMENTATION TABSSQLCommit : public TABSSQLCommand 
{
	typedef TABSSQLCommand inherited;
	
private:
	bool FFlush;
	
public:
	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));
public:
	#pragma option push -w-inl
	/* TABSSQLCommand.Create */ inline __fastcall TABSSQLCommit(Abslexer::TABSLexer* Lexer, Db::TDataSet* Query) : TABSSQLCommand(Lexer, Query) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TABSSQLCommit(void) { }
	#pragma option pop
	
};


class DELPHICLASS TABSSQLRollback;
class PASCALIMPLEMENTATION TABSSQLRollback : public TABSSQLCommand 
{
	typedef TABSSQLCommand inherited;
	
public:
	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));
public:
	#pragma option push -w-inl
	/* TABSSQLCommand.Create */ inline __fastcall TABSSQLRollback(Abslexer::TABSLexer* Lexer, Db::TDataSet* Query) : TABSSQLCommand(Lexer, Query) { }
	#pragma option pop
	
public:
	#pragma option push -w-inl
	/* TObject.Destroy */ inline __fastcall virtual ~TABSSQLRollback(void) { }
	#pragma option pop
	
};


//-- var, const, procedure ---------------------------------------------------
extern PACKAGE void __fastcall SetABSVariantIntoField(Absvariant::TABSVariant* Value, Db::TField* Field);

}	/* namespace Abssqlprocessor */
using namespace Abssqlprocessor;
#pragma pack(pop)
#pragma option pop

#pragma delphiheader end.
//-- end unit ----------------------------------------------------------------
#endif	// Abssqlprocessor