package br.com.senior.svcl.db; import static br.com.senior.svcl.base.Classes.*; import static br.com.senior.svcl.base.Delphi.*; import static br.com.senior.svcl.base.R900GPRConst.*; import static br.com.senior.svcl.base.RtBaseUtil.*; import static br.com.senior.svcl.base.RtDateUtil.*; import static br.com.senior.svcl.base.RtInterfaces.*; import static br.com.senior.svcl.base.RtIntfUtil.*; import static br.com.senior.svcl.base.RtStrUtil.*; import static br.com.senior.svcl.base.RtStringTranslator.*; import static br.com.senior.svcl.base.RtTypes.*; import static br.com.senior.svcl.base.SysInit.*; import static br.com.senior.svcl.base.SysUtils.*; import static br.com.senior.svcl.base.Windows.*; import static br.com.senior.svcl.db.RtClass.*; import static br.com.senior.svcl.db.RtCompiler.*; import static br.com.senior.svcl.db.RtNativeInterfaces.*; import static br.com.senior.svcl.db.RtOldCompilerUtil.*; import static br.com.senior.svcl.db.RtSQLCompiler.*; import static br.com.senior.svcl.db.RtStruct.*; import static br.com.senior.svcl.db.RtStructCreator.*; import static br.com.senior.svcl.db.RtToken.*; import static br.com.senior.svcl.db.rtDBConst.*; import static br.com.senior.svcl.db.rtsqlcmdparts.*; import br.com.senior.svcl.base.DelphiSet; import br.com.senior.svcl.base.RtStrUtil; import br.com.senior.svcl.base.Util; import br.com.senior.svcl.base.Classes.TComponent; import br.com.senior.svcl.base.Classes.TList; import br.com.senior.svcl.base.Classes.TNotifyEvent; import br.com.senior.svcl.base.Classes.TPersistent; import br.com.senior.svcl.base.Classes.TPersistentClass; import br.com.senior.svcl.base.Classes.TReader; import br.com.senior.svcl.base.Classes.TResourceStream; import br.com.senior.svcl.base.Classes.TStream; import br.com.senior.svcl.base.Classes.TStringList; import br.com.senior.svcl.base.Classes.TStrings; import br.com.senior.svcl.base.Classes.TWriter; import br.com.senior.svcl.base.Delphi.TBoolean; import br.com.senior.svcl.base.Delphi.TClass; import br.com.senior.svcl.base.Delphi.TInt; import br.com.senior.svcl.base.Delphi.TObject; import br.com.senior.svcl.base.Delphi.TReference; import br.com.senior.svcl.base.Delphi.TString; import br.com.senior.svcl.base.Delphi.TVarRec; import br.com.senior.svcl.base.RtBaseUtil.TRtOnUpdateProgress; import br.com.senior.svcl.base.RtInterfaces.IRtCursor; import br.com.senior.svcl.base.RtInterfaces.IRtDBBatchCommandProcessor; import br.com.senior.svcl.base.RtInterfaces.IRtDBCommandProcessor; import br.com.senior.svcl.base.RtInterfaces.IRtDBConnection; import br.com.senior.svcl.base.RtInterfaces.IRtDBParam; import br.com.senior.svcl.base.RtInterfaces.IRtDBSecurityManager; import br.com.senior.svcl.base.RtInterfaces.IRtDatabaseDef; import br.com.senior.svcl.base.RtInterfaces.IRtIndexDef; import br.com.senior.svcl.base.RtInterfaces.IRtSQLStmt; import br.com.senior.svcl.base.RtInterfaces.IRtSortInfo; import br.com.senior.svcl.base.RtInterfaces.IRtStmt; import br.com.senior.svcl.base.RtInterfaces.TRtTableInfo; import br.com.senior.svcl.base.RtInterfaces.TTypeDesc; import br.com.senior.svcl.base.RtTypes.TRtRecValueClass; import br.com.senior.svcl.base.RtTypes.TRtSqlParam; import br.com.senior.svcl.base.RtTypes.TRtSqlParams; import br.com.senior.svcl.base.RtTypes.TRtSqlParamsClass; import br.com.senior.svcl.base.SysUtils.DelphiException; import br.com.senior.svcl.base.SysUtils.TExceptionClass; import br.com.senior.svcl.db.RtAccess.EExAccess; import br.com.senior.svcl.db.RtAccess.TRtDatabase; import br.com.senior.svcl.db.RtAccess.TRtQuery; import br.com.senior.svcl.db.RtAccess.TRtTranEvent; import br.com.senior.svcl.db.RtBaseCursor.TRtCursorField; import br.com.senior.svcl.db.RtClass.TContainerItem; import br.com.senior.svcl.db.RtClass.TContainerItemClass; import br.com.senior.svcl.db.RtClass.TKeyedContainerItem; import br.com.senior.svcl.db.RtClass.TKeyedContainerItemClass; import br.com.senior.svcl.db.RtClass.TKeyedListOwner; import br.com.senior.svcl.db.RtClass.TKeyedListOwnerClass; import br.com.senior.svcl.db.RtClass.TListOwner; import br.com.senior.svcl.db.RtClass.TListOwnerClass; import br.com.senior.svcl.db.RtClass.TNamedContainerItem; import br.com.senior.svcl.db.RtClass.TNamedContainerItemClass; import br.com.senior.svcl.db.RtClass.TNamedListOwner; import br.com.senior.svcl.db.RtClass.TNamedListOwnerClass; import br.com.senior.svcl.db.RtClass.TStringListOwner; import br.com.senior.svcl.db.RtClass.TTypedListOwner; import br.com.senior.svcl.db.RtClass.TTypedListOwnerClass; import br.com.senior.svcl.db.RtCommProc.TRtDBBatchCommandProcessor; import br.com.senior.svcl.db.RtCommProc.TRtDBCommandProcessor; import br.com.senior.svcl.db.RtCompiler.ECCompiler; import br.com.senior.svcl.db.RtCompiler.TRtCBNFData; import br.com.senior.svcl.db.RtCompiler.TRtCCompiledNodeList; import br.com.senior.svcl.db.RtCompiler.TRtCCompiler; import br.com.senior.svcl.db.RtCompiler.TRtCCompilerShowErrorEvent; import br.com.senior.svcl.db.RtDBKnl.ERtDBObjectNotFound; import br.com.senior.svcl.db.RtDBKnl.TDBParamStrings; import br.com.senior.svcl.db.RtDBKnl.TOnGetIRInfo; import br.com.senior.svcl.db.RtDBKnl.TOnIdleTimeout; import br.com.senior.svcl.db.RtDBKnl.TRtDBGenericFunctionsClass; import br.com.senior.svcl.db.RtDBKnl.TRtDBKernel; import br.com.senior.svcl.db.RtDBKnl.TRtDBKernelClass; import br.com.senior.svcl.db.RtDBKnl.TRtDBKernelListClass; import br.com.senior.svcl.db.RtDBKnl.TRtDBRawDatabase; import br.com.senior.svcl.db.RtDBKnl.TRtDBRawSession; import br.com.senior.svcl.db.RtNativeInterfaces.IRtBatchNativeStmtHelper; import br.com.senior.svcl.db.RtNativeInterfaces.IRtDBNativeCommandProcessor; import br.com.senior.svcl.db.RtNativeInterfaces.IRtDBNativeConnection; import br.com.senior.svcl.db.RtNativeInterfaces.IRtNativeStmt; import br.com.senior.svcl.db.RtNativeInterfaces.IRtNativeStmtHelper; import br.com.senior.svcl.db.RtNativeInterfaces.TRtBatchNativeCtx; import br.com.senior.svcl.db.RtParams.TRtParam; import br.com.senior.svcl.db.RtRevEng.TRtDbCatalogsClass; import br.com.senior.svcl.db.RtSQLCompiler.TRtSQLCompiler; import br.com.senior.svcl.db.RtSQLCompiler.TRtSQLTokenItem; import br.com.senior.svcl.db.RtSQLCompiler.TRtSQLTokenList; import br.com.senior.svcl.db.RtSQLCompiler.TRtSQLTokenListClass; import br.com.senior.svcl.db.RtSQLCompilerEx.TRtCCompiledNodeSQL; import br.com.senior.svcl.db.RtSQLCompilerEx.TRtCCompilerSQL; import br.com.senior.svcl.db.RtStruct.TRtDatabaseDef; import br.com.senior.svcl.db.RtStruct.TRtDatabaseDefClass; import br.com.senior.svcl.db.RtStruct.TRtEnumerationDef; import br.com.senior.svcl.db.RtStruct.TRtFieldDef; import br.com.senior.svcl.db.RtStruct.TRtIndexDef; import br.com.senior.svcl.db.RtStruct.TRtIndexFieldDef; import br.com.senior.svcl.db.RtStruct.TRtPhyBaseTypeClass; import br.com.senior.svcl.db.RtStruct.TRtPhyNumberClass; import br.com.senior.svcl.db.RtStruct.TRtPhyStringClass; import br.com.senior.svcl.db.RtStruct.TRtRelationDef; import br.com.senior.svcl.db.RtStruct.TRtStoredProcDef; import br.com.senior.svcl.db.RtStruct.TRtStoredProcItem; import br.com.senior.svcl.db.RtStruct.TRtTableDef; import br.com.senior.svcl.db.RtStruct.TRtTriggerDef; import br.com.senior.svcl.db.RtStruct.TRtUniqueConstraintDef; import br.com.senior.svcl.db.RtStruct.TRtUniqueConstraintFieldDef; import br.com.senior.svcl.db.RtStruct.TRtViewDef; import br.com.senior.svcl.db.RtToken.TSimpleParser; import br.com.senior.svcl.db.rtRec.TRtFullDatabaseDef; import br.com.senior.svcl.db.rtRec.TRtFullFieldDef; import br.com.senior.svcl.db.rtRec.TRtFullSessionDef; import br.com.senior.svcl.db.rtRec.TRtFullTableDef; import br.com.senior.svcl.db.rtRevDB.TRtDbRevEng; import br.com.senior.svcl.db.rtsqlcmdparts.TNameExpr; import br.com.senior.svcl.db.rtsqlcmdparts.TQualifiedNameExpr; import br.com.senior.svcl.db.rtsqlcmdparts.TSelect; import br.com.senior.svcl.db.rtsqlcmdparts.TSelectColumn; import br.com.senior.svcl.db.rtsqlcmdparts.TStatement; import br.com.senior.svcl.db.rtsqlcmdparts.TVisitProc; import br.com.senior.svcl.db.rtsqlgen_senior.TRtSeniorSqlGeneratorClass; import br.com.senior.svcl.db.rtsqlworks.TSQLStatement; import br.com.senior.svcl.db.rtsqlworks.TSQLWorks; public final class RtSql { public interface TOnNotifyDBConnection { public void run(int aDBAccessKind, int aDBVersionKind); } public interface TOnDBSQLGenerate { public String run(TStatement aStatement); } public static class TRtCustomSQLClass extends TSQLContainerItemClass { public static final TRtCustomSQLClass SINGLETON = new TRtCustomSQLClass(); protected final TRtCustomSQL CreateWithDBVersionKind(int aDBVersionKind) { return TRtCustomSQL.CreateWithDBVersionKind(aDBVersionKind); } public TRtCustomSQL Create() { return TRtCustomSQL.Create(); } public TRtCustomSQL CreateSQL(TRtDBConnection AConn) { return TRtCustomSQL.CreateSQL(AConn); } public Class ClassInfo() { return TRtCustomSQL.class; } } public static class TRtColumnSqlGeneratorClass extends TPersistentClass { public static final TRtColumnSqlGeneratorClass SINGLETON = new TRtColumnSqlGeneratorClass(); public String GenColumnName(TRtAddColumnItem aColumnItem) { return aColumnItem.FColName; } public String GenColumnDetailDataType(TRtAddColumnItem aColumnItem, IRtDatabaseDef aDataBaseDef, TString aKindName, TString aLength, TString aPrecision) { String Result = ""; aKindName.v = RtPhyFieldNames[aColumnItem.FColType]; aLength.v = ""; aPrecision.v = ""; switch (aColumnItem.FColType) { case rftString: aLength.v = IntToStr(aColumnItem.FColLen); aPrecision.v = ""; Result = aKindName.v + SQL_LParenthesis + aLength.v + ToStr(SQL_RParenthesis); break; case rftNumber: aLength.v = IntToStr(aColumnItem.FColLen); Result = aKindName.v + SQL_LParenthesis + aLength.v; if (aColumnItem.FColPrec != 0) { aPrecision.v = IntToStr(aColumnItem.FColPrec); Result = Result + SQL_Comma + SQL_Space + aPrecision.v; } else { aPrecision.v = ""; } Result = Result + ToStr(SQL_RParenthesis); break; default: break; } return Result; } public String GenColumnNotNull(TRtAddColumnItem aColumnItem) { String Result = ""; if (aColumnItem.FNotNull) { Result = SQL_NOTNULL; } else { Result = SQL_NULL; } return Result; } public String GenColumnStorage(TRtAddColumnItem aColumnItem, TRtCustomStorageList aStorage, String aTableName) { return ""; } public Class ClassInfo() { return TRtColumnSqlGenerator.class; } } public static class TRtReplG6FunctionsClass extends TClass { private final class ClearOldTriggers_Context { private final TRtDBConnection aConn; private final static String cDropTrigger = "drop trigger %s"; private TStringList xTriggerList; private TStringList xTableReplList; private int i; private IRtDBNativeCommandProcessor xCmdProc; public ClearOldTriggers_Context(TRtDBConnection aConn) { this.aConn = aConn; } public void execute() { xTriggerList = aConn.GetTriggersFromDB(cREPLG6Prefix); try { if (xTriggerList.GetCount() > 0) { xTableReplList = GetReplTables(aConn); try { xCmdProc = ((IRtDBNativeCommandProcessor) aConn.NewDBCommandProcessor()); xCmdProc.SetNativeSQL(true); i = 0; while (i < xTriggerList.GetCount()) { if (xTableReplList.IndexOf(xTriggerList.GetValue(xTriggerList.GetName(i))) == -1) { xCmdProc.SetCommand(Format(cDropTrigger, new Object[] { xTriggerList.GetName(i) })); xCmdProc.Execute(); } i++; } } finally { xTableReplList.Destroy(); } } } finally { xTriggerList.Destroy(); } } } private final class ClearTriggerFromTable_Context { private final String aTableName; private final TRtDBConnection aConn; private final static String cDropTrigger = "drop trigger %s"; private TStringList xTriggerList; private int i; private IRtDBNativeCommandProcessor xCmdProc; public ClearTriggerFromTable_Context(String aTableName, TRtDBConnection aConn) { this.aTableName = aTableName; this.aConn = aConn; } public void execute() { xTriggerList = aConn.GetTriggersFromDB(cREPLG6Prefix + aTableName); try { xCmdProc = ((IRtDBNativeCommandProcessor) aConn.NewDBCommandProcessor()); xCmdProc.SetNativeSQL(true); i = 0; while (i < xTriggerList.GetCount()) { xCmdProc.SetCommand(Format(cDropTrigger, new Object[] { xTriggerList.GetName(i) })); xCmdProc.Execute(); i++; } } finally { xTriggerList.Destroy(); } } } public static final TRtReplG6FunctionsClass SINGLETON = new TRtReplG6FunctionsClass(); final void CreateTableTrigger(TRtDBConnection aConn, TRtTableDef aTableDef) { IRtDBNativeCommandProcessor xCmdProc; String xDroptrigger = ""; if (aTableDef != null) { xCmdProc = ((IRtDBNativeCommandProcessor) aConn.NewDBCommandProcessor()); xCmdProc.SetNativeSQL(true); xDroptrigger = GetDropTriggerCommand(aTableDef, ttvInsert); if (!xDroptrigger.equals("")) { xCmdProc.SetCommand(xDroptrigger); xCmdProc.Execute(); } xDroptrigger = GetDropTriggerCommand(aTableDef, ttvUpdate); if (!xDroptrigger.equals("")) { xCmdProc.SetCommand(xDroptrigger); xCmdProc.Execute(); } xDroptrigger = GetDropTriggerCommand(aTableDef, ttvDelete); if (!xDroptrigger.equals("")) { xCmdProc.SetCommand(xDroptrigger); xCmdProc.Execute(); } xCmdProc.SetCommand(GenerateInsertReplTrigger(aConn, aTableDef)); xCmdProc.Execute(); xCmdProc.SetCommand(GenerateUpdateReplTrigger(aConn, aTableDef)); xCmdProc.Execute(); xCmdProc.SetCommand(GenerateDeleteReplTrigger(aConn, aTableDef)); xCmdProc.Execute(); } } protected final TStringList GetReplTables(TRtDBConnection aConn) { TStringList Result; IRtDBNativeCommandProcessor xCmdProc; IRtCursor xCursor; Result = TStringList.Create(); try { if (aConn.TableExists("R900IG6")) { xCmdProc = ((IRtDBNativeCommandProcessor) aConn.NewDBCommandProcessor()); xCmdProc.SetNativeSQL(true); xCmdProc.SetCommand("select TblNam from R900IG6 order by TblNam"); xCursor = xCmdProc.Open(); while (xCursor.Next()) { Result.Add(xCursor.GetField(0).GetAsString()); } } } catch (Throwable any) { Result.Destroy(); throw wrap(any); } return Result; } protected String GenerateInsertReplTrigger(TRtDBConnection aDBConn, TRtTableDef aTableDef) { throw DelphiException.Create(TransStr("TC643", "Integração não suportada para esse banco.", true)); } protected String GenerateUpdateReplTrigger(TRtDBConnection aDBConn, TRtTableDef aTableDef) { throw DelphiException.Create(TransStr("TC643", "Integração não suportada para esse banco.", true)); } protected String GenerateDeleteReplTrigger(TRtDBConnection aDBConn, TRtTableDef aTableDef) { throw DelphiException.Create(TransStr("TC643", "Integração não suportada para esse banco.", true)); } protected String GetDropTriggerCommand(TRtTableDef aTableDef, int aTriggerEvent) { return ""; } public void CreateReplControlObjects(TRtDBConnection aConn) { throw DelphiException.Create(TransStr("TC643", "Integração não suportada para esse banco.", true)); } public void CreateReplTablesIntoTBS(TRtDBConnection aConn, TRtFullDatabaseDef aTBS) { TStringList xReplTables; TRtFullTableDef xTableDef; TRtFullTableDef xReplTableDef; TRtFullFieldDef xFieldDef; TRtFullFieldDef xReplFieldDef; int i; int j; xTableDef = aTBS.NewTableDef(cREPLG6Prefix + "CONTROLE"); xFieldDef = xTableDef.NewFieldDef("SEQTRAN"); xFieldDef.SetKind(TRtPhyNumberClass.SINGLETON); xFieldDef.SetLength(9); xFieldDef.SetPrecision(0); xFieldDef.SetNotNull(true); xFieldDef = xTableDef.NewFieldDef("SEQOP"); xFieldDef.SetKind(TRtPhyNumberClass.SINGLETON); xFieldDef.SetLength(9); xFieldDef.SetPrecision(0); xFieldDef.SetNotNull(true); xFieldDef = xTableDef.NewFieldDef("CODOP"); xFieldDef.SetKind(TRtPhyNumberClass.SINGLETON); xFieldDef.SetLength(1); xFieldDef.SetPrecision(0); xFieldDef.SetNotNull(true); xFieldDef = xTableDef.NewFieldDef("REPLTABLE"); xFieldDef.SetKind(TRtPhyStringClass.SINGLETON); xFieldDef.SetLength(26); xFieldDef.SetPrecision(0); xFieldDef.SetNotNull(true); xFieldDef = xTableDef.NewFieldDef("TABELA"); xFieldDef.SetKind(TRtPhyStringClass.SINGLETON); xFieldDef.SetLength(18); xFieldDef.SetPrecision(0); xFieldDef.SetNotNull(true); xFieldDef = xTableDef.NewFieldDef("CAMPOSALT"); xFieldDef.SetKind(TRtPhyStringClass.SINGLETON); xFieldDef.SetLength(1400); xFieldDef.SetPrecision(0); xFieldDef = xTableDef.NewFieldDef("STATUS"); xFieldDef.SetKind(TRtPhyNumberClass.SINGLETON); xFieldDef.SetLength(1); xFieldDef.SetPrecision(0); xTableDef.SetPrimaryKey("SEQTRAN;SEQOP"); xReplTables = GetReplTables(aConn); try { for (i = 0; i <= xReplTables.GetCount() - 1; ++i) { xTableDef = aTBS.TableByName(xReplTables.Get(i)); if (xTableDef != null) { xReplTableDef = aTBS.NewTableDef(cREPLG6Prefix + xTableDef.GetName()); xReplFieldDef = xReplTableDef.NewFieldDef("SeqTran"); xReplFieldDef.SetKind(TRtPhyNumberClass.SINGLETON); xReplFieldDef.SetLength(9); xReplFieldDef.SetPrecision(0); xReplFieldDef.SetNotNull(true); xReplFieldDef = xReplTableDef.NewFieldDef("SeqOp"); xReplFieldDef.SetKind(TRtPhyNumberClass.SINGLETON); xReplFieldDef.SetLength(9); xReplFieldDef.SetPrecision(0); xReplFieldDef.SetNotNull(true); for (j = 0; j <= xTableDef.GetFieldCount() - 1; ++j) { xFieldDef = xTableDef.GetField(j); xReplFieldDef = xReplTableDef.NewFieldDef(xFieldDef.GetName()); xReplFieldDef.SetKind(xFieldDef.GetKind()); xReplFieldDef.SetLength(xFieldDef.GetLength()); xReplFieldDef.SetPrecision(xFieldDef.GetPrecision()); xReplFieldDef.SetNotNull(xFieldDef.getNotNull()); xReplFieldDef.SetOptions(xFieldDef.GetOptions()); } xReplTableDef.SetPrimaryKey("SeqTran;SeqOp"); } } } finally { xReplTables.Destroy(); } } public void DropReplTablesFromTBS(TRtDBConnection aConn, TRtFullDatabaseDef aTBS) { TStringList xReplTables; TRtFullTableDef xTableDef; int i; xTableDef = aTBS.TableByName(cREPLG6Prefix + "CONTROLE"); xTableDef.Free(); xReplTables = GetReplTables(aConn); try { for (i = 0; i <= xReplTables.GetCount() - 1; ++i) { xTableDef = aTBS.TableByName(cREPLG6Prefix + xReplTables.Get(i)); xTableDef.Free(); } } finally { xReplTables.Destroy(); } } public void ClearOldTriggers(TRtDBConnection aConn) { ClearOldTriggers_Context ctx = new ClearOldTriggers_Context(aConn); ctx.execute(); } public void ClearTriggerFromTable(String aTableName, TRtDBConnection aConn) { ClearTriggerFromTable_Context ctx = new ClearTriggerFromTable_Context(aTableName, aConn); ctx.execute(); } public final void CreateTriggers(TRtDBConnection aConn, TRtFullDatabaseDef aTBS) { TStringList xReplTables; TBoolean xEnabled = new TBoolean(); int i; xReplTables = GetReplTables(aConn); try { for (i = 0; i <= xReplTables.GetCount() - 1; ++i) { if (!(aConn.TriggerExists(cREPLG6Prefix + xReplTables.Get(i) + "_I", xReplTables.Get(i), xEnabled) && xEnabled.v) || !(aConn.TriggerExists(cREPLG6Prefix + xReplTables.Get(i) + "_U", xReplTables.Get(i), xEnabled) && xEnabled.v) || !(aConn.TriggerExists(cREPLG6Prefix + xReplTables.Get(i) + "_D", xReplTables.Get(i), xEnabled) && xEnabled.v)) { CreateTableTrigger(aConn, aTBS.TableByName(xReplTables.Get(i))); } } } finally { xReplTables.Destroy(); } } public void ExecBeforeBeginTran(IRtDBConnection aConn) { } public void ExecBeforeCommit(IRtDBConnection aConn) { } public void ExecAfterEndTran(IRtDBConnection aConn) { } public boolean GetInReplG6(TRtDBConnection aConn) { return false; } public boolean ExistsTablesToRepl(TRtDBConnection aConn) { return false; } public void InitControlObjects(TRtDBConnection aConn) { throw DelphiException.Create(TransStr("TC643", "Integração não suportada para esse banco.", true)); } public void DisableRepl(TRtDBConnection aConn) { } public Class ClassInfo() { return TRtReplG6Functions.class; } } public static final class EMoveDataIgnoreRowClass extends TExceptionClass { public static final EMoveDataIgnoreRowClass SINGLETON = new EMoveDataIgnoreRowClass(); public Class ClassInfo() { return EMoveDataIgnoreRow.class; } } public static final class EMoveDataIgnoreRow extends DelphiException { public EMoveDataIgnoreRowClass ClassType() { return EMoveDataIgnoreRowClass.SINGLETON; } } public interface TRtSQLAssignTableDefEvent { public void run(TRtCustomSQL ASql, TRtTableDef OldTblDef, TRtTableDef NewTblDef); } public interface TRtHasCriticalChange { public boolean run(TRtAlterTable aAlterTable); } public interface TRtSQLMustDropTableEvent { public void run(TRtTableDef OldTblDef, TBoolean LDrop); } public interface TRtSQLMustRenameTableEvent { public void run(TRtTableDef NewTblDef, TString NewTableName); } public interface TRtSQLMustDropStoredProcEvent { public void run(TRtStoredProcItem OldStoredProcItem, TBoolean LDrop); } public interface TRtSQLMustDropViewEvent { public void run(TRtViewDef OldViewDef, TBoolean LDrop); } public interface TRtSQLMustCreateViewEvent { public void run(TRtViewDef NewViewDef, TBoolean LCreate); } public interface TRtSQLVerifyAssignObjectDef { public void run(TObject aObjectDef, TBoolean aForceDrop); } public interface TRtDDLErrorEvent { public void run(TRtCustomDDL ADDL, TBoolean LRetry, int AAltStep, TRtQuery ACur, br.com.senior.svcl.db.RtAccess.TRtUpdate aNewRec); } public interface TRtDDLStepEvent { public void run(TRtCustomDDL ADDL, int AAltStep, TRtQuery ACur, br.com.senior.svcl.db.RtAccess.TRtUpdate ANewRec); } public interface TRtOnStoredProcMoveData { public void run(TRtDBConnection aConnection, String aTableName, boolean aCreateSP, TRtStoredProcDef aStoredProcDef); } public interface TRtOnExecStoredProcMoveData { public void run(br.com.senior.svcl.db.RtAccess.TRtUpdate aStoredProc); } public interface TRtOnCustomAlterTableUpdateData { public boolean run(TRtUpdate aUpdateObject, TRtDBConnection aConn); } public interface TRtOnDeleteStorage { public void run(TRtDBConnection aDBConnection, String aStorage); } public interface TRtOnAddStorageIndexClustered { public void run(TRtDBConnection aDBConnection, String aTable, String aIndexName, boolean isPk); } public interface TRtOnAddStorageLockEscalation { public void run(TRtDBConnection aDBConnection, String aTable, String aOpt); } public interface TRtOnApplyLockEscalationInDb { public void run(TRtDBConnection aDBConnection, String aTable, String aOpt); } public interface TRtDBInitializeProc { public void run(TRtDBConnection aConn); } public static final class TRtSqlDriver { public TRtCustomSQLClass[] SQLClasses = new TRtCustomSQLClass[0]; public TClass DBCatalogsClass; public TRtColumnSqlGeneratorClass ColumnSqlGeneratorClass; public TRtDBInitializeProc DBInitProc; public TRtSQLFunctionTableList FuncList; public Object PLGenerator; public TRtDBGenericFunctionsClass DBGenericFunctionsClass; public TRtReplG6FunctionsClass ReplG6FunctionsClass; public TRtHasCriticalChange OnHasCriticalChange; final void assign(TRtSqlDriver other) { SQLClasses = other.SQLClasses; DBCatalogsClass = other.DBCatalogsClass; ColumnSqlGeneratorClass = other.ColumnSqlGeneratorClass; DBInitProc = other.DBInitProc; FuncList = other.FuncList; PLGenerator = other.PLGenerator; DBGenericFunctionsClass = other.DBGenericFunctionsClass; ReplG6FunctionsClass = other.ReplG6FunctionsClass; OnHasCriticalChange = other.OnHasCriticalChange; } public TRtSqlDriver(TRtCustomSQLClass[] SQLClasses, TClass DBCatalogsClass, TRtColumnSqlGeneratorClass ColumnSqlGeneratorClass, TRtDBInitializeProc DBInitProc, TRtSQLFunctionTableList FuncList, Object PLGenerator, TRtDBGenericFunctionsClass DBGenericFunctionsClass, TRtReplG6FunctionsClass ReplG6FunctionsClass, TRtHasCriticalChange OnHasCriticalChange) { this.SQLClasses = SQLClasses; this.DBCatalogsClass = DBCatalogsClass; this.ColumnSqlGeneratorClass = ColumnSqlGeneratorClass; this.DBInitProc = DBInitProc; this.FuncList = FuncList; this.PLGenerator = PLGenerator; this.DBGenericFunctionsClass = DBGenericFunctionsClass; this.ReplG6FunctionsClass = ReplG6FunctionsClass; this.OnHasCriticalChange = OnHasCriticalChange; } public TRtSqlDriver() { } } public static final class TRtDatabaseServerClass extends TContainerItemClass { public static final TRtDatabaseServerClass SINGLETON = new TRtDatabaseServerClass(); public TRtDatabaseServer Create() { return TRtDatabaseServer.Create(); } public final TRtDatabaseServer GlobalInstance() { return vDBServer; } public Class ClassInfo() { return TRtDatabaseServer.class; } } public static final class TRtDatabaseServer extends TContainerItem { TListOwner FDBConnections; TRtSqlDriver[] FSqlDrivers = new TRtSqlDriver[0]; private final TRtDBKernelClass[] FSqlKnlClasses = new TRtDBKernelClass[0]; private final TDBParamStrings[][] FConnectionParams = null; private TRtCBNFData FBNFData; private TList FRtSQLFunctionTableList; private TList FParamsList; final TRtDBRawDatabase NewRawDataBase(int aDBAccessKind, int aDBVersionKind, TDBParamStrings aParams, IRtDBConnection aConn) { TRtDBRawDatabase Result; TRtDBKernel xDbKnl; TRtDBKernelClass xDbKnlClass; TRtDBRawSession xDBRawSession; boolean xIsNewKernel; boolean xIsNewRawSession; xDbKnlClass = GetSqlKnl(aDBAccessKind); xDbKnl = TRtDBKernelListClass.SINGLETON.GlobalInstance().DBKernelByClassName(xDbKnlClass.ClassName()); if (xDbKnl == null) { xDbKnl = TRtDBKernelListClass.SINGLETON.GlobalInstance().AddDBKernel(xDbKnlClass); xIsNewKernel = true; } else { xIsNewKernel = false; } try { if (xDbKnl.getDBRawSessionList().GetCount() == 0) { xDBRawSession = xDbKnl.NewDBRawSession(); xIsNewRawSession = true; } else { xIsNewRawSession = false; xDBRawSession = xDbKnl.getDBRawSessionList().GetDBRawSession(0); } try { Result = xDBRawSession.NewDBRawDataBase(aDBAccessKind, aDBVersionKind, aParams, aConn, GetDbGenericFunctionsClass(aDBVersionKind)); } catch (Throwable any) { if (xIsNewRawSession) { xDbKnl.DeleteDBRawSession(xDBRawSession); } throw wrap(any); } } catch (Throwable any) { if (xIsNewKernel) { TRtDBKernelListClass.SINGLETON.GlobalInstance().DeleteDBKernel(xDbKnl); } throw wrap(any); } return Result; } final void AddConnectionItem(TRtDBConnection AConn) { FDBConnections.Add(AConn); AConn.SetFOwner(FDBConnections); } private final String GetNextDBConnectionName() { String Result = ""; int i; if (FDBConnections.GetCount() == 0) { Result = cDefaultDbConnectionName; } else { i = 0; do { i++; Result = cDefaultDbConnectionName + IntToStr(i); } while (GetDbConnectionByName(Result) != null); } return Result; } public final TRtDBConnection GetDbConnectionByName(String Index) { TRtDBConnection Result; int i; Result = null; for (i = 0; i <= FDBConnections.GetCount() - 1; ++i) { if (SameText((((TRtDBConnection) FDBConnections.Get(i))).getName(), Index)) { Result = ((TRtDBConnection) FDBConnections.Get(i)); break; } } return Result; } public final TRtSqlDriver GetSqlDriver(int aDBVersionKind) { TRtSqlDriver Result = null; Result = FSqlDrivers[aDBVersionKind]; Assert(Result != null, Format(TransStr("TC640", "Driver \"%s\" não registrado.", true), new Object[] { cDBVersionKindNameArray[aDBVersionKind] })); return Result; } private final TRtDBKernelClass GetSqlKnl(int aDBAccessKind) { TRtDBKernelClass Result; Result = FSqlKnlClasses[aDBAccessKind]; Assert(Result != null, Format(TransStr("TC641", "Kernel \"%s\" não registrado.", true), new Object[] { cDBAccessKindNameNameArray[aDBAccessKind] })); return Result; } public final TDBParamStrings GetConnectionParams(int aDBAccessKind, int aDBVersionKind) { TDBParamStrings Result; Result = FConnectionParams[aDBAccessKind][aDBVersionKind]; Assert(Result != null, Format(TransStr("TC642", "Parâmetros de conexão para o banco \"%s\" via \"%s\" não registrados", true), new Object[] { cDBVersionKindNameArray[aDBVersionKind], cDBAccessKindNameNameArray[aDBAccessKind] })); return Result; } public void runCreate() { TResourceStream Stream; super.runCreate(); FParamsList = TList.Create(); FRtSQLFunctionTableList = TList.Create(); FDBConnections = ((TListOwner) Creator(this, TListOwnerClass.SINGLETON)); FBNFData = TRtCBNFData.Create(); Stream = TResourceStream.Create(HInstance, "PLBNF", RT_RCDATA); try { FBNFData.LoadFromStream(Stream); } finally { Stream.Destroy(); } } public static TRtDatabaseServer Create() { TRtDatabaseServer Result; Result = new TRtDatabaseServer(); Result.runCreate(); return Result; } public void Destroy() { int i; for (i = 0; i <= FParamsList.getCount() - 1; ++i) { ((TObject) FParamsList.getList()[i]).Free(); } for (i = 0; i <= FRtSQLFunctionTableList.getCount() - 1; ++i) { ((TObject) FRtSQLFunctionTableList.getList()[i]).Free(); } FParamsList.Free(); FRtSQLFunctionTableList.Free(); FDBConnections.Free(); FBNFData.Free(); super.Destroy(); } public final void AssignDbConnectionsNameList(TStrings aStrings) { int i; for (i = 0; i <= FDBConnections.GetCount() - 1; ++i) { aStrings.Add((((TRtDBConnection) FDBConnections.Get(i))).getName()); } } public final TRtDBConnection NewDBConnection(int aDBAccessKind, int aDBVersionKind) { TRtDBConnection Result; String DBConnName = ""; DBConnName = GetNextDBConnectionName(); Result = ((TRtDBConnection) Creator(this, TRtDBConnectionClass.SINGLETON)); Result.InitConnection(this, aDBAccessKind, aDBVersionKind); Result.SetName(DBConnName); return Result; } public final TRtDBConnection NewNamedDBConnection(String aName, int aDBAccessKind, int aDBVersionKind) { TRtDBConnection Result; if (GetDbConnectionByName(aName) != null) { throw DelphiException.CreateFmt(TransStr("TC633", "Já existe uma conexão de banco de dados com este nome(%s)", true), new Object[] { aName }); } Result = NewDBConnection(aDBAccessKind, aDBVersionKind); Result.SetName(aName); return Result; } public final void RegisterSqlDriver(int aDBVersionKind, TRtSqlDriver aSqlDriver) { Assert(FSqlDrivers[aDBVersionKind] == null, TransStr("TC634", "Erro no Registro dos Driver SQL", true)); FSqlDrivers[aDBVersionKind] = aSqlDriver; } public final void RegisterSqlKnl(int aDBAccessKind, TRtDBKernelClass aDbKernelClass) { Assert(FSqlKnlClasses[aDBAccessKind] == null, TransStr("TC635", "Erro no Registro do Kernel de Acesso", true)); FSqlKnlClasses[aDBAccessKind] = aDbKernelClass; } public final void RegisterConnectionParams(int aDBAccessKind, int aDBVersionKind, TDBParamStrings aDBParamStrings) { Assert(FConnectionParams[aDBAccessKind][aDBVersionKind] == null, "Erro no Registro dos parâmetros de conexão"); FConnectionParams[aDBAccessKind][aDBVersionKind] = aDBParamStrings; } public final void UnregisterSqlDriver(int aDBVersionKind) { Assert(FSqlDrivers[aDBVersionKind] != null, TransStr("TC634", "Erro no Registro dos Driver SQL", true)); FSqlDrivers[aDBVersionKind] = null; } public final void UnregisterSqlKnl(int aDBAccessKind) { Assert(FSqlKnlClasses[aDBAccessKind] != null, TransStr("TC635", "Erro no Registro do Kernel de Acesso", true)); FSqlKnlClasses[aDBAccessKind] = null; } public final void UnregisterConnectionParams(int aDBAccessKind, int aDBVersionKind) { Assert(FConnectionParams[aDBAccessKind][aDBVersionKind] != null, "Erro no Registro dos parâmetros de conexão"); FConnectionParams[aDBAccessKind][aDBVersionKind] = null; } public final TClass GetDbCatalogsClass(int aDBVersionKind) { TClass Result; Result = GetSqlDriver(aDBVersionKind).DBCatalogsClass; Assert(Result != null, Format(TransStr("TC636", "Catálogos para o Driver \"%s\" não registrado.", true), new Object[] { cDBVersionKindNameArray[aDBVersionKind] })); return Result; } public final TRtDBGenericFunctionsClass GetDbGenericFunctionsClass(int aDBVersionKind) { TRtDBGenericFunctionsClass Result; Result = GetSqlDriver(aDBVersionKind).DBGenericFunctionsClass; Assert(Result != null, Format(TransStr("TC637", "Funções Genéricas para o Driver \"%s\" não registradas.", true), new Object[] { cDBVersionKindNameArray[aDBVersionKind] })); return Result; } public final TRtReplG6FunctionsClass GetReplG6FunctionsClass(int aDBVersionKind) { TRtReplG6FunctionsClass Result; Result = GetSqlDriver(aDBVersionKind).ReplG6FunctionsClass; Assert(Result != null, Format(TransStr("TC638", "Funções de replicação G6 para o Driver \"%s\" não registradas.", true), new Object[] { cDBVersionKindNameArray[aDBVersionKind] })); return Result; } public final TRtColumnSqlGeneratorClass GetColumnSqlGeneratorClass(int aDBVersionKind) { TRtColumnSqlGeneratorClass Result; Result = GetSqlDriver(aDBVersionKind).ColumnSqlGeneratorClass; Assert(Result != null, Format(TransStr("TC639", "Gerador Sql de Colunas para o Driver \"%s\" não registrado.", true), new Object[] { cDBVersionKindNameArray[aDBVersionKind] })); return Result; } public final void SetColumnSqlGeneratorClass(int aDBVersionKind, TRtColumnSqlGeneratorClass aColumnSqlGeneratorClass) { GetSqlDriver(aDBVersionKind).ColumnSqlGeneratorClass = aColumnSqlGeneratorClass; } public final TRtCustomSQL InstanceOfSQLClass(int aSQLClassesKind, int aDBVersionKind) { TRtSqlDriver xSqlDriver = null; xSqlDriver = GetSqlDriver(aDBVersionKind); return xSqlDriver.SQLClasses[aSQLClassesKind].CreateWithDBVersionKind(aDBVersionKind); } public final boolean DbDriverIsRegistred(int aDBAccessKind, int aDBVersionKind) { return FConnectionParams[aDBAccessKind][aDBVersionKind] != null; } public final String GetDbDriverDescription(int aDBVersionKind) { return cDBVersionKindNameArray[aDBVersionKind]; } public final TRtDBInitializeProc GetDbInitializeProc(int aDBVersionKind) { return GetSqlDriver(aDBVersionKind).DBInitProc; } public final TRtSQLFunctionTableList GetDbDriverFunctions(int aDBVersionKind) { return GetSqlDriver(aDBVersionKind).FuncList; } public final Object GetDbPLGenerator(int aDBVersionKind) { return GetSqlDriver(aDBVersionKind).PLGenerator; } public final TRtCBNFData GetCBNFDataPtr() { return FBNFData; } public final TRtDBRawDatabase GetRawDataBaseFromAcessDatabase(TRtDatabase aDataBase) { TRtDBRawDatabase Result; int i; i = 0; while (i < FDBConnections.GetCount() && (((TRtDBConnection) FDBConnections.Get(i)).IsOpen() && ((TRtDBConnection) FDBConnections.Get(i)).GetAccess() != aDataBase || !((TRtDBConnection) FDBConnections.Get(i)).IsOpen())) { i++; } if (i < FDBConnections.GetCount()) { Result = ((TRtDBConnection) FDBConnections.Get(i)).FRawDatabase; } else { Result = null; } return Result; } public final TRtDatabaseServer GlobalInstance() { return ClassType().GlobalInstance(); } public TRtDatabaseServerClass ClassType() { return TRtDatabaseServerClass.SINGLETON; } } public static final class TCustomAlterDefIndexClusterClass extends TClass { public static final TCustomAlterDefIndexClusterClass SINGLETON = new TCustomAlterDefIndexClusterClass(); public final TCustomAlterDefIndexCluster Create(TRtDBConnection aConnection) { return TCustomAlterDefIndexCluster.Create(aConnection); } public Class ClassInfo() { return TCustomAlterDefIndexCluster.class; } } public static final class TCustomAlterDefIndexCluster extends TObject { protected TRtDBConnection FConnection; public final void runCreate(TRtDBConnection aConnection) { FConnection = aConnection; } public static TCustomAlterDefIndexCluster Create(TRtDBConnection aConnection) { TCustomAlterDefIndexCluster Result; Result = new TCustomAlterDefIndexCluster(); Result.runCreate(aConnection); return Result; } public void AddDefaultIndexCluster(String aTableName, String aIndexValue) { } public void RemoveDefaultIndexCluster(String aTableName) { } public void SaveAlterDefaultIndexClustered() { } public TCustomAlterDefIndexClusterClass ClassType() { return TCustomAlterDefIndexClusterClass.SINGLETON; } } public static class TRtReplG6Functions extends TObject { //private final void CreateTableTrigger(TRtDBConnection aConn, TRtTableDef aTableDef) { // ClassType().CreateTableTrigger(aConn, aTableDef); //} protected final TStringList GetReplTables(TRtDBConnection aConn) { return ClassType().GetReplTables(aConn); } protected String GenerateInsertReplTrigger(TRtDBConnection aDBConn, TRtTableDef aTableDef) { return ClassType().GenerateInsertReplTrigger(aDBConn, aTableDef); } protected String GenerateUpdateReplTrigger(TRtDBConnection aDBConn, TRtTableDef aTableDef) { return ClassType().GenerateUpdateReplTrigger(aDBConn, aTableDef); } protected String GenerateDeleteReplTrigger(TRtDBConnection aDBConn, TRtTableDef aTableDef) { return ClassType().GenerateDeleteReplTrigger(aDBConn, aTableDef); } protected String GetDropTriggerCommand(TRtTableDef aTableDef, int aTriggerEvent) { return ClassType().GetDropTriggerCommand(aTableDef, aTriggerEvent); } public void CreateReplControlObjects(TRtDBConnection aConn) { ClassType().CreateReplControlObjects(aConn); } public void CreateReplTablesIntoTBS(TRtDBConnection aConn, TRtFullDatabaseDef aTBS) { ClassType().CreateReplTablesIntoTBS(aConn, aTBS); } public void DropReplTablesFromTBS(TRtDBConnection aConn, TRtFullDatabaseDef aTBS) { ClassType().DropReplTablesFromTBS(aConn, aTBS); } public final void ClearOldTriggers(TRtDBConnection aConn) { ClassType().ClearOldTriggers(aConn); } public final void ClearTriggerFromTable(String aTableName, TRtDBConnection aConn) { ClassType().ClearTriggerFromTable(aTableName, aConn); } public final void CreateTriggers(TRtDBConnection aConn, TRtFullDatabaseDef aTBS) { ClassType().CreateTriggers(aConn, aTBS); } public void ExecBeforeBeginTran(IRtDBConnection aConn) { ClassType().ExecBeforeBeginTran(aConn); } public void ExecBeforeCommit(IRtDBConnection aConn) { ClassType().ExecBeforeCommit(aConn); } public void ExecAfterEndTran(IRtDBConnection aConn) { ClassType().ExecAfterEndTran(aConn); } public boolean GetInReplG6(TRtDBConnection aConn) { return ClassType().GetInReplG6(aConn); } public boolean ExistsTablesToRepl(TRtDBConnection aConn) { return ClassType().ExistsTablesToRepl(aConn); } public void InitControlObjects(TRtDBConnection aConn) { ClassType().InitControlObjects(aConn); } public void DisableRepl(TRtDBConnection aConn) { ClassType().DisableRepl(aConn); } public TRtReplG6FunctionsClass ClassType() { return TRtReplG6FunctionsClass.SINGLETON; } } public interface TOnForceAlterTableMode { public boolean run(TRtAlterTable aAlterTable, TInt aMode); } public interface TRtGetConversionProp { public Object run(int aPropID); } public interface TRtOnGetTableSecurityValues { public DelphiSet run(String aTableName, String[] aFieldsNames); } public interface TRtOnGetFieldSecurityValues { public DelphiSet run(String aTableName, String aFieldName); } public interface TRtOnGetTableEventValues { public DelphiSet run(String aTableName); } public interface TRtOnCreateTemporaryTables { public void run(); } public interface TRtOnTableIsTemporary { public boolean run(String aTableName); } public static final class TRtDBConnectionClass extends TContainerItemClass { public static final TRtDBConnectionClass SINGLETON = new TRtDBConnectionClass(); protected final TRtDBConnection CreateConnection(TRtDatabaseServer AOwner, int aDBAccessKind, int aDBVersionKind) { return TRtDBConnection.CreateConnection(AOwner, aDBAccessKind, aDBVersionKind); } public TRtDBConnection Create() { return TRtDBConnection.Create(); } public Class ClassInfo() { return TRtDBConnection.class; } } public static final class TRtDBConnection2 extends TContainerItem implements IRtDBConnection, IRtDBNativeConnection { public static TRtDBConnection2 Create() { return new TRtDBConnection2(); } @Override public DelphiSet AcceptStrFunctions(int aSize) { // TODO Implement method IRtDBConnection.AcceptStrFunctions. throw new RuntimeException("Pending implementation: IRtDBConnection.AcceptStrFunctions"); // return null; } @Override public void Commit() { // TODO Implement method IRtDBConnection.Commit. throw new RuntimeException("Pending implementation: IRtDBConnection.Commit"); // } @Override public int ExecuteDML(String aCommand, Object aParams) { // TODO Implement method IRtDBConnection.ExecuteDML. throw new RuntimeException("Pending implementation: IRtDBConnection.ExecuteDML"); // return 0; } @Override public int ExecuteDMLByConst(String aCommand, Object[] aParams) { // TODO Implement method IRtDBConnection.ExecuteDMLByConst. throw new RuntimeException("Pending implementation: IRtDBConnection.ExecuteDMLByConst"); // return 0; } @Override public IRtCursor ExecuteSQL(String aCommand, Object aParams, boolean aBidirectionalCursor) { // TODO Implement method IRtDBConnection.ExecuteSQL. throw new RuntimeException("Pending implementation: IRtDBConnection.ExecuteSQL"); // return null; } @Override public IRtCursor ExecuteSQL(String aCommand, Object aParams) { // TODO Implement method IRtDBConnection.ExecuteSQL. throw new RuntimeException("Pending implementation: IRtDBConnection.ExecuteSQL"); // return null; } @Override public IRtCursor ExecuteSQLByConst(String aCommand, Object[] aParams, boolean aBidirectionalCursor) { // TODO Implement method IRtDBConnection.ExecuteSQLByConst. throw new RuntimeException("Pending implementation: IRtDBConnection.ExecuteSQLByConst"); // return null; } @Override public IRtCursor ExecuteSQLByConst(String aCommand, Object[] aParams) { // TODO Implement method IRtDBConnection.ExecuteSQLByConst. throw new RuntimeException("Pending implementation: IRtDBConnection.ExecuteSQLByConst"); // return null; } @Override public void FreeIDValue(String aID) { // TODO Implement method IRtDBConnection.FreeIDValue. throw new RuntimeException("Pending implementation: IRtDBConnection.FreeIDValue"); // } @Override public void FreeKeyValue(String aTableName, Object[] aValues) { // TODO Implement method IRtDBConnection.FreeKeyValue. throw new RuntimeException("Pending implementation: IRtDBConnection.FreeKeyValue"); // } @Override public boolean GetCanUseInCompare(TTypeDesc aTypeDesc) { // TODO Implement method IRtDBConnection.GetCanUseInCompare. throw new RuntimeException("Pending implementation: IRtDBConnection.GetCanUseInCompare"); // return false; } @Override public double GetDBDateTime() { // TODO Implement method IRtDBConnection.GetDBDateTime. throw new RuntimeException("Pending implementation: IRtDBConnection.GetDBDateTime"); // return 0; } @Override public IRtDatabaseDef GetDatabaseDef() { // TODO Implement method IRtDBConnection.GetDatabaseDef. throw new RuntimeException("Pending implementation: IRtDBConnection.GetDatabaseDef"); // return null; } @Override public int GetNextIDValue(boolean aUseSameTransaction, String aID, int aIncrement) { // TODO Implement method IRtDBConnection.GetNextIDValue. throw new RuntimeException("Pending implementation: IRtDBConnection.GetNextIDValue"); // return 0; } @Override public int GetNextIDValue(String aID) { // TODO Implement method IRtDBConnection.GetNextIDValue. throw new RuntimeException("Pending implementation: IRtDBConnection.GetNextIDValue"); // return 0; } @Override public int GetNextKeyValue(boolean aUseSameTransaction, String aTableName, Object[] aValues, int aIncrement, boolean aIgnoreOldValues) { // TODO Implement method IRtDBConnection.GetNextKeyValue. throw new RuntimeException("Pending implementation: IRtDBConnection.GetNextKeyValue"); // return 0; } @Override public int GetNextKeyValue(String aTableName, Object[] aValues) { // TODO Implement method IRtDBConnection.GetNextKeyValue. throw new RuntimeException("Pending implementation: IRtDBConnection.GetNextKeyValue"); // return 0; } @Override public IRtDBConnection GetParallel() { // TODO Implement method IRtDBConnection.GetParallel. throw new RuntimeException("Pending implementation: IRtDBConnection.GetParallel"); // return null; } @Override public int GetRowSetSize() { // TODO Implement method IRtDBConnection.GetRowSetSize. throw new RuntimeException("Pending implementation: IRtDBConnection.GetRowSetSize"); // return 0; } @Override public IRtDBSecurityManager GetSecurityManager() { // TODO Implement method IRtDBConnection.GetSecurityManager. throw new RuntimeException("Pending implementation: IRtDBConnection.GetSecurityManager"); // return null; } @Override public IRtSortInfo GetSortInfo() { // TODO Implement method IRtDBConnection.GetSortInfo. throw new RuntimeException("Pending implementation: IRtDBConnection.GetSortInfo"); // return null; } @Override public int GetTransactionLevel() { // TODO Implement method IRtDBConnection.GetTransactionLevel. throw new RuntimeException("Pending implementation: IRtDBConnection.GetTransactionLevel"); // return 0; } @Override public IRtDBBatchCommandProcessor NewDBBatchCommandProcessor() { // TODO Implement method IRtDBConnection.NewDBBatchCommandProcessor. throw new RuntimeException("Pending implementation: IRtDBConnection.NewDBBatchCommandProcessor"); // return null; } @Override public IRtDBCommandProcessor NewDBCommandProcessor() { // TODO Implement method IRtDBConnection.NewDBCommandProcessor. throw new RuntimeException("Pending implementation: IRtDBConnection.NewDBCommandProcessor"); // return null; } @Override public IRtStmt NewStmtFromCommand(String aCommand) { // TODO Implement method IRtDBConnection.NewStmtFromCommand. throw new RuntimeException("Pending implementation: IRtDBConnection.NewStmtFromCommand"); // return null; } @Override public void Rollback() { // TODO Implement method IRtDBConnection.Rollback. throw new RuntimeException("Pending implementation: IRtDBConnection.Rollback"); // } @Override public void SetRowSetSize(int aValue) { // TODO Implement method IRtDBConnection.SetRowSetSize. throw new RuntimeException("Pending implementation: IRtDBConnection.SetRowSetSize"); // } @Override public void SetSecurityManager(IRtDBSecurityManager aSecurityManager) { // TODO Implement method IRtDBConnection.SetSecurityManager. throw new RuntimeException("Pending implementation: IRtDBConnection.SetSecurityManager"); // } @Override public void StartTransaction() { // TODO Implement method IRtDBConnection.StartTransaction. throw new RuntimeException("Pending implementation: IRtDBConnection.StartTransaction"); // } @Override public IRtDBConnection iClone() { // TODO Implement method IRtDBConnection.iClone. throw new RuntimeException("Pending implementation: IRtDBConnection.iClone"); // return null; } @Override public void BeginBusinessOperation(int BusinessTransactionId) { // TODO Implement method IRtDBCustomConnection.BeginBusinessOperation. throw new RuntimeException("Pending implementation: IRtDBCustomConnection.BeginBusinessOperation"); // } @Override public void CommitBusinessOperation(String UndoData) { // TODO Implement method IRtDBCustomConnection.CommitBusinessOperation. throw new RuntimeException("Pending implementation: IRtDBCustomConnection.CommitBusinessOperation"); // } @Override public void CommitBusinessTransaction() { // TODO Implement method IRtDBCustomConnection.CommitBusinessTransaction. throw new RuntimeException("Pending implementation: IRtDBCustomConnection.CommitBusinessTransaction"); // } @Override public int CurrentBusinessTransactionId() { // TODO Implement method IRtDBCustomConnection.CurrentBusinessTransactionId. throw new RuntimeException("Pending implementation: IRtDBCustomConnection.CurrentBusinessTransactionId"); // return 0; } @Override public void RollbackBusinessOperation() { // TODO Implement method IRtDBCustomConnection.RollbackBusinessOperation. throw new RuntimeException("Pending implementation: IRtDBCustomConnection.RollbackBusinessOperation"); // } @Override public void RollbackBusinessTransaction() { // TODO Implement method IRtDBCustomConnection.RollbackBusinessTransaction. throw new RuntimeException("Pending implementation: IRtDBCustomConnection.RollbackBusinessTransaction"); // } @Override public int StartBusinessTransaction() { // TODO Implement method IRtDBCustomConnection.StartBusinessTransaction. throw new RuntimeException("Pending implementation: IRtDBCustomConnection.StartBusinessTransaction"); // return 0; } @Override public int QueryInterface(Class IID, TReference Obj) { // TODO Implement method IUnknown.QueryInterface. throw new RuntimeException("Pending implementation: IUnknown.QueryInterface"); // return 0; } @Override public int _AddRef() { // TODO Implement method IUnknown._AddRef. throw new RuntimeException("Pending implementation: IUnknown._AddRef"); // return 0; } @Override public int _Release() { // TODO Implement method IUnknown._Release. throw new RuntimeException("Pending implementation: IUnknown._Release"); // return 0; } @Override public DelphiSet GetAccessOptions(int aStmtKind, TRtTableInfo[] aTableInfo) { // TODO Implement method IRtDBNativeConnection.GetAccessOptions. throw new RuntimeException("Pending implementation: IRtDBNativeConnection.GetAccessOptions"); // return null; } @Override public int GetDBType() { // TODO Implement method IRtDBNativeConnection.GetDBType. throw new RuntimeException("Pending implementation: IRtDBNativeConnection.GetDBType"); // return 0; } @Override public boolean GetSupportNestedTransaction() { // TODO Implement method IRtDBNativeConnection.GetSupportNestedTransaction. throw new RuntimeException("Pending implementation: IRtDBNativeConnection.GetSupportNestedTransaction"); // return false; } @Override public String NativeParsedBatchSqlFromStmt(IRtNativeStmt aStmt, int[] aParamsPosArray) { // TODO Implement method IRtDBNativeConnection.NativeParsedBatchSqlFromStmt. throw new RuntimeException("Pending implementation: IRtDBNativeConnection.NativeParsedBatchSqlFromStmt"); // return null; } @Override public String NativeParsedSqlFromStmt(IRtNativeStmt aStmt, int[] aParamsPosArray) { // TODO Implement method IRtDBNativeConnection.NativeParsedSqlFromStmt. throw new RuntimeException("Pending implementation: IRtDBNativeConnection.NativeParsedSqlFromStmt"); // return null; } @Override public String NativeSqlFromStmt(IRtNativeStmt aStmt) { // TODO Implement method IRtDBNativeConnection.NativeSqlFromStmt. throw new RuntimeException("Pending implementation: IRtDBNativeConnection.NativeSqlFromStmt"); // return null; } @Override public IRtBatchNativeStmtHelper NewBatchNativeStmtHelper(TRtBatchNativeCtx aCtx) { // TODO Implement method IRtDBNativeConnection.NewBatchNativeStmtHelper. throw new RuntimeException("Pending implementation: IRtDBNativeConnection.NewBatchNativeStmtHelper"); // return null; } @Override public IRtNativeStmt NewNativeStmtFromCommand(String aCommand) { // TODO Implement method IRtDBNativeConnection.NewNativeStmtFromCommand. throw new RuntimeException("Pending implementation: IRtDBNativeConnection.NewNativeStmtFromCommand"); // return null; } @Override public IRtNativeStmtHelper NewNativeStmtHelper() { // TODO Implement method IRtDBNativeConnection.NewNativeStmtHelper. throw new RuntimeException("Pending implementation: IRtDBNativeConnection.NewNativeStmtHelper"); // return null; } public void Open() { } public TRtDatabase GetAccess() { return null; } } public static final class TRtDBConnection extends TContainerItem implements IRtDBConnection, IRtDBNativeConnection { private final class QueryInterface_Context { private final Class IID; private final TReference Obj; private int Result; private final static int E_NOINTERFACE = (int) 0x80004002L; public QueryInterface_Context(Class IID, TReference Obj) { this.IID = IID; this.Obj = Obj; } public int execute() { if (GetInterface(IID, Obj)) { Result = 0; } else { Result = E_NOINTERFACE; } return Result; } } private final class MonitorTableVerify_Context { private final int aCommandKind; private final String aTableName; private boolean Result; private final int[] cEvents = new int[] { (int) -1, (int) -1, tdloInsert, tdloUpdate, tdloDelete, (int) -1 }; public MonitorTableVerify_Context(int aCommandKind, String aTableName) { this.aCommandKind = aCommandKind; this.aTableName = aTableName; } public boolean execute() { Result = false; if (cEvents[aCommandKind] != (int) -1 && FOnGetTableEventValues != null) { Result = FOnGetTableEventValues.run(aTableName).contains(cEvents[aCommandKind]); } return Result; } } private final class AccessTableVerify_Context { private final int aCommandKind; private final TRtTableInfo aTableInfo; private final TRtTableInfo aAccessDenied; private boolean Result; private int TablePermissionsByCommandKind(int aCommandKind) { int Result; if (aCommandKind == nskSelect) { Result = tdpSelect; } else if (aCommandKind == nskInsert) { Result = tdpInsert; } else if (aCommandKind == nskUpdate) { Result = tdpUpdate; } else if (aCommandKind == nskDelete) { Result = tdpDelete; } else { throw DelphiException.Create(TransStr("TC644", "Tipo de comando não cadastrado para verificação de permissão", true)); } return Result; } public AccessTableVerify_Context(int aCommandKind, TRtTableInfo aTableInfo, TRtTableInfo aAccessDenied) { this.aCommandKind = aCommandKind; this.aTableInfo = aTableInfo; this.aAccessDenied = aAccessDenied; } public boolean execute() { Result = true; if (FOnGetTableSecurityValues != null) { Result = FOnGetTableSecurityValues.run(aTableInfo.TableName, aTableInfo.FieldsNames).contains(TablePermissionsByCommandKind(aCommandKind)); if (!Result) { aAccessDenied.TableName = aTableInfo.TableName; } } return Result; } } private final class StartBusinessTransaction_Context { private int NextCodTra() { int Result; IRtDBCommandProcessor Cmd; IRtCursor Cursor; StartTransaction(); Cmd = NewDBCommandProcessor(); Cmd.SetCommand("update R999TPX set CodPrxTra = CodPrxTra + 1"); Cmd.Prepare(); switch (Cmd.Execute()) { case 0: Result = 1; Cmd.SetCommand("insert into R999TPX (CodPrxTra) values (1)"); Cmd.Prepare(); if (Cmd.Execute() != 1) { throw DelphiException.Create("Erro ao adquirir um novo identificador de transação de negócios."); } break; case 1: Cmd.SetCommand("select CodPrxTra from R999TPX"); Cmd.Prepare(); Cursor = Cmd.Open(); try { if (!Cursor.Next()) { Assert(false); } Result = Cursor.FieldByName("CodPrxTra").GetAsInteger(); } finally { Cursor.Close(); } break; default: Rollback(); throw DelphiException.Create("Multiplas linhas afetadas."); } Commit(); return Result; } private IRtDBCommandProcessor Cmd; private int CodPrxTra; public StartBusinessTransaction_Context() { } public int execute() { CheckNotInBusinessTransaction(); CheckNotInBusinessOperation(); CheckNotInTransaction(); try { CodPrxTra = NextCodTra(); } catch (EExAccess E) { CodPrxTra = NextCodTra(); } BeginTran(); Cmd = NewDBCommandProcessor(); Cmd.SetCommand("insert R999TRA (CodTra, DesTra) values (:CodTra, :DesTra)"); Cmd.ParamByName("CodTra").SetAsInteger(CodPrxTra); Cmd.ParamByName("DesTra").SetAsString("ACTIVE"); Cmd.Prepare(); if (Cmd.Execute() != 1) { throw DelphiException.Create("Erro ao inicar a transação de negócio."); } FInBusinessTransaction = true; FBusinessTransactionId = CodPrxTra; return FBusinessTransactionId; } } private final class CommitBusinessOperation_Context { private final String UndoData; private int NextCodTraDet() { int Result; IRtDBCommandProcessor Cmd; IRtCursor C; Cmd = NewDBCommandProcessor(); Cmd.SetCommand("insert into R999TRD (CodTra, CodTraDet) values (:CodTra, -1)"); Cmd.ParamByName("CodTra").SetAsInteger(FBusinessTransactionId); Cmd.Prepare(); Cmd.Execute(); Cmd.SetCommand("select max(CodTraDet) from R999TRD where CodTra = :CodTra and CodTraDet > -1"); Cmd.ParamByName("CodTra").SetAsInteger(FBusinessTransactionId); Cmd.Prepare(); C = Cmd.Open(); try { if (C.Next()) { Result = C.GetField(0).GetAsInteger() + 1; } else { Result = 1; } } finally { C.Close(); } Cmd.SetCommand("delete from R999TRD where CodTra = :CodTra and CodTraDet = -1"); Cmd.ParamByName("CodTra").SetAsInteger(FBusinessTransactionId); Cmd.Prepare(); Cmd.Execute(); return Result; } private IRtDBCommandProcessor Cmd; private int CodTraDet; public CommitBusinessOperation_Context(String UndoData) { this.UndoData = UndoData; } public void execute() { CheckNotInBusinessTransaction(); CheckInBusinessOperation(); CheckRootTransactionLevel(); CodTraDet = NextCodTraDet(); Cmd = NewDBCommandProcessor(); Cmd.SetCommand("insert into R999TRD (CodTra, CodTraDet, BinTraDet) values (:CodTra, :CodTraDet, :BinTraDet)"); Cmd.ParamByName("CodTra").SetAsInteger(FBusinessTransactionId); Cmd.ParamByName("CodTraDet").SetAsInteger(CodTraDet); Cmd.ParamByName("BinTraDet").SetAsBlob(UndoData); Cmd.Prepare(); if (Cmd.Execute() != 1) { throw DelphiException.Create("Erro ao finalizar a operação de negócio."); } FInBusinessOperation = false; try { Commit(); } catch (Throwable any) { FInBusinessOperation = true; throw wrap(any); } FBusinessTransactionId = -1; } } private final class AssignFromDatabaseDef_Context { private final int aLevelAlterTableMode; private final TRtDatabaseDef NewDbDef; private final DelphiSet AAssOpt; private final TRtGetConversionProp aGetConversionProp; private int i; private TRtCustomSQL ASQL; private TRtAlterTable AT; private final TBoolean LDrop = new TBoolean(); private final TBoolean LCreate = new TBoolean(); private final TString NewTblName = new TString(); private String xDBNameSpecificSP = ""; private TRtTableDef ATmpTblDef; private TRtTableDef ATblDef; private TRtStoredProcItem ASPItem; private TRtStoredProcItem AOldSPItem; private TRtViewDef AViewDef; private TRtViewDef AOldViewDef; private TStringList xForceDropTableList; private TStringList xExcludeForceAlterTableList; private void ProcessAlterTables() { TInt xMode = new TInt(); int i; for (i = 0; i <= FSQLList.GetCount() - 1; ++i) { ASQL = ((TRtCustomSQL) FSQLList.Get(i)); if (ASQL instanceof TRtAlterTable) { if (getOnForceAlterTableMode() != null && xExcludeForceAlterTableList.IndexOf(((TRtAlterTable) ASQL).GetTableName()) == -1) { xMode.v = ((TRtAlterTable) ASQL).GetAlterTableMode(); if (getOnForceAlterTableMode().run((TRtAlterTable) ASQL, xMode)) { ((TRtAlterTable) ASQL).SetAlterTableMode(xMode.v); } } if (((TRtAlterTable) ASQL).GetAlterTableMode() == atmAlterTable) { if (((TRtAlterTable) ASQL).GetDATNeedForceModifyAllFks()) { ((TRtAlterTable) ASQL).ForceModifyAllFks(); } ((TRtAlterTable) ASQL).ForceModifyAllTriggers(); } ((TRtAlterTable) ASQL).DoImplicitChanges(); } } } private boolean ViewsxSPsChanged() { TBoolean Result = new TBoolean(); TRtStoredProcDef xProcDef; int i; for (i = 0; i <= FPhyDatabase.GetViewCount() - 1; ++i) { Result.v = NewDbDef.ViewByName(FPhyDatabase.GetView(i).GetName()) == null; if (!Result.v && getOnVerifyAssignObjectDef() != null) { getOnVerifyAssignObjectDef().run(FPhyDatabase.GetView(i), Result); } if (Result.v) { return Result.v; } } for (i = 0; i <= NewDbDef.GetViewCount() - 1; ++i) { AViewDef = NewDbDef.GetView(i); AOldViewDef = FPhyDatabase.ViewByName(AViewDef.GetName()); Result.v = AOldViewDef == null || CompareText(AViewDef.getSelectSQL(), AOldViewDef.getSelectSQL()) != 0; if (Result.v) { return Result.v; } } for (i = 0; i <= FPhyDatabase.GetStoredProcCount() - 1; ++i) { Result.v = NewDbDef.StoredProcByName(FPhyDatabase.GetStoredProc(i).GetName()) == null; if (Result.v) { return Result.v; } } for (i = 0; i <= NewDbDef.GetStoredProcCount() - 1; ++i) { ASPItem = NewDbDef.GetStoredProc(i).GetSpecificCodes(xDBNameSpecificSP, NewDbDef.getCustomerCode()); xProcDef = FPhyDatabase.StoredProcByName(ASPItem.GetOwnerStoredProcDef().GetName()); if (xProcDef != null) { AOldSPItem = xProcDef.GetSpecificCodes(xDBNameSpecificSP, FPhyDatabase.getCustomerCode()); } else { AOldSPItem = null; } Result.v = ASPItem == null || AOldSPItem == null; if (Result.v) { if (ASPItem == AOldSPItem) { continue; } return Result.v; } Result.v = CompareText(ASPItem.GetDatabaseName(), AOldSPItem.GetDatabaseName()) != 0 || CompareText(ASPItem.getCode(), AOldSPItem.getCode()) != 0; if (Result.v) { return Result.v; } } Result.v = false; return Result.v; } private void ProcessDropTable(TRtTableDef _TblDef) { TRtAlterTable AT; int i; TRtRelationDef xRelDef; TRtForeignKeyItem xRelItem; if (AAssOpt.contains(raaForeignKeys)) { if (_TblDef.GetRelationCount() > 0) { AT = SQLAlterTable(); AT.setLevelAlterTableMode(aLevelAlterTableMode); AT.SetTableName(_TblDef.GetName()); for (i = 0; i <= _TblDef.GetRelationCount() - 1; ++i) { xRelDef = ATblDef.GetRelation(i); if (CompareText(xRelDef.getForeignTable().GetName(), _TblDef.GetName()) == 0) { xRelItem = AT.FForeignKeys.AddForeignKey(xRelDef.GetName(), xRelDef.getReferenceTable().GetName()); xRelItem.SetOption(rcaDrop); xRelItem.FForeignTable = xRelDef.getForeignTable().GetName(); } } } } } private boolean xUseNewOperationKind; public AssignFromDatabaseDef_Context(int aLevelAlterTableMode, TRtDatabaseDef NewDbDef, DelphiSet AAssOpt, TRtGetConversionProp aGetConversionProp) { this.aLevelAlterTableMode = aLevelAlterTableMode; this.NewDbDef = NewDbDef; this.AAssOpt = AAssOpt; this.aGetConversionProp = aGetConversionProp; } public void execute() { if (FSQLList.GetCount() > 0) { throw DelphiException.Create(TransStr("TC650", "Já existem objetos SQL sobre esta conexão.", true)); } if (NewDbDef == null) { throw DelphiException.Create(TransStr("TC651", "Parâmetro para o DatabaseDef é nulo.", true)); } Assert(aGetConversionProp != null, TransStr("TC5145", "aGetConversionProp não pode ser nulo.")); xUseNewOperationKind = VarToBoolean(aGetConversionProp.run(cpiUseNewOperationKind)); SetNewDatabase(NewDbDef); try { xExcludeForceAlterTableList = TStringList.Create(); try { xDBNameSpecificSP = GetDBNameSpecificSPByDBVersionKind(FDBVersionKind); xForceDropTableList = TStringList.Create(); try { for (i = 0; i <= FPhyDatabase.GetTableCount() - 1; ++i) { ATblDef = FPhyDatabase.GetTable(i); LDrop.v = false; if (getOnVerifyAssignObjectDef() != null) { getOnVerifyAssignObjectDef().run(ATblDef, LDrop); if (LDrop.v) { xForceDropTableList.Add(ATblDef.GetName()); } } if (NewDbDef.TableByName(ATblDef.GetName()) == null || LDrop.v) { LDrop.v = true; if (!FDisableEvents && FOnMustDropTable != null) { FOnMustDropTable.run(ATblDef, LDrop); } if (LDrop.v) { ASQL = SQLDropTable(); ((TRtDropTable) ASQL).SetTableName(ATblDef.GetName()); ((TRtDropTable) ASQL).SetRIntOpt(rroCascade); ProcessDropTable(ATblDef); xExcludeForceAlterTableList.Add(ATblDef.GetName()); } } } for (i = 0; i <= NewDbDef.GetTableCount() - 1; ++i) { ATblDef = NewDbDef.GetTable(i); NewTblName.v = ""; if (!FDisableEvents && FOnMustRenameTable != null) { FOnMustRenameTable.run(ATblDef, NewTblName); } if (!StrIsBlank(NewTblName.v)) { ASQL = SQLRenameTable(); ((TRtRenameTable) ASQL).SetTableName(ATblDef.GetName()); ((TRtRenameTable) ASQL).SetNewTableName(NewTblName.v); } else { ASQL = null; try { if (FPhyDatabase.TableByName(ATblDef.GetName()) == null) { ASQL = SQLCreateTable(); ((TRtCreateTable) ASQL).AssignFromTableDef(ATblDef, AAssOpt); if (AAssOpt.contains(raaForeignKeys) && ((TRtCreateTable) ASQL).GetOperations(raaForeignKeys) != DelphiSet.get() || ((TRtCreateTable) ASQL).GetOperations(raaTriggers) != DelphiSet.get()) { ASQL.Free(); ASQL = SQLCreateTable(); ((TRtCreateTable) ASQL).AssignFromTableDef(ATblDef, AAssOpt.sub(DelphiSet.get(raaForeignKeys, raaTriggers))); ATmpTblDef = FPhyDatabase.NewTableDef(ATblDef.GetName()); ((TRtCreateTable) ASQL).AssignToTableDef(ATmpTblDef, AAssOpt.sub(DelphiSet.get(raaForeignKeys, raaTriggers))); AT = SQLAlterTable(); AT.setLevelAlterTableMode(aLevelAlterTableMode); AT.AssignFromTableDef(ATblDef, DelphiSet.get(raaForeignKeys, raaTriggers)); } xExcludeForceAlterTableList.Add(ATblDef.GetName()); } else { ASQL = SQLAlterTable(); ((TRtAlterTable) ASQL).setUseNewOperationKind(xUseNewOperationKind); if (xForceDropTableList.IndexOf(ATblDef.GetName()) == -1) { ((TRtAlterTable) ASQL).setLevelAlterTableMode(aLevelAlterTableMode); ((TRtAlterTable) ASQL).AssignFromTableDef(ATblDef, AAssOpt); } } if (!ASQL.GetHasOperation() && (!VersionTBSRotGreaterOrEqual(FNewDatabase, 5, 5, 0, 21) || getStorage().StorageByName(DBGenericFunctions().GetPartitionTableName(ATblDef.GetName())) == null)) { ASQL.Free(); } } catch (Throwable any) { ASQL.Free(); throw wrap(any); } } } } finally { xForceDropTableList.Destroy(); } ProcessAlterTables(); } finally { xExcludeForceAlterTableList.Free(); } if (FSQLList.GetCount() > 0 || ViewsxSPsChanged()) { if (AAssOpt.contains(raaStoredProcedures)) { for (i = 0; i <= FPhyDatabase.GetStoredProcCount() - 1; ++i) { ASPItem = FPhyDatabase.GetStoredProc(i).GetSpecificCodes(xDBNameSpecificSP, FPhyDatabase.getCustomerCode()); if (ASPItem != null) { LDrop.v = true; if (!FDisableEvents && FOnMustDropStoredProc != null) { FOnMustDropStoredProc.run(ASPItem, LDrop); } if (LDrop.v) { ASQL = SQLDropProcedure(); ((TRtDropProcedure) ASQL).SetProcedureName(ASPItem.GetOwnerStoredProcDef().GetName()); } } } for (i = 0; i <= NewDbDef.GetStoredProcCount() - 1; ++i) { ASPItem = NewDbDef.GetStoredProc(i).GetSpecificCodes(xDBNameSpecificSP, NewDbDef.getCustomerCode()); if (ASPItem != null) { ASQL = null; try { ASQL = SQLCreateProcedure(); ((TRtCreateProcedure) ASQL).AssignFromStoredProcItem(ASPItem); } catch (Throwable any) { ASQL.Free(); throw wrap(any); } } } } if (AAssOpt.contains(raaViews)) { for (i = 0; i <= FPhyDatabase.GetViewCount() - 1; ++i) { AViewDef = FPhyDatabase.GetView(i); LDrop.v = true; if (!FDisableEvents && FOnMustDropView != null) { FOnMustDropView.run(AViewDef, LDrop); } if (LDrop.v) { ASQL = SQLDropView(); ((TRtDropView) ASQL).setViewName(AViewDef.GetName()); } } for (i = 0; i <= NewDbDef.GetViewCount() - 1; ++i) { AViewDef = NewDbDef.GetView(i); LCreate.v = true; if (FOnMustCreateView != null) { FOnMustCreateView.run(AViewDef, LCreate); } if (LCreate.v) { ASQL = null; try { ASQL = SQLCreateView(); ((TRtCreateView) ASQL).setViewName(AViewDef.GetName()); switch (AViewDef.getSQLKind()) { case skSenior2: ((TRtCreateView) ASQL).SetSelect_SeniorSQL_2(CompileViewSelect(NewDbDef, AViewDef.GetName(), AViewDef.getSelectSQL())); break; case skSenior1: ((TRtCreateView) ASQL).SetSelect_SeniorSQL_1(((TRtSelect) SQLObjectFrom(AViewDef.getSelectSQL()))); break; case skNative: ((TRtCreateView) ASQL).setSelect_NativeSQL(AViewDef.getSelectSQL()); break; default: break; } } catch (Throwable any) { ASQL.Free(); throw wrap(any); } } } } } } finally { SetNewDatabase(null); } } } private TRtOnCreateTemporaryTables FOnCreateTemporaryTables; private TRtOnTableIsTemporary FOnTableIsTemporary; public final boolean GetSupportNestedTransaction() { return FRawDatabase.GetNestedTrans(); } public final IRtNativeStmtHelper NewNativeStmtHelper() { CheckIsOpen(); return FRawDatabase.NewNativeStmtHelper(); } public final IRtBatchNativeStmtHelper NewBatchNativeStmtHelper(TRtBatchNativeCtx aCtx) { CheckIsOpen(); return FRawDatabase.NewBatchNativeStmtHelper(aCtx); } public final IRtNativeStmt NewNativeStmtFromCommand(String aCommand) { return GetSQLWorks().CompileStatement(aCommand); } public final String NativeSqlFromStmt(IRtNativeStmt aStmt) { return DBGenericFunctions().SeniorSqlToNativeSql((TStatement) aStmt.CompiledData()); } public final String NativeParsedSqlFromStmt(IRtNativeStmt aStmt, int[] aParamsPosArray) { return DBGenericFunctions().SeniorSqlToNativeParsedSql((TStatement) aStmt.CompiledData(), FRawDatabase.GetParamMark(), aParamsPosArray); } public final String NativeParsedBatchSqlFromStmt(IRtNativeStmt aStmt, int[] aParamsPosArray) { throw DelphiException.Create("Unsupported Operation"); } public final IRtDBConnection iClone() { return CloneConnection(); } public final IRtDBConnection GetParallel() { FParallelTimer.Free(); if (FParallelConn == null) { FParallelConn = iClone(); } FParallelTimer = TParallelTimer.CreateTimer(this); return FParallelConn; } public final void StartTransaction() { BeginTran(); } public final IRtDBCommandProcessor NewDBCommandProcessor() { CheckIsOpen(); return TRtDBCommandProcessor.Create(this); } public final IRtDBBatchCommandProcessor NewDBBatchCommandProcessor() { CheckIsOpen(); return TRtDBBatchCommandProcessor.Create(this); } //private final IRtCursor IExecuteSQL(String aCommand, Object aParams, boolean aBidirectionalCursor) { // return ExecuteSQL(SeniorSql_2ToNativeSql(aCommand), aParams); //} //private final IRtCursor IExecuteSQL(String aCommand, Object aParams) { // return IExecuteSQL(aCommand, aParams, false); //} //private final IRtCursor IExecuteSQLByConst(String aCommand, Object[] aParams, boolean aBidirectionalCursor) { // return ExecuteSQLByConst(SeniorSql_2ToNativeSql(aCommand), aParams, aBidirectionalCursor); //} //private final IRtCursor IExecuteSQLByConst(String aCommand, Object[] aParams) { // return IExecuteSQLByConst(aCommand, aParams, false); //} public final int GetTransactionLevel() { return FRawDatabase.GetTransactionLevel(); } public final IRtDatabaseDef GetDatabaseDef() { return getPhyDatabase(); } public final int GetRowSetSize() { return FRowSetSize; } public final IRtDBSecurityManager GetSecurityManager() { return FIRtSecurityManager; } public final void SetRowSetSize(int aValue) { FRowSetSize = aValue; } public final void SetSecurityManager(IRtDBSecurityManager aSecurityManager) { FIRtSecurityManager = aSecurityManager; } public final DelphiSet AcceptStrFunctions(int aSize) { return (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).GetAcceptStrFunctions(aSize); } public final boolean GetCanUseInCompare(TTypeDesc aTypeDesc) { return (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).GetCanUseInCompare(aTypeDesc); } public final IRtSortInfo GetSortInfo() { return RtStrUtil.GetSortInfo(getName()); } public final int ExecuteDML(String aCommand, Object aParams) { IRtDBCommandProcessor xDBCmdPrcr; int i; int j; xDBCmdPrcr = NewDBCommandProcessor(); xDBCmdPrcr.SetCommand(aCommand); j = xDBCmdPrcr.GetValueCount() - 1; if (j >= 0) { if (VarIsArray(aParams)) { for (i = 0; i <= j; ++i) { xDBCmdPrcr.GetParam(i).SetAsVariant(VarArrayGet(aParams, i)); } } else { xDBCmdPrcr.GetParam(0).SetAsVariant(aParams); } } return xDBCmdPrcr.Execute(); } public final int ExecuteDMLByConst(String aCommand, Object[] aParams) { return ExecuteDML(aCommand, ArrayOfConstToVarArray(aParams)); } public final IRtCursor ExecuteSQL(String aCommand, Object aParams, boolean aBidirectionalCursor) { IRtCursor Result; TRtQuery xQuery; int i; int j; xQuery = GetAccess().NewQuery(); try { xQuery.SetCommand(aCommand); j = xQuery.GetParamCount() - 1; if (j >= 0) { if (VarIsArray(aParams)) { i = VarArrayHighBound(aParams, 1); if (i < j) { j = i; } for (i = 0; i <= j; ++i) { xQuery.GetParams(i).SetAsVariant(VarArrayGet(aParams, i)); } } else { xQuery.GetParams(0).SetAsVariant(aParams); } } } catch (Throwable any) { xQuery.Destroy(); throw wrap(any); } Result = xQuery; Result.Open(); return Result; } public final IRtCursor ExecuteSQL(String aCommand, Object aParams) { return ExecuteSQL(aCommand, aParams, false); } public final IRtCursor ExecuteSQLByConst(String aCommand, Object[] aParams, boolean aBidirectionalCursor) { return ExecuteSQL(aCommand, ArrayOfConstToVarArray(aParams)); } public final IRtCursor ExecuteSQLByConst(String aCommand, Object[] aParams) { return ExecuteSQLByConst(aCommand, aParams, false); } public final int GetNextKeyValue(boolean aUseSameTransaction, String aTableName, Object[] aValues, int aIncrement, boolean aIgnoreOldValues) { TStringList xCacheSelects; IRtIndexDef xIndexDef; String[] xStrValues = null; String xSelectFmt = ""; int i; xIndexDef = GetPKFromTable(this, aTableName); xStrValues = GenerateNextValueStrKeyValues(xIndexDef, aValues); if (!aIgnoreOldValues) { xCacheSelects = GetCacheSelectNextValue(); xSelectFmt = xCacheSelects.GetValue(aTableName); if (xSelectFmt.equals("")) { xSelectFmt = DBGenericFunctions().GenNextValueSelectFmt(xIndexDef); xCacheSelects.SetValue(aTableName, xSelectFmt); } for (i = 0; i <= xIndexDef.GetIndexFieldCount() - 2; ++i) { xSelectFmt = StringReplace(xSelectFmt, "$param", xStrValues[i], DelphiSet.get()); } } else { xSelectFmt = " "; } return DBGenericFunctions().GetNextValue(this, GenerateNextValueKey(aTableName, xStrValues), xSelectFmt, aIncrement, aUseSameTransaction || GetTransactionLevel() == 0); } public final int GetNextKeyValue(String aTableName, Object[] aValues) { return GetNextKeyValue(false, aTableName, aValues, 1, false); } public final void FreeKeyValue(String aTableName, Object[] aValues) { String[] xStrValues = null; xStrValues = GenerateNextValueStrKeyValues(GetPKFromTable(this, aTableName), aValues); DBGenericFunctions().FreeNextValueKey(this, GenerateNextValueKey(aTableName, xStrValues)); } public final int GetNextIDValue(boolean aUseSameTransaction, String aID, int aIncrement) { return DBGenericFunctions().GetNextValue(this, aID, " ", aIncrement, aUseSameTransaction || GetTransactionLevel() == 0); } public final int GetNextIDValue(String aID) { return GetNextIDValue(false, aID, 1); } public final void FreeIDValue(String aID) { DBGenericFunctions().FreeNextValueKey(this, aID); } final DelphiSet GetAccessOptions(IRtSQLStmt aSQLStmt) { IRtNativeStmt xStmt; xStmt = (IRtNativeStmt) aSQLStmt; return GetAccessOptions(xStmt.NativeStmtKind(), aSQLStmt.GetTableInfoArray()); } public final void SetOnCreateTemporaryTables(TRtOnCreateTemporaryTables Value) { FOnCreateTemporaryTables.run(); } public final void SetOnTableIsTemporary(TRtOnTableIsTemporary Value) { FOnTableIsTemporary = Value; } public int QueryInterface(Class IID, TReference Obj) { QueryInterface_Context ctx = new QueryInterface_Context(IID, Obj); return ctx.execute(); } int FDBVersionKind; private int FDBAccessKind; private double FDBDateTime; private long FTickCount; private boolean FGetDateFromDB; private String FName; private String FCompilErrs; private int FSQLProcessMode; private TRtCustomStorageList FStorageList; private TRtCustomTablePrivilegesList FTablePrivilegesList; private TStringList FSortLanguageList; private TComponent FComponentOwner; private int FRowSetSize; private TSQLWorks FSQLWorks; private IRtDBSecurityManager FIRtSecurityManager; TRtOnGetTableSecurityValues FOnGetTableSecurityValues; private TRtOnGetFieldSecurityValues FOnGetFieldSecurityValues; TRtOnGetTableEventValues FOnGetTableEventValues; TObject FParallelTimer; IRtDBConnection FParallelConn; private TStringList FCacheSelectNextValue; private TRtOnDeleteStorage FOnDeleteStorage; private TRtOnAddStorageIndexClustered FOnAddStorageIndexClustered; private TRtOnAddStorageLockEscalation FOnAddStorageLockEscalation; private TRtOnApplyLockEscalationInDb FOnApplyLockEscalationInDb; private TCustomAlterDefIndexCluster FCustomAlterDefValue; private final TStringList GetCacheSelectNextValue() { if (FCacheSelectNextValue == null) { FCacheSelectNextValue = TStringList.Create(); } return FCacheSelectNextValue; } private boolean MonitorTableVerify(int aCommandKind, String aTableName) { MonitorTableVerify_Context ctx = new MonitorTableVerify_Context(aCommandKind, aTableName); return ctx.execute(); } private boolean AccessTableVerify(int aCommandKind, TRtTableInfo aTableInfo, TRtTableInfo aAccessDenied) { AccessTableVerify_Context ctx = new AccessTableVerify_Context(aCommandKind, aTableInfo, aAccessDenied); return ctx.execute(); } private final void CheckOnOffIrEvent() { if (FRawDatabase != null && getPhyDatabase() == null) { FRawDatabase.setOnGetIRInfo(null); } else if (FRawDatabase != null && getPhyDatabase() != null) { TOnGetIRInfo proc = new TOnGetIRInfo() { public boolean run(String aIrName, TString aToTableName, TString aToFields, TString aFromTableName, TString aFromFields) { return getPhyDatabase().GetIrInfo(aIrName, aToTableName, aToFields, aFromTableName, aFromFields); } }; FRawDatabase.setOnGetIRInfo(proc); } } private final TRtDatabaseServer CheckOwnerServer() { return ((TRtDatabaseServer) CheckTypedOwner(TRtDatabaseServerClass.SINGLETON)); } public final void SetSQLProcessMode(int Value) { FSQLProcessMode = Value; } final void CatchErrors(String AErrMess, int aErrCode) { if (aErrCode != CERR_COMPILEERR) { FCompilErrs = FCompilErrs + AErrMess + EOL; } } public final TRtCCompiler GetSQLCompiler() { if (FSQLCompiler == null) { FSQLCompiler = TRtCCompilerSQL.Create(); ((TRtCCompilerSQL) FSQLCompiler).setCompileToEOF(true); ((TRtCCompilerSQL) FSQLCompiler).SetBNFData(TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetCBNFDataPtr()); TRtCCompilerShowErrorEvent proc = new TRtCCompilerShowErrorEvent() { public void run(String AErrMess, int aErrCode) { CatchErrors(AErrMess, aErrCode); } }; ((TRtCCompilerSQL) FSQLCompiler).setOnShowError(proc); } FCompilErrs = ""; return FSQLCompiler; } public final TRtDatabase GetAccess() { CheckIsOpen(); if (FRtDatabase == null) { FRtDatabase = FRawDatabase.GetAccess(); FRtDatabase.setDatabaseDef(FPhyDatabase); } return FRtDatabase; } public final void SetUseShortMessageError(boolean Value) { FRawDatabase.setUseShortMessageError(Value); } public final boolean GetUseShortMessageError() { return FRawDatabase.getUseShortMessageError(); } public final void SetName(String Value) { TRtDBConnection xDBConnection; xDBConnection = CheckOwnerServer().GetDbConnectionByName(Value); if (xDBConnection == null) { FName = Value; } else if (xDBConnection != this) { throw DelphiException.CreateFmt(TransStr("TC633", "Já existe uma conexão de banco de dados com este nome(%s)", true), new Object[] { Value }); } } public final int GetDBType() { return DbVersionKindWithDBAccessKind(FDBVersionKind, FDBAccessKind); } public final String GetUserName() { String Result = ""; switch (getDBAccessKind()) { case dbakBDE: Result = getParam().GetValues(cBDEUserName); break; case dbakDBXpressBorland: case dbakDBXpressODBC: Result = getParam().GetValues(cDBXUserName); break; case dbakOCI: Result = getParam().GetValues(cOCIUserName); break; default: break; } return Result; } public final String GetPassword() { String Result = ""; switch (getDBAccessKind()) { case dbakBDE: Result = getParam().GetValues(cBDEPassWord); break; case dbakDBXpressBorland: case dbakDBXpressODBC: Result = getParam().GetValues(cDBXPassword); break; case dbakOCI: Result = getParam().GetValues(cOCIPassword); break; default: break; } return Result; } private final double DWordToDateTime(long MSec) { return (double) MSec / 86400000; } private final double GetDBDateTimeWithTimeZone() { double Result; long xTickCount; xTickCount = GetTickCount(); Result = FDBDateTime + DWordToDateTime(xTickCount - FTickCount); if (FGetDateFromDB || FTickCount == 0 || FTickCount > xTickCount || Trunc(FDBDateTime) != Trunc(Result)) { FTickCount = xTickCount; FDBDateTime = (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).CurrentDateWithTimeZone(this); Result = FDBDateTime; } return Result; } private final double GetDBDateTimeWithoutTimeZone() { double Result; long xTickCount; xTickCount = GetTickCount(); if (FGetDateFromDB || FTickCount == 0 || FTickCount > xTickCount) { FTickCount = xTickCount; FDBDateTime = (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).CurrentDate(this); Result = FDBDateTime; } else { Result = FDBDateTime + DWordToDateTime(xTickCount - FTickCount); } return Result; } public final void SetUseTimeZone(boolean aUseTimeZone) { if (FUseTimeZone != aUseTimeZone) { FTickCount = 0; FUseTimeZone = aUseTimeZone; DBGenericFunctions().SetUseTimeZoneSqlGenerator(FUseTimeZone); } } protected TRtDatabaseServer FOwner; protected TRtDBRawDatabase FRawDatabase; protected TRtDatabase FRtDatabase; protected TDBParamStrings FParams; protected TRtDBInitializeProc FDBInitProc; protected TListOwner FSQLList; protected TRtDatabaseDef FPhyDatabase; protected TRtDatabaseDef FNewDatabase; protected boolean FCheckedDataTableSpace; protected String FDataTableSpace; protected boolean FCheckedIndexTableSpace; protected String FIndexTableSpace; protected boolean FIgnoreSortErrors; protected TRtCCompiler FSQLCompiler; protected boolean FNotUpdatePhyDatabase; protected boolean FDisableEvents; protected TRtSQLAssignTableDefEvent FOnBeforeAssignFromTableDef; protected TRtSQLAssignTableDefEvent FOnAfterAssignFromTableDef; protected TRtSQLAssignTableDefEvent FOnBeforeAssignToTableDef; protected TRtSQLAssignTableDefEvent FOnAfterAssignToTableDef; protected TRtSQLMustDropTableEvent FOnMustDropTable; protected TRtSQLMustDropStoredProcEvent FOnMustDropStoredProc; protected TRtSQLMustDropViewEvent FOnMustDropView; protected TRtSQLMustCreateViewEvent FOnMustCreateView; protected TRtSQLMustRenameTableEvent FOnMustRenameTable; protected TRtDDLErrorEvent FOnDDLError; protected TRtDDLStepEvent FOnBeforeDDLStep; protected TOnForceAlterTableMode FOnForceAlterTableMode; protected boolean FUseTimeZone; protected TRtSQLVerifyAssignObjectDef FOnVerifyAssignObjectDef; protected String FDBUserID; protected final void InitConnection(TRtDatabaseServer aOwner, int aDBAccessKind, int aDBVersionKind) { TDBParamStrings xParams; FOwner = aOwner; FDBAccessKind = aDBAccessKind; FDBVersionKind = aDBVersionKind; aOwner.AddConnectionItem(this); xParams = aOwner.GetConnectionParams(FDBAccessKind, FDBVersionKind); if (xParams != null) { FParams.Assign(xParams); } FDBInitProc = aOwner.GetDbInitializeProc(FDBVersionKind); if (vOnCreateDBConnection != null) { vOnCreateDBConnection.run(FDBAccessKind, FDBVersionKind); } } public final String GetDataTableSpace() { if (!FCheckedDataTableSpace && !FDataTableSpace.equals("")) { if (!(((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(getDBVersionKind()))).IsValidTableSpace(this, FDataTableSpace)) { FDataTableSpace = ""; } FCheckedDataTableSpace = true; } return FDataTableSpace; } public final void SetDataTableSpace(String aDataTableSpace) { FCheckedDataTableSpace = FCheckedDataTableSpace && CompareText(FDataTableSpace, Trim(aDataTableSpace)) == 0; FDataTableSpace = Trim(aDataTableSpace); } public final String GetIndexTableSpace() { if (!FCheckedIndexTableSpace && !FIndexTableSpace.equals("")) { if (!(((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(getDBVersionKind()))).IsValidTableSpace(this, FIndexTableSpace)) { FIndexTableSpace = ""; } FCheckedIndexTableSpace = true; } return FIndexTableSpace; } public final void SetIndexTableSpace(String aIndexTableSpace) { FCheckedIndexTableSpace = FCheckedIndexTableSpace && CompareText(FIndexTableSpace, Trim(aIndexTableSpace)) == 0; FIndexTableSpace = Trim(aIndexTableSpace); } protected final void AddSQL(TRtCustomSQL ASql) { if (FPhyDatabase == null) { if (!(ASql instanceof TRtCreateTable) && !(ASql instanceof TRtCreateIndex) && !(ASql instanceof TRtCreateProcedure) && !(ASql instanceof TRtDropProcedure) && !(ASql instanceof TRtCreateView) && !(ASql instanceof TRtDropView) && ASql instanceof TRtCustomDDL) { throw DelphiException.Create(TransStr("TC645", "É necessário definir o Database físico.", true)); } } ASql.InitSQLKernel(this); FSQLList.Add(ASql); ASql.SetFOwner(FSQLList); } public final void SetPhyDatabase(TRtDatabaseDef Value) { if (FSQLList.GetCount() > 0) { throw DelphiException.Create(TransStr("TC646", "Já existem objetos SQL em uso.", true)); } FreeAndNil(AsVar(FSQLWorks)); FPhyDatabase = Value; CheckOnOffIrEvent(); if (FRtDatabase != null) { FRtDatabase.setDatabaseDef(FPhyDatabase); } } public final void SetNewDatabase(TRtDatabaseDef Value) { FNewDatabase = Value; } public final TRtDatabaseDef GetNewDatabase() { TRtDatabaseDef Result; Result = FNewDatabase; if (Result == null) { Result = FPhyDatabase; } return Result; } protected final TSQLStatement InternalSelectSQLSenior_2(TRtDatabaseDef aDatabase, String aSelectSQLSenior_2, boolean aConsistTypes) { TSQLStatement Result; TSQLWorks xSQLWorks; xSQLWorks = TSQLWorks.Create(aDatabase); try { xSQLWorks.SetConsistTypes(aConsistTypes); Result = xSQLWorks.CompileStatement(aSelectSQLSenior_2); if (getRawDatabase().GetTransactionLevel() > 0 && vUseRowLockForDML) { if (Result.getStatement().Kind == skUpdate) { Result.getStatement().Update.TableRef.XLock = true; } else if (Result.getStatement().Kind == skDelete) { Result.getStatement().Delete.TableRef.XLock = true; } } } finally { xSQLWorks.Free(); } return Result; } protected final TSQLStatement InternalSelectSQLSenior_2(TRtDatabaseDef aDatabase, String aSelectSQLSenior_2) { return InternalSelectSQLSenior_2(aDatabase, aSelectSQLSenior_2, true); } protected final void CheckIsOpen() { if (!IsOpen()) { throw DelphiException.Create(TransStr("TC652", "A conexão está fechada.", true)); } } public final boolean GetInTransaction() { CheckIsOpen(); return FRawDatabase.GetInTransaction(); } public final int GetSQLObjectCount() { return FSQLList.GetCount(); } public final TRtCustomSQL GetSQLObjects(int Index) { return ((TRtCustomSQL) FSQLList.Get(Index)); } protected final void ExecuteInitSqlCommands() { TReference xNativeComProc = new TReference(); IRtDBCommandProcessor xComProc; String xCommands = ""; TInt xPChar = new TInt(); String xCommand = ""; int i; i = getParam().IndexOfName(cGlobalInitSqlCommands); if (i != -1) { xCommands = getParam().GetValuesByIndex(i); xPChar.v = 0; xCommand = StrGetNextToken(xCommands, xPChar, ";"); xComProc = NewDBCommandProcessor(); xComProc.QueryInterface(IRtDBNativeCommandProcessor.class, xNativeComProc); Assert(xNativeComProc.v != null, TransStr("TC647", "IRtDBNativeCommandProcessor não suportado", true)); xNativeComProc.v.SetNativeSQL(true); while (!xCommand.equals("")) { xNativeComProc.v.SetCommand(xCommand); try { xNativeComProc.v.Execute(); } catch (DelphiException E) { //Application.MessageBox(((CharPointer) TransStrFmt("TC3293", "Erro executando comandos de inicialização%0:s Verifique o seu Arquivo de configuração(*.CFG)%1:s Error(\"%2:s\")", new Object[] { '\r', '\r', E.getMessage() }, true)), ((CharPointer) TransStr("TC89", "Erro")), MB_OK | MB_ICONERROR); throw pending(); } xCommand = StrGetNextToken(xCommand, xPChar, ";"); } } RegisterSortInfo(getName(), (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).GetSortInfo(this, FIgnoreSortErrors)); } public final TSQLWorks GetSQLWorks() { if (FSQLWorks == null) { FSQLWorks = TSQLWorks.Create(FPhyDatabase); } return FSQLWorks; } public final int GetDBKind() { return DbVersionKindToDbKind(getDBVersionKind()); } public final int GetDBConnectedVersionKind() { return (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).GetDbVersionKind(this); } public final boolean GetEnabledSortLanguage() { return FSortLanguageList != null; } public final void SetEnabledSortLanguage(boolean aValue) { if (aValue) { if (FSortLanguageList == null) { FSortLanguageList = TStringList.Create(); } } else { FreeAndNil(AsVar(FSortLanguageList)); } } public final boolean GetUseCollationRule() { boolean Result; Result = false; try { if (DelphiSet.get(dbkOracle, dbkSQLServer, dbkDB2, dbkSybSvr).contains(DbVersionKindToDbKind(FDBVersionKind))) { Result = StrToIntDef(DoR900GPRGetFlagValue(this, cFlagSortMode), 0) >= StrToInt(cFlagSortMode_CollationRule); } } catch (ERtDBObjectNotFound any) {} return Result; } public final void SetUseCollationRule(boolean aValue) { try { if (DoR900GPRGetFlagValue(this, cFlagSortMode).equals(ToStr(cFlagSortMode_BD))) { throw DelphiException.Create(TransStr("TC675", "Já está sendo usado linguagem do banco de dados para ordenação, por isso a regra não pode ser configurada.", true)); } if (aValue) { DoR900GPRSetFlag(this, cFlagSortMode, ToStr(cFlagSortMode_CollationRule)); } else { DoR900GPRSetFlag(this, cFlagSortMode, ToStr(cFlagSortMode_Binary)); } } catch (ERtDBObjectNotFound any) {} } public final String GetCollationRule(int aRuleCode) { String Result = ""; IRtDBCommandProcessor xCmdProc; IRtCursor xCursor; TStringList xText; xCmdProc = NewDBCommandProcessor(); xCmdProc.SetCommand("select SeqRul, RulStr from R999RUL where CodRul = :CodRul order by SeqRul"); xCmdProc.GetParam(0).SetAsInteger(aRuleCode); xCursor = xCmdProc.Open(); xText = TStringList.Create(); try { while (xCursor.Next()) { xText.Add(xCursor.GetField(1).GetAsString()); } Result = xText.GetTextStr(); } finally { xText.Destroy(); } return Result; } public final void SetCollationRule(int aRuleCode, String aRuleText) { IRtDBCommandProcessor xCmdProc; TStringList xText; int i; xCmdProc = NewDBCommandProcessor(); xCmdProc.SetCommand("delete R999RUL where CodRul = :CodRul"); xCmdProc.GetParam(0).SetAsInteger(aRuleCode); xCmdProc.Execute(); xCmdProc.SetCommand("insert into R999RUL (CodRul, SeqRul, RulStr) values (:CodRul, :SeqRul, :RulStr)"); xCmdProc.GetParam(0).SetAsInteger(aRuleCode); xText = TStringList.Create(); try { xText.SetTextStr(aRuleText); i = 0; while (i < xText.GetCount()) { xCmdProc.GetParam(1).SetAsInteger(i); xCmdProc.GetParam(2).SetAsString(xText.Get(i)); xCmdProc.Execute(); i++; } } finally { xText.Destroy(); } } protected final void runCreateConnection(TRtDatabaseServer AOwner, int aDBAccessKind, int aDBVersionKind) { runCreate(); InitConnection(AOwner, aDBAccessKind, aDBVersionKind); } protected static TRtDBConnection CreateConnection(TRtDatabaseServer AOwner, int aDBAccessKind, int aDBVersionKind) { TRtDBConnection Result; Result = new TRtDBConnection(); Result.runCreateConnection(AOwner, aDBAccessKind, aDBVersionKind); return Result; } boolean FInBusinessTransaction; boolean FInBusinessOperation; int FBusinessTransactionId; private TRtTranEvent fBeforeCommitRollback = new TRtTranEvent() { public void run(IRtDBConnection aConn) { BeforeCommitRollbackEvent(aConn); } }; private TRtTranEvent fExecBeforeCommit = new TRtTranEvent() { public void run(IRtDBConnection aConn) { ReplG6Functions().ExecBeforeCommit(aConn); } }; private TRtTranEvent BeforeBeginTran = new TRtTranEvent() { public void run(IRtDBConnection aConn) { ReplG6Functions().ExecBeforeBeginTran(aConn); } }; private TRtTranEvent AfterEndTran = new TRtTranEvent() { public void run(IRtDBConnection aConn) { ReplG6Functions().ExecAfterEndTran(aConn); } }; final void CheckNotInBusinessTransaction() { if (FInBusinessTransaction) { throw DelphiException.Create(TransStr("TC6534", "Existe uma transação de negócio ativa.")); } } final void CheckNotInBusinessOperation() { if (FInBusinessOperation) { throw DelphiException.Create(TransStr("TC6535", "Existe uma operação de negócio ativa.")); } } private final void CheckInBusinessTransaction() { if (!FInBusinessTransaction) { throw DelphiException.Create(TransStr("TC6536", "Não existe uma transação de negócio ativa.")); } } final void CheckInBusinessOperation() { if (!FInBusinessOperation) { throw DelphiException.Create(TransStr("TC6537", "Não existe uma operação de negócio ativa.")); } } final void CheckNotInTransaction() { if (GetInTransaction()) { throw DelphiException.Create(TransStr("TC6538", "Já existe uma transação ativa.")); } } final void CheckRootTransactionLevel() { if (FRawDatabase.GetTransactionLevel() > 1) { throw DelphiException.Create(TransStr("TC6540", "Operação não permitida. Existem outras transações ativas.")); } } private final void CheckCommitRollbackPermission() { if ((FInBusinessTransaction || FInBusinessOperation) && FRawDatabase.GetTransactionLevel() == 1) { throw DelphiException.Create(TransStr("TC6539", "Operação não permitida sobre uma transação de negócio.")); } } final void BeforeCommitRollbackEvent(IRtDBConnection aConn) { CheckCommitRollbackPermission(); } public int StartBusinessTransaction() { StartBusinessTransaction_Context ctx = new StartBusinessTransaction_Context(); return ctx.execute(); } public final int CurrentBusinessTransactionId() { int Result; if (FInBusinessTransaction) { Result = FBusinessTransactionId; } else { Result = -1; } return Result; } public final void CommitBusinessTransaction() { IRtDBCommandProcessor Cmd; CheckInBusinessTransaction(); CheckNotInBusinessOperation(); CheckRootTransactionLevel(); Cmd = NewDBCommandProcessor(); Cmd.SetCommand("delete from R999TRD where CodTra = :CodTra"); Cmd.ParamByName("CodTra").SetAsInteger(FBusinessTransactionId); Cmd.Prepare(); Cmd.Execute(); Cmd.SetCommand("delete from R999TRA where CodTra = :CodTra"); Cmd.ParamByName("CodTra").SetAsInteger(FBusinessTransactionId); Cmd.Prepare(); if (Cmd.Execute() != 1) { throw DelphiException.Create("Erro ao finalizar a transação de negócio."); } FInBusinessTransaction = false; try { Commit(); } catch (Throwable any) { FInBusinessTransaction = true; throw wrap(any); } FBusinessTransactionId = -1; } public final void RollbackBusinessTransaction() { CheckInBusinessTransaction(); CheckNotInBusinessOperation(); CheckRootTransactionLevel(); FInBusinessTransaction = false; try { Rollback(); } catch (Throwable any) { FInBusinessTransaction = true; throw wrap(any); } FBusinessTransactionId = -1; FInBusinessTransaction = false; } public final void BeginBusinessOperation(int BusinessTransactionId) { CheckNotInBusinessTransaction(); CheckNotInBusinessOperation(); CheckNotInTransaction(); BeginTran(); FInBusinessOperation = true; FBusinessTransactionId = BusinessTransactionId; } public void CommitBusinessOperation(String UndoData) { CommitBusinessOperation_Context ctx = new CommitBusinessOperation_Context(UndoData); ctx.execute(); } public final void RollbackBusinessOperation() { CheckNotInBusinessTransaction(); CheckInBusinessOperation(); CheckRootTransactionLevel(); FInBusinessOperation = false; try { Rollback(); } catch (Throwable any) { FInBusinessOperation = true; throw wrap(any); } FBusinessTransactionId = -1; } public void runCreate() { super.runCreate(); FRawDatabase = null; FRtDatabase = null; FPhyDatabase = null; FParams = TDBParamStrings.Create(); FSQLList = ((TListOwner) Creator(this, TListOwnerClass.SINGLETON)); SetSQLProcessMode(spmIndividual); FStorageList = TRtCustomStorageList.Create(this); FTablePrivilegesList = TRtCustomTablePrivilegesList.Create(); FIgnoreSortErrors = true; FDBDateTime = 0.0; FTickCount = 0; FGetDateFromDB = false; FDBUserID = ""; FOnGetTableSecurityValues = null; FOnGetFieldSecurityValues = null; FOnGetTableEventValues = null; FInBusinessTransaction = false; FInBusinessOperation = false; FBusinessTransactionId = -1; } public static TRtDBConnection Create() { TRtDBConnection Result; Result = new TRtDBConnection(); Result.runCreate(); return Result; } public void Destroy() { int xDBAccessKind; int xDBVersionKind; xDBAccessKind = FDBAccessKind; xDBVersionKind = FDBVersionKind; if (IsOpen()) { Close(); } FSQLWorks.Free(); FSQLList.Free(); FParams.Free(); FStorageList.Free(); FTablePrivilegesList.Free(); FreeAndNil(AsVar(FSortLanguageList)); ((TRtCCompilerSQL) FSQLCompiler).Free(); FCacheSelectNextValue.Free(); super.Destroy(); if (vOnDestroyDBConnection != null) { vOnDestroyDBConnection.run(xDBAccessKind, xDBVersionKind); } } public final void Open() { if (!IsOpen()) { DBGenericFunctions().CheckKernelOptions(FDBAccessKind, FDBVersionKind); FRawDatabase = (((TRtDatabaseServer) CheckOwnerServer())).NewRawDataBase(FDBAccessKind, FDBVersionKind, FParams, this); try { CheckOnOffIrEvent(); if (FDBInitProc != null) { FDBInitProc.run(this); } ExecuteInitSqlCommands(); if (ReplG6Functions().GetInReplG6(this) && ReplG6Functions().ExistsTablesToRepl(this)) { EnableReplG6(); } try { if (FDBVersionKind != dbvkSenior) { FGetDateFromDB = SameText(DoR900GPRGetFlagValue(this, cGetDateTimeFromDB), cGetDateTimeFromDBTrue); } else { FGetDateFromDB = false; } } catch (Throwable any) { FGetDateFromDB = false; } } catch (Throwable any) { Close(); throw wrap(any); } GetAccess().getBeforeCommit().AddEvent(fBeforeCommitRollback); GetAccess().getBeforeRollBack().AddEvent(fBeforeCommitRollback); } } public final void Close() { if (IsOpen()) { GetAccess().getBeforeCommit().RemoveEvent(fBeforeCommitRollback); GetAccess().getBeforeRollBack().RemoveEvent(fBeforeCommitRollback); FRawDatabase.getDBRawSessionOwner().DeleteDBRawDataBase(FRawDatabase); FRawDatabase = null; FRtDatabase = null; CheckOnOffIrEvent(); } } public final boolean IsOpen() { return FRawDatabase != null; } public final TRtDBConnection CloneConnection() { TRtDBConnection Result; Result = (((TRtDatabaseServer) GetTypedOwner(TRtDatabaseServerClass.SINGLETON))).NewDBConnection(FDBAccessKind, FDBVersionKind); Result.FIgnoreSortErrors = FIgnoreSortErrors; Result.FParams.Assign(FParams); Result.SetPhyDatabase(FPhyDatabase); if (IsOpen()) { Result.Open(); } return Result; } public void Assign(TPersistent Source) { if (Source instanceof TRtDBConnection) { if (IsOpen()) { Close(); } FSQLList.Clear(); SetPhyDatabase(((TRtDBConnection) Source).FPhyDatabase); FParams.Assign(((TRtDBConnection) Source).FParams); FSQLList.Assign(((TRtDBConnection) Source).FSQLList); } else { super.Assign(Source); } } public void ReadData(TReader Reader) { Assert(false, "TRtDBConnection.ReadData"); } public void WriteData(TWriter Writer) { Assert(false, "TRtDBConnection.WriteData"); } public final void BeginTran() { CheckIsOpen(); FRawDatabase.BeginTransaction(); } public final void Commit() { CheckIsOpen(); FRawDatabase.Commit(); } public final void Rollback() { CheckIsOpen(); FRawDatabase.RollBack(); } public final double GetDBDateTime() { double Result; if (FUseTimeZone) { Result = GetDBDateTimeWithTimeZone(); } else { Result = GetDBDateTimeWithoutTimeZone(); } return Result; } public final String GetDBUserID() { if (FDBUserID.equals("")) { FDBUserID = (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).GetDBUserID(this, this.GetUserName()); } return FDBUserID; } public final String GetDBUserInfoForBaseType() { return GetDBUserID(); } public final double GetDBUserCreatedDate() { return (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).GetDBUserCreatedDate(this); } public final boolean TableExists(String ATableName) { return (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).TableExists(this, ATableName); } public final boolean SynonymExists(String ATableName) { return (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).SynonymExists(this, ATableName); } public final boolean StoredProcExists(String ASPName, TBoolean _enabled) { return (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).SPExists(this, ASPName, _enabled); } public final boolean ViewExists(String _ViewName, TBoolean _enabled) { return (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).ViewExists(this, _ViewName, _enabled); } public final boolean TriggerExists(String _TriggerName, String _TableName, TBoolean _Enabled) { return (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).TriggerExists(this, _TriggerName, _TableName, _Enabled); } public final TStringList GetStoredProcsFromDB() { return (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).GetStoredProcs(this); } public final TStringList GetTriggersFromDB(String aTriggersPrefix) { return (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).GetTriggers(this, aTriggersPrefix); } public final TStringList GetTriggersFromDB() { return GetTriggersFromDB(""); } public final TStringList GetViewsFromDB(String aPrefixName) { return (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).GetViews(this, aPrefixName); } public final void AddTemporaryTable(String aTableName) { (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).AddTableAsTemporary(this, aTableName); } public final String GetOldTablesPattern() { return (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).GetOldTablesPattern(); } public final String GetErrTablesPattern() { return (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).GetErrTablesPattern(); } public final TStrings GetTablesFromDB(String aPattern) { return (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).GetTables(this, aPattern); } public final void DropAllTriggersFromDB(TStrings AScript, TStrings ALog, TRtOnUpdateProgress aOnProgress) { (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).DropAllTriggersFromDB(this, AScript, ALog, aOnProgress); } public final void DropAllStoredProcsFromDB(TStrings AScript, TStrings ALog, TRtOnUpdateProgress aOnProgress) { (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).DropAllStoredProcsFromDB(this, AScript, ALog, aOnProgress); } public final void DropViewsFromDB(String aPrefixName, TStrings aScript, TStrings aLog, TRtOnUpdateProgress aOnProgress) { (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).DropViewsFromDB(this, aPrefixName, aScript, aLog, aOnProgress); } public final DelphiSet GetAccessOptions(int aStmtKind, TRtTableInfo[] aTableInfo) { DelphiSet Result = DelphiSet.get(); TRtTableInfo xTableDenied = new TRtTableInfo(); int i; Result = DelphiSet.get(); for (i = Low(aTableInfo); i <= High(aTableInfo); ++i) { if (!Result.contains(aoLog) && MonitorTableVerify(aStmtKind, aTableInfo[i].TableName)) { Result = Result.add(DelphiSet.get(aoLog)); } if (!AccessTableVerify(aStmtKind, aTableInfo[i], xTableDenied)) { Result = Result.add(DelphiSet.get(aoAccessDenied)); } } return Result; } public final void LoadNativeStoredProc() { (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).LoadNativeStoredProc(this); } public final boolean LoadSortLanguage() { return (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).LoadSortLanguage(this); } public final void LoadStorageFromPhyDataBase() { (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).LoadStorageFromPhyDataBase(this); } public final void LoadStorageFromDB() { (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).LoadStorageFromDB(this); } public final String LoadStorageFromStream(TStream aStream, String aDBVersionKindName) { aDBVersionKindName = (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).LoadStorageFromStream(this, aStream, aDBVersionKindName); return aDBVersionKindName; } public final void SaveStorageFromDBToStream(TStream aStream) { (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).SaveStorageFromDBToStream(this, aStream); } public final void LoadPrivilegesFromPhyDatabase() { (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).LoadPrivilegesFromPhyDatabase(this); } public final TRtDbRevEng GetDbAnalyzer(TRtDatabaseDef ADatabase) { return (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).GetDbAnalyzer(this, ADatabase); } public final void CreateUser(TStrings aParams) { (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).CreateUser(this, aParams); } public final void ConsistViews(TRtDatabaseDef _OldDataBase, TRtDatabaseDef _NewDataBase) { (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).ConsistViews(this, _OldDataBase, _NewDataBase); } public final void ConsistViewsToUser(TRtDatabaseDef _DataBase) { (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).ConsistViewsToUser(this, _DataBase); } public final int GetDBViewsStatus(String aViewName) { return (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).GetDBViewStatus(this, aViewName); } public final IRtCursor GetTableListWithIncompatiblePhyTypes(TRtDatabaseDef _DataBase) { return (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).GetTableListWithIncompatiblePhyTypes(this, _DataBase); } public final void ConsistStoredProc(TRtDatabaseDef _OldDataBase, TRtDatabaseDef _NewDataBase, TRtGetConversionProp aGetConversionProp) { (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).ConsistStoredProc(this, _OldDataBase, _NewDataBase, aGetConversionProp); } public final int GetDBStoredProcStatus(String aStoredProcName) { return (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).GetDBStoredProcsStatus(this, aStoredProcName); } public final void ConsistDependences(TRtDatabaseDef _OldDataBase, TRtDatabaseDef _NewDataBase) { (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).ConsistDependences(this, _OldDataBase, _NewDataBase); } public final void ConsistTriggers(TRtDatabaseDef _OldDataBase, TRtDatabaseDef _NewDataBase) { (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).ConsistTriggers(this, _OldDataBase, _NewDataBase); } public final int GetDBTriggerStatus(TRtTableDef aTableDef, String aTableName, String aTriggerName) { return (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).GetDBTriggerStatus(this, aTableDef, aTableName, aTriggerName); } public final void ConsistTriggerFromTableDef(TRtTableDef _TableDef, int _Option) { (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).ConsistTriggerFromTableDef(this, _TableDef, _Option); } public final void CreateTableFromDef(TRtTableDef TblDef) { CheckIsOpen(); { TRtCreateTable context = ((TRtCreateTable) TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(sckCreateTable, FDBVersionKind)); try { context.AssignFromTableDef(TblDef, DelphiSet.getRange(raaColumns, raaForeignKeys)); context.ExecuteUpd(); } finally { context.Free(); } } } public final void AlterTableFromDef(TRtTableDef NewTblDef) { CheckIsOpen(); { TRtAlterTable context = ((TRtAlterTable) TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(sckAlterTable, FDBVersionKind)); try { context.AssignFromTableDef(NewTblDef, DelphiSet.getRange(raaColumns, raaForeignKeys)); context.ExecuteUpd(); } finally { context.Free(); } } } public void AssignFromDatabaseDef(int aLevelAlterTableMode, TRtDatabaseDef NewDbDef, DelphiSet AAssOpt, TRtGetConversionProp aGetConversionProp) { AssignFromDatabaseDef_Context ctx = new AssignFromDatabaseDef_Context(aLevelAlterTableMode, NewDbDef, AAssOpt, aGetConversionProp); ctx.execute(); } public final void DisableForeignKeys(TRtTableDef TblDef) { int I; CheckIsOpen(); { TRtCreateTable context = ((TRtCreateTable) TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(sckAlterTable, FDBVersionKind)); try { context.AssignFromTableDef(TblDef, DelphiSet.get(raaForeignKeys)); for (I = 0; I <= context.FForeignKeys.GetCount() - 1; ++I) { context.FForeignKeys.GetItem(I).FOption = rcaDrop; } context.ExecuteUpd(); } finally { context.Free(); } } } public final void EnableForeignKeys(TRtTableDef TblDef) { CheckIsOpen(); { TRtCreateTable context = ((TRtCreateTable) TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(sckAlterTable, FDBVersionKind)); try { context.AssignFromTableDef(TblDef, DelphiSet.get(raaForeignKeys)); context.ExecuteUpd(); } finally { context.Free(); } } } public final void DisableAllForeignKeys() { int I; CheckIsOpen(); for (I = 0; I <= FPhyDatabase.GetTableCount() - 1; ++I) { DisableForeignKeys(FPhyDatabase.GetTable(I)); } } public final void EnableAllForeignKeys() { int I; CheckIsOpen(); for (I = 0; I <= FPhyDatabase.GetTableCount() - 1; ++I) { EnableForeignKeys(FPhyDatabase.GetTable(I)); } } public final String SeniorSqlToNativeSql(String aSql) { String Result = ""; TRtCustomSQL SqlObject; TStringList SourceParams; TStringList ReplaceParams; int i; int ii; String Par = ""; String Rep = ""; String xSql = ""; xSql = aSql; SourceParams = TStringList.Create(); ReplaceParams = TStringList.Create(); i = Pos("{", xSql); while (i > 0) { Par = ""; Rep = ":P" + IntToStr(SourceParams.GetCount()); ii = Pos('}', xSql) - i + 1; if (ii == 0) { ii = Length(xSql) - i + 1; } Par = Copy(xSql, i, ii); SourceParams.Add(Par); ReplaceParams.Add(Rep); xSql = Delete(xSql, i, ii); xSql = Insert(Rep, xSql, i); i = Pos("{", xSql); } SqlObject = SQLObjectFrom(xSql); try { Result = SqlObject.GenSQL(); while (SourceParams.GetCount() > 0) { Par = ReplaceParams.Get(0); Rep = SourceParams.Get(0); i = Pos(Par, Result); if (i == 0) { i = Pos(LowerCase(Par), Result); Rep = LowerCase(Rep); } ii = Length(Par); Result = Delete(Result, i, ii); Result = Insert(Rep, Result, i); SourceParams.Delete(0); ReplaceParams.Delete(0); } } finally { SqlObject.Free(); SourceParams.Free(); ReplaceParams.Free(); } return Result; } public final String SeniorSqlToNativeSql(TStatement aStatement) { return DBGenericFunctions().SeniorSqlToNativeSql(aStatement); } public final String SeniorSql_2ToNativeSql(String aSqlSenior_2, boolean aConsistTypes) { String Result = ""; TSQLStatement xSQLStatement; xSQLStatement = SelectSQLSenior_2(aSqlSenior_2, aConsistTypes); try { Result = SeniorSqlToNativeSql(xSQLStatement.getStatement()); } finally { xSQLStatement.Free(); } return Result; } public final String SeniorSql_2ToNativeSql(String aSqlSenior_2) { return SeniorSql_2ToNativeSql(aSqlSenior_2, true); } public final IRtStmt NewStmtFromCommand(String aCommand) { return NewNativeStmtFromCommand(aCommand); } public final void ClearSQLObjects() { FSQLList.Clear(); } public final TSQLStatement SelectSQLSenior_2(String aSelectSQLSenior_2, boolean aConsistTypes) { return InternalSelectSQLSenior_2(getPhyDatabase(), aSelectSQLSenior_2, aConsistTypes); } public final TSQLStatement SelectSQLSenior_2(String aSelectSQLSenior_2) { return SelectSQLSenior_2(aSelectSQLSenior_2, true); } public final TRtCustomSQL SQLObjectFrom(String ASql) { TRtCustomSQL Result; TRtCCompiledNodeList CompiledList; if (TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetCBNFDataPtr() == null) { throw DelphiException.Create(TransStr("TC653", "Não foi definido nenhum arquivo de layout de compilação.", true)); } Result = null; (((TRtCCompilerSQL) GetSQLCompiler())).SetPhyDatabase(FPhyDatabase); try { CompiledList = (((TRtCCompilerSQL) GetSQLCompiler())).Compile(ASql); if (CompiledList == null) { Abort(); } try { if (CompiledList.GetItems(0).getSubNodes().GetItems(0) instanceof TRtCCompiledNodeSQL) { Result = (((TRtCCompiledNodeSQL) CompiledList.GetItems(0).getSubNodes().GetItems(0))).CreateSQL(this, Result); } if (Result instanceof TRtSelect) { try { ((TRtSelect) Result).CheckUnresolvedRefs(); } catch (Throwable any) { Result.Free(); throw wrap(any); } } } finally { CompiledList.Free(); } } catch (ECCompiler E) { throw DelphiException.Create(TransStr("TC654", "Erro na compilação: ", true) + EOL + FCompilErrs); } catch (DelphiException E) { throw DelphiException.Create(TransStr("TC654", "Erro na compilação: ", true) + EOL + E.getMessage()); } return Result; } public final TRtCustomSQL AddCopySQLObject(TRtCustomSQL ASql) { TRtCustomSQL Result; if (ASql == null) { throw DelphiException.Create(TransStr("TC537", "Parâmetro nulo.", true)); } Result = TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(ASql.GetSQLClassesKind(), FDBVersionKind); try { AddSQL(Result); Result.Assign(ASql); } catch (Throwable any) { Result.Free(); throw wrap(any); } return Result; } public final TRtCreateTable SQLCreateTable() { TRtCreateTable Result; Result = ((TRtCreateTable) TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(sckCreateTable, FDBVersionKind)); try { AddSQL(Result); } catch (Throwable any) { Result.Free(); throw wrap(any); } return Result; } public final TRtAlterTable SQLAlterTable() { TRtAlterTable Result; Result = ((TRtAlterTable) TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(sckAlterTable, FDBVersionKind)); try { AddSQL(Result); } catch (Throwable any) { Result.Free(); throw wrap(any); } return Result; } public final TRtDropTable SQLDropTable() { TRtDropTable Result; Result = ((TRtDropTable) TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(sckDropTable, FDBVersionKind)); try { AddSQL(Result); } catch (Throwable any) { Result.Free(); throw wrap(any); } return Result; } public final TRtCreateTrigger SQLCreateTrigger() { TRtCreateTrigger Result; Result = ((TRtCreateTrigger) TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(sckCreateTrigger, FDBVersionKind)); try { AddSQL(Result); } catch (Throwable any) { Result.Free(); throw wrap(any); } return Result; } public final TRtDropTrigger SQLDropTrigger() { TRtDropTrigger Result; Result = ((TRtDropTrigger) TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(sckDropTrigger, FDBVersionKind)); try { AddSQL(Result); } catch (Throwable any) { Result.Free(); throw wrap(any); } return Result; } public final TRtCreateProcedure SQLCreateProcedure() { TRtCreateProcedure Result; Result = ((TRtCreateProcedure) TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(sckCreateProcedure, FDBVersionKind)); try { AddSQL(Result); } catch (Throwable any) { Result.Free(); throw wrap(any); } return Result; } public final TRtDropProcedure SQLDropProcedure() { TRtDropProcedure Result; Result = ((TRtDropProcedure) TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(sckDropProcedure, FDBVersionKind)); try { AddSQL(Result); } catch (Throwable any) { Result.Free(); throw wrap(any); } return Result; } public final TRtRenameTable SQLRenameTable() { TRtRenameTable Result; Result = ((TRtRenameTable) TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(sckRenameTable, FDBVersionKind)); try { AddSQL(Result); } catch (Throwable any) { Result.Free(); throw wrap(any); } return Result; } public final TRtCreateIndex SQLCreateIndex() { TRtCreateIndex Result; Result = ((TRtCreateIndex) TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(sckCreateIndex, FDBVersionKind)); try { AddSQL(Result); } catch (Throwable any) { Result.Free(); throw wrap(any); } return Result; } public final TRtDropIndex SQLDropIndex() { TRtDropIndex Result; Result = ((TRtDropIndex) TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(sckDropIndex, FDBVersionKind)); try { AddSQL(Result); } catch (Throwable any) { Result.Free(); throw wrap(any); } return Result; } public final TRtCreateView SQLCreateView() { TRtCreateView Result; Result = ((TRtCreateView) TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(sckCreateView, FDBVersionKind)); try { AddSQL(Result); } catch (Throwable any) { Result.Free(); throw wrap(any); } return Result; } public final TRtDropView SQLDropView() { TRtDropView Result; Result = ((TRtDropView) TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(sckDropView, FDBVersionKind)); try { AddSQL(Result); } catch (Throwable any) { Result.Free(); throw wrap(any); } return Result; } public final TRtBeginTran SQLBeginTran() { TRtBeginTran Result; Result = ((TRtBeginTran) TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(sckBeginTran, FDBVersionKind)); try { AddSQL(Result); } catch (Throwable any) { Result.Free(); throw wrap(any); } return Result; } public final TRtSetTransaction SQLSetTransaction() { TRtSetTransaction Result; Result = ((TRtSetTransaction) TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(sckSetTransaction, FDBVersionKind)); try { AddSQL(Result); } catch (Throwable any) { Result.Free(); throw wrap(any); } return Result; } public final TRtSavePoint SQLSavePoint() { TRtSavePoint Result; Result = ((TRtSavePoint) TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(sckSavePoint, FDBVersionKind)); try { AddSQL(Result); } catch (Throwable any) { Result.Free(); throw wrap(any); } return Result; } public final TRtRollBack SQLRollBack() { TRtRollBack Result; Result = ((TRtRollBack) TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(sckRollBack, FDBVersionKind)); try { AddSQL(Result); } catch (Throwable any) { Result.Free(); throw wrap(any); } return Result; } public final TRtCommit SQLCommit() { TRtCommit Result; Result = ((TRtCommit) TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(sckCommit, FDBVersionKind)); try { AddSQL(Result); } catch (Throwable any) { Result.Free(); throw wrap(any); } return Result; } public final TRtDeleteFrom SQLDeleteFrom() { TRtDeleteFrom Result; Result = ((TRtDeleteFrom) TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(sckDeleteFrom, FDBVersionKind)); try { AddSQL(Result); } catch (Throwable any) { Result.Free(); throw wrap(any); } return Result; } public final TRtInsertSelectInto SQLInsertSelectInto() { TRtInsertSelectInto Result; Result = ((TRtInsertSelectInto) TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(sckInsertSelectInto, FDBVersionKind)); try { AddSQL(Result); } catch (Throwable any) { Result.Free(); throw wrap(any); } return Result; } public final TRtInsertInto SQLInsertInto() { TRtInsertInto Result; Result = ((TRtInsertInto) TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(sckInsertInto, FDBVersionKind)); try { AddSQL(Result); } catch (Throwable any) { Result.Free(); throw wrap(any); } return Result; } public final TRtUpdate SQLUpdate() { TRtUpdate Result; Result = ((TRtUpdate) TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(sckUpdate, FDBVersionKind)); try { AddSQL(Result); } catch (Throwable any) { Result.Free(); throw wrap(any); } return Result; } public final TRtSelect SQLSelect() { TRtSelect Result; Result = ((TRtSelect) TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(sckSelect, FDBVersionKind)); try { AddSQL(Result); } catch (Throwable any) { Result.Free(); throw wrap(any); } return Result; } public final TRtDBGenericFunctionsClass DBGenericFunctions() { return TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbGenericFunctionsClass(getDBVersionKind()); } public final TRtReplG6FunctionsClass ReplG6Functions() { return TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetReplG6FunctionsClass(getDBVersionKind()); } public final boolean DisableReplG6() { boolean Result; Result = GetAccess().getBeforeBeginTran() != null; if (Result) { GetAccess().setBeforeBeginTran(null); GetAccess().setAfterEndTran(null); GetAccess().getBeforeCommit().RemoveEvent(fExecBeforeCommit); ReplG6Functions().DisableRepl(this); } return Result; } public final void EnableReplG6() { try { ReplG6Functions().InitControlObjects(this); GetAccess().setBeforeBeginTran(BeforeBeginTran); GetAccess().getBeforeCommit().AddEvent(fExecBeforeCommit); GetAccess().setAfterEndTran(AfterEndTran); } catch (Throwable any) { //Application.MessageBox(((CharPointer) TransStrFmt("TC3294", "A base de dados está marcada para integração com G6, mas alguns objetos estão " + "corrompidos ou não foram encontrados.%0:s" + "É necessário executar uma consistência de base para corrigir esta situação.", new Object[] { '\r' }, true)), ((CharPointer) TransStr("TC89", "Erro")), MB_OK | MB_ICONERROR); throw pending(); } } public final void DisableDBTrace() { getRawDatabase().DisableDBTrace(); } public final void EnableDBTrace() { getRawDatabase().EnableDBTrace(); } public final void SetIdleTimeoutEvent(TOnIdleTimeout aEvent) { //getRawDatabase().SetOnIdleTimeout(aEvent); throw pending(); } public final String TranslateTemporaryTableName(String aTableName) { String Result = ""; Result = aTableName; if (getOnTableIsTemporary() != null && getOnTableIsTemporary().run(aTableName)) { Result = (((TRtDbCatalogsClass) TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetDbCatalogsClass(FDBVersionKind))).TranslateTemporaryTableName(aTableName); } return Result; } public TRtDBConnectionClass ClassType() { return TRtDBConnectionClass.SINGLETON; } public int getSQLProcessMode() { return FSQLProcessMode; } public void setDisableEvents(boolean value) { FDisableEvents = value; } public boolean getDisableEvents() { return FDisableEvents; } public void setOnBeforeAssignFromTableDef(TRtSQLAssignTableDefEvent value) { FOnBeforeAssignFromTableDef = value; } public TRtSQLAssignTableDefEvent getOnBeforeAssignFromTableDef() { return FOnBeforeAssignFromTableDef; } public void setOnAfterAssignFromTableDef(TRtSQLAssignTableDefEvent value) { FOnAfterAssignFromTableDef = value; } public TRtSQLAssignTableDefEvent getOnAfterAssignFromTableDef() { return FOnAfterAssignFromTableDef; } public void setOnBeforeAssignToTableDef(TRtSQLAssignTableDefEvent value) { FOnBeforeAssignToTableDef = value; } public TRtSQLAssignTableDefEvent getOnBeforeAssignToTableDef() { return FOnBeforeAssignToTableDef; } public void setOnAfterAssignToTableDef(TRtSQLAssignTableDefEvent value) { FOnAfterAssignToTableDef = value; } public TRtSQLAssignTableDefEvent getOnAfterAssignToTableDef() { return FOnAfterAssignToTableDef; } public void setOnMustDropTable(TRtSQLMustDropTableEvent value) { FOnMustDropTable = value; } public TRtSQLMustDropTableEvent getOnMustDropTable() { return FOnMustDropTable; } public void setOnMustRenameTable(TRtSQLMustRenameTableEvent value) { FOnMustRenameTable = value; } public TRtSQLMustRenameTableEvent getOnMustRenameTable() { return FOnMustRenameTable; } public void setOnMustDropStoredProc(TRtSQLMustDropStoredProcEvent value) { FOnMustDropStoredProc = value; } public TRtSQLMustDropStoredProcEvent getOnMustDropStoredProc() { return FOnMustDropStoredProc; } public void setOnMustDropView(TRtSQLMustDropViewEvent value) { FOnMustDropView = value; } public TRtSQLMustDropViewEvent getOnMustDropView() { return FOnMustDropView; } public void setOnMustCreateView(TRtSQLMustCreateViewEvent value) { FOnMustCreateView = value; } public TRtSQLMustCreateViewEvent getOnMustCreateView() { return FOnMustCreateView; } public void setOnDDLError(TRtDDLErrorEvent value) { FOnDDLError = value; } public TRtDDLErrorEvent getOnDDLError() { return FOnDDLError; } public void setOnBeforeDDLStep(TRtDDLStepEvent value) { FOnBeforeDDLStep = value; } public TRtDDLStepEvent getOnBeforeDDLStep() { return FOnBeforeDDLStep; } public void setOnForceAlterTableMode(TOnForceAlterTableMode value) { FOnForceAlterTableMode = value; } public TOnForceAlterTableMode getOnForceAlterTableMode() { return FOnForceAlterTableMode; } public TDBParamStrings getParam() { return FParams; } public TRtDatabaseDef getPhyDatabase() { return FPhyDatabase; } public void setNotUpdatePhyDatabase(boolean value) { FNotUpdatePhyDatabase = value; } public boolean getNotUpdatePhyDatabase() { return FNotUpdatePhyDatabase; } public TRtDBRawDatabase getRawDatabase() { return FRawDatabase; } public TRtCustomStorageList getStorage() { return FStorageList; } public TRtCustomTablePrivilegesList getPrivileges() { return FTablePrivilegesList; } public TStringList getSortLanguageList() { return FSortLanguageList; } public String getName() { return FName; } public void setComponentOwner(TComponent value) { FComponentOwner = value; } public TComponent getComponentOwner() { return FComponentOwner; } public void setOnVerifyAssignObjectDef(TRtSQLVerifyAssignObjectDef value) { FOnVerifyAssignObjectDef = value; } public TRtSQLVerifyAssignObjectDef getOnVerifyAssignObjectDef() { return FOnVerifyAssignObjectDef; } public void setIgnoreSortErrors(boolean value) { FIgnoreSortErrors = value; } public boolean getIgnoreSortErrors() { return FIgnoreSortErrors; } public int getDBVersionKind() { return FDBVersionKind; } public int getDBAccessKind() { return FDBAccessKind; } public boolean getUseTimeZone() { return FUseTimeZone; } public boolean getGetDateFromDB() { return FGetDateFromDB; } public void setOnGetTableSecurityValues(TRtOnGetTableSecurityValues value) { FOnGetTableSecurityValues = value; } public TRtOnGetTableSecurityValues getOnGetTableSecurityValues() { return FOnGetTableSecurityValues; } public void setOnGetFieldSecurityValues(TRtOnGetFieldSecurityValues value) { FOnGetFieldSecurityValues = value; } public TRtOnGetFieldSecurityValues getOnGetFieldSecurityValues() { return FOnGetFieldSecurityValues; } public void setOnGetTableEventValues(TRtOnGetTableEventValues value) { FOnGetTableEventValues = value; } public TRtOnGetTableEventValues getOnGetTableEventValues() { return FOnGetTableEventValues; } public void setOnDeleteStorage(TRtOnDeleteStorage value) { FOnDeleteStorage = value; } public TRtOnDeleteStorage getOnDeleteStorage() { return FOnDeleteStorage; } public void setOnAddStorageIndexClustered(TRtOnAddStorageIndexClustered value) { FOnAddStorageIndexClustered = value; } public TRtOnAddStorageIndexClustered getOnAddStorageIndexClustered() { return FOnAddStorageIndexClustered; } public void setOnAddStorageLockEscalation(TRtOnAddStorageLockEscalation value) { FOnAddStorageLockEscalation = value; } public TRtOnAddStorageLockEscalation getOnAddStorageLockEscalation() { return FOnAddStorageLockEscalation; } public void setOnApplyLockEscalationInDb(TRtOnApplyLockEscalationInDb value) { FOnApplyLockEscalationInDb = value; } public TRtOnApplyLockEscalationInDb getOnApplyLockEscalationInDb() { return FOnApplyLockEscalationInDb; } public void setCustomAlterDefValue(TCustomAlterDefIndexCluster value) { FCustomAlterDefValue = value; } public TCustomAlterDefIndexCluster getCustomAlterDefValue() { return FCustomAlterDefValue; } public TRtOnTableIsTemporary getOnTableIsTemporary() { return FOnTableIsTemporary; } public int _AddRef() { return 0; } public int _Release() { return 0; } } public static class TSQLContainerItemClass extends TContainerItemClass { public static final TSQLContainerItemClass SINGLETON = new TSQLContainerItemClass(); public TSQLContainerItem Create() { return TSQLContainerItem.Create(); } public Class ClassInfo() { return TSQLContainerItem.class; } } public static class TSQLContainerItem extends TContainerItem { protected void CheckUnprepare() { _CheckUnprepare(this); } public void Destroy() { CheckUnprepare(); super.Destroy(); } public void Assign(TPersistent Source) { if (Source instanceof TSQLContainerItem) { CheckUnprepare(); } else { super.Assign(Source); } } public void ReadData(TReader Reader) { CheckUnprepare(); super.ReadData(Reader); } public static TSQLContainerItem Create() { TSQLContainerItem Result; Result = new TSQLContainerItem(); Result.runCreate(); return Result; } public TSQLContainerItemClass ClassType() { return TSQLContainerItemClass.SINGLETON; } } public static class TSQLTypedListOwnerClass extends TTypedListOwnerClass { public static final TSQLTypedListOwnerClass SINGLETON = new TSQLTypedListOwnerClass(); public Class ClassInfo() { return TSQLTypedListOwner.class; } } public static abstract class TSQLTypedListOwner extends TTypedListOwner { protected void CheckUnprepare() { _CheckUnprepare(this); } public void Destroy() { CheckUnprepare(); super.Destroy(); } public void Delete(int AIndex) { super.Delete(AIndex); CheckUnprepare(); } public void Assign(TPersistent Source) { CheckUnprepare(); super.Assign(Source); } public void ReadData(TReader Reader) { CheckUnprepare(); super.ReadData(Reader); } public TSQLTypedListOwnerClass ClassType() { return TSQLTypedListOwnerClass.SINGLETON; } } public static class TSQLKeyedContainerItemClass extends TKeyedContainerItemClass { public static final TSQLKeyedContainerItemClass SINGLETON = new TSQLKeyedContainerItemClass(); public TSQLKeyedContainerItem Create() { return TSQLKeyedContainerItem.Create(); } public Class ClassInfo() { return TSQLKeyedContainerItem.class; } } public static class TSQLKeyedContainerItem extends TKeyedContainerItem { protected void CheckUnprepare() { _CheckUnprepare(this); } protected void SetKey(Object Value) { CheckUnprepare(); super.SetKey(Value); } public void Destroy() { CheckUnprepare(); super.Destroy(); } public void Assign(TPersistent Source) { CheckUnprepare(); super.Assign(Source); } public void ReadData(TReader Reader) { CheckUnprepare(); super.ReadData(Reader); } public static TSQLKeyedContainerItem Create() { TSQLKeyedContainerItem Result; Result = new TSQLKeyedContainerItem(); Result.runCreate(); return Result; } public TSQLKeyedContainerItemClass ClassType() { return TSQLKeyedContainerItemClass.SINGLETON; } } public static class TSQLKeyedListOwnerClass extends TKeyedListOwnerClass { public static final TSQLKeyedListOwnerClass SINGLETON = new TSQLKeyedListOwnerClass(); public TSQLKeyedListOwner Create() { return TSQLKeyedListOwner.Create(); } public Class ClassInfo() { return TSQLKeyedListOwner.class; } } public static class TSQLKeyedListOwner extends TKeyedListOwner { protected void CheckUnprepare() { _CheckUnprepare(this); } public void Destroy() { CheckUnprepare(); super.Destroy(); } public void Delete(int AIndex) { super.Delete(AIndex); CheckUnprepare(); } public void Assign(TPersistent Source) { CheckUnprepare(); super.Assign(Source); } public void ReadData(TReader Reader) { CheckUnprepare(); super.ReadData(Reader); } public static TSQLKeyedListOwner Create() { TSQLKeyedListOwner Result; Result = new TSQLKeyedListOwner(); Result.runCreate(); return Result; } public TSQLKeyedListOwnerClass ClassType() { return TSQLKeyedListOwnerClass.SINGLETON; } } public static class TSQLNamedContainerItemClass extends TNamedContainerItemClass { public static final TSQLNamedContainerItemClass SINGLETON = new TSQLNamedContainerItemClass(); public TSQLNamedContainerItem Create() { return TSQLNamedContainerItem.Create(); } public Class ClassInfo() { return TSQLNamedContainerItem.class; } } public static class TSQLNamedContainerItem extends TNamedContainerItem { protected void CheckUnprepare() { _CheckUnprepare(this); } protected void SetKey(Object Value) { CheckUnprepare(); super.SetKey(Value); } public void Destroy() { CheckUnprepare(); super.Destroy(); } public void Assign(TPersistent Source) { CheckUnprepare(); super.Assign(Source); } public void ReadData(TReader Reader) { CheckUnprepare(); super.ReadData(Reader); } public static TSQLNamedContainerItem Create() { TSQLNamedContainerItem Result; Result = new TSQLNamedContainerItem(); Result.runCreate(); return Result; } public TSQLNamedContainerItemClass ClassType() { return TSQLNamedContainerItemClass.SINGLETON; } } public static class TSQLNamedListOwnerClass extends TNamedListOwnerClass { public static final TSQLNamedListOwnerClass SINGLETON = new TSQLNamedListOwnerClass(); public TSQLNamedListOwner Create() { return TSQLNamedListOwner.Create(); } public Class ClassInfo() { return TSQLNamedListOwner.class; } } public static class TSQLNamedListOwner extends TNamedListOwner { protected void CheckUnprepare() { _CheckUnprepare(this); } public void Destroy() { CheckUnprepare(); super.Destroy(); } public void Delete(int AIndex) { super.Delete(AIndex); CheckUnprepare(); } public void Assign(TPersistent Source) { CheckUnprepare(); super.Assign(Source); } public void ReadData(TReader Reader) { CheckUnprepare(); super.ReadData(Reader); } public static TSQLNamedListOwner Create() { TSQLNamedListOwner Result; Result = new TSQLNamedListOwner(); Result.runCreate(); return Result; } public TSQLNamedListOwnerClass ClassType() { return TSQLNamedListOwnerClass.SINGLETON; } } public static final class TRtParamSelectItemClass extends TSQLNamedContainerItemClass { public static final TRtParamSelectItemClass SINGLETON = new TRtParamSelectItemClass(); public final TRtParamSelectItem CreateParam(TRtCustomSQL AOwner, String AName) { return TRtParamSelectItem.CreateParam(AOwner, AName); } public Class ClassInfo() { return TRtParamSelectItem.class; } } public static final class TRtParamSelectItem extends TSQLNamedContainerItem { protected TRtSelect FSelect; protected final void CheckInitSelect() { if (FSelect == null) { FSelect = ((TRtSelect) TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(sckSelect, (((TRtCustomSQL) CheckTypedOwner(TRtCustomSQLClass.SINGLETON))).FDBVersionKind)); FSelect.SetFOwner(this); } } public final TRtSelect GetSelect() { CheckInitSelect(); return FSelect; } public final void SetSelect(TRtSelect AValue) { CheckUnprepare(); CheckInitSelect(); FSelect.Assign(AValue); } public final void runCreateParam(TRtCustomSQL AOwner, String AName) { super.runCreate(); FSelect = ((TRtSelect) TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(sckSelect, AOwner.GetOwnerConnection().getDBVersionKind())); FSelect.SetFOwner(this); if (!StrIsBlank(AName)) { SetName(AName); AOwner.AddSelectParamItem(this); } } public static TRtParamSelectItem CreateParam(TRtCustomSQL AOwner, String AName) { TRtParamSelectItem Result; Result = new TRtParamSelectItem(); Result.runCreateParam(AOwner, AName); return Result; } public void Destroy() { if (FSelect != null) { FSelect.Free(); } super.Destroy(); } public void Assign(TPersistent Source) { super.Assign(Source); if (Source instanceof TRtParamSelectItem) { CheckInitSelect(); FSelect.Assign(((TRtParamSelectItem) Source).GetSelect()); } } public void ReadData(TReader Reader) { super.ReadData(Reader); CheckInitSelect(); FSelect.ReadData(Reader); } public void WriteData(TWriter Writer) { super.WriteData(Writer); CheckInitSelect(); FSelect.WriteData(Writer); } public TRtParamSelectItemClass ClassType() { return TRtParamSelectItemClass.SINGLETON; } } public static final class TRtParamSelectListClass extends TSQLNamedListOwnerClass { public static final TRtParamSelectListClass SINGLETON = new TRtParamSelectListClass(); public Class ClassInfo() { return TRtParamSelectList.class; } } public static final class TRtParamSelectList extends TSQLNamedListOwner { protected TContainerItemClass AllocItemType() { return TRtParamSelectItemClass.SINGLETON; } public final TRtParamSelectItem GetItem(int Index) { return ((TRtParamSelectItem) Get(Index)); } public final TRtParamSelectItem ItemByName(String AName) { return ((TRtParamSelectItem) super.ItemByName(AName)); } public TRtParamSelectListClass ClassType() { return TRtParamSelectListClass.SINGLETON; } } public static class TRtCustomSQL extends TSQLContainerItem { short FAssigning; public boolean GetHasOperation() { return false; } protected int FReadVersion; protected boolean FUsesScriptTerminator; protected int FDBVersionKind; protected TRtSqlParams FParams; protected TRtParamSelectList FSelectParams; protected String FSql; protected TRtDatabaseDef FUseDataBaseDef; protected String GenSQL() { return ""; } public final String GenSQLScript() { String Result = ""; FUsesScriptTerminator = true; try { Result = StrReplaceStr(GenSQL(), ToStr(SQLEOC_SEP), EOL); Result = StrBreakLine(Result, " ,", 250, 0, kblNone); } finally { FUsesScriptTerminator = false; } return Result; } public final String GetSQL() { String Result = ""; FSql = GenSQL(); if (getUsesScriptTerminator() && !FSql.equals("")) { Result = StrReplaceStr(FSql, ToStr(SQLEOC_SEP), EOL); } else { Result = FSql; } return Result; } protected boolean GetConvertSQLToAccess() { return true; } protected final String GetSQLToAccess(String aSQL) { String Result = ""; TSimpleParser xParser; String xToken = ""; if (GetConvertSQLToAccess()) { xParser = TSimpleParser.Create(aSQL); try { Result = ""; while (xParser.GetCurrentTokenKind() != tkEOF) { Result = Result + StringOfChar(' ', xParser.GetChrCountBtwTokens()); xToken = xParser.GetCurrentToken(); if (xParser.GetCurrentTokenKind() == tkSimbol && SameText(xToken, ':')) { xParser.NexToken(); xToken = '{' + xParser.GetCurrentToken() + "}"; } Result = Result + xToken; xParser.NexToken(); } } finally { xParser.Free(); } } else { Result = aSQL; } return Result; } protected void UpdatePhyDatabase() { } protected final TRtCustomSQL GetRootSQL() { TRtCustomSQL Result; TRtCustomSQL AOwnerSQL; AOwnerSQL = ((TRtCustomSQL) GetTypedOwner(TRtCustomSQLClass.SINGLETON)); Result = AOwnerSQL; while (AOwnerSQL != null) { AOwnerSQL = ((TRtCustomSQL) AOwnerSQL.GetTypedOwner(TRtCustomSQLClass.SINGLETON)); if (AOwnerSQL != null) { Result = AOwnerSQL; } } return Result; } public final TRtSqlParams GetParams() { TRtSqlParams Result; TRtCustomSQL AOwnerSQL; AOwnerSQL = GetRootSQL(); if (AOwnerSQL != null) { Result = AOwnerSQL.GetParams(); } else { Result = FParams; } return Result; } public final TRtParamSelectList GetSelectParams() { TRtParamSelectList Result; TRtCustomSQL AOwnerSQL; AOwnerSQL = GetRootSQL(); if (AOwnerSQL != null) { Result = AOwnerSQL.GetSelectParams(); } else { Result = FSelectParams; } return Result; } protected final void AddSelectParamItem(TRtParamSelectItem AParam) { GetSelectParams().Add(AParam); } protected final TRtDatabaseDef CheckGetDatabaseDef() { TRtDatabaseDef Result; Result = GetDatabaseDef(); if (Result == null) { throw DelphiException.Create(TransStr("TC656", "Database (TBS) não encontrado.", true)); } return Result; } protected final TRtDatabaseDef GetDatabaseDef() { TRtDatabaseDef Result; TRtDBConnection AConn; if (FUseDataBaseDef != null) { Result = FUseDataBaseDef; } else { AConn = GetOwnerConnection(); if (AConn != null) { Result = AConn.FPhyDatabase; } else { Result = null; } } return Result; } public TRtDBConnection GetOwnerConnection() { return ((TRtDBConnection) GetTypedOwner(TRtDBConnectionClass.SINGLETON)); } public final boolean GetNotUpdatePhyDatabase() { return GetOwnerConnection().FNotUpdatePhyDatabase; } protected Object VersionInfo(int InfoType, Object Version) { Object Result = null; Result = null; switch (InfoType) { case vitVersioned: Result = (Object) 1; break; case vitGetVersionLen: Result = ((Object) SizeOf(FReadVersion)); break; case vitGetReadVersion: Result = FReadVersion; break; case vitSetReadVersion: //Move(Version, FReadVersion, SizeOf(FReadVersion)); FReadVersion = ToInt((byte[]) Version); break; case vitGetWriteVersion: if (FReadVersion >= NUM_DATA_VERSION1 && FReadVersion <= CUR_DATA_VERSION) { Result = FReadVersion; } else { Result = WRITE_VERSION; } break; default: break; } return Result; } protected void CheckConnected() { throw DelphiException.Create(TransStr("TC657", "Objeto SQL não conectado ao banco.", true)); } protected void InternalUnPrepare() { CheckConnected(); } public boolean GetPrepared() { return false; } protected void InitSQLKernel(TRtDBConnection aDbConn) { } protected final void LoadParamToAccess(TRtSqlParam aParam, TRtParam aParamAccess) { if (aParam.GetIsNull()) { switch (aParam.getDataType()) { case rdtBoolean: aParamAccess.GetTypeDesc().assign(cTypeDescBoolean); break; case rdtChar: case rdtPChar: case rdtText: aParamAccess.GetTypeDesc().assign(cTypeDescString); break; case rdtByte: case rdtShortint: case rdtSmallint: case rdtWord: case rdtLongint: aParamAccess.GetTypeDesc().assign(cTypeDescInteger); break; case rdtSingle: case rdtDouble: case rdtExtended: case rdtComp: case rdtCurrency: aParamAccess.GetTypeDesc().assign(cTypeDescDouble); break; case rdtDate: case rdtTime: case rdtDateTime: aParamAccess.GetTypeDesc().assign(cTypeDescDate); break; case rdtBlob: case rdtImage: aParamAccess.GetTypeDesc().assign(cTypeDescBlob); break; default: break; } aParamAccess.SetToNull(); } else { switch (aParam.getDataType()) { case rdtBoolean: aParamAccess.SetAsBoolean(aParam.GetBoolean()); break; case rdtChar: case rdtPChar: case rdtText: aParamAccess.SetAsString(aParam.GetString()); break; case rdtByte: case rdtShortint: case rdtSmallint: case rdtWord: case rdtLongint: aParamAccess.SetAsInteger(aParam.GetLongint()); break; case rdtSingle: case rdtDouble: case rdtExtended: case rdtComp: case rdtCurrency: aParamAccess.SetAsFloat(aParam.GetExtended()); break; case rdtDate: aParamAccess.SetAsDateTime(TRtRecValueClass.SINGLETON.RtDateToDateTime(aParam.GetDate())); break; case rdtTime: aParamAccess.SetAsDateTime(TRtRecValueClass.SINGLETON.RtTimeToDateTime(aParam.GetTime())); break; case rdtDateTime: aParamAccess.SetAsDateTime(aParam.GetDateTime()); break; case rdtBlob: case rdtImage: aParamAccess.SetAsBlob(aParam.GetBlob()); break; default: throw DelphiException.CreateFmt(TransStr("TC658", "Erro na conversão do parâmetro %s tipo %s para um parâmetro do RtAccess", true), new Object[] { aParam.GetName(), TRtDataTypeNames[aParam.getDataType()] }); } } } protected final void runCreateWithDBVersionKind(int aDBVersionKind) { FDBVersionKind = aDBVersionKind; runCreate(); } protected static TRtCustomSQL CreateWithDBVersionKind(int aDBVersionKind) { TRtCustomSQL Result; Result = new TRtCustomSQL(); Result.runCreateWithDBVersionKind(aDBVersionKind); return Result; } protected final int GetSQLClassesKind() { int Result; if (this instanceof TRtCreateTable) { Result = sckCreateTable; } else if (this instanceof TRtAlterTable) { Result = sckAlterTable; } else if (this instanceof TRtCreateIndex) { Result = sckCreateIndex; } else if (this instanceof TRtDropIndex) { Result = sckDropIndex; } else if (this instanceof TRtCreateTrigger) { Result = sckCreateTrigger; } else if (this instanceof TRtDropTrigger) { Result = sckDropTrigger; } else if (this instanceof TRtCreateProcedure) { Result = sckCreateProcedure; } else if (this instanceof TRtDropProcedure) { Result = sckDropProcedure; } else if (this instanceof TRtCreateView) { Result = sckCreateView; } else if (this instanceof TRtDropView) { Result = sckDropView; } else if (this instanceof TRtDropTable) { Result = sckDropTable; } else if (this instanceof TRtRenameTable) { Result = sckRenameTable; } else if (this instanceof TRtBeginTran) { Result = sckBeginTran; } else if (this instanceof TRtSetTransaction) { Result = sckSetTransaction; } else if (this instanceof TRtSavePoint) { Result = sckSavePoint; } else if (this instanceof TRtRollBack) { Result = sckRollBack; } else if (this instanceof TRtCommit) { Result = sckCommit; } else if (this instanceof TRtDeleteFrom) { Result = sckDeleteFrom; } else if (this instanceof TRtInsertSelectInto) { Result = sckInsertSelectInto; } else if (this instanceof TRtInsertInto) { Result = sckInsertInto; } else if (this instanceof TRtUpdate) { Result = sckUpdate; } else if (this instanceof TRtSelect) { Result = sckSelect; } else { Result = sckSelect; Assert(false, "class not fount"); } return Result; } protected final boolean GetIsIncremental(String aTableName, String aFieldName) { boolean Result; TRtFullDatabaseDef xDataBaseDef; TRtFullTableDef xTableDef; TRtFullFieldDef xFieldDef; Result = false; xDataBaseDef = GetDefaultNewDatabaseDef(); if (xDataBaseDef != null) { xTableDef = xDataBaseDef.TableByName(aTableName); if (xTableDef != null) { xFieldDef = xTableDef.FieldByName(aFieldName); if (xFieldDef != null) { Result = xFieldDef.getIncrementInDb(); } } } return Result; } public void runCreate() { super.runCreate(); InitSQLKernel(null); FParams = ((TRtSqlParams) Creator(this, TRtSqlParamsClass.SINGLETON)); FSelectParams = ((TRtParamSelectList) Creator(this, TRtParamSelectListClass.SINGLETON)); FReadVersion = CUR_DATA_VERSION; FUseDataBaseDef = null; } public static TRtCustomSQL Create() { TRtCustomSQL Result; Result = new TRtCustomSQL(); Result.runCreate(); return Result; } public void runCreateSQL(TRtDBConnection AConn) { super.runCreate(); FDBVersionKind = AConn.FDBVersionKind; FParams = ((TRtSqlParams) Creator(this, TRtSqlParamsClass.SINGLETON)); FSelectParams = ((TRtParamSelectList) Creator(this, TRtParamSelectListClass.SINGLETON)); FReadVersion = CUR_DATA_VERSION; AConn.AddSQL(this); FUseDataBaseDef = null; } public static TRtCustomSQL CreateSQL(TRtDBConnection AConn) { TRtCustomSQL Result; Result = new TRtCustomSQL(); Result.runCreateSQL(AConn); return Result; } public void Destroy() { FSelectParams.Free(); FParams.Free(); super.Destroy(); } public void Assign(TPersistent Source) { FAssigning++; try { if (Source instanceof TRtCustomSQL) { FReadVersion = ((TRtCustomSQL) Source).FReadVersion; FSql = ((TRtCustomSQL) Source).FSql; if (GetRootSQL() == null) { FParams.Assign(((TRtCustomSQL) Source).FParams); FSelectParams.Assign(((TRtCustomSQL) Source).FSelectParams); } } super.Assign(Source); } finally { FAssigning--; } } public void ReadData(TReader Reader) { TRtParamSelectItem SelItem; boolean LWasOwned; FAssigning++; try { super.ReadData(Reader); LWasOwned = Reader.ReadBoolean(); if (!LWasOwned) { FParams.ReadData(Reader); { TReader context_Reader = Reader; FSelectParams.Clear(); context_Reader.ReadListBegin(); while (!context_Reader.EndOfList()) { SelItem = TRtParamSelectItem.CreateParam(this, TempName()); try { SelItem.ReadData(Reader); } catch (Throwable any) { SelItem.Free(); } } context_Reader.ReadListEnd(); FSql = context_Reader.ReadString(); } } } finally { FAssigning--; } } public void ReadDataOnConnection(TRtDBConnection AConn, TReader Reader) { TRtDBConnection ACurConn; ACurConn = GetOwnerConnection(); if (ACurConn == null) { if (AConn != null && AConn != ACurConn) { // ACurConn.AddSQL(this); throw new NullPointerException(); } } ReadData(Reader); } public void WriteData(TWriter Writer) { int i; boolean LWasOwned; super.WriteData(Writer); LWasOwned = GetRootSQL() != null; Writer.WriteBoolean(LWasOwned); if (!LWasOwned) { FParams.WriteData(Writer); { TWriter context_Writer = Writer; context_Writer.WriteListBegin(); for (i = 0; i <= FSelectParams.GetCount() - 1; ++i) { FSelectParams.GetItem(i).WriteData(Writer); } context_Writer.WriteListEnd(); context_Writer.WriteString(FSql); } } } public final void UnPrepare() { InternalUnPrepare(); } public TRtCustomSQLClass ClassType() { return TRtCustomSQLClass.SINGLETON; } public void setUsesScriptTerminator(boolean value) { FUsesScriptTerminator = value; } public boolean getUsesScriptTerminator() { return FUsesScriptTerminator; } public int getDBVersionKind() { return FDBVersionKind; } public void setUseDataBaseDef(TRtDatabaseDef value) { FUseDataBaseDef = value; } public TRtDatabaseDef getUseDataBaseDef() { return FUseDataBaseDef; } } public static class TRtCustomSelectSQLClass extends TRtCustomSQLClass { public static final TRtCustomSelectSQLClass SINGLETON = new TRtCustomSelectSQLClass(); public TRtCustomSelectSQL CreateSQL(TRtDBConnection AConn) { return TRtCustomSelectSQL.CreateSQL(AConn); } public TRtCustomSelectSQL Create() { return TRtCustomSelectSQL.Create(); } public Class ClassInfo() { return TRtCustomSelectSQL.class; } } public static class TRtCustomSelectSQL extends TRtCustomSQL { private final class InternalPrepareQuery_Context { private void iLoadParams() { TRtSqlParam xParam; TRtParam xParamAccess; int i; for (i = 0; i <= FParams.GetCount() - 1; ++i) { xParam = FParams.GetItem(i); xParamAccess = FQuery.ParamByName(xParam.GetName()); LoadParamToAccess(xParam, xParamAccess); } } public InternalPrepareQuery_Context() { } public void execute() { if (!GetPrepared()) { CheckConnected(); FQuery.SetCommand(GetSQLToAccess(FSql)); iLoadParams(); FQuery.Prepare(); } } } TRtQuery FQuery; protected void CheckConnected() { if (FQuery == null) { super.CheckConnected(); } } protected void InternalPrepareQuery() { InternalPrepareQuery_Context ctx = new InternalPrepareQuery_Context(); ctx.execute(); } protected void InternalUnPrepare() { if (GetPrepared()) { CheckConnected(); if (FQuery.GetActive()) { FQuery.Close(); } FQuery.UnPrepare(); } } public boolean GetPrepared() { return FQuery != null && FQuery.GetPrepared(); } protected void InitSQLKernel(TRtDBConnection aDbConn) { if (FQuery != null) { FQuery.Free(); FQuery = null; } if (aDbConn != null && aDbConn.IsOpen()) { if (getDBVersionKind() != aDbConn.getDBVersionKind()) { throw DelphiException.CreateFmt(TransStr("TC659", "Driver deveria se \"%s\" e não \"%s\".", true), new Object[] { cDBVersionKindNameArray[getDBVersionKind()], cDBVersionKindNameArray[aDbConn.getDBVersionKind()] }); } FQuery = aDbConn.GetAccess().NewQuery(); } } public void runCreateSQL(TRtDBConnection AConn) { super.runCreateSQL(AConn); FQuery = AConn.GetAccess().NewQuery(); } public static TRtCustomSelectSQL CreateSQL(TRtDBConnection AConn) { TRtCustomSelectSQL Result; Result = new TRtCustomSelectSQL(); Result.runCreateSQL(AConn); return Result; } public void Destroy() { FQuery.Free(); FQuery = null; super.Destroy(); } public final TRtQuery GetRtQuery() { if (!GetPrepared()) { FSql = GenSQL(); InternalPrepareQuery(); } return FQuery; } public static TRtCustomSelectSQL Create() { TRtCustomSelectSQL Result; Result = new TRtCustomSelectSQL(); Result.runCreate(); return Result; } public TRtCustomSelectSQLClass ClassType() { return TRtCustomSelectSQLClass.SINGLETON; } } public interface TRtOnErrorExecutingMultipleSQLs { public void run(int aSubStep); } public static class TRtCustomUpdateSQLClass extends TRtCustomSQLClass { public static final TRtCustomUpdateSQLClass SINGLETON = new TRtCustomUpdateSQLClass(); public TRtCustomUpdateSQL CreateSQL(TRtDBConnection AConn) { return TRtCustomUpdateSQL.CreateSQL(AConn); } public Class ClassInfo() { return TRtCustomUpdateSQL.class; } } public static class TRtCustomUpdateSQL extends TRtCustomSQL { private final class InternalPrepareUpdate_Context { private void iLoadParams() { TRtSqlParam xParam; TRtParam xParamAccess; int i; for (i = 0; i <= FParams.GetCount() - 1; ++i) { xParam = FParams.GetItem(i); xParamAccess = FUpdate.FindParam(xParam.GetName()); if (xParamAccess != null) { LoadParamToAccess(xParam, xParamAccess); } } } public InternalPrepareUpdate_Context() { } public void execute() { if (!GetPrepared()) { CheckConnected(); FUpdate.SetCommand(GetSQLToAccess(FSql)); iLoadParams(); FUpdate.Prepare(); } } } br.com.senior.svcl.db.RtAccess.TRtUpdate FUpdate; private TRtOnErrorExecutingMultipleSQLs FOnErrorExecutingMultipleSQLs; protected void CheckConnected() { if (FUpdate == null) { super.CheckConnected(); } } protected String ExecuteMultipleSQLs(String ASql, int aInitSubStep, String ALastSQLs) { int xCount; TInt p = new TInt(); ALastSQLs = ""; CheckConnected(); xCount = 0; p.v = 0; while (p.v != -1) { FSql = TrimRight(StrGetNextToken(ASql, p, SQLEOC_SEP)); if (!FSql.equals("") && xCount >= aInitSubStep) { ALastSQLs = ALastSQLs + FSql + EOL; try { InternalExecuteUpdate(); } catch (Throwable any) { if (FOnErrorExecutingMultipleSQLs != null) { FOnErrorExecutingMultipleSQLs.run(xCount); } throw wrap(any); } } xCount++; } FUpdate.UnPrepare(); return ALastSQLs; } protected void InternalPrepareUpdate() { InternalPrepareUpdate_Context ctx = new InternalPrepareUpdate_Context(); ctx.execute(); } protected final void InternalExecuteUpdate() { FUpdate.UnPrepare(); InternalPrepareUpdate(); if (FUseDataBaseDef != null && GetOwnerConnection().FRtDatabase != null) { GetOwnerConnection().FRtDatabase.setDatabaseDef(FUseDataBaseDef); } try { FUpdate.Execute(); } finally { if (FUseDataBaseDef != null && GetOwnerConnection().FRtDatabase != null) { GetOwnerConnection().FRtDatabase.setDatabaseDef(GetOwnerConnection().getPhyDatabase()); } } } protected void InternalUnPrepare() { if (GetPrepared()) { CheckConnected(); FUpdate.UnPrepare(); } } public boolean GetPrepared() { return FUpdate != null && FUpdate.GetPrepared(); } protected void InitSQLKernel(TRtDBConnection aDbConn) { if (FUpdate != null) { FUpdate.Free(); FUpdate = null; } if (aDbConn != null && aDbConn.IsOpen()) { if (getDBVersionKind() != aDbConn.getDBVersionKind()) { throw DelphiException.CreateFmt(TransStr("TC659", "Driver deveria se \"%s\" e não \"%s\".", true), new Object[] { cDBVersionKindNameArray[getDBVersionKind()], cDBVersionKindNameArray[aDbConn.getDBVersionKind()] }); } FUpdate = aDbConn.GetAccess().NewUpdate(); } } public void runCreateSQL(TRtDBConnection AConn) { super.runCreateSQL(AConn); FUpdate = AConn.GetAccess().NewUpdate(); } public static TRtCustomUpdateSQL CreateSQL(TRtDBConnection AConn) { TRtCustomUpdateSQL Result; Result = new TRtCustomUpdateSQL(); Result.runCreateSQL(AConn); return Result; } public void Destroy() { FUpdate.Free(); FUpdate = null; super.Destroy(); } public void ExecuteUpd() { FSql = GetSQL(); InternalExecuteUpdate(); FUpdate.UnPrepare(); } public final br.com.senior.svcl.db.RtAccess.TRtUpdate GetRtUpdate() { if (!GetPrepared() && Trim(FSql).equals("")) { FSql = GetSQL(); } InternalPrepareUpdate(); return FUpdate; } public TRtCustomUpdateSQLClass ClassType() { return TRtCustomUpdateSQLClass.SINGLETON; } public void setOnErrorExecutingMultipleSQLs(TRtOnErrorExecutingMultipleSQLs value) { FOnErrorExecutingMultipleSQLs = value; } public TRtOnErrorExecutingMultipleSQLs getOnErrorExecutingMultipleSQLs() { return FOnErrorExecutingMultipleSQLs; } } public static class TRtColumnSqlGenerator extends TPersistent { public String GenColumnName(TRtAddColumnItem aColumnItem) { return ClassType().GenColumnName(aColumnItem); } public String GenColumnDetailDataType(TRtAddColumnItem aColumnItem, IRtDatabaseDef aDataBaseDef, TString aKindName, TString aLength, TString aPrecision) { return ClassType().GenColumnDetailDataType(aColumnItem, aDataBaseDef, aKindName, aLength, aPrecision); } public String GenColumnNotNull(TRtAddColumnItem aColumnItem) { return ClassType().GenColumnNotNull(aColumnItem); } public String GenColumnStorage(TRtAddColumnItem aColumnItem, TRtCustomStorageList aStorage, String aTableName) { return ClassType().GenColumnStorage(aColumnItem, aStorage, aTableName); } public TRtColumnSqlGeneratorClass ClassType() { return TRtColumnSqlGeneratorClass.SINGLETON; } } public static class TRtAddColumnItemClass extends TSQLNamedContainerItemClass { public static final TRtAddColumnItemClass SINGLETON = new TRtAddColumnItemClass(); public final TRtAddColumnItem CreateAdd(TRtAddColumnsList AOwner, String AColName, int AColType, int AColLen, int AColPrec, boolean LNotNull) { return TRtAddColumnItem.CreateAdd(AOwner, AColName, AColType, AColLen, AColPrec, LNotNull); } public TRtAddColumnItem Create() { return TRtAddColumnItem.Create(); } public Class ClassInfo() { return TRtAddColumnItem.class; } } public static class TRtAddColumnItem extends TSQLNamedContainerItem { protected int FDBVersionKind; protected int FOption; protected String FColName; protected int FColType; protected int FColLen; protected int FColPrec; protected boolean FNotNull; protected void SetOption(int Value) { CheckUnprepare(); SetName(IntToStr((int) Value) + FColName); FOption = Value; } public final void SetColName(String Value) { CheckUnprepare(); SetName(IntToStr((int) FOption) + Value); FColName = Value; } public final void SetColType(int Value) { CheckUnprepare(); FColType = Value; } public final void SetColLen(int Value) { CheckUnprepare(); FColLen = Value; } public final void SetColPrec(short Value) { CheckUnprepare(); FColPrec = Value; } public final void SetNotNull(boolean Value) { CheckUnprepare(); FNotNull = Value; } protected final void InitAdd(TRtAddColumnsList aOwner, String AColName, int aColType, int aColLen, int aColPrec, boolean LNotNull) { FOption = rcaAdd; FColName = AColName; FColType = aColType; FColLen = (int) aColLen; FColPrec = (short) aColPrec; FNotNull = LNotNull; FDBVersionKind = aOwner.FDBVersionKind; SetName(IntToStr((int) FOption) + FColName); aOwner.AddItem(this); } public final void runCreateAdd(TRtAddColumnsList AOwner, String AColName, int AColType, int AColLen, int AColPrec, boolean LNotNull) { super.runCreate(); InitAdd(AOwner, AColName, AColType, AColLen, AColPrec, LNotNull); } public static TRtAddColumnItem CreateAdd(TRtAddColumnsList AOwner, String AColName, int AColType, int AColLen, int AColPrec, boolean LNotNull) { TRtAddColumnItem Result; Result = new TRtAddColumnItem(); Result.runCreateAdd(AOwner, AColName, AColType, AColLen, AColPrec, LNotNull); return Result; } public final String GenSql(IRtDatabaseDef aDataBaseDef, TRtCustomStorageList aStorage, String aTableName) { return GenSqlEx(DelphiSet.get(cgsoColumnName, cgsoColumnType, cgsoColumnNotNull, cgsoColumnStorage), aDataBaseDef, aStorage, aTableName); } public final String GenSqlEx(DelphiSet aColumnGenSqlOptionSet, IRtDatabaseDef aDataBaseDef, TRtCustomStorageList aStorage, String aTableName) { String Result = ""; TString xKindName = new TString(); TString xLeng = new TString(); TString xPrec = new TString(); TRtColumnSqlGeneratorClass vColumnSqlGeneratorClass; vColumnSqlGeneratorClass = TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetColumnSqlGeneratorClass(FDBVersionKind); if (aColumnGenSqlOptionSet.contains(cgsoColumnName)) { Result = vColumnSqlGeneratorClass.GenColumnName(this) + ToStr(SQL_Space); } else { Result = ""; } if (aColumnGenSqlOptionSet.contains(cgsoColumnType)) { Result = Result + vColumnSqlGeneratorClass.GenColumnDetailDataType(this, aDataBaseDef, xKindName, xLeng, xPrec) + ToStr(SQL_Space); } if (aColumnGenSqlOptionSet.contains(cgsoColumnNotNull)) { Result = Result + vColumnSqlGeneratorClass.GenColumnNotNull(this); } if (aColumnGenSqlOptionSet.contains(cgsoColumnStorage)) { Result = Result + vColumnSqlGeneratorClass.GenColumnStorage(this, aStorage, aTableName); } return TrimRight(Result); } public final void GenSqlKind(IRtDatabaseDef aDataBaseDef, TString aKindName, TString aLength, TString aPrecision, TString aNull) { TRtColumnSqlGeneratorClass vColumnSqlGeneratorClass; vColumnSqlGeneratorClass = TRtDatabaseServerClass.SINGLETON.GlobalInstance().GetColumnSqlGeneratorClass(FDBVersionKind); vColumnSqlGeneratorClass.GenColumnDetailDataType(this, aDataBaseDef, aKindName, aLength, aPrecision); aNull.v = vColumnSqlGeneratorClass.GenColumnNotNull(this); } public void Assign(TPersistent Source) { super.Assign(Source); if (Source instanceof TRtAddColumnItem) { FOption = ((TRtAddColumnItem) Source).FOption; FColName = ((TRtAddColumnItem) Source).FColName; FColType = ((TRtAddColumnItem) Source).FColType; FColLen = ((TRtAddColumnItem) Source).FColLen; FColPrec = ((TRtAddColumnItem) Source).FColPrec; FNotNull = ((TRtAddColumnItem) Source).FNotNull; } } public final void AssignFromFieldDef(TRtFieldDef AFldDef) { CheckUnprepare(); { TRtFieldDef context_AFldDef = AFldDef; FColName = context_AFldDef.GetName(); FColType = context_AFldDef.GetFullKind().GetEnumType(); FColLen = context_AFldDef.GetLength(); FColPrec = context_AFldDef.GetPrecision(); FNotNull = context_AFldDef.getNotNull(); } } public final void AssignToFieldDef(TRtFieldDef AFldDef) { AFldDef.SetFullKind(TRtPhyBaseTypeClass.SINGLETON.ClassFromEnumType(FColType), "", FColLen, FColPrec); AFldDef.SetNotNull(FNotNull); } public void ReadData(TReader Reader) { super.ReadData(Reader); { TReader context_Reader = Reader; context_Reader.Read(AsVar(FOption), SizeOf(FOption)); FColName = context_Reader.ReadString(); context_Reader.Read(AsVar(FColType), SizeOf(FColType)); context_Reader.Read(AsVar(FColLen), SizeOf_UShort); context_Reader.Read(AsVar(FColPrec), SizeOf_UByte); FNotNull = context_Reader.ReadBoolean(); } } public void WriteData(TWriter Writer) { super.WriteData(Writer); { TWriter context_Writer = Writer; context_Writer.Write(AsConst(FOption), SizeOf(FOption)); context_Writer.WriteString(FColName); context_Writer.Write(AsConst(FColType), SizeOf(FColType)); context_Writer.Write(AsConst(FColLen), SizeOf_UShort); context_Writer.Write(AsConst(FColPrec), SizeOf_UByte); context_Writer.WriteBoolean(FNotNull); } } public static TRtAddColumnItem Create() { TRtAddColumnItem Result; Result = new TRtAddColumnItem(); Result.runCreate(); return Result; } public TRtAddColumnItemClass ClassType() { return TRtAddColumnItemClass.SINGLETON; } public int getOption() { return FOption; } public String getColName() { return FColName; } public int getColType() { return FColType; } public int getColLength() { return FColLen; } public int getColPrecision() { return FColPrec; } public boolean getNotNull() { return FNotNull; } } public static final class TRtModifyColumnItemClass extends TRtAddColumnItemClass { public static final TRtModifyColumnItemClass SINGLETON = new TRtModifyColumnItemClass(); public final TRtModifyColumnItem CreateModify(TRtModifyColumnsList AOwner, String AOldColName, String ANewColName, int AColType, int AColLen, int AColPrec, boolean LNotNull, boolean LNotNullChanged) { return TRtModifyColumnItem.CreateModify(AOwner, AOldColName, ANewColName, AColType, AColLen, AColPrec, LNotNull, LNotNullChanged); } public final TRtModifyColumnItem CreateDrop(TRtModifyColumnsList AOwner, String AColName) { return TRtModifyColumnItem.CreateDrop(AOwner, AColName); } public Class ClassInfo() { return TRtModifyColumnItem.class; } } public static final class TRtModifyColumnItem extends TRtAddColumnItem { public final boolean GetCriticalChange() { boolean Result; TRtAlterTable OwnerAT; TRtTableDef OldTblDef; TRtFieldDef AFldDef; boolean LDropColumnOnUC; boolean LChangeColumnType; boolean LDecraseColumnSize; boolean LNewNotNullColumn; String s = ""; String xPhyNativeKindName = ""; Result = false; OwnerAT = ((TRtAlterTable) GetTypedOwner(TRtAlterTableClass.SINGLETON)); LDropColumnOnUC = false; LChangeColumnType = false; LDecraseColumnSize = false; LNewNotNullColumn = false; switch (getOption()) { case rcaDrop: if (Result) { OldTblDef = OwnerAT.GetOwnerConnection().FPhyDatabase.CheckTableByName(OwnerAT.FTableName); AFldDef = OldTblDef.FieldByName(getColName()); LDropColumnOnUC = AFldDef.GetIsUniqueKey() || AFldDef.GetIsPrimaryKey() || AFldDef.GetIsUniqueConstraint(); } break; case rcaModify: if (!LChangeColumnType) { if (GetIsRenamingCol()) { s = getOldColName(); } else { s = getColName(); } OldTblDef = OwnerAT.GetOwnerConnection().FPhyDatabase.CheckTableByName(OwnerAT.FTableName); AFldDef = OldTblDef.FieldByName(s); LNewNotNullColumn = !AFldDef.getNotNull() && FNotNull; if (AFldDef.GetPhyNativeStrKindName().equals("")) { LChangeColumnType = AFldDef.GetFullKind().GetEnumType() != getColType(); } else { xPhyNativeKindName = OwnerAT.GetOwnerConnection().GetNewDatabase().CheckTableByName(OwnerAT.FTableName).CheckFieldByName(getOldColName()).GetPhyNativeStrKindName(); LChangeColumnType = !SameText(AFldDef.GetPhyNativeStrKindName(), xPhyNativeKindName); } LDecraseColumnSize = !LChangeColumnType && (AFldDef.GetLength() - AFldDef.GetPrecision() > getColLength() - getColPrecision() || AFldDef.GetPrecision() > getColPrecision()); } break; default: LNewNotNullColumn = FNotNull; break; } return Result || LDropColumnOnUC || LChangeColumnType || LDecraseColumnSize || LNewNotNullColumn || OwnerAT.MaxRestrictionGenCriticalChanges(); } public final void SetOption(int Value) { CheckUnprepare(); FOption = Value; } public final void SetOldColName(String Value) { CheckUnprepare(); FOldColName = Value; } protected String FOldColName; protected boolean FNotNullChanged; protected final void InitModify(TRtModifyColumnsList AOwner, String AOldColName, String ANewColName, int AColType, int AColLen, int AColPrec, boolean LNotNull, boolean LNotNullChanged) { FOption = rcaModify; FOldColName = AOldColName; FColName = ANewColName; FColType = AColType; FColLen = (int) AColLen; FColPrec = (short) AColPrec; FNotNull = LNotNull; FNotNullChanged = LNotNullChanged; FDBVersionKind = AOwner.FDBVersionKind; SetName(IntToStr((int) FOption) + FColName); AOwner.AddItem(this); } protected final void InitDrop(TRtModifyColumnsList AOwner, String AColName) { FOption = rcaDrop; FColName = AColName; SetName(IntToStr((int) FOption) + FColName); AOwner.AddItem(this); } public final boolean GetIsRenamingCol() { return !StrIsBlank(getOldColName()) && CompareText(getOldColName(), getColName()) != 0; } public final void SetNotNullChanged(boolean Value) { CheckUnprepare(); FNotNullChanged = Value; } public final void runCreateModify(TRtModifyColumnsList AOwner, String AOldColName, String ANewColName, int AColType, int AColLen, int AColPrec, boolean LNotNull, boolean LNotNullChanged) { super.runCreate(); InitModify(AOwner, AOldColName, ANewColName, AColType, AColLen, AColPrec, LNotNull, LNotNullChanged); } public static TRtModifyColumnItem CreateModify(TRtModifyColumnsList AOwner, String AOldColName, String ANewColName, int AColType, int AColLen, int AColPrec, boolean LNotNull, boolean LNotNullChanged) { TRtModifyColumnItem Result; Result = new TRtModifyColumnItem(); Result.runCreateModify(AOwner, AOldColName, ANewColName, AColType, AColLen, AColPrec, LNotNull, LNotNullChanged); return Result; } public final void runCreateDrop(TRtModifyColumnsList AOwner, String AColName) { super.runCreate(); InitDrop(AOwner, AColName); } public static TRtModifyColumnItem CreateDrop(TRtModifyColumnsList AOwner, String AColName) { TRtModifyColumnItem Result; Result = new TRtModifyColumnItem(); Result.runCreateDrop(AOwner, AColName); return Result; } public void Assign(TPersistent Source) { super.Assign(Source); if (Source instanceof TRtModifyColumnItem) { FOldColName = ((TRtModifyColumnItem) Source).FOldColName; FNotNullChanged = ((TRtModifyColumnItem) Source).FNotNullChanged; } } public void ReadData(TReader Reader) { super.ReadData(Reader); { TReader context_Reader = Reader; FOldColName = context_Reader.ReadString(); FNotNullChanged = context_Reader.ReadBoolean(); } } public void WriteData(TWriter Writer) { super.WriteData(Writer); { TWriter context_Writer = Writer; context_Writer.WriteString(FOldColName); context_Writer.WriteBoolean(FNotNullChanged); } } public TRtModifyColumnItemClass ClassType() { return TRtModifyColumnItemClass.SINGLETON; } public int getOption() { return FOption; } public String getOldColName() { return FOldColName; } public boolean getNotNullChanged() { return FNotNullChanged; } } public static class TRtAddColumnsListClass extends TSQLNamedListOwnerClass { public static final TRtAddColumnsListClass SINGLETON = new TRtAddColumnsListClass(); public TRtAddColumnsList Create() { return TRtAddColumnsList.Create(); } public Class ClassInfo() { return TRtAddColumnsList.class; } } public static class TRtAddColumnsList extends TSQLNamedListOwner { protected int FDBVersionKind; protected TContainerItemClass AllocItemType() { return TRtAddColumnItemClass.SINGLETON; } public TRtAddColumnItem GetItem(int Index) { return ((TRtAddColumnItem) Get(Index)); } public TRtAddColumnItem AddColumn(String ANewColName, int AColType, int AColLen, int AColPrec, boolean LNotNull) { TRtAddColumnItem Result; CheckUnprepare(); Result = ((TRtAddColumnItem) AllocItemType().Create()); Result.InitAdd(this, ANewColName, AColType, AColLen, AColPrec, LNotNull); return Result; } public TRtAddColumnItem ItemByName(String AName, int AOption) { return ((TRtAddColumnItem) super.ItemByName(IntToStr((int) AOption) + AName)); } public final int IndexByName(String AName, int AOption) { return super.IndexByName(IntToStr((int) AOption) + AName); } public final int RemoveByName(String AName, int AOption) { return super.RemoveByName(IntToStr((int) AOption) + AName); } public TRtAddColumnItem ItemByColumnName(String AName) { TRtAddColumnItem Result; int i; i = IndexByColumnName(AName); if (i >= 0) { Result = this.GetItem(i); } else { Result = null; } return Result; } public final int IndexByColumnName(String AName) { int Result; int i; for (i = 0; i <= GetCount() - 1; ++i) { if (CompareText(this.GetItem(i).getColName(), AName) == 0) { Result = i; return Result; } } return -1; } public final int RemoveByColumnName(String AName) { int Result; Result = IndexByColumnName(AName); if (Result >= 0) { Delete(Result); } return Result; } public static TRtAddColumnsList Create() { TRtAddColumnsList Result; Result = new TRtAddColumnsList(); Result.runCreate(); return Result; } public TRtAddColumnsListClass ClassType() { return TRtAddColumnsListClass.SINGLETON; } } public static final class TRtModifyColumnsListClass extends TRtAddColumnsListClass { public static final TRtModifyColumnsListClass SINGLETON = new TRtModifyColumnsListClass(); public Class ClassInfo() { return TRtModifyColumnsList.class; } } public static final class TRtModifyColumnsList extends TRtAddColumnsList { protected TContainerItemClass AllocItemType() { return TRtModifyColumnItemClass.SINGLETON; } public final TRtModifyColumnItem GetItem(int Index) { return ((TRtModifyColumnItem) Get(Index)); } public final TRtModifyColumnItem AddColumn(String ANewColName, int AColType, int AColLen, int AColPrec, boolean LNotNull) { return ((TRtModifyColumnItem) super.AddColumn(ANewColName, AColType, AColLen, AColPrec, LNotNull)); } public final TRtModifyColumnItem ModifyColumn(String AOldColName, String ANewColName, int AColType, int AColLen, int AColPrec, boolean LNotNull, boolean LNotNullChanged) { TRtModifyColumnItem Result; CheckUnprepare(); Result = ((TRtModifyColumnItem) AllocItemType().Create()); Result.InitModify(this, AOldColName, ANewColName, AColType, AColLen, AColPrec, LNotNull, LNotNullChanged); return Result; } public final TRtModifyColumnItem DropColumn(String AColName) { TRtModifyColumnItem Result; CheckUnprepare(); Result = ((TRtModifyColumnItem) AllocItemType().Create()); Result.InitDrop(this, AColName); return Result; } public final TRtModifyColumnItem ItemByName(String AName, int AOption) { return ((TRtModifyColumnItem) super.ItemByName(AName, AOption)); } public final TRtModifyColumnItem ItemByColumnName(String AName) { return ((TRtModifyColumnItem) super.ItemByColumnName(AName)); } public final TRtModifyColumnItem ItemByOldColumnName(String AName) { TRtModifyColumnItem Result; int i; i = IndexByOldColumnName(AName); if (i >= 0) { Result = this.GetItem(i); } else { Result = null; } return Result; } public final int IndexByOldColumnName(String AName) { int Result; int i; for (i = 0; i <= GetCount() - 1; ++i) { if (CompareText(this.GetItem(i).getOldColName(), AName) == 0) { Result = i; return Result; } } return -1; } public final int RemoveByOldColumnName(String AName) { int Result; Result = IndexByOldColumnName(AName); if (Result >= 0) { Delete(Result); } return Result; } public TRtModifyColumnsListClass ClassType() { return TRtModifyColumnsListClass.SINGLETON; } } public static class TRtSingleIndexColumnItem extends TSQLContainerItem { String FColName; public final void SetColName(String Value) { CheckUnprepare(); FColName = Value; } public final void runCreateColumn(TRtSingleIndexItem AOwner, String AColName) { super.runCreate(); FColName = AColName; AOwner.AddItem(this); } public static TRtSingleIndexColumnItem CreateColumn(TRtSingleIndexItem AOwner, String AColName) { TRtSingleIndexColumnItem Result; Result = new TRtSingleIndexColumnItem(); Result.runCreateColumn(AOwner, AColName); return Result; } public void Assign(TPersistent Source) { if (Source instanceof TRtSingleIndexColumnItem) { FColName = ((TRtSingleIndexColumnItem) Source).FColName; } else { super.Assign(Source); } } public void ReadData(TReader Reader) { super.ReadData(Reader); { TReader context_Reader = Reader; FColName = context_Reader.ReadString(); } } public void WriteData(TWriter Writer) { super.WriteData(Writer); { TWriter context_Writer = Writer; context_Writer.WriteString(FColName); } } public static TRtSingleIndexColumnItem Create() { TRtSingleIndexColumnItem Result; Result = new TRtSingleIndexColumnItem(); Result.runCreate(); return Result; } public TRtSingleIndexColumnItemClass ClassType() { return TRtSingleIndexColumnItemClass.SINGLETON; } public String getColName() { return FColName; } } public static class TRtSingleIndexColumnItemClass extends TSQLContainerItemClass { public static final TRtSingleIndexColumnItemClass SINGLETON = new TRtSingleIndexColumnItemClass(); public final TRtSingleIndexColumnItem CreateColumn(TRtSingleIndexItem AOwner, String AColName) { return TRtSingleIndexColumnItem.CreateColumn(AOwner, AColName); } public TRtSingleIndexColumnItem Create() { return TRtSingleIndexColumnItem.Create(); } public Class ClassInfo() { return TRtSingleIndexColumnItem.class; } } public static final class TRtIndexColumnItem extends TRtSingleIndexColumnItem { private int FOrder; public final void SetOrder(int Value) { CheckUnprepare(); FOrder = Value; } public final void runCreateColumn(TRtIndexItem AOwner, String AColName, int AOrder) { super.runCreate(); FColName = AColName; FOrder = AOrder; AOwner.AddItem(this); } public static TRtIndexColumnItem CreateColumn(TRtIndexItem AOwner, String AColName, int AOrder) { TRtIndexColumnItem Result; Result = new TRtIndexColumnItem(); Result.runCreateColumn(AOwner, AColName, AOrder); return Result; } public void Assign(TPersistent Source) { super.Assign(Source); if (Source instanceof TRtIndexColumnItem) { FOrder = ((TRtIndexColumnItem) Source).FOrder; } } public void ReadData(TReader Reader) { super.ReadData(Reader); { TReader context_Reader = Reader; context_Reader.Read(AsVar(FOrder), SizeOf(FOrder)); } } public void WriteData(TWriter Writer) { super.WriteData(Writer); { TWriter context_Writer = Writer; context_Writer.Write(AsConst(FOrder), SizeOf(FOrder)); } } public TRtIndexColumnItemClass ClassType() { return TRtIndexColumnItemClass.SINGLETON; } public int getOrder() { return FOrder; } } public static final class TRtIndexColumnItemClass extends TRtSingleIndexColumnItemClass { public static final TRtIndexColumnItemClass SINGLETON = new TRtIndexColumnItemClass(); public final TRtIndexColumnItem CreateColumn(TRtIndexItem AOwner, String AColName, int AOrder) { return TRtIndexColumnItem.CreateColumn(AOwner, AColName, AOrder); } public Class ClassInfo() { return TRtIndexColumnItem.class; } } public static class TRtSingleIndexColumnListClass extends TSQLTypedListOwnerClass { public static final TRtSingleIndexColumnListClass SINGLETON = new TRtSingleIndexColumnListClass(); public Class ClassInfo() { return TRtSingleIndexColumnList.class; } } public static class TRtSingleIndexColumnList extends TSQLTypedListOwner { protected TContainerItemClass AllocItemType() { return TRtSingleIndexColumnItemClass.SINGLETON; } public TRtSingleIndexColumnItem GetItem(int Index) { return ((TRtSingleIndexColumnItem) Get(Index)); } public TRtSingleIndexColumnListClass ClassType() { return TRtSingleIndexColumnListClass.SINGLETON; } } public static final class TRtIndexColumnListClass extends TRtSingleIndexColumnListClass { public static final TRtIndexColumnListClass SINGLETON = new TRtIndexColumnListClass(); public Class ClassInfo() { return TRtIndexColumnList.class; } } public static final class TRtIndexColumnList extends TRtSingleIndexColumnList { protected TContainerItemClass AllocItemType() { return TRtIndexColumnItemClass.SINGLETON; } public final TRtIndexColumnItem GetItem(int Index) { return ((TRtIndexColumnItem) Get(Index)); } public TRtIndexColumnListClass ClassType() { return TRtIndexColumnListClass.SINGLETON; } } public static class TRtSingleIndexItemClass extends TSQLNamedContainerItemClass { public static final TRtSingleIndexItemClass SINGLETON = new TRtSingleIndexItemClass(); public TRtSingleIndexItem Create() { return TRtSingleIndexItem.Create(); } public final TRtSingleIndexItem CreateParented(TRtSingleIndexItemList AOwner, String IndexName) { return TRtSingleIndexItem.CreateParented(AOwner, IndexName); } public Class ClassInfo() { return TRtSingleIndexItem.class; } } public static class TRtSingleIndexItem extends TSQLNamedContainerItem { int FOption; TRtSingleIndexColumnList FColumns; final void AddItem(TRtSingleIndexColumnItem AItem) { CheckUnprepare(); FColumns.Add(AItem); } final void Init(TRtSingleIndexItemList AOwner, String IndexName) { SetName(IndexName); if (AOwner != null) { AOwner.AddItem(this); } FColumns = ((TRtSingleIndexColumnList) Creator(this, TRtSingleIndexColumnListClass.SINGLETON)); } public final void SetOption(int AOption) { if (AOption != rcaAdd && GetTypedOwner(TRtAlterTableClass.SINGLETON) == null) { throw DelphiException.Create(TransStr("TC660", "Opção suportada só sobre TRtAlterTable.", true)); } FOption = AOption; CheckUnprepare(); } public void runCreate() { super.runCreate(); FColumns = ((TRtSingleIndexColumnList) Creator(this, TRtSingleIndexColumnListClass.SINGLETON)); } public static TRtSingleIndexItem Create() { TRtSingleIndexItem Result; Result = new TRtSingleIndexItem(); Result.runCreate(); return Result; } public final void runCreateParented(TRtSingleIndexItemList AOwner, String IndexName) { super.runCreate(); Init(AOwner, IndexName); } public static TRtSingleIndexItem CreateParented(TRtSingleIndexItemList AOwner, String IndexName) { TRtSingleIndexItem Result; Result = new TRtSingleIndexItem(); Result.runCreateParented(AOwner, IndexName); return Result; } public void Destroy() { FColumns.Free(); super.Destroy(); } public void Assign(TPersistent Source) { super.Assign(Source); if (Source instanceof TRtSingleIndexItem) { FOption = ((TRtSingleIndexItem) Source).FOption; FColumns.Assign(((TRtSingleIndexItem) Source).FColumns); } } public void ReadData(TReader Reader) { super.ReadData(Reader); Reader.Read(AsVar(FOption), SizeOf(FOption)); FColumns.ReadData(Reader); } public void WriteData(TWriter Writer) { super.WriteData(Writer); Writer.Write(AsConst(FOption), SizeOf(FOption)); FColumns.WriteData(Writer); } public TRtSingleIndexColumnItem ItemByColumnName(String AColName) { TRtSingleIndexColumnItem Result; int i; i = IndexByColumnName(AColName); if (i >= 0) { Result = FColumns.GetItem(i); } else { Result = null; } return Result; } public final int IndexByColumnName(String AColName) { int Result; int i; for (i = 0; i <= FColumns.GetCount() - 1; ++i) { if (CompareText(FColumns.GetItem(i).getColName(), AColName) == 0) { Result = i; return Result; } } return -1; } public final int RemoveByColumnName(String AColName) { int Result; Result = IndexByColumnName(AColName); if (Result >= 0) { FColumns.Delete(Result); } return Result; } public final void AddColumn(String AColName) { TRtSingleIndexColumnItemClass AClass; CheckUnprepare(); AClass = ((TRtSingleIndexColumnItemClass) FColumns.AllocItemType()); AClass.CreateColumn(this, AColName); } public final void AddAllColumns(String AColNames) { TInt p = new TInt(); String s = ""; CheckUnprepare(); p.v = 0; s = StrGetNextToken(AColNames, p, ';'); while (!StrIsBlank(s)) { AddColumn(s); s = StrGetNextToken(AColNames, p, ';'); } } public TRtSingleIndexItemClass ClassType() { return TRtSingleIndexItemClass.SINGLETON; } public int getOption() { return FOption; } public TRtSingleIndexColumnList getColumns() { return FColumns; } } public static final class TRtIndexItemClass extends TRtSingleIndexItemClass { public static final TRtIndexItemClass SINGLETON = new TRtIndexItemClass(); public final TRtIndexItem CreateParented(TRtIndexItemList AOwner, String IndexName, boolean LUnique) { return TRtIndexItem.CreateParented(AOwner, IndexName, LUnique); } public TContainerItem Creator(TPersistent AOwner, TContainerItemClass AType) { if (AType == TRtSingleIndexColumnListClass.SINGLETON) { AType = TRtIndexColumnListClass.SINGLETON; } return super.Creator(AOwner, AType); } public Class ClassInfo() { return TRtIndexItem.class; } } public static final class TRtIndexItem extends TRtSingleIndexItem { boolean FUnique; final void Init(TRtIndexItemList AOwner, String IndexName, boolean LUnique) { super.Init(AOwner, IndexName); FUnique = LUnique; } public final TRtIndexColumnList GetColumns() { return (TRtIndexColumnList) FColumns; } public final void SetUnique(boolean Value) { CheckUnprepare(); FUnique = Value; } public final void runCreateParented(TRtIndexItemList AOwner, String IndexName, boolean LUnique) { super.runCreate(); Init(AOwner, IndexName, LUnique); } public static TRtIndexItem CreateParented(TRtIndexItemList AOwner, String IndexName, boolean LUnique) { TRtIndexItem Result; Result = new TRtIndexItem(); Result.runCreateParented(AOwner, IndexName, LUnique); return Result; } public TContainerItem Creator(TPersistent AOwner, TContainerItemClass AType) { return ClassType().Creator(AOwner, AType); } public void Assign(TPersistent Source) { super.Assign(Source); if (Source instanceof TRtIndexItem) { FUnique = ((TRtIndexItem) Source).FUnique; } } public void ReadData(TReader Reader) { super.ReadData(Reader); FUnique = Reader.ReadBoolean(); } public void WriteData(TWriter Writer) { super.WriteData(Writer); Writer.WriteBoolean(FUnique); } public final TRtIndexColumnItem ItemByColumnName(String AColName) { return ((TRtIndexColumnItem) super.ItemByColumnName(AColName)); } public final void AddColumnOrdered(String AColName, int AOrder) { TRtIndexColumnItemClass AClass; CheckUnprepare(); AClass = ((TRtIndexColumnItemClass) FColumns.AllocItemType()); AClass.CreateColumn(this, AColName, AOrder); } public TRtIndexItemClass ClassType() { return TRtIndexItemClass.SINGLETON; } public int getOption() { return FOption; } public boolean getUnique() { return FUnique; } } public static class TRtSingleIndexItemListClass extends TSQLNamedListOwnerClass { public static final TRtSingleIndexItemListClass SINGLETON = new TRtSingleIndexItemListClass(); public Class ClassInfo() { return TRtSingleIndexItemList.class; } } public static class TRtSingleIndexItemList extends TSQLNamedListOwner { protected TContainerItemClass AllocItemType() { return TRtSingleIndexItemClass.SINGLETON; } public TRtSingleIndexItem GetItem(int Index) { return ((TRtSingleIndexItem) Get(Index)); } protected final TRtSingleIndexItem AddUniqueConstraint(String IndexName) { CheckUnprepare(); return ((TRtSingleIndexItem) AddNewItem(IndexName)); } public TRtSingleIndexItem ItemByName(String IndexName) { return ((TRtSingleIndexItem) super.ItemByName(IndexName)); } public TRtSingleIndexItemListClass ClassType() { return TRtSingleIndexItemListClass.SINGLETON; } } public static final class TRtIndexItemListClass extends TRtSingleIndexItemListClass { public static final TRtIndexItemListClass SINGLETON = new TRtIndexItemListClass(); public Class ClassInfo() { return TRtIndexItemList.class; } } public static final class TRtIndexItemList extends TRtSingleIndexItemList { protected TContainerItemClass AllocItemType() { return TRtIndexItemClass.SINGLETON; } public final TRtIndexItem GetItem(int Index) { return ((TRtIndexItem) Get(Index)); } public final TRtIndexItem AddIndex(String IndexName, boolean LUnique) { TRtIndexItem Result; CheckUnprepare(); Result = ((TRtIndexItem) AddNewItem(IndexName)); Result.FUnique = LUnique; return Result; } public final TRtIndexItem ItemByName(String IndexName) { return ((TRtIndexItem) super.ItemByName(IndexName)); } public TRtIndexItemListClass ClassType() { return TRtIndexItemListClass.SINGLETON; } } public static final class TRtForeignKeyColumnItemClass extends TSQLNamedContainerItemClass { public static final TRtForeignKeyColumnItemClass SINGLETON = new TRtForeignKeyColumnItemClass(); public final TRtForeignKeyColumnItem CreateParented(TRtForeignKeyItem AOwner, String AThsColName, String AOthColName) { return TRtForeignKeyColumnItem.CreateParented(AOwner, AThsColName, AOthColName); } public Class ClassInfo() { return TRtForeignKeyColumnItem.class; } } public static final class TRtForeignKeyColumnItem extends TSQLNamedContainerItem { String FThsColName; String FOthColName; public final void SetThsColName(String Value) { CheckUnprepare(); SetName(Value + FOthColName); FThsColName = Value; } public final void SetOthColName(String Value) { CheckUnprepare(); SetName(FThsColName + Value); FOthColName = Value; } final void Init(TRtForeignKeyItem AOwner, String AThsColName, String AOthColName) { FThsColName = AThsColName; FOthColName = AOthColName; SetName(FThsColName + FOthColName); AOwner.AddItem(this); } public final void runCreateParented(TRtForeignKeyItem AOwner, String AThsColName, String AOthColName) { super.runCreate(); Init(AOwner, AThsColName, AOthColName); } public static TRtForeignKeyColumnItem CreateParented(TRtForeignKeyItem AOwner, String AThsColName, String AOthColName) { TRtForeignKeyColumnItem Result; Result = new TRtForeignKeyColumnItem(); Result.runCreateParented(AOwner, AThsColName, AOthColName); return Result; } public void Assign(TPersistent Source) { super.Assign(Source); if (Source instanceof TRtForeignKeyColumnItem) { FThsColName = ((TRtForeignKeyColumnItem) Source).FThsColName; FOthColName = ((TRtForeignKeyColumnItem) Source).FOthColName; } } public void ReadData(TReader Reader) { super.ReadData(Reader); { TReader context_Reader = Reader; FThsColName = context_Reader.ReadString(); FOthColName = context_Reader.ReadString(); } } public void WriteData(TWriter Writer) { super.WriteData(Writer); { TWriter context_Writer = Writer; context_Writer.WriteString(FThsColName); context_Writer.WriteString(FOthColName); } } public TRtForeignKeyColumnItemClass ClassType() { return TRtForeignKeyColumnItemClass.SINGLETON; } public String getThsColName() { return FThsColName; } public String getOthColName() { return FOthColName; } } public static final class TRtForeignKeyColumnListClass extends TSQLNamedListOwnerClass { public static final TRtForeignKeyColumnListClass SINGLETON = new TRtForeignKeyColumnListClass(); public Class ClassInfo() { return TRtForeignKeyColumnList.class; } } public static final class TRtForeignKeyColumnList extends TSQLNamedListOwner { protected TContainerItemClass AllocItemType() { return TRtForeignKeyColumnItemClass.SINGLETON; } public final TRtForeignKeyColumnItem GetItem(int Index) { return ((TRtForeignKeyColumnItem) Get(Index)); } public TRtForeignKeyColumnListClass ClassType() { return TRtForeignKeyColumnListClass.SINGLETON; } } public static final class TRtForeignKeyItemClass extends TSQLNamedContainerItemClass { public static final TRtForeignKeyItemClass SINGLETON = new TRtForeignKeyItemClass(); public TRtForeignKeyItem Create() { return TRtForeignKeyItem.Create(); } public final TRtForeignKeyItem CreateParented(TRtForeignKeyList AOwner, String AConstraintName) { return TRtForeignKeyItem.CreateParented(AOwner, AConstraintName); } public Class ClassInfo() { return TRtForeignKeyItem.class; } } public static final class TRtForeignKeyItem extends TSQLNamedContainerItem { int FOption; private TRtForeignKeyColumnList FColRelList; String FForeignTable; private String FReferenceTable; final void AddItem(TRtForeignKeyColumnItem AItem) { CheckUnprepare(); FColRelList.AddItem(AItem); } final void Init(TRtForeignKeyList AOwner, String AConstraintName) { SetName(AConstraintName); if (AOwner != null) { AOwner.AddItem(this); } } public final void SetOption(int AOption) { if (AOption != rcaAdd && GetTypedOwner(TRtAlterTableClass.SINGLETON) == null) { throw DelphiException.Create(TransStr("TC660", "Opção suportada só sobre TRtAlterTable.", true)); } FOption = AOption; CheckUnprepare(); } public final void SetReferenceTable(String Value) { CheckUnprepare(); FReferenceTable = Value; } public final void SetForeignTable(String Value) { CheckUnprepare(); FForeignTable = Value; } public final String GetForeignTable() { String Result = ""; if (StrIsBlank(FForeignTable)) { Result = (((TRtCreateTable) GetTypedOwner(TRtCreateTableClass.SINGLETON))).GetTableName(); } else { Result = FForeignTable; } return Result; } public void runCreate() { super.runCreate(); FColRelList = ((TRtForeignKeyColumnList) Creator(this, TRtForeignKeyColumnListClass.SINGLETON)); } public static TRtForeignKeyItem Create() { TRtForeignKeyItem Result; Result = new TRtForeignKeyItem(); Result.runCreate(); return Result; } public final void runCreateParented(TRtForeignKeyList AOwner, String AConstraintName) { runCreate(); Init(AOwner, AConstraintName); } public static TRtForeignKeyItem CreateParented(TRtForeignKeyList AOwner, String AConstraintName) { TRtForeignKeyItem Result; Result = new TRtForeignKeyItem(); Result.runCreateParented(AOwner, AConstraintName); return Result; } public void Destroy() { FColRelList.Free(); super.Destroy(); } public void Assign(TPersistent Source) { super.Assign(Source); if (Source instanceof TRtForeignKeyItem) { FOption = ((TRtForeignKeyItem) Source).FOption; FForeignTable = ((TRtForeignKeyItem) Source).FForeignTable; FReferenceTable = ((TRtForeignKeyItem) Source).FReferenceTable; FColRelList.Assign(((TRtForeignKeyItem) Source).FColRelList); } } public void ReadData(TReader Reader) { super.ReadData(Reader); Reader.Read(AsVar(FOption), SizeOf(FOption)); FForeignTable = Reader.ReadString(); FReferenceTable = Reader.ReadString(); FColRelList.ReadData(Reader); } public void WriteData(TWriter Writer) { super.WriteData(Writer); Writer.Write(AsConst(FOption), SizeOf(FOption)); Writer.WriteString(FForeignTable); Writer.WriteString(FReferenceTable); FColRelList.WriteData(Writer); } public final int IndexByColumnNames(String ThsColName, String OthColName) { int Result; for (Result = 0; Result <= FColRelList.GetCount() - 1; ++Result) { { TRtForeignKeyColumnItem context_GetItem = FColRelList.GetItem(Result); if (CompareText(context_GetItem.FThsColName, context_GetItem.getThsColName()) == 0 && CompareText(context_GetItem.FOthColName, context_GetItem.getOthColName()) == 0) { return Result; } } } return -1; } public final int RemoveByColumnNames(String ThsColName, String OthColName) { int Result; Result = IndexByColumnNames(ThsColName, OthColName); if (Result >= 0) { FColRelList.Delete(Result); } return Result; } public final int IndexByThsColumnName(String ThsColName) { int Result; for (Result = 0; Result <= FColRelList.GetCount() - 1; ++Result) { if (CompareText(FColRelList.GetItem(Result).getThsColName(), ThsColName) == 0) { return Result; } } return -1; } public final int RemoveByThsColumnName(String ThsColName) { int Result; Result = IndexByThsColumnName(ThsColName); if (Result >= 0) { FColRelList.Delete(Result); } return Result; } public final int IndexByOthColumnName(String OthColName) { int Result; for (Result = 0; Result <= FColRelList.GetCount() - 1; ++Result) { if (CompareText(FColRelList.GetItem(Result).getOthColName(), OthColName) == 0) { return Result; } } return -1; } public final int RemoveByOthColumnName(String OthColName) { int Result; Result = IndexByOthColumnName(OthColName); if (Result >= 0) { FColRelList.Delete(Result); } return Result; } public final void AddColumns(String ThsColName, String OthColName) { CheckUnprepare(); (((TRtForeignKeyColumnItem) FColRelList.AllocItemType().Create())).Init(this, ThsColName, OthColName); } public TRtForeignKeyItemClass ClassType() { return TRtForeignKeyItemClass.SINGLETON; } public int getOption() { return FOption; } public String getReferenceTable() { return FReferenceTable; } public TRtForeignKeyColumnList getColumns() { return FColRelList; } } public static final class TRtForeignKeyListClass extends TSQLNamedListOwnerClass { public static final TRtForeignKeyListClass SINGLETON = new TRtForeignKeyListClass(); public Class ClassInfo() { return TRtForeignKeyList.class; } } public static final class TRtForeignKeyList extends TSQLNamedListOwner { protected TContainerItemClass AllocItemType() { return TRtForeignKeyItemClass.SINGLETON; } public final TRtForeignKeyItem GetItem(int Index) { return ((TRtForeignKeyItem) Get(Index)); } public final TRtForeignKeyItem AddForeignKey(String AConstraintName, String AReferenceTable) { TRtForeignKeyItem Result; CheckUnprepare(); Result = ((TRtForeignKeyItem) AddNewItem(AConstraintName)); Result.SetReferenceTable(AReferenceTable); return Result; } public final TRtForeignKeyItem ItemByName(String ConstraintName) { return ((TRtForeignKeyItem) super.ItemByName(ConstraintName)); } public TRtForeignKeyListClass ClassType() { return TRtForeignKeyListClass.SINGLETON; } } public static final class TRtTriggerItemClass extends TSQLNamedContainerItemClass { public static final TRtTriggerItemClass SINGLETON = new TRtTriggerItemClass(); public TRtTriggerItem Create() { return TRtTriggerItem.Create(); } public Class ClassInfo() { return TRtTriggerItem.class; } } public static final class TRtTriggerItem extends TSQLNamedContainerItem { protected String FCode; protected TRtCCompiledNodeList FCompiledCode; protected int FOption; protected boolean FForEachRow; public void SetName(String Value) { if (StrIsBlank(GetName())) { super.SetName(Value); } } public final void SetCode(String Value) { TString AName = new TString(); TString ATableName = new TString(); DelphiSet AEvents = DelphiSet.get(); TBoolean AForEachRow = new TBoolean(); TRtTableSQL ATableSql; TRtCCompiledNodeList ACCode; CheckUnprepare(); if (StrIsBlank(Value)) { if (FCompiledCode != null) { FCompiledCode.Free(); } FCompiledCode = null; } else if (CompareText(Value, FCode) != 0 || FCompiledCode == null) { ACCode = TriggerCreatorFunc(Value, AName, ATableName, AEvents, AForEachRow); try { super.SetName(AName.v); ATableSql = ((TRtTableSQL) GetTypedOwner(TRtTableSQLClass.SINGLETON)); if (ATableSql != null) { if (StrIsBlank(ATableSql.GetName())) { ATableSql.SetTableName(ATableName.v); } else if (CompareText(ATableSql.GetName(), ATableName.v) != 0) { throw DelphiException.CreateFmt(TransStr("TC661", "Nome da tabela \"%s\", referenciada pela trigger \"%s\" não confere com a tabela \"%s\".", true), new Object[] { ATableName.v, GetName(), ATableSql.GetName() }); } } } catch (Throwable any) { ACCode.Free(); throw wrap(any); } if (FCompiledCode != null) { FCompiledCode.Free(); } FCompiledCode = ACCode; } FCode = Value; } public final void SetOption(int AOption) { CheckUnprepare(); FOption = AOption; } protected final void Init(TRtTriggerItemList AOwner, String ATriggerName) { CheckUnprepare(); FCode = ""; if (FCompiledCode != null) { FCompiledCode.Free(); FCompiledCode = null; } SetName(ATriggerName); if (AOwner != null) { AOwner.AddItem(this); } } public void Destroy() { if (FCompiledCode != null) { FCompiledCode.Free(); FCompiledCode = null; } super.Destroy(); } public void Assign(TPersistent Source) { super.Assign(Source); if (Source instanceof TRtTriggerItem) { FCode = ((TRtTriggerItem) Source).FCode; FForEachRow = ((TRtTriggerItem) Source).FForEachRow; if (((TRtTriggerItem) Source).FCompiledCode != null) { if (FCompiledCode == null) { FCompiledCode = TRtCCompiledNodeList.Create(); } FCompiledCode.Assign(((TRtTriggerItem) Source).FCompiledCode); } else if (FCompiledCode != null) { FCompiledCode.Free(); FCompiledCode = null; } FOption = ((TRtTriggerItem) Source).FOption; } } public void ReadData(TReader Reader) { boolean LHasCompiledCode; super.ReadData(Reader); FCode = Reader.ReadString(); LHasCompiledCode = Reader.ReadBoolean(); if (LHasCompiledCode) { if (FCompiledCode == null) { FCompiledCode = TRtCCompiledNodeList.Create(); } FCompiledCode.ReadData(Reader); } else if (FCompiledCode != null) { FCompiledCode.Free(); FCompiledCode = null; } Reader.Read(AsVar(FOption), SizeOf(FOption)); FForEachRow = Reader.ReadBoolean(); } public void WriteData(TWriter Writer) { boolean LHasCompiledCode; super.WriteData(Writer); Writer.WriteString(FCode); LHasCompiledCode = FCompiledCode != null; Writer.WriteBoolean(LHasCompiledCode); if (LHasCompiledCode) { FCompiledCode.WriteData(Writer); } Writer.Write(AsConst(FOption), SizeOf(FOption)); Writer.WriteBoolean(FForEachRow); } public final void AssignFromTriggerDef(TRtTriggerDef ATrgDef) { String ATableName = ""; TRtTableSQL ATableSql; CheckUnprepare(); ATableName = ATrgDef.GetTable().GetName(); ATableSql = ((TRtTableSQL) GetTypedOwner(TRtTableSQLClass.SINGLETON)); if (ATableSql != null) { if (StrIsBlank(ATableSql.GetName())) { ATableSql.SetTableName(ATableName); } else if (CompareText(ATableSql.GetName(), ATableName) != 0) { throw DelphiException.CreateFmt(TransStr("TC661", "Nome da tabela \"%s\", referenciada pela trigger \"%s\" não confere com a tabela \"%s\".", true), new Object[] { ATableName, GetName(), ATableSql.GetName() }); } } if (FCompiledCode != null) { FCompiledCode.Free(); } FCompiledCode = null; FCode = ATrgDef.getCode(); FForEachRow = ATrgDef.getForEachRow(); super.SetName(ATrgDef.GetName()); } public final void CheckCompiledCode() { if (FCompiledCode == null) { SetCode(FCode); } } public static TRtTriggerItem Create() { TRtTriggerItem Result; Result = new TRtTriggerItem(); Result.runCreate(); return Result; } public TRtTriggerItemClass ClassType() { return TRtTriggerItemClass.SINGLETON; } public String getCode() { return FCode; } public int getOption() { return FOption; } public TRtCCompiledNodeList getCompiledCode() { return FCompiledCode; } public boolean getForEachRow() { return FForEachRow; } } public static final class TRtTriggerItemListClass extends TSQLNamedListOwnerClass { public static final TRtTriggerItemListClass SINGLETON = new TRtTriggerItemListClass(); public Class ClassInfo() { return TRtTriggerItemList.class; } } public static final class TRtTriggerItemList extends TSQLNamedListOwner { protected TContainerItemClass AllocItemType() { return TRtTriggerItemClass.SINGLETON; } public final TRtTriggerItem GetItem(int Index) { return ((TRtTriggerItem) Get(Index)); } protected final TRtTriggerItem AddNewItem(String _TrgName, boolean _ForEachRow) { TRtTriggerItem Result; int i; Result = TRtTriggerItem.Create(); Result.SetName(_TrgName); Result.FForEachRow = _ForEachRow; i = 0; while (i < GetCount() && !GetItem(i).getForEachRow()) { i++; } super.InsertItem(i, Result); return Result; } public final TRtTriggerItem AddTrigger(String ATrgName, String ACode, boolean _ForEachRow) { TRtTriggerItem Result; CheckUnprepare(); Result = AddNewItem(ATrgName, _ForEachRow); try { Result.SetCode(ACode); } catch (Throwable any) { Result.Free(); throw wrap(any); } return Result; } public final TRtTriggerItem AddTriggerFromTriggerDef(TRtTriggerDef ATrgDef) { TRtTriggerItem Result; CheckUnprepare(); Result = AddNewItem(ATrgDef.GetName(), ATrgDef.getForEachRow()); try { Result.AssignFromTriggerDef(ATrgDef); } catch (Throwable any) { Result.Free(); throw wrap(any); } return Result; } public final TRtTriggerItem ItemByName(String AName) { return ((TRtTriggerItem) super.ItemByName(AName)); } public TRtTriggerItemListClass ClassType() { return TRtTriggerItemListClass.SINGLETON; } } public static class TRtTableSQLClass extends TRtCustomUpdateSQLClass { public static final TRtTableSQLClass SINGLETON = new TRtTableSQLClass(); protected TRtTableSQL CreateSQL(TRtDBConnection AConn, String ATableName) { return TRtTableSQL.CreateSQL(AConn, ATableName); } public TRtTableSQL Create() { return TRtTableSQL.Create(); } public Class ClassInfo() { return TRtTableSQL.class; } } public static class TRtTableSQL extends TRtCustomUpdateSQL { private String FTableName; public boolean GetHasOperation() { return !StrIsBlank(GetName()); } public final void SetTableName(String Value) { CheckUnprepare(); FTableName = Value; } public final String GetName() { return FTableName; } protected void runCreateSQL(TRtDBConnection AConn, String ATableName) { super.runCreateSQL(AConn); FTableName = ATableName; } protected static TRtTableSQL CreateSQL(TRtDBConnection AConn, String ATableName) { TRtTableSQL Result; Result = new TRtTableSQL(); Result.runCreateSQL(AConn, ATableName); return Result; } public void Assign(TPersistent Source) { super.Assign(Source); if (Source instanceof TRtTableSQL) { FTableName = ((TRtTableSQL) Source).FTableName; } } public void ReadData(TReader Reader) { super.ReadData(Reader); FTableName = Reader.ReadString(); } public void WriteData(TWriter Writer) { super.WriteData(Writer); Writer.WriteString(FTableName); } public static TRtTableSQL Create() { TRtTableSQL Result; Result = new TRtTableSQL(); Result.runCreate(); return Result; } public TRtTableSQLClass ClassType() { return TRtTableSQLClass.SINGLETON; } } public static class TRtDDLFunctions extends TPersistent { public void CreateTriggers(TRtDBConnection _Connection, TRtTableDef _TableDef, TRtOnUpdateProgress _OnCompleted, TStrings _Script, boolean _reRaise) { throw abstractCall(); } public void DropTriggers(TRtDBConnection _Connection, TRtTableDef _TableDef, TRtOnUpdateProgress _OnCompleted, TStrings _Script, boolean _reRaise) { throw abstractCall(); } public void DisableConstraints(TRtDBConnection aConnection, TRtTableDef aTableDef, TStrings aScript, boolean areRaise) { throw abstractCall(); } public void EnableConstraints(TRtDBConnection aConnection, TStrings aTableList, TRtOnUpdateProgress aOnCompleted, TStrings aScript) { throw abstractCall(); } public TRtDDLFunctionsClass ClassType() { return TRtDDLFunctionsClass.SINGLETON; } } public static class TRtDDLFunctionsClass extends TPersistentClass { public static final TRtDDLFunctionsClass SINGLETON = new TRtDDLFunctionsClass(); public void CreateTriggers(TRtDBConnection _Connection, TRtTableDef _TableDef, TRtOnUpdateProgress _OnCompleted, TStrings _Script, boolean _reRaise) { throw abstractCall(); } public void DropTriggers(TRtDBConnection _Connection, TRtTableDef _TableDef, TRtOnUpdateProgress _OnCompleted, TStrings _Script, boolean _reRaise) { throw abstractCall(); } public void DisableConstraints(TRtDBConnection aConnection, TRtTableDef aTableDef, TStrings aScript, boolean areRaise) { throw abstractCall(); } public void EnableConstraints(TRtDBConnection aConnection, TStrings aTableList, TRtOnUpdateProgress aOnCompleted, TStrings aScript) { throw abstractCall(); } public Class ClassInfo() { return TRtDDLFunctions.class; } } public static class TRtCustomDDLClass extends TRtCustomUpdateSQLClass { public static final TRtCustomDDLClass SINGLETON = new TRtCustomDDLClass(); public TRtCustomDDL CreateSQL(TRtDBConnection AConn) { return TRtCustomDDL.CreateSQL(AConn); } public Class ClassInfo() { return TRtCustomDDL.class; } } public static abstract class TRtCustomDDL extends TRtCustomUpdateSQL { private TRtDDLErrorEvent FOnDDLError; private TRtDDLStepEvent FOnBeforeDDLStep; public final void SetOnDDLError(TRtDDLErrorEvent Value) { FOnDDLError = Value; } public final TRtDDLErrorEvent GetOnDDLError() { TRtDDLErrorEvent Result; if (FOnDDLError != null) { Result = FOnDDLError; } else { Result = GetOwnerConnection().FOnDDLError; } return Result; } public final void SetOnBeforeDDLStep(TRtDDLStepEvent Value) { FOnBeforeDDLStep = Value; } public final TRtDDLStepEvent GetOnBeforeDDLStep() { TRtDDLStepEvent Result; if (FOnBeforeDDLStep != null) { Result = FOnBeforeDDLStep; } else { Result = GetOwnerConnection().FOnBeforeDDLStep; } return Result; } protected final boolean DoOnDDLError(int AAltStep, TRtQuery aCurRec, br.com.senior.svcl.db.RtAccess.TRtUpdate ANewRec) { TRtDDLErrorEvent Event; TBoolean LRetry = new TBoolean(); Event = GetOnDDLError(); if (Event != null) { Event.run(this, LRetry, AAltStep, aCurRec, ANewRec); } return LRetry.v; } protected final boolean DoOnDDLError(int AAltStep, TRtQuery aCurRec) { return DoOnDDLError(AAltStep, aCurRec, null); } protected final boolean DoOnDDLError(int AAltStep) { return DoOnDDLError(AAltStep, null, null); } protected final boolean DoOnDDLError() { return DoOnDDLError(atsNone, null, null); } protected final void DoOnBeforeDDLStep(int AAltStep, TRtQuery aCurRec, br.com.senior.svcl.db.RtAccess.TRtUpdate aNewRec) { TRtDDLStepEvent Event; Event = GetOnBeforeDDLStep(); if (Event != null) { Event.run(this, AAltStep, aCurRec, aNewRec); } } protected final void DoOnBeforeDDLStep(int AAltStep, TRtQuery aCurRec) { DoOnBeforeDDLStep(AAltStep, aCurRec, null); } protected final void DoOnBeforeDDLStep(int AAltStep) { DoOnBeforeDDLStep(AAltStep, null, null); } protected final void DoOnBeforeDDLStep() { DoOnBeforeDDLStep(atsNone, null, null); } protected final void InternalExecuteWithRetry() { boolean LRetry; DoOnBeforeDDLStep(); while (true) { try { InternalExecuteUpdate(); break; } catch (Throwable any) { LRetry = DoOnDDLError(); if (LRetry) { continue; } else { throw wrap(any); } } } } public abstract String GetName(); public void ExecuteUpd() { String ASql = ""; String ALastSQLs = ""; boolean LRetry; DoOnBeforeDDLStep(); ASql = GenSQL(); while (true) { try { ALastSQLs = ExecuteMultipleSQLs(ASql, 0, ALastSQLs); UpdatePhyDatabase(); break; } catch (Throwable any) { LRetry = DoOnDDLError(); if (LRetry) { continue; } else { throw wrap(any); } } } } public static TRtCustomDDL CreateSQL(TRtDBConnection AConn) { // TRtCustomDDL Result; // Result = new TRtCustomDDL(); // Result.runCreateSQL(AConn); // return Result; throw pending(); } public TRtCustomDDLClass ClassType() { return TRtCustomDDLClass.SINGLETON; } } public static class TRtCustomDDLTableClass extends TRtCustomDDLClass { public static final TRtCustomDDLTableClass SINGLETON = new TRtCustomDDLTableClass(); protected TRtCustomDDLTable CreateSQL(TRtDBConnection AConn, String ATableName) { return TRtCustomDDLTable.CreateSQL(AConn, ATableName); } public TRtCustomDDLTable Create() { return TRtCustomDDLTable.Create(); } public Class ClassInfo() { return TRtCustomDDLTable.class; } } public static class TRtCustomDDLTable extends TRtCustomDDL { String FTableName; public boolean GetHasOperation() { return !StrIsBlank(GetTableName()); } public final void SetTableName(String Value) { CheckUnprepare(); FTableName = Value; } protected void runCreateSQL(TRtDBConnection AConn, String ATableName) { super.runCreateSQL(AConn); FTableName = ATableName; } protected static TRtCustomDDLTable CreateSQL(TRtDBConnection AConn, String ATableName) { TRtCustomDDLTable Result; Result = new TRtCustomDDLTable(); Result.runCreateSQL(AConn, ATableName); return Result; } public String GetName() { return FTableName; } public final String GetTableName() { return FTableName; } public final TRtTableDef CheckTableDef(boolean aNewDatabase, boolean aRaiseNotFound) { TRtTableDef Result; TRtDatabaseDef xDatabasedef; if (aNewDatabase) { xDatabasedef = GetOwnerConnection().GetNewDatabase(); } else { xDatabasedef = GetOwnerConnection().getPhyDatabase(); } Assert(xDatabasedef != null, TransStrFmt("TC3295", "Database não informado - CheckTable(%0:s)", new Object[] { ClassName() }, true)); Result = xDatabasedef.TableByName(GetTableName()); if (aRaiseNotFound && Result == null) { throw DelphiException.CreateFmt(TransStr("TC662", "Tabela %s não encontrada para %s", true), new Object[] { GetTableName(), ClassName() }); } return Result; } public void Assign(TPersistent Source) { super.Assign(Source); if (Source instanceof TRtCustomDDLTable) { FTableName = ((TRtCustomDDLTable) Source).FTableName; } } public void ReadData(TReader Reader) { super.ReadData(Reader); FTableName = Reader.ReadString(); } public void WriteData(TWriter Writer) { super.WriteData(Writer); Writer.WriteString(FTableName); } public static TRtCustomDDLTable Create() { TRtCustomDDLTable Result; Result = new TRtCustomDDLTable(); Result.runCreate(); return Result; } public TRtCustomDDLTableClass ClassType() { return TRtCustomDDLTableClass.SINGLETON; } } public static class TRtAliasedTableSQLClass extends TRtTableSQLClass { public static final TRtAliasedTableSQLClass SINGLETON = new TRtAliasedTableSQLClass(); protected TRtAliasedTableSQL CreateSQL(TRtDBConnection AConn, String ATableName, String AAlias) { return TRtAliasedTableSQL.CreateSQL(AConn, ATableName, AAlias); } public TRtAliasedTableSQL Create() { return TRtAliasedTableSQL.Create(); } public Class ClassInfo() { return TRtAliasedTableSQL.class; } } public static class TRtAliasedTableSQL extends TRtTableSQL { protected String FALias; protected void runCreateSQL(TRtDBConnection AConn, String ATableName, String AAlias) { super.runCreateSQL(AConn, ATableName); FALias = AAlias; } protected static TRtAliasedTableSQL CreateSQL(TRtDBConnection AConn, String ATableName, String AAlias) { TRtAliasedTableSQL Result; Result = new TRtAliasedTableSQL(); Result.runCreateSQL(AConn, ATableName, AAlias); return Result; } public final void SetAlias(String Value) { CheckUnprepare(); FALias = Value; } public void Assign(TPersistent Source) { super.Assign(Source); if (Source instanceof TRtAliasedTableSQL) { FALias = ((TRtAliasedTableSQL) Source).FALias; } } public void ReadData(TReader Reader) { super.ReadData(Reader); FALias = Reader.ReadString(); } public void WriteData(TWriter Writer) { super.WriteData(Writer); Writer.WriteString(FALias); } public static TRtAliasedTableSQL Create() { TRtAliasedTableSQL Result; Result = new TRtAliasedTableSQL(); Result.runCreate(); return Result; } public TRtAliasedTableSQLClass ClassType() { return TRtAliasedTableSQLClass.SINGLETON; } public String getAlias() { return FALias; } } public static class TRtCreateTableClass extends TRtCustomDDLTableClass { public static final TRtCreateTableClass SINGLETON = new TRtCreateTableClass(); public TRtCreateTable Create() { return TRtCreateTable.Create(); } public final TRtCreateTable CreateSQL(TRtDBConnection AConn, String ATableName) { return TRtCreateTable.CreateSQL(AConn, ATableName); } public Class ClassInfo() { return TRtCreateTable.class; } } public static class TRtCreateTable extends TRtCustomDDLTable { public boolean GetHasOperation() { int Op; DelphiSet aSet = DelphiSet.get(); aSet = DelphiSet.get(); for (Op = RtSql.Low_TRtCrtAltAssignOption; Op <= RtSql.High_TRtCrtAltAssignOption; ++Op) { aSet = aSet.add(GetOperations(Op)); } return aSet != DelphiSet.get() && super.GetHasOperation(); } protected TRtAddColumnsList FColumns; protected TRtSingleIndexItem FPrimaryKey; protected TRtSingleIndexItemList FUniqueConstraints; protected TRtIndexItemList FIndexes; protected TRtForeignKeyList FForeignKeys; protected TRtTriggerItemList FTriggers; protected String FDataTableSpace; protected String FIndexTableSpace; protected void UpdatePhyDatabase() { TRtDatabaseDef ADbDef; TRtTableDef ATblDef; ADbDef = GetDatabaseDef(); if (ADbDef != null && !GetNotUpdatePhyDatabase()) { ATblDef = ADbDef.TableByName(FTableName); if (ATblDef == null) { ATblDef = ADbDef.NewTableDef(FTableName); } AssignToTableDef(ATblDef, DelphiSet.getRange(raaColumns, raaForeignKeys)); } } protected final void Init() { FColumns = ((TRtAddColumnsList) Creator(this, TRtAddColumnsListClass.SINGLETON)); FColumns.FDBVersionKind = getDBVersionKind(); FPrimaryKey = ((TRtSingleIndexItem) Creator(this, TRtSingleIndexItemClass.SINGLETON)); FUniqueConstraints = ((TRtSingleIndexItemList) Creator(this, TRtSingleIndexItemListClass.SINGLETON)); FIndexes = ((TRtIndexItemList) Creator(this, TRtIndexItemListClass.SINGLETON)); FForeignKeys = ((TRtForeignKeyList) Creator(this, TRtForeignKeyListClass.SINGLETON)); FTriggers = ((TRtTriggerItemList) Creator(this, TRtTriggerItemListClass.SINGLETON)); } public TRtAddColumnsList GetColumn() { return FColumns; } public final TRtSingleIndexItem GetPrimaryKey() { return FPrimaryKey; } public final TRtSingleIndexItem GetUniqueConstraint(String AName) { TRtSingleIndexItem Result; Result = FUniqueConstraints.ItemByName(AName); if (Result == null) { Result = ((TRtSingleIndexItem) Creator(null, TRtSingleIndexItemClass.SINGLETON)); Result.Init(FUniqueConstraints, AName); } return Result; } public final TRtIndexItem GetUniqueKey(String AName) { TRtIndexItem Result; Result = ((TRtIndexItem) FIndexes.ItemByName(AName)); if (Result != null) { if (!Result.getUnique()) { throw DelphiException.CreateFmt(TransStr("TC663", "%s não é um índice único.", true), new Object[] { AName }); } } else { Result = ((TRtIndexItem) Creator(null, TRtIndexItemClass.SINGLETON)); Result.Init(FIndexes, AName, true); } return Result; } public final TRtIndexItem GetIndex(String AName) { TRtIndexItem Result; Result = ((TRtIndexItem) FIndexes.ItemByName(AName)); if (Result != null) { if (Result.getUnique()) { throw DelphiException.CreateFmt(TransStr("TC664", "%s é um índice único.", true), new Object[] { AName }); } } else { Result = ((TRtIndexItem) Creator(null, TRtIndexItemClass.SINGLETON)); Result.Init(FIndexes, AName, false); } return Result; } public final TRtForeignKeyItem GetForeignKey(String AName) { TRtForeignKeyItem Result; Result = FForeignKeys.ItemByName(AName); if (Result == null) { Result = ((TRtForeignKeyItem) Creator(null, TRtForeignKeyItemClass.SINGLETON)); Result.Init(FForeignKeys, AName); } return Result; } public final TRtTriggerItem GetTrigger(String AName) { TRtTriggerItem Result; Result = FTriggers.ItemByName(AName); if (Result == null) { Result = ((TRtTriggerItem) Creator(null, TRtTriggerItemClass.SINGLETON)); Result.Init(FTriggers, AName); } return Result; } protected final void _AssignToTableDef(TRtTableDef ATblDef, DelphiSet AAssOpt, boolean LAlter) { int i; int c; String s = ""; TRtTableDef OldTblDef; TRtTableDef RelTblDef; TRtFieldDef AFldDef; TRtIndexDef ANdxDef; TRtUniqueConstraintDef AUniqueDef; TRtRelationDef ARelDef; TRtDatabaseDef ADbDef; if (LAlter) { OldTblDef = CheckGetDatabaseDef().CheckTableByName(FTableName); if (OldTblDef != ATblDef) { ATblDef.SetName(TempName()); ATblDef.setFixedName(true); ATblDef.Assign(OldTblDef); } } else { OldTblDef = null; } if (!GetOwnerConnection().FDisableEvents && GetOwnerConnection().FOnBeforeAssignToTableDef != null) { GetOwnerConnection().FOnBeforeAssignToTableDef.run(this, OldTblDef, ATblDef); } if (AAssOpt.contains(raaColumns)) { if (!LAlter) { ATblDef.ClearFields(); } for (i = 0; i <= FColumns.GetCount() - 1; ++i) { if (LAlter && (((TRtModifyColumnItem) FColumns.GetItem(i))).GetIsRenamingCol()) { s = (((TRtModifyColumnItem) FColumns.GetItem(i))).getOldColName(); } else { s = FColumns.GetItem(i).getColName(); } { TRtAddColumnItem context_GetItem = FColumns.GetItem(i); if (context_GetItem.getOption() == rcaDrop) { if (LAlter) { ATblDef.DropFieldDef(s); } continue; } if (LAlter) { AFldDef = ATblDef.FieldByName(s); } else { AFldDef = null; } if (AFldDef == null) { AFldDef = ATblDef.NewFieldDef(context_GetItem.getColName()); } else { AFldDef.SetName(context_GetItem.getColName()); } try { AFldDef.SetFullKind(TRtPhyBaseTypeClass.SINGLETON.ClassFromEnumType(context_GetItem.FColType), "", context_GetItem.FColLen, context_GetItem.FColPrec); AFldDef.SetNotNull(context_GetItem.FNotNull); } catch (Throwable any) { ATblDef.DropFieldDef(context_GetItem.getColName()); throw wrap(any); } } } } for (i = 0; i <= FIndexes.GetCount() - 1; ++i) { if (!LAlter) { if (AAssOpt.contains(raaUniqueKeys)) { ATblDef.ClearIndexes(true); } if (AAssOpt.contains(raaIndexes)) { ATblDef.ClearIndexes(false); } } { TRtIndexItem item = FIndexes.GetItem(i); if (item.getUnique()) { if (!AAssOpt.contains(raaUniqueKeys)) { continue; } } else if (!AAssOpt.contains(raaIndexes)) { continue; } if (LAlter) { ATblDef.DropIndexDef(item.GetName()); } if (FIndexes.GetItem(i).FOption == rcaDrop) { continue; } ANdxDef = ATblDef.NewIndexDef(item.GetName(), ""); try { for (c = 0; c <= item.GetColumns().GetCount() - 1; ++c) { { TRtIndexColumnItem column = item.GetColumns().GetItem(c); ANdxDef.NewFieldDef(column.getColName(), column.getOrder() == risDesc); } } } catch (Throwable any) { ATblDef.DropIndexDef(item.GetName()); } } } if (AAssOpt.contains(raaPrimaryKey)) { s = ""; if (!(this instanceof TRtAlterTable) || ((TRtAlterTable) this).GetPrimaryKey().getOption() != rcaDrop) { for (i = 0; i <= FPrimaryKey.getColumns().GetCount() - 1; ++i) { { TRtSingleIndexColumnItem context_GetItem = FPrimaryKey.getColumns().GetItem(i); if (!s.equals("")) { s = s + ";"; } s = s + context_GetItem.getColName(); } } if (!s.equals("")) { ATblDef.SetPrimaryKey(s); } } else { ATblDef.SetPrimaryKey(""); } } if (AAssOpt.contains(raaUniqueConstraints)) { for (i = 0; i <= FUniqueConstraints.GetCount() - 1; ++i) { if (!LAlter) { ATblDef.ClearUniqueConstraints(); } { TRtSingleIndexItem item = FUniqueConstraints.GetItem(i); if (LAlter) { ATblDef.DropUniqueConstraintDef(item.GetName()); } if (item.FOption == rcaDrop) { continue; } AUniqueDef = ATblDef.NewUniqueConstraintDef(item.GetName(), ""); try { for (c = 0; c <= item.getColumns().GetCount() - 1; ++c) { { TRtSingleIndexColumnItem column = item.getColumns().GetItem(c); AUniqueDef.NewFieldDef(column.getColName()); } } } catch (Throwable any) { ATblDef.DropUniqueConstraintDef(item.GetName()); } } } } if (AAssOpt.contains(raaTriggers)) { for (i = 0; i <= FTriggers.GetCount() - 1; ++i) { if (!LAlter) { ATblDef.ClearTriggers(); } { TRtTriggerItem context_GetItem = FTriggers.GetItem(i); if (LAlter) { ATblDef.DropTriggerDef(context_GetItem.GetName()); } if (context_GetItem.FOption == rcaDrop) { continue; } ATblDef.NewTriggerDef(context_GetItem.FCode); } } } if (AAssOpt.contains(raaForeignKeys)) { if (!LAlter) { ATblDef.ClearRelations(); } ADbDef = ((TRtDatabaseDef) ATblDef.GetTypedOwner(TRtDatabaseDefClass.SINGLETON)); for (i = 0; i <= FForeignKeys.GetCount() - 1; ++i) { { TRtForeignKeyItem item = FForeignKeys.GetItem(i); if (LAlter) { ADbDef.DropRelationDef(item.GetName()); } if (item.FOption == rcaDrop) { continue; } RelTblDef = ADbDef.TableByName(item.getReferenceTable()); ARelDef = ADbDef.NewRelationDef(item.GetName(), item.GetForeignTable(), item.getReferenceTable()); try { s = ""; for (c = 0; c <= item.getColumns().GetCount() - 1; ++c) { { TRtForeignKeyColumnItem column = item.getColumns().GetItem(c); ARelDef.AddForeignField(column.getThsColName()); if (!s.equals("")) { s = s + ";"; } s = s + column.getOthColName(); } } AUniqueDef = RelTblDef.GetUniqueDefForFields(s); if (AUniqueDef != null) { ARelDef.SetReferenceUniqueDef(AUniqueDef.GetName()); } } catch (Throwable any) { ADbDef.DropRelationDef(item.GetName()); throw wrap(any); } } } } if (!GetOwnerConnection().FDisableEvents && GetOwnerConnection().FOnAfterAssignToTableDef != null) { GetOwnerConnection().FOnAfterAssignToTableDef.run(this, OldTblDef, ATblDef); } } public String GetDataTableSpace() { String Result = ""; if (StrIsBlank(FDataTableSpace)) { Result = TrimRight(GetOwnerConnection().GetDataTableSpace()); } else { Result = TrimRight(FDataTableSpace); } return Result; } public final String GetIndexTableSpace() { String Result = ""; if (StrIsBlank(FIndexTableSpace)) { Result = TrimRight(GetOwnerConnection().GetIndexTableSpace()); } else { Result = TrimRight(FIndexTableSpace); } return Result; } public final void SetDataTableSpace(String Value) { CheckUnprepare(); FDataTableSpace = Value; } public final void SetIndexTableSpace(String Value) { CheckUnprepare(); FIndexTableSpace = Value; } public void runCreate() { super.runCreate(); Init(); } public static TRtCreateTable Create() { TRtCreateTable Result; Result = new TRtCreateTable(); Result.runCreate(); return Result; } public final void runCreateSQL(TRtDBConnection AConn, String ATableName) { super.runCreateSQL(AConn, ATableName); Init(); } public static TRtCreateTable CreateSQL(TRtDBConnection AConn, String ATableName) { TRtCreateTable Result; Result = new TRtCreateTable(); Result.runCreateSQL(AConn, ATableName); return Result; } public void Destroy() { FColumns.Free(); FPrimaryKey.Free(); FUniqueConstraints.Free(); FIndexes.Free(); FForeignKeys.Free(); FTriggers.Free(); super.Destroy(); } public void ExecuteUpd() { String ASql = ""; String ALastSQLs = ""; String ExceptMessage = ""; boolean LRetry; DoOnBeforeDDLStep(); ASql = GenSQL(); while (true) { try { ALastSQLs = ExecuteMultipleSQLs(ASql, 0, ALastSQLs); UpdatePhyDatabase(); break; } catch (DelphiException E) { LRetry = DoOnDDLError(); if (LRetry) { continue; } else { ExceptMessage = TransStrFmt("TC3296", "Não foi possível criar a tabela: %0:s - [%1:s, %2:s] - \"%3:s\"", new Object[] { GetTableName(), StrReplaceStr(FSql, SQLEOC_SEP, EOL), StrReplaceStr(ALastSQLs, SQLEOC_SEP, EOL), E.getMessage() }, true); E.setMessage(ExceptMessage); throw wrap(E); } } } } public void Assign(TPersistent Source) { FAssigning++; try { super.Assign(Source); if (Source instanceof TRtCreateTable) { FColumns.Assign(((TRtCreateTable) Source).FColumns); FPrimaryKey.Assign(((TRtCreateTable) Source).FPrimaryKey); FUniqueConstraints.Assign(((TRtCreateTable) Source).FUniqueConstraints); FIndexes.Assign(((TRtCreateTable) Source).FIndexes); FForeignKeys.Assign(((TRtCreateTable) Source).FForeignKeys); FTriggers.Assign(((TRtCreateTable) Source).FTriggers); FDataTableSpace = ((TRtCreateTable) Source).FDataTableSpace; FIndexTableSpace = ((TRtCreateTable) Source).FIndexTableSpace; } } finally { FAssigning--; } } public Object AssignFromTableDef(TRtTableDef ATblDef, DelphiSet AAssOpt) { int i; int c; TRtIndexItem NdxItem; TRtSingleIndexItem UniqueItem; int AOrder; TRtForeignKeyItem RelItem; Clear(); FTableName = ATblDef.GetName(); if (!GetOwnerConnection().FDisableEvents && GetOwnerConnection().FOnBeforeAssignFromTableDef != null) { GetOwnerConnection().FOnBeforeAssignFromTableDef.run(this, null, ATblDef); } if (AAssOpt.contains(raaColumns)) { for (i = 0; i <= ATblDef.GetFieldCount() - 1; ++i) { { TRtFieldDef context_GetField = ATblDef.GetField(i); FColumns.AddColumn(context_GetField.GetName(), context_GetField.GetFullKind().GetEnumType(), context_GetField.GetLength(), context_GetField.GetPrecision(), context_GetField.getNotNull()); } } } for (i = 0; i <= ATblDef.GetIndexCount() - 1; ++i) { { TRtIndexDef context_GetIndex = (TRtIndexDef) ATblDef.GetIndex(i); if (context_GetIndex.GetIsUnique()) { if (!AAssOpt.contains(raaUniqueKeys)) { continue; } } else if (!AAssOpt.contains(raaIndexes)) { continue; } NdxItem = FIndexes.AddIndex(context_GetIndex.GetName(), context_GetIndex.GetIsUnique()); for (c = 0; c <= context_GetIndex.GetFieldCount() - 1; ++c) { { TRtIndexFieldDef context_GetField = context_GetIndex.GetField(c); if (context_GetField.getDescendent()) { AOrder = risDesc; } else { AOrder = risAsc; } NdxItem.AddColumnOrdered(context_GetField.getField().GetName(), AOrder); } } } } if (AAssOpt.contains(raaForeignKeys)) { for (i = 0; i <= ATblDef.GetRelationCount() - 1; ++i) { { TRtRelationDef context_GetRelation = ATblDef.GetRelation(i); if (CompareText(context_GetRelation.getForeignTable().GetName(), FTableName) == 0) { RelItem = FForeignKeys.AddForeignKey(context_GetRelation.GetName(), context_GetRelation.getReferenceTable().GetName()); for (c = 0; c <= context_GetRelation.GetFieldCount() - 1; ++c) { RelItem.AddColumns(context_GetRelation.GetForeignField(c).GetName(), context_GetRelation.GetReferenceField(c).GetName()); } } } } } if (AAssOpt.contains(raaPrimaryKey)) { FPrimaryKey.SetName(ATblDef.GetPrimaryKeyName()); for (i = 0; i <= ATblDef.GetKeyCount() - 1; ++i) { FPrimaryKey.AddColumn(ATblDef.GetPrimaryKeyField(i).GetName()); } } if (AAssOpt.contains(raaUniqueConstraints)) { for (i = 0; i <= ATblDef.GetUniqueConstraintCount() - 1; ++i) { { TRtUniqueConstraintDef context_GetUniqueConstraint = ATblDef.GetUniqueConstraint(i); UniqueItem = FUniqueConstraints.AddUniqueConstraint(context_GetUniqueConstraint.GetName()); for (c = 0; c <= context_GetUniqueConstraint.GetFieldCount() - 1; ++c) { { TRtUniqueConstraintFieldDef context_GetField = context_GetUniqueConstraint.GetField(c); UniqueItem.AddColumn(context_GetField.getField().GetName()); } } } } } if (AAssOpt.contains(raaTriggers)) { for (i = 0; i <= ATblDef.GetTriggerCount() - 1; ++i) { FTriggers.AddTriggerFromTriggerDef(ATblDef.GetTrigger(i)); } } if (!GetOwnerConnection().FDisableEvents && GetOwnerConnection().FOnAfterAssignFromTableDef != null) { GetOwnerConnection().FOnAfterAssignFromTableDef.run(this, null, ATblDef); } return null; } public void AssignToTableDef(TRtTableDef ATblDef, DelphiSet AAssOpt) { _AssignToTableDef(ATblDef, AAssOpt, false); } public final void Clear() { CheckUnprepare(); FTableName = ""; FColumns.Clear(); FPrimaryKey.FColumns.Clear(); FPrimaryKey.FOption = rcaAdd; FUniqueConstraints.Clear(); FIndexes.Clear(); FForeignKeys.Clear(); FTriggers.Clear(); } public void ReadData(TReader Reader) { FAssigning++; try { super.ReadData(Reader); FColumns.ReadData(Reader); FPrimaryKey.ReadData(Reader); FUniqueConstraints.ReadData(Reader); FIndexes.ReadData(Reader); FForeignKeys.ReadData(Reader); FTriggers.ReadData(Reader); FDataTableSpace = Reader.ReadString(); FIndexTableSpace = Reader.ReadString(); } finally { FAssigning--; } } public void WriteData(TWriter Writer) { super.WriteData(Writer); FColumns.WriteData(Writer); FPrimaryKey.WriteData(Writer); FUniqueConstraints.WriteData(Writer); FIndexes.WriteData(Writer); FForeignKeys.WriteData(Writer); FTriggers.WriteData(Writer); Writer.WriteString(FDataTableSpace); Writer.WriteString(FIndexTableSpace); } public final void RemoveUniqueConstraintByName(String AName) { CheckUnprepare(); FUniqueConstraints.RemoveByName(AName); } public final void RemoveAnyIndexByName(String AName) { CheckUnprepare(); FIndexes.RemoveByName(AName); } public final void RemoveForeignKeyByName(String AName) { CheckUnprepare(); FForeignKeys.RemoveByName(AName); } public final DelphiSet GetOperations(int Op) { DelphiSet Result = DelphiSet.get(); int i; Result = DelphiSet.get(); switch (Op) { case raaColumns: for (i = 0; i <= FColumns.GetCount() - 1; ++i) { Result = Result.add(DelphiSet.get(FColumns.GetItem(i).getOption())); } break; case raaPrimaryKey: if (FPrimaryKey.getOption() != rcaAdd || FPrimaryKey.getColumns().GetCount() != 0) { Result = DelphiSet.get(FPrimaryKey.getOption()); } break; case raaUniqueKeys: for (i = 0; i <= FIndexes.GetCount() - 1; ++i) { if (FIndexes.GetItem(i).getUnique()) { Result = Result.add(DelphiSet.get(FIndexes.GetItem(i).getOption())); } } break; case raaIndexes: for (i = 0; i <= FIndexes.GetCount() - 1; ++i) { if (!FIndexes.GetItem(i).getUnique()) { Result = Result.add(DelphiSet.get(FIndexes.GetItem(i).getOption())); } } break; case raaUniqueConstraints: for (i = 0; i <= FUniqueConstraints.GetCount() - 1; ++i) { Result = Result.add(DelphiSet.get(FUniqueConstraints.GetItem(i).getOption())); } break; case raaForeignKeys: for (i = 0; i <= FForeignKeys.GetCount() - 1; ++i) { Result = Result.add(DelphiSet.get(FForeignKeys.GetItem(i).getOption())); } break; case raaTriggers: for (i = 0; i <= FTriggers.GetCount() - 1; ++i) { Result = Result.add(DelphiSet.get(FTriggers.GetItem(i).getOption())); } break; default: break; } return Result; } public final int GetOperationsCount(int Op, DelphiSet AltSet) { int Result; int i; Result = 0; switch (Op) { case raaColumns: for (i = 0; i <= FColumns.GetCount() - 1; ++i) { if (AltSet.contains(FColumns.GetItem(i).getOption())) { Result++; } } break; case raaPrimaryKey: if (FPrimaryKey.getOption() != rcaAdd || FPrimaryKey.getColumns().GetCount() != 0) { if (AltSet.contains(FPrimaryKey.getOption())) { Result++; } } break; case raaUniqueKeys: for (i = 0; i <= FIndexes.GetCount() - 1; ++i) { if (FIndexes.GetItem(i).getUnique()) { if (AltSet.contains(FIndexes.GetItem(i).getOption())) { Result++; } } } break; case raaIndexes: for (i = 0; i <= FIndexes.GetCount() - 1; ++i) { if (!FIndexes.GetItem(i).getUnique()) { if (AltSet.contains(FIndexes.GetItem(i).getOption())) { Result++; } } } break; case raaUniqueConstraints: for (i = 0; i <= FUniqueConstraints.GetCount() - 1; ++i) { if (AltSet.contains(FUniqueConstraints.GetItem(i).getOption())) { Result++; } } break; case raaForeignKeys: for (i = 0; i <= FForeignKeys.GetCount() - 1; ++i) { if (AltSet.contains(FForeignKeys.GetItem(i).getOption())) { Result++; } } break; case raaTriggers: for (i = 0; i <= FTriggers.GetCount() - 1; ++i) { if (AltSet.contains(FTriggers.GetItem(i).getOption())) { Result++; } } break; default: break; } return Result; } public TRtCreateTableClass ClassType() { return TRtCreateTableClass.SINGLETON; } public TRtSingleIndexItemList getUniqueConstraintList() { return FUniqueConstraints; } public TRtIndexItemList getIndexList() { return FIndexes; } public TRtForeignKeyList getForeignKeyList() { return FForeignKeys; } public TRtTriggerItemList getTriggerList() { return FTriggers; } } public static final class TRtAlterTableClass extends TRtCreateTableClass { public static final TRtAlterTableClass SINGLETON = new TRtAlterTableClass(); public TRtAlterTable Create() { return TRtAlterTable.Create(); } public TContainerItem Creator(TPersistent AOwner, TContainerItemClass AType) { if (AType == TRtAddColumnsListClass.SINGLETON) { AType = TRtModifyColumnsListClass.SINGLETON; } return super.Creator(AOwner, AType); } public Class ClassInfo() { return TRtAlterTable.class; } } public static final class TRtAlterTable extends TRtCreateTable { private final class ForceModifyAllFks_Context { private TRtDBConnection DBConn; private TRtTableDef OldTblDef; private TRtRelationDef ARelDef; private TRtForeignKeyItem RelItem; private int i; private TRtAlterTable GetOtherAlterTableForFk() { TRtAlterTable Result; TRtCustomSQL AObj; int i; Result = null; for (i = 0; i <= DBConn.FSQLList.GetCount() - 1; ++i) { AObj = ((TRtCustomSQL) DBConn.FSQLList.Get(i)); if (AObj instanceof TRtAlterTable && CompareText(ARelDef.getForeignTable().GetName(), ((TRtAlterTable) AObj).GetTableName()) == 0) { Result = (TRtAlterTable) AObj; break; } } if (Result == null) { Result = DBConn.SQLAlterTable(); Result.SetTableName(ARelDef.getForeignTable().GetName()); } return Result; } private void ModifyFk() { TRtAlterTable AT; int i; if (CompareText(ARelDef.getForeignTable().GetName(), FTableName) != 0 && DBConn.getSQLProcessMode() == spmGroup) { AT = GetOtherAlterTableForFk(); } else { AT = TRtAlterTable.this; } if (AT != null && AT.FForeignKeys.ItemByName(ARelDef.GetName()) == null) { RelItem = AT.FForeignKeys.AddForeignKey(ARelDef.GetName(), ARelDef.getReferenceTable().GetName()); RelItem.FForeignTable = ARelDef.getForeignTable().GetName(); if (HasDropTable(DBConn, AT.GetTableName())) { RelItem.SetOption(rcaDrop); } else { RelItem.SetOption(rcaModify); for (i = 0; i <= ARelDef.GetFieldCount() - 1; ++i) { RelItem.AddColumns(ARelDef.GetForeignField(i).GetName(), ARelDef.GetReferenceField(i).GetName()); } } } } public ForceModifyAllFks_Context() { } public void execute() { DBConn = GetOwnerConnection(); OldTblDef = CheckGetDatabaseDef().TableByName(FTableName); if (OldTblDef == null) { return; } for (i = 0; i <= OldTblDef.GetRelationCount() - 1; ++i) { ARelDef = OldTblDef.GetRelation(i); if (FForeignKeys.ItemByName(ARelDef.GetName()) == null) { ModifyFk(); } } } } private final class ForceModifyAllTriggers_Context { private TRtDBConnection DBConn; private TRtTableDef OldTblDef; private TRtTriggerDef ATrgDef; private int i; private void ModifyTrigger() { if (HasDropTable(DBConn, GetTableName())) { FTriggers.AddTrigger(ATrgDef.GetName(), "", ATrgDef.getForEachRow()).FOption = rcaDrop; } else { FTriggers.AddTriggerFromTriggerDef(ATrgDef).FOption = rcaModify; } } public ForceModifyAllTriggers_Context() { } public void execute() { DBConn = GetOwnerConnection(); OldTblDef = CheckGetDatabaseDef().TableByName(FTableName); if (OldTblDef == null) { return; } for (i = 0; i <= OldTblDef.GetTriggerCount() - 1; ++i) { ATrgDef = OldTblDef.GetTrigger(i); if (FTriggers.ItemByName(ATrgDef.GetName()) == null) { ModifyTrigger(); } } } } private final class CheckGetAlterTableMode_Context { private int Result; private int i; private boolean LCriticalColumnChange; private boolean LNewUC; private boolean CheckChanges() { return LCriticalColumnChange || LNewUC; } public CheckGetAlterTableMode_Context() { } public int execute() { LCriticalColumnChange = false; LNewUC = false; i = 0; while (i < GetColumn().GetCount() && !CheckChanges()) { LCriticalColumnChange = GetColumn().GetItem(i).GetCriticalChange(); i++; } LNewUC = FPrimaryKey.getOption() == rcaModify || FPrimaryKey.getOption() == rcaAdd && FPrimaryKey.getColumns().GetCount() > 0; i = 0; while (!CheckChanges() && i < FIndexes.GetCount()) { LNewUC = FIndexes.GetItem(i).getUnique() && DelphiSet.get(rcaAdd, rcaModify).contains(FIndexes.GetItem(i).getOption()); i++; } i = 0; while (!CheckChanges() && i < FUniqueConstraints.GetCount()) { LNewUC = DelphiSet.get(rcaAdd, rcaModify).contains(FUniqueConstraints.GetItem(i).getOption()); i++; } if (CheckChanges()) { Result = atmCursor; } else { Result = atmAlterTable; } return Result; } } private final class TranslateOldFieldValue_Context { private final TRtFieldDef AFld; private final TRtModifyColumnItem ACol; private final String AColName; private String Result = ""; private String GetConvFunctionForType(int AType, String AColName) { String Result = ""; int OldType; Result = AColName; OldType = AFld.GetFullKind().GetEnumType(); switch (AType) { case rftString: switch (OldType) { case rftNumber: case rftBoolean: Result = SQL_Convert + SQL_LParenthesis + SQLNumberToChar + SQL_Comma + AColName + ToStr(SQL_RParenthesis); break; case rftDate: case rftTime: Result = SQL_Convert + SQL_LParenthesis + SQLDateToChar + SQL_Comma + AColName + ToStr(SQL_RParenthesis); break; default: break; } break; case rftNumber: switch (OldType) { case rftString: Result = SQL_Convert + SQL_LParenthesis + SQLCharToNumber + SQL_Comma + AColName + ToStr(SQL_RParenthesis); break; default: break; } break; case rftDate: case rftTime: switch (OldType) { case rftString: Result = SQL_Convert + SQL_LParenthesis + SQLCharToDate + SQL_Comma + AColName + ToStr(SQL_RParenthesis); break; default: break; } break; default: break; } return Result; } public TranslateOldFieldValue_Context(TRtFieldDef AFld, TRtModifyColumnItem ACol, String AColName) { this.AFld = AFld; this.ACol = ACol; this.AColName = AColName; } public String execute() { if (ACol.getColType() != AFld.GetFullKind().GetEnumType()) { Result = GetConvFunctionForType(ACol.getColType(), AColName); } else if (ACol.getColType() == rftNumber && AFld.GetPrecision() > ACol.getColPrecision()) { if (ACol.getColPrecision() == 0) { Result = "\"TRUNCATE\"(" + AColName + ",0)"; } else { Result = "ROUND(" + AColName + SQL_Comma + IntToStr(ACol.getColPrecision()) + ")"; } } else { Result = AColName; } return Result; } } private final class GenSQLObjectsStep_Context { private final class GetFieldPairs_Context { private final boolean LInsertIntoSelect; private int I; private TRtAddColumnItem ACol; private TRtModifyColumnItem Col; private TRtModifyColumnItem OldCol; private TRtFieldDef AFldDef; private TRtCreateTable ACrtTbl; private void IncSelFlds(String AColName) { if (AInsSelFlds != null) { AInsSelFlds.Sel.Add(AColName); } } private void IncInsFlds(String AColName) { if (AInsSelFlds != null) { AInsSelFlds.Ins.Add(AColName); } } private void IncSel(String AColName) { if (ASel.IndexOf(AColName) < 0) { ASel.Add(AColName); } } private boolean ChangeColType(TRtModifyColumnItem ACol) { return ACol.getColType() != AFldDef.GetFullKind().GetEnumType(); } public GetFieldPairs_Context(boolean LInsertIntoSelect) { this.LInsertIntoSelect = LInsertIntoSelect; } public int execute() { GetOldTableDef(); for (I = 0; I <= OldTblDef.GetFieldCount() - 1; ++I) { AFldDef = OldTblDef.GetField(I); Col = GetColumn().ItemByColumnName(AFldDef.GetName()); OldCol = GetColumn().ItemByOldColumnName(AFldDef.GetName()); if (Col == null && OldCol == null || Col != null && Col.getOption() != rcaDrop && OldCol == null) { if (LInsertIntoSelect && Col != null && Col.getOption() == rcaModify) { try { ASel.Add(TranslateOldFieldValue(AFldDef, Col, AFldDef.GetName())); } catch (Throwable any) { continue; } } else { ASel.Add(AFldDef.GetName()); } AIns.Add(AFldDef.GetName()); IncSelFlds(AFldDef.GetName()); IncInsFlds(AFldDef.GetName()); if (Col != null && ChangeColType(Col)) { AInsTypes.Add(((Object) TRtPhyBaseTypeClass.SINGLETON.ParamTypeFromPhyType(Col.getColType(), Col.getColLength(), Col.getColPrecision()))); } else { AInsTypes.Add((Object) rdtUnknown); } } else if (OldCol != null) { try { if (LInsertIntoSelect) { ASel.Add(TranslateOldFieldValue(AFldDef, OldCol, OldCol.getOldColName())); } else { ASel.Add(OldCol.getOldColName()); } } catch (Throwable any) { continue; } AIns.Add(OldCol.getColName()); IncSelFlds(OldCol.getOldColName()); IncInsFlds(OldCol.getColName()); if (ChangeColType(OldCol)) { AInsTypes.Add(((Object) TRtPhyBaseTypeClass.SINGLETON.ParamTypeFromPhyType(OldCol.getColType(), OldCol.getColLength(), OldCol.getColPrecision()))); } else { AInsTypes.Add((Object) rdtUnknown); } } } if (!LInsertIntoSelect) { ACrtTbl = ((TRtCreateTable) AsCreateTable()); try { for (i = 0; i <= ACrtTbl.GetColumn().GetCount() - 1; ++i) { ACol = ACrtTbl.GetColumn().GetItem(I); if (AIns.IndexOf(ACol.getColName()) < 0) { AIns.Add(ACol.getColName()); AInsTypes.Add(((Object) TRtPhyBaseTypeClass.SINGLETON.ParamTypeFromPhyType(ACol.getColType(), ACol.getColLength(), ACol.getColPrecision()))); } } } finally { ACrtTbl.Free(); } for (i = 0; i <= OldTblDef.GetFieldCount() - 1; ++i) { IncSel(OldTblDef.GetField(I).GetName()); } } return AIns.GetCount(); } } private final int AStep; private final int AAlterTableMode; private final int ASeq; private TList Result; TRtTableDef OldTblDef; TStringList ASel; TStringList AIns; TInsSelFieldPairs AInsSelFlds; TList AInsTypes; int i; void GetOldTableDef() { if (OldTblDef == null) { OldTblDef = CheckGetDatabaseDef().TableByName(FTableName); } } private boolean HasAlterTableFor(String ATableName) { boolean Result; TRtDBConnection DBConn; TRtCustomSQL AObj; int i; DBConn = GetOwnerConnection(); if (CompareText(FTableName, ATableName) != 0 && DBConn.getSQLProcessMode() == spmGroup) { for (i = 0; i <= DBConn.FSQLList.GetCount() - 1; ++i) { AObj = ((TRtCustomSQL) DBConn.FSQLList.Get(i)); Result = AObj instanceof TRtAlterTable && CompareText(((TRtAlterTable) AObj).GetTableName(), ATableName) == 0; if (Result) { return Result; } } } return false; } private TRtCustomSQL AsDropTriggers() { TRtCustomSQL Result; int i; TRtTriggerItem STrgItem; TRtTriggerItem DTrgItem; Result = GetOwnerConnection().SQLAlterTable(); try { ((TRtAlterTable) Result).SetTableName(FTableName); for (i = 0; i <= FTriggers.GetCount() - 1; ++i) { STrgItem = FTriggers.GetItem(i); if (STrgItem.getOption() != rcaAdd) { DTrgItem = ((TRtAlterTable) Result).FTriggers.AddTrigger(STrgItem.GetName(), "", STrgItem.getForEachRow()); DTrgItem.SetOption(rcaDrop); } } if (((TRtAlterTable) Result).FTriggers.GetCount() == 0) { Abort(); } } catch (Throwable any) { Result.Free(); Result = null; } return Result; } private TRtCustomSQL AsDropFks(int ASeq) { TRtCustomSQL Result; int i; int iSeq; TRtForeignKeyItem SFkItem; TRtForeignKeyItem DFkItem; Result = GetOwnerConnection().SQLAlterTable(); try { ((TRtAlterTable) Result).SetTableName(FTableName); iSeq = 0; for (i = 0; i <= FForeignKeys.GetCount() - 1; ++i) { SFkItem = FForeignKeys.GetItem(i); if (SFkItem.getOption() != rcaAdd) { iSeq++; if (ASeq == 0 || ASeq == iSeq) { if (HasAlterTableFor(SFkItem.GetForeignTable())) { continue; } DFkItem = ((TRtAlterTable) Result).FForeignKeys.AddForeignKey(SFkItem.GetName(), SFkItem.getReferenceTable()); DFkItem.SetForeignTable(SFkItem.GetForeignTable()); DFkItem.SetOption(rcaDrop); } } } if (((TRtAlterTable) Result).FForeignKeys.GetCount() == 0) { Abort(); } } catch (Throwable any) { Result.Free(); Result = null; } return Result; } private TRtCustomSQL AsDropInnerConstraints() { TRtCustomSQL Result; int i; GetOldTableDef(); Result = GetOwnerConnection().SQLAlterTable(); try { ((TRtAlterTable) Result).SetTableName(FTableName); if (OldTblDef.GetHasPrimaryKey()) { ((TRtAlterTable) Result).GetPrimaryKey().SetName(OldTblDef.GetPrimaryKeyName()); ((TRtAlterTable) Result).GetPrimaryKey().SetOption(rcaDrop); } for (i = 0; i <= OldTblDef.GetIndexCount() - 1; ++i) { ((TRtAlterTable) Result).FIndexes.AddIndex(OldTblDef.GetIndex(i).GetName(), OldTblDef.GetIndex(i).GetIsUnique()).SetOption(rcaDrop); } for (i = 0; i <= OldTblDef.GetUniqueConstraintCount() - 1; ++i) { ((TRtAlterTable) Result).FUniqueConstraints.AddUniqueConstraint(OldTblDef.GetUniqueConstraint(i).GetName()).SetOption(rcaDrop); } if (((TRtAlterTable) Result).GetPrimaryKey().getOption() != rcaDrop && ((TRtAlterTable) Result).FIndexes.GetCount() == 0 && ((TRtAlterTable) Result).FUniqueConstraints.GetCount() == 0) { Abort(); } } catch (Throwable any) { Result.Free(); Result = null; } return Result; } private TRtCustomSQL AsRenameTableNewToOld() { TRtCustomSQL Result; Result = GetOwnerConnection().SQLRenameTable(); try { ((TRtRenameTable) Result).SetTableName(GetTableName()); ((TRtRenameTable) Result).SetNewTableName(GetOldTableName()); } catch (Throwable any) { Result.Free(); Result = null; } return Result; } TRtCustomSQL AsCreateTable() { TRtCustomSQL Result; Result = GetOwnerConnection().SQLCreateTable(); try { if (getKeepPKInOLDTable() || GetUseNewOperationKind()) { AssignToCreateTable((TRtCreateTable) Result, DelphiSet.get(raaColumns)); } else { AssignToCreateTable((TRtCreateTable) Result, DelphiSet.get(raaColumns, raaPrimaryKey, raaUniqueKeys, raaIndexes, raaUniqueConstraints)); } } catch (Throwable any) { Result.Free(); Result = null; } return Result; } private TRtCustomSQL AsCreateErrTable() { TRtCustomSQL Result; GetOldTableDef(); Result = GetOwnerConnection().SQLCreateTable(); try { Result.setUseDataBaseDef(GetOwnerConnection().getPhyDatabase()); ((TRtCreateTable) Result).AssignFromTableDef(OldTblDef, DelphiSet.get(raaColumns)); ((TRtCreateTable) Result).SetTableName(GetErrTableName()); } catch (Throwable any) { Result.Free(); Result = null; } return Result; } private TRtCustomSQL AsRecreateFks(int ASeq) { TRtCustomSQL Result; int i; int iSeq; TRtForeignKeyItem SFkItem; TRtForeignKeyItem DFkItem; Result = GetOwnerConnection().SQLAlterTable(); try { ((TRtAlterTable) Result).SetTableName(FTableName); iSeq = 0; for (i = 0; i <= FForeignKeys.GetCount() - 1; ++i) { SFkItem = FForeignKeys.GetItem(i); if (SFkItem.getOption() != rcaDrop) { iSeq++; if (ASeq == 0 || ASeq == iSeq) { if (HasAlterTableFor(SFkItem.GetForeignTable())) { continue; } DFkItem = ((TRtAlterTable) Result).FForeignKeys.AddForeignKey(SFkItem.GetName(), SFkItem.getReferenceTable()); DFkItem.Assign(SFkItem); DFkItem.SetOption(rcaAdd); } } } if (((TRtAlterTable) Result).FForeignKeys.GetCount() == 0) { Abort(); } } catch (Throwable any) { Result.Free(); Result = null; } return Result; } private TRtCustomSQL AsRecreateTriggers() { TRtCustomSQL Result; int i; TRtTriggerItem STrgItem; TRtTriggerItem DTrgItem; Result = GetOwnerConnection().SQLAlterTable(); try { ((TRtAlterTable) Result).SetTableName(FTableName); for (i = 0; i <= FTriggers.GetCount() - 1; ++i) { STrgItem = FTriggers.GetItem(i); if (STrgItem.getOption() != rcaDrop) { DTrgItem = ((TRtAlterTable) Result).FTriggers.AddTrigger(STrgItem.GetName(), "", STrgItem.getForEachRow()); DTrgItem.Assign(STrgItem); DTrgItem.SetOption(rcaAdd); } } if (((TRtAlterTable) Result).FTriggers.GetCount() == 0) { Abort(); } } catch (Throwable any) { Result.Free(); Result = null; } return Result; } private TRtCustomSQL AsDropTable() { TRtCustomSQL Result; Result = GetOwnerConnection().SQLDropTable(); try { ((TRtDropTable) Result).SetTableName(GetOldTableName()); } catch (Throwable any) { Result.Free(); Result = null; } return Result; } private TRtCustomSQL AsCreatePK() { TRtCustomSQL Result; TRtTableDef xTableDef; int i; int j; TRtIndexItem xIndex; TRtSingleIndexItem xUC; Result = GetOwnerConnection().SQLAlterTable(); try { ((TRtAlterTable) Result).SetTableName(GetTableName()); xTableDef = GetOwnerConnection().GetNewDatabase().TableByName(GetTableName()); ((TRtAlterTable) Result).GetPrimaryKey().AddAllColumns(xTableDef.GetPrimaryKeyStr()); ((TRtAlterTable) Result).GetPrimaryKey().SetName(xTableDef.GetPrimaryKeyName()); ((TRtAlterTable) Result).GetPrimaryKey().SetOption(rcaAdd); for (i = 0; i <= xTableDef.GetIndexCount() - 1; ++i) { xIndex = ((TRtAlterTable) Result).getIndexList().AddIndex(xTableDef.GetIndex(i).GetName(), xTableDef.GetIndex(i).GetIsUnique()); xIndex.SetOption(rcaAdd); for (j = 0; j <= ((TRtIndexDef) xTableDef.GetIndex(i)).GetFieldCount() - 1; ++j) { if (((TRtIndexDef) xTableDef.GetIndex(i)).GetField(j).getDescendent()) { xIndex.AddColumnOrdered(((TRtIndexDef) xTableDef.GetIndex(i)).GetField(j).getField().GetName(), risDesc); } else { xIndex.AddColumnOrdered(((TRtIndexDef) xTableDef.GetIndex(i)).GetField(j).getField().GetName(), risAsc); } } } for (i = 0; i <= xTableDef.GetUniqueConstraintCount() - 1; ++i) { xUC = getUniqueConstraintList().AddUniqueConstraint(xTableDef.GetUniqueConstraint(i).GetName()); xUC.SetOption(rcaAdd); for (j = 0; j <= xTableDef.GetUniqueConstraint(i).GetFieldCount() - 1; ++j) { xUC.AddColumn(xTableDef.GetUniqueConstraint(i).GetField(j).getField().GetName()); } } } catch (Throwable any) { Result.Free(); Result = null; } return Result; } private int GetFieldPairs(boolean LInsertIntoSelect) { GetFieldPairs_Context ctx = new GetFieldPairs_Context(LInsertIntoSelect); return ctx.execute(); } private TRtCustomSQL AsSelectOld() { TRtCustomSQL Result; int i; Result = GetOwnerConnection().SQLSelect(); try { ((TRtSelect) Result).getFrom().AddTable(GetOldTableName()); for (i = 0; i <= ASel.GetCount() - 1; ++i) { ((TRtSelect) Result).getColumns().AddColumn(ASel.Get(i)); } } catch (Throwable any) { Result.Free(); Result = null; } return Result; } private TRtCustomSQL AsInsertNew() { TRtCustomSQL Result; int i; String STmp = ""; Result = GetOwnerConnection().SQLInsertInto(); try { Result.setUseDataBaseDef(GetOwnerConnection().GetNewDatabase()); ((TRtInsertInto) Result).SetTableName(FTableName); for (i = 0; i <= AIns.GetCount() - 1; ++i) { STmp = AIns.Get(i); ((TRtInsertInto) Result).getColumns().SetColumnExp(STmp, ':' + STmp); ((TRtInsertInto) Result).GetParams().GetItem(i).SetDataType(((Number) AInsTypes.Get(i)).intValue()); } } catch (Throwable any) { Result.Free(); Result = null; } return Result; } private TRtCustomSQL AsInsertErr() { TRtCustomSQL Result; int i; TRtFieldDef AFldDef; GetOldTableDef(); Result = GetOwnerConnection().SQLInsertInto(); try { Result.setUseDataBaseDef(GetOwnerConnection().getPhyDatabase()); ((TRtInsertInto) Result).SetTableName(GetErrTableName()); for (i = 0; i <= OldTblDef.GetFieldCount() - 1; ++i) { AFldDef = OldTblDef.GetField(i); ((TRtInsertInto) Result).getColumns().SetColumnExp(AFldDef.GetName(), ':' + AFldDef.GetName()); ((TRtInsertInto) Result).GetParams().GetItem(i).SetDataType(TRtPhyBaseTypeClass.SINGLETON.ParamTypeFromPhyType(AFldDef.GetFullKind().GetEnumType(), AFldDef.GetLength(), AFldDef.GetPrecision())); } } catch (Throwable any) { Result.Free(); Result = null; } return Result; } private TRtCustomSQL AsRenameTableErrToOld() { TRtCustomSQL Result; Result = GetOwnerConnection().SQLRenameTable(); try { ((TRtRenameTable) Result).SetTableName(GetErrTableName()); ((TRtRenameTable) Result).SetNewTableName(GetOldTableName()); } catch (Throwable any) { Result.Free(); Result = null; } return Result; } private TRtCustomSQL AsDeleteAllFromErr() { TRtCustomSQL Result; Result = GetOwnerConnection().SQLDeleteFrom(); try { ((TRtDeleteFrom) Result).SetTableName(GetErrTableName()); } catch (Throwable any) { Result.Free(); Result = null; } return Result; } private TRtCustomSQL AsDeleteAllFromNew() { TRtCustomSQL Result; Result = GetOwnerConnection().SQLDeleteFrom(); try { ((TRtDeleteFrom) Result).SetTableName(GetTableName()); } catch (Throwable any) { Result.Free(); Result = null; } return Result; } private TRtCustomSQL AsDropErrTable() { TRtCustomSQL Result; Result = GetOwnerConnection().SQLDropTable(); try { ((TRtDropTable) Result).SetTableName(GetErrTableName()); } catch (Throwable any) { Result.Free(); Result = null; } return Result; } private TRtCustomSQL AsInsertSelect() { TRtCustomSQL Result; TRtSelect Select; int i; Select = ((TRtSelect) AsSelectOld()); try { Result = GetOwnerConnection().SQLInsertSelectInto(); try { ((TRtInsertSelectInto) Result).SetTableName(FTableName); for (i = 0; i <= AIns.GetCount() - 1; ++i) { ((TRtInsertSelectInto) Result).getColumns().Add(AIns.Get(i)); } ((TRtInsertSelectInto) Result).SetSelect(Select); } catch (Throwable any) { Result.Free(); Result = null; } } finally { Select.Free(); } return Result; } public GenSQLObjectsStep_Context(int AStep, int AAlterTableMode, int ASeq) { this.AStep = AStep; this.AAlterTableMode = AAlterTableMode; this.ASeq = ASeq; } public TList execute() { Result = TList.Create(); OldTblDef = null; AInsSelFlds = null; switch (AStep) { case atsDropTriggers: Result.Add(AsDropTriggers()); break; case atsDropFks: Result.Add(AsDropFks(ASeq)); break; case atsRenameTable: if (!(getKeepPKInOLDTable() || GetUseNewOperationKind())) { Result.Add(AsDropInnerConstraints()); } Result.Add(AsRenameTableNewToOld()); break; case atsRecreateTable: Result.Add(AsCreateTable()); break; case atsMoveData: AInsSelFlds = TInsSelFieldPairs.Create(); ASel = TStringList.Create(); AIns = TStringList.Create(); AInsTypes = TList.Create(); try { if (AAlterTableMode == atmInsertIntoSelect) { if (GetFieldPairs(true) > 0) { Result.Add(AsInsertSelect()); } } else { AInsSelFlds = TInsSelFieldPairs.Create(); try { if (GetFieldPairs(false) > 0) { Result.Add(AsCreateErrTable()); Result.Add(AsSelectOld()); Result.Add(AsInsertNew()); Result.Add(AsInsertErr()); Result.Add(AsRenameTableErrToOld()); Result.Add(AsDeleteAllFromErr()); Result.Add(AsDeleteAllFromNew()); Result.Add(AsDropErrTable()); Result.Add(AInsSelFlds); } else { AInsSelFlds.Free(); } } catch (Throwable any) { AInsSelFlds.Free(); throw wrap(any); } } } finally { AInsTypes.Free(); AIns.Free(); ASel.Free(); } break; case atsRecreateFks: Result.Add(AsRecreateFks(ASeq)); break; case atsRecreateTriggers: Result.Add(AsRecreateTriggers()); break; case atsDropOldTable: Result.Add(AsDropTable()); break; case atsCreatePkIdxInNewTable: Result.Add(AsCreatePK()); break; case atsCustomAlterTable_1: case atsCustomAlterTable_Data: case atsCustomAlterTable_3: throw DelphiException.Create(TransStr("TC4931", "Alteração customizada não pode ser usada por esse banco de dados.", true)); default: break; } if (Result.getCount() == 0) { Result.Free(); Result = null; } else { for (i = 0; i <= Result.getCount() - 1; ++i) { if (Result.Get(i) != null && ((TObject) Result.Get(i)) instanceof TRtCustomSQL) { (((TRtCustomSQL) Result.Get(i))).FUsesScriptTerminator = FUsesScriptTerminator; } else { break; } } } return Result; } } private final class DoImplicitChanges_Context { private int i; private int c; private int j; private String TmpName = ""; private String AColName = ""; private String ANewColName = ""; private boolean LRenameCol; private boolean LDuplName; private TList AList; private TRtDBConnection DBConn; private TRtTableDef OldTblDef; private TRtModifyColumnItem ColItem; private TRtIndexDef ANdxDef; private TRtIndexItem NdxItem; private TRtUniqueConstraintDef AUniqueDef; private TRtSingleIndexItem UniqueItem; private TRtRelationDef ARelDef; private int AOrder; private void ProcessIndex(boolean LUnique) { int i; NdxItem = FIndexes.ItemByName(ANdxDef.GetName()); if (NdxItem != null) { if (NdxItem.getOption() != rcaDrop && !LDuplName) { NdxItem.SetOption(rcaModify); if (ColItem.getOption() == rcaDrop || LRenameCol) { i = 0; while (i < NdxItem.GetColumns().GetCount()) { if (CompareText(NdxItem.GetColumns().GetItem(i).getColName(), AColName) == 0) { if (LRenameCol) { NdxItem.GetColumns().GetItem(i).SetColName(ANewColName); i++; } else { NdxItem.GetColumns().GetItem(i).Free(); } } else { i++; } } } } } else { NdxItem = FIndexes.AddIndex(ANdxDef.GetName(), LUnique); NdxItem.FOption = rcaModify; for (i = 0; i <= ANdxDef.GetFieldCount() - 1; ++i) { { TRtIndexFieldDef context_GetField = ANdxDef.GetField(i); if (CompareText(context_GetField.getField().GetName(), AColName) == 0) { if (ColItem.getOption() == rcaDrop) { continue; } TmpName = ANewColName; } else { TmpName = context_GetField.getField().GetName(); } if (context_GetField.getDescendent()) { AOrder = risDesc; } else { AOrder = risAsc; } NdxItem.AddColumnOrdered(TmpName, AOrder); } } } if (NdxItem.GetColumns().GetCount() == 0 && NdxItem.getOption() == rcaModify) { NdxItem.SetOption(rcaDrop); } } private boolean ExistsAlterTableForFk(String ATableName, String AFkName) { boolean Result; TObject AObj; int i; TRtForeignKeyItem AFkItem; if (DBConn.getSQLProcessMode() == spmGroup) { for (i = 0; i <= DBConn.FSQLList.GetCount() - 1; ++i) { AObj = DBConn.FSQLList.Get(i); if (AObj instanceof TRtAlterTable) { AFkItem = ((TRtAlterTable) AObj).FForeignKeys.ItemByName(AFkName); Result = AFkItem != null && CompareText(AFkItem.GetForeignTable(), ATableName) == 0; if (Result) { return Result; } } } } else { AFkItem = FForeignKeys.ItemByName(AFkName); Result = AFkItem != null && CompareText(AFkItem.GetForeignTable(), ATableName) == 0; if (Result) { return Result; } } return false; } private TRtAlterTable NewAT(String ATableName) { TRtAlterTable Result; int i; TObject AObj; for (i = 0; i <= DBConn.FSQLList.GetCount() - 1; ++i) { AObj = DBConn.FSQLList.Get(i); if (AObj instanceof TRtAlterTable && CompareText(((TRtAlterTable) AObj).GetTableName(), ATableName) == 0) { Result = (TRtAlterTable) AObj; return Result; } } Result = DBConn.SQLAlterTable(); Result.SetTableName(ATableName); return Result; } private void ProcessForeignKeyList() { int i; int c; TRtForeignKeyItem AFkItem; TRtAlterTable AT; if (AList != null) { try { for (i = 0; i <= AList.getCount() - 1; ++i) { ARelDef = ((TRtRelationDef) AList.Get(i)); if (!ExistsAlterTableForFk(ARelDef.getForeignTable().GetName(), ARelDef.GetName())) { if (DBConn.getSQLProcessMode() == spmGroup && CompareText(ARelDef.getForeignTable().GetName(), FTableName) != 0) { AT = NewAT(ARelDef.getForeignTable().GetName()); } else { AT = TRtAlterTable.this; } AFkItem = AT.getForeignKeyList().AddForeignKey(ARelDef.GetName(), ARelDef.getReferenceTable().GetName()); AFkItem.SetForeignTable(ARelDef.getForeignTable().GetName()); if (DBConn.getSQLProcessMode() == spmGroup && FAssignConsistent && !HasDropTable(DBConn, AFkItem.GetForeignTable())) { AFkItem.SetReferenceTable(ARelDef.getReferenceTable().GetName()); AFkItem.SetOption(rcaModify); for (c = 0; c <= ARelDef.GetFieldCount() - 1; ++c) { AFkItem.AddColumns(ARelDef.GetForeignField(c).GetName(), ARelDef.GetReferenceField(c).GetName()); } } else { AFkItem.SetOption(rcaDrop); } } } } finally { AList.Free(); } } } private void ProcessForeignKeysOnUC(String AConstraintName) { AList = OldTblDef.GetForeignKeysForUniqueConstraintDef(AConstraintName); ProcessForeignKeyList(); } private void ProcessForeignKeysOnColumn(String AColName) { AList = OldTblDef.GetForeignKeysForField(AColName); ProcessForeignKeyList(); } public DoImplicitChanges_Context() { } public void execute() { FInnerJob++; try { DBConn = GetOwnerConnection(); OldTblDef = CheckGetDatabaseDef().TableByName(FTableName); if (OldTblDef == null) { return; } for (i = 0; i <= GetColumn().GetCount() - 1; ++i) { ColItem = GetColumn().GetItem(i); if (ColItem.getOption() == rcaAdd) { continue; } LRenameCol = ColItem.GetIsRenamingCol(); if (LRenameCol) { AColName = ColItem.getOldColName(); LDuplName = GetColumn().ItemByName(AColName, rcaAdd) != null; } else { AColName = ColItem.getColName(); LDuplName = false; } ANewColName = ColItem.getColName(); AList = OldTblDef.GetIndexesForField(AColName); if (AList != null) { try { for (c = 0; c <= AList.getCount() - 1; ++c) { ANdxDef = ((TRtIndexDef) AList.Get(c)); ProcessIndex(false); } } finally { AList.Free(); } } AList = OldTblDef.GetUniqueKeysForField(AColName); if (AList != null) { try { for (c = 0; c <= AList.getCount() - 1; ++c) { ANdxDef = ((TRtIndexDef) AList.Get(c)); ProcessIndex(true); } } finally { AList.Free(); } } AList = OldTblDef.GetUniqueConstraintsForField(AColName); if (AList != null) { try { for (c = 0; c <= AList.getCount() - 1; ++c) { AUniqueDef = ((TRtUniqueConstraintDef) AList.Get(c)); UniqueItem = FUniqueConstraints.ItemByName(AUniqueDef.GetName()); if (UniqueItem != null) { if (UniqueItem.getOption() != rcaDrop && !LDuplName) { UniqueItem.SetOption(rcaModify); if (ColItem.getOption() == rcaDrop || LRenameCol) { j = 0; while (j < UniqueItem.getColumns().GetCount()) { if (CompareText(UniqueItem.getColumns().GetItem(j).getColName(), AColName) == 0) { if (LRenameCol) { UniqueItem.getColumns().GetItem(j).SetColName(ANewColName); j++; } else { UniqueItem.getColumns().GetItem(j).Free(); } } else { j++; } } } } } else { UniqueItem = FUniqueConstraints.AddUniqueConstraint(AUniqueDef.GetName()); UniqueItem.FOption = rcaModify; for (j = 0; j <= AUniqueDef.GetFieldCount() - 1; ++j) { { TRtUniqueConstraintFieldDef context_GetField = AUniqueDef.GetField(j); if (CompareText(context_GetField.getField().GetName(), AColName) == 0) { if (ColItem.getOption() == rcaDrop) { continue; } TmpName = ANewColName; } else { TmpName = context_GetField.getField().GetName(); } UniqueItem.AddColumn(TmpName); } } } if (UniqueItem.getColumns().GetCount() == 0 && UniqueItem.getOption() == rcaModify) { UniqueItem.SetOption(rcaDrop); } } } finally { AList.Free(); } } if (OldTblDef.GetIsInPrimaryKey(AColName) && FPrimaryKey.getOption() != rcaDrop && !LDuplName) { if (FPrimaryKey.getColumns().GetCount() > 0) { FPrimaryKey.SetOption(rcaModify); if (ColItem.getOption() == rcaDrop || LRenameCol) { j = 0; while (j < FPrimaryKey.getColumns().GetCount()) { if (CompareText(FPrimaryKey.getColumns().GetItem(j).getColName(), AColName) == 0) { if (LRenameCol) { FPrimaryKey.getColumns().GetItem(j).SetColName(ANewColName); j++; } else { FPrimaryKey.getColumns().GetItem(j).Free(); } } else { j++; } } } } else { FPrimaryKey.SetOption(rcaModify); for (j = 0; j <= OldTblDef.GetKeyCount() - 1; ++j) { { TRtFieldDef context_GetPrimaryKeyField = OldTblDef.GetPrimaryKeyField(j); if (CompareText(context_GetPrimaryKeyField.GetName(), AColName) == 0) { if (ColItem.getOption() == rcaDrop) { continue; } TmpName = ANewColName; } else { TmpName = context_GetPrimaryKeyField.GetName(); } FPrimaryKey.AddColumn(TmpName); } } FPrimaryKey.SetName(OldTblDef.GetPrimaryKeyName()); } if (FPrimaryKey.getColumns().GetCount() == 0 && FPrimaryKey.FOption == rcaModify) { FPrimaryKey.SetOption(rcaDrop); } } ProcessForeignKeysOnColumn(AColName); } if (DelphiSet.get(rcaDrop, rcaModify).contains(FPrimaryKey.FOption)) { ProcessForeignKeysOnUC(FPrimaryKey.GetName()); } for (i = 0; i <= FIndexes.GetCount() - 1; ++i) { NdxItem = FIndexes.GetItem(i); if (NdxItem.getUnique() && DelphiSet.get(rcaDrop, rcaModify).contains(NdxItem.getOption())) { ProcessForeignKeysOnUC(NdxItem.GetName()); } } for (i = 0; i <= FUniqueConstraints.GetCount() - 1; ++i) { UniqueItem = FUniqueConstraints.GetItem(i); if (DelphiSet.get(rcaDrop, rcaModify).contains(UniqueItem.getOption())) { ProcessForeignKeysOnUC(UniqueItem.GetName()); } } if (GetAlterTableMode() != atmAlterTable) { if (GetAlterTableMode() != atmCustomDB) { ForceModifyAllFks(); } ForceModifyAllTriggers(); } } finally { FInnerJob--; } } } private final class ExecuteStepEx_Context { private final class ExecuteMoveData_Context { private void AddParamsValues(TRtQuery aCur, br.com.senior.svcl.db.RtAccess.TRtUpdate aUpd, TInsSelFieldPairs aInsSelFlds) { TRtParam xParam; TRtCursorField xField; int i; int c; for (i = 0; i <= aUpd.GetParamCount() - 1; ++i) { xParam = aUpd.GetParams(i); if (aInsSelFlds != null && aInsSelFlds.Ins.IndexOf(xParam.GetName()) >= 0) { c = aInsSelFlds.Ins.IndexOf(xParam.GetName()); xField = aCur.FindField(aInsSelFlds.Sel.Get(c)); } else { xField = aCur.FindField(xParam.GetName()); } try { if (xField != null) { if (DelphiSet.get(varEmpty, varNull, varUnknown).contains(xParam.GetTypeDesc().vType)) { xParam.GetTypeDesc().assign(xField.GetTypeDesc()); } xParam.SetAsVariant(xField.GetAsVariant()); } } catch (Throwable any) { xParam.SetToNull(); } } } private TList AList; private TRtSelect ASelOld; private TRtQuery aCur; private TRtInsertInto aNewInsInto; private TRtInsertInto AErrInsInto; private br.com.senior.svcl.db.RtAccess.TRtUpdate AInsNew; private br.com.senior.svcl.db.RtAccess.TRtUpdate AInsErr; private TRtDeleteFrom ADelErr; private TRtDeleteFrom ADelNew; private TRtRenameTable ARenErrToOld; private TRtCreateTable ACrtErr; private TRtDropTable ADropErr; private TInsSelFieldPairs AInsSelFlds; private boolean LRetry; private boolean LInsError; private boolean LMustIns; private int NMoves; private int NErrCount; private void DoAriseErrTable() { TRtDBConnection DBConn; boolean LMustCreateErr; DBConn = GetOwnerConnection(); if (DBConn.TableExists(GetErrTableName())) { LMustCreateErr = false; if (DBConn.TableExists(GetOldTableName())) { ADelErr.ExecuteUpd(); ADelNew.ExecuteUpd(); } else { ARenErrToOld.ExecuteUpd(); LMustCreateErr = true; } } else { LMustCreateErr = true; } if (LMustCreateErr) { ACrtErr.ExecuteUpd(); } } private TRtStoredProcDef xSpDef; private br.com.senior.svcl.db.RtAccess.TRtUpdate xExecSP; private TRtParam xParam; private int i; private TRtTableDef xTblDef; private TRtFieldDef xFldDef; public ExecuteMoveData_Context() { } public void execute() { AList = GenSQLObjectsStep(atsMoveData, atmCursor, 0); if (AList != null) { try { ACrtErr = ((TRtCreateTable) AList.Get(0)); ASelOld = ((TRtSelect) AList.Get(1)); aNewInsInto = ((TRtInsertInto) AList.Get(2)); AErrInsInto = ((TRtInsertInto) AList.Get(3)); ARenErrToOld = ((TRtRenameTable) AList.Get(4)); ADelErr = ((TRtDeleteFrom) AList.Get(5)); ADelNew = ((TRtDeleteFrom) AList.Get(6)); ADropErr = ((TRtDropTable) AList.Get(7)); AInsSelFlds = ((TInsSelFieldPairs) AList.Get(8)); DoAriseErrTable(); try { if (FOnStoredProcMoveData != null) { xSpDef = null; FOnStoredProcMoveData.run(GetOwnerConnection(), GetTableName(), true, xSpDef); if (xSpDef == null) { throw DelphiException.CreateFmt(TransStr("TC665", "Procedure para operação de move data da tabela %s não retornada", true), new Object[] { GetTableName() }); } xExecSP = GetOwnerConnection().GetAccess().NewUpdate(); try { xExecSP.SetStoredProc(UpperCase(xSpDef.GetName())); if (getOnBeforeExecStoredProcMoveData() != null) { getOnBeforeExecStoredProcMoveData().run(xExecSP); } xExecSP.Execute(); xParam = xExecSP.ParamByName(cParamNameErrorLineCountInSPMoveData); if (xParam == null || xParam.GetAsInteger() == 0) { ADropErr.ExecuteUpd(); } else { LRetry = DoOnDDLError(atsMoveData, null, xExecSP); } FOnStoredProcMoveData.run(GetOwnerConnection(), GetTableName(), false, xSpDef); } finally { xExecSP.Free(); } } else { aCur = ASelOld.GetRtQuery(); aCur.SetBidirectional(false); aCur.Open(); AInsNew = aNewInsInto.GetRtUpdate(); AInsNew.Prepare(); xTblDef = GetOwnerConnection().GetNewDatabase().CheckTableByName(GetTableName()); for (i = 0; i <= GetColumn().GetCount() - 1; ++i) { if (GetColumn().GetItem(i).getOption() == rcaAdd && GetColumn().GetItem(i).getNotNull()) { xParam = AInsNew.FindParam(GetColumn().GetItem(i).getColName()); if (xParam != null) { xFldDef = xTblDef.FieldByName(GetColumn().GetItem(i).getColName()); xParam.SetAsVariant(NullValue(xFldDef.GetTypeDesc().vType)); } } } AInsErr = AErrInsInto.GetRtUpdate(); AInsErr.Prepare(); NMoves = 0; NErrCount = 0; GetOwnerConnection().BeginTran(); try { while (!aCur.GetEOF()) { AddParamsValues(aCur, AInsNew, AInsSelFlds); LMustIns = true; try { DoOnBeforeDDLStep(atsMoveData, aCur, AInsNew); } catch (EMoveDataIgnoreRow any) { LMustIns = false; LRetry = DoOnDDLError(atsMoveData, aCur, AInsNew); } catch (Throwable any) { throw wrap(any); } LInsError = false; if (LMustIns) { while (true) { try { if (aNewInsInto.getUseDataBaseDef() != null && GetOwnerConnection().FRtDatabase != null) { GetOwnerConnection().FRtDatabase.setDatabaseDef(aNewInsInto.getUseDataBaseDef()); } try { AInsNew.Execute(); } finally { if (aNewInsInto.getUseDataBaseDef() != null && GetOwnerConnection().FRtDatabase != null) { GetOwnerConnection().FRtDatabase.setDatabaseDef(GetOwnerConnection().getPhyDatabase()); } } break; } catch (Throwable any) { LRetry = DoOnDDLError(atsMoveData, aCur, AInsNew); if (LRetry) { continue; } else { LInsError = true; break; } } } } if (LInsError) { AddParamsValues(aCur, AInsErr, null); if (AErrInsInto.getUseDataBaseDef() != null && GetOwnerConnection().FRtDatabase != null) { GetOwnerConnection().FRtDatabase.setDatabaseDef(AErrInsInto.getUseDataBaseDef()); } try { AInsErr.Execute(); NErrCount++; } finally { if (AErrInsInto.getUseDataBaseDef() != null && GetOwnerConnection().FRtDatabase != null) { GetOwnerConnection().FRtDatabase.setDatabaseDef(GetOwnerConnection().getPhyDatabase()); } } } if (NMoves != 0 && NMoves % 0x80 == 0x0) { GetOwnerConnection().Commit(); GetOwnerConnection().BeginTran(); } NMoves++; aCur.Next(); } if (NErrCount == 0) { GetOwnerConnection().Commit(); ADropErr.ExecuteUpd(); } } finally { if (GetOwnerConnection().GetInTransaction()) { GetOwnerConnection().Commit(); } } } } finally { AInsSelFlds.Free(); ADropErr.Free(); ADelNew.Free(); ADelErr.Free(); ARenErrToOld.Free(); AErrInsInto.Free(); aNewInsInto.Free(); ASelOld.Free(); ACrtErr.Free(); } } finally { AList.Free(); } } } } private final int aStep; private final int ASeq; private final int aInitSubStep; private void ExecuteMoveData() { ExecuteMoveData_Context ctx = new ExecuteMoveData_Context(); ctx.execute(); } private String OldSQL = ""; private String ASql = ""; private String ALastSQLs = ""; private String ExceptMessage = ""; private int AMode; private int iStep; private boolean LRetry; private TRtTableDef xTableDef; public ExecuteStepEx_Context(int aStep, int ASeq, int aInitSubStep) { this.aStep = aStep; this.ASeq = ASeq; this.aInitSubStep = aInitSubStep; } public void execute() { switch (aStep) { case atsMoveData: ExecuteMoveData(); break; case atsAllSteps: AMode = GetAlterTableMode(); if (AMode == atmCustomDB) { throw DelphiException.Create(TransStrFmt("TC428", "Alteração customizada pelo banco deve ser tratada pela classe específica do banco: %0:s", new Object[] { ClassName() }, true)); } ExecuteStep(atsDropTriggers, 0); ExecuteStep(atsDropFks, 0); if (AMode == atmCursor) { for (iStep = atsRenameTable; iStep <= atsDropOldTable; ++iStep) { ExecuteStep(iStep, 0); } if (GetUseNewOperationKind()) { xTableDef = GetOwnerConnection().GetNewDatabase().TableByName(GetTableName()); if (xTableDef.GetHasPrimaryKey() || xTableDef.GetHasIndex() || xTableDef.GetHasUniqueIndex() || xTableDef.GetHasUniqueConstraint()) { ExecuteStep(atsCreatePkIdxInNewTable); } } } else { ExecuteStep(atsAlterTable, 0); } ExecuteStep(atsRecreateFks, 0); ExecuteStep(atsRecreateTriggers, 0); UpdatePhyDatabase(); break; default: OldSQL = FSql; try { DoOnBeforeDDLStep(aStep); ASql = GenSQLStep(aStep, ASeq); while (true) { try { if (aStep == atsRecreateTriggers) { ALastSQLs = ExecuteRecreateTriggers(ASql, ALastSQLs); } else { ALastSQLs = ExecuteMultipleSQLs(ASql, aInitSubStep, ALastSQLs); } break; } catch (DelphiException E) { LRetry = DoOnDDLError(aStep); if (LRetry) { continue; } else { ExceptMessage = TransStrFmt("TC3297", "Mensagem: %0:s%1:sComando: %2:s%3:s%4:s%5:sGrupo de comandos relacionados:%6:s%7:s", new Object[] { GetATOperation(aStep, new Object[] { GetTableName() }), EOL, StrBreakLine(StrReplaceStr(FSql, SQLEOC_SEP, EOL), " ", 80, 4, kblNone), EOL, StrBreakLine(E.getMessage(), " ", 80, 4, kblNone), EOL, EOL, StrBreakLine(StrReplaceStr(ALastSQLs, SQLEOC_SEP, EOL), " ", 80, 4, kblNone) }, true); E.setMessage(ExceptMessage); throw wrap(E); } } } } finally { FSql = OldSQL; } break; } } } private int FLevelAlterTableMode; private int FAlterTableMode; short FInnerJob; boolean FAssignConsistent; private boolean FKeepPKInOLDTable; private TNotifyEvent FOnCommitMoveData; TRtOnStoredProcMoveData FOnStoredProcMoveData; private TRtOnExecStoredProcMoveData FOnBeforeExecStoredProcMoveData; private TRtOnCustomAlterTableUpdateData FOnCustomAlterTableUpdateData; public final int GetAlterTableMode() { int AMode; if (FAlterTableMode != atmCursor) { AMode = CheckGetAlterTableMode(); } else { AMode = atmCursor; } if (FAlterTableMode != AMode && AMode != atmAlterTable) { FAlterTableMode = AMode; } return FAlterTableMode; } public final void SetAlterTableMode(int Value) { FAlterTableMode = Value; } final String GetOldTableName() { return GetTableName() + "_OLD"; } final String GetErrTableName() { return GetTableName() + "_ERR"; } void ForceModifyAllFks() { ForceModifyAllFks_Context ctx = new ForceModifyAllFks_Context(); ctx.execute(); } void ForceModifyAllTriggers() { ForceModifyAllTriggers_Context ctx = new ForceModifyAllTriggers_Context(); ctx.execute(); } public final boolean GetUsingCursor() { return GetAlterTableMode() == atmCursor; } public final void SetUsingCursor(boolean Value) { int AMode; if (Value) { SetAlterTableMode(atmCursor); } else { AMode = CheckGetAlterTableMode(); if (AMode == atmCursor) { AMode = atmAlterTable; } SetAlterTableMode(AMode); } } protected boolean FUseNewOperationKind; public boolean GetUseNewOperationKind() { return false; } protected boolean GetDATNeedForceModifyAllFks() { return true; } protected final boolean MaxRestrictionGenCriticalChanges() { boolean Result; int i; TRtSqlDriver xSqlDriver = null; Result = false; if (getLevelAlterTableMode() == latmMaxRestriction) { for (i = rtDBConst.Low_TDBVersionKind; i <= rtDBConst.High_TDBVersionKind; ++i) { xSqlDriver = TRtDatabaseServerClass.SINGLETON.GlobalInstance().FSqlDrivers[i]; if (xSqlDriver != null && xSqlDriver.OnHasCriticalChange != null && xSqlDriver.OnHasCriticalChange.run(this)) { Result = true; return Result; } } } return Result; } protected boolean GetConvertSQLToAccess() { return false; } protected void CheckUnprepare() { super.CheckUnprepare(); if (FInnerJob == 0) { FAssignConsistent = false; } } protected int CheckGetAlterTableMode() { CheckGetAlterTableMode_Context ctx = new CheckGetAlterTableMode_Context(); return ctx.execute(); } protected void UpdatePhyDatabase() { TRtTableDef ATblDef; if (!GetNotUpdatePhyDatabase()) { ATblDef = CheckGetDatabaseDef().TableByName(FTableName); if (ATblDef != null) { AssignToTableDef(ATblDef, DelphiSet.getRange(raaColumns, raaForeignKeys)); } } } public final TRtModifyColumnsList GetColumn() { return ((TRtModifyColumnsList) super.GetColumn()); } protected final boolean AssignFksFromTableDef(TRtTableDef _NewTableDef, int _AFkOption) { boolean Result; boolean LModify; TBoolean xForceDrop = new TBoolean(); int i; int c; TRtTableDef OldTblDef; int AOption; TRtRelationDef ARelDef; TRtForeignKeyItem RelItem; TStringList xForceDropFKList; OldTblDef = CheckGetDatabaseDef().CheckTableByName(_NewTableDef.GetName()); FForeignKeys.Clear(); xForceDropFKList = TStringList.Create(); try { if (!GetOwnerConnection().FDisableEvents && GetOwnerConnection().FOnBeforeAssignFromTableDef != null) { GetOwnerConnection().FOnBeforeAssignFromTableDef.run(this, OldTblDef, _NewTableDef); } if (DelphiSet.get(rcaDrop, rcaModify).contains(_AFkOption)) { for (i = 0; i <= OldTblDef.GetRelationCount() - 1; ++i) { { TRtRelationDef context_GetRelation = OldTblDef.GetRelation(i); if (CompareText(context_GetRelation.getForeignTable().GetName(), FTableName) == 0) { xForceDrop.v = false; if (GetOwnerConnection().getOnVerifyAssignObjectDef() != null) { GetOwnerConnection().getOnVerifyAssignObjectDef().run(OldTblDef.GetRelation(i), xForceDrop); if (xForceDrop.v) { xForceDropFKList.Add(OldTblDef.GetRelation(i).GetName()); } } if (_NewTableDef.RelationByName(context_GetRelation.GetName()) == null || xForceDrop.v) { FForeignKeys.AddForeignKey(context_GetRelation.GetName(), context_GetRelation.getReferenceTable().GetName()).FOption = rcaDrop; } } } } } for (i = 0; i <= _NewTableDef.GetRelationCount() - 1; ++i) { { TRtRelationDef context_GetRelation = _NewTableDef.GetRelation(i); if (xForceDropFKList.IndexOf(context_GetRelation.GetName()) == -1) { if (CompareText(context_GetRelation.getForeignTable().GetName(), FTableName) != 0) { continue; } ARelDef = OldTblDef.RelationByName(context_GetRelation.GetName()); LModify = false; if (ARelDef != null) { LModify = CompareText(context_GetRelation.getForeignTable().GetName(), ARelDef.getForeignTable().GetName()) != 0 || CompareText(context_GetRelation.getReferenceTable().GetName(), ARelDef.getReferenceTable().GetName()) != 0 || context_GetRelation.GetFieldCount() != ARelDef.GetFieldCount(); if (!LModify) { for (c = 0; c <= context_GetRelation.GetFieldCount() - 1; ++c) { LModify = CompareText(context_GetRelation.GetForeignField(c).GetName(), ARelDef.GetForeignField(c).GetName()) != 0 || CompareText(context_GetRelation.GetReferenceField(c).GetName(), ARelDef.GetReferenceField(c).GetName()) != 0; if (LModify) { break; } } } } AOption = rcaModify; if (!LModify) { if (ARelDef != null) { continue; } AOption = rcaAdd; } if (_AFkOption == rcaDrop) { if (AOption == rcaModify) { AOption = rcaDrop; } else { continue; } } else if (_AFkOption == rcaAdd) { AOption = rcaAdd; } RelItem = FForeignKeys.AddForeignKey(context_GetRelation.GetName(), context_GetRelation.getReferenceTable().GetName()); RelItem.FOption = AOption; if (AOption != rcaDrop) { for (c = 0; c <= context_GetRelation.GetFieldCount() - 1; ++c) { RelItem.AddColumns(context_GetRelation.GetForeignField(c).GetName(), context_GetRelation.GetReferenceField(c).GetName()); } } } } } } finally { xForceDropFKList.Destroy(); } Result = FForeignKeys.GetCount() > 0; if (!GetOwnerConnection().FDisableEvents && GetOwnerConnection().FOnAfterAssignFromTableDef != null) { GetOwnerConnection().FOnAfterAssignFromTableDef.run(this, OldTblDef, _NewTableDef); } return Result; } protected final boolean AssignTriggersFromTableDef(TRtTableDef _NewTableDef, int _ATrgOption) { boolean Result; int i; TRtTableDef OldTblDef; TRtTriggerItem ATrgItem; boolean LModify; OldTblDef = CheckGetDatabaseDef().CheckTableByName(_NewTableDef.GetName()); FTriggers.Clear(); if (!GetOwnerConnection().FDisableEvents && GetOwnerConnection().FOnBeforeAssignFromTableDef != null) { GetOwnerConnection().FOnBeforeAssignFromTableDef.run(this, OldTblDef, _NewTableDef); } if (DelphiSet.get(rcaDrop, rcaModify).contains(_ATrgOption)) { for (i = 0; i <= OldTblDef.GetTriggerCount() - 1; ++i) { if (_ATrgOption == rcaDrop || _NewTableDef.TriggerByName(OldTblDef.GetTrigger(i).GetName()) == null) { FTriggers.AddTrigger(OldTblDef.GetTrigger(i).GetName(), "", OldTblDef.GetTrigger(i).getForEachRow()).FOption = rcaDrop; } } } if (DelphiSet.get(rcaAdd, rcaModify).contains(_ATrgOption)) { for (i = 0; i <= _NewTableDef.GetTriggerCount() - 1; ++i) { LModify = _ATrgOption == rcaModify && OldTblDef.TriggerByName(_NewTableDef.GetTrigger(i).GetName()) != null; ATrgItem = FTriggers.AddTriggerFromTriggerDef(_NewTableDef.GetTrigger(i)); if (LModify) { ATrgItem.FOption = rcaModify; } } } Result = FTriggers.GetCount() > 0; if (!GetOwnerConnection().FDisableEvents && GetOwnerConnection().FOnAfterAssignFromTableDef != null) { GetOwnerConnection().FOnAfterAssignFromTableDef.run(this, OldTblDef, _NewTableDef); } return Result; } protected String TranslateOldFieldValue(TRtFieldDef AFld, TRtModifyColumnItem ACol, String AColName) { TranslateOldFieldValue_Context ctx = new TranslateOldFieldValue_Context(AFld, ACol, AColName); return ctx.execute(); } protected String GenSQL() { DoImplicitChanges(); return GenPlainAlterTable(); } protected String GenSQLStep(int AStep, int ASeq) { String Result = ""; TList AList; int AMode; int iStep; String s = ""; int i; TRtTableDef xTableDef; switch (AStep) { case atsAlterTable: Result = ""; break; case atsAllSteps: AMode = GetAlterTableMode(); if (AMode == atmCustomDB) { throw DelphiException.Create(TransStrFmt("TC428", "Alteração customizada pelo banco deve ser tratada pela classe específica do banco: %0:s", new Object[] { ClassName() }, true)); } Result = GenSQLStep(atsDropTriggers, 0) + ToStr(SQLEOC_SEP); Result = Result + GenSQLStep(atsDropFks, 0) + ToStr(SQLEOC_SEP); if (AMode == atmCursor) { for (iStep = atsRenameTable; iStep <= atsDropOldTable; ++iStep) { Result = Result + GenSQLStep(iStep, 0) + ToStr(SQLEOC_SEP); } if (GetUseNewOperationKind()) { xTableDef = GetOwnerConnection().GetNewDatabase().TableByName(GetTableName()); if (xTableDef.GetHasPrimaryKey() || xTableDef.GetHasIndex() || xTableDef.GetHasIndex() || xTableDef.GetHasUniqueConstraint()) { Result = Result + GenSQLStep(atsCreatePkIdxInNewTable, 0) + ToStr(SQLEOC_SEP); } } } else { Result = Result + GenSQLStep(atsAlterTable, 0) + ToStr(SQLEOC_SEP); } Result = Result + GenSQLStep(atsRecreateFks, 0) + ToStr(SQLEOC_SEP); Result = Result + GenSQLStep(atsRecreateTriggers, 0) + ToStr(SQLEOC_SEP); break; default: AList = GenSQLObjectsStep(AStep, atmInsertIntoSelect, ASeq); if (AList != null) { try { Result = ""; for (i = 0; i <= AList.getCount() - 1; ++i) { if (AList.Get(i) != null) { if (((TObject) AList.Get(i)) instanceof TRtAlterTable) { Result = Result + (((TRtAlterTable) AList.Get(i))).GenPlainAlterTable() + ToStr(SQLEOC_SEP); } else { s = (((TRtCustomSQL) AList.Get(i))).GenSQL(); Result = Result + s + ToStr(SQLEOC_SEP); } } } } finally { for (i = 0; i <= AList.getCount() - 1; ++i) { if (AList.Get(i) != null) { (((TRtCustomSQL) AList.Get(i))).Free(); } else { break; } } AList.Free(); } } else { Result = ""; } break; } return Result; } public String GetSQLStep(int AStep, int ASeq) { return StrReplaceStr(GenSQLStep(AStep, ASeq), ToStr(SQLEOC_SEP), EOL); } public final String GetSQLStepScript(int AStep, int ASeq) { String Result = ""; FUsesScriptTerminator = true; try { Result = StrReplaceStr(GenSQLStep(AStep, ASeq), ToStr(SQLEOC_SEP), EOL); Result = StrBreakLine(Result, " ,", 250, 0, kblNone); } finally { FUsesScriptTerminator = false; } return Result; } protected String GenPlainAlterTable() { return ""; } protected TList GenSQLObjectsStep(int AStep, int AAlterTableMode, int ASeq) { GenSQLObjectsStep_Context ctx = new GenSQLObjectsStep_Context(AStep, AAlterTableMode, ASeq); return ctx.execute(); } protected final TList GenSQLObjectsStep(int AStep, int AAlterTableMode) { return GenSQLObjectsStep(AStep, AAlterTableMode, 0); } protected final TList GenSQLObjectsStep(int AStep) { return GenSQLObjectsStep(AStep, atmInsertIntoSelect, 0); } protected void DoImplicitChanges() { DoImplicitChanges_Context ctx = new DoImplicitChanges_Context(); ctx.execute(); } protected final String ExecuteRecreateTriggers(String ASql, String ALastSQLs) { TInt p = new TInt(); ALastSQLs = ""; CheckConnected(); p.v = 0; while (p.v != -1) { FSql = TrimRight(StrGetNextToken(ASql, p, SQLEOC_SEP)); if (!FSql.equals("")) { ALastSQLs = ALastSQLs + FSql + EOL; FUpdate.UnPrepare(); FUpdate.SetCommand(FSql); FUpdate.Execute(); } } FUpdate.UnPrepare(); return ALastSQLs; } public void runCreate() { super.runCreate(); FLevelAlterTableMode = latmDefault; setKeepPKInOLDTable(false); FUseNewOperationKind = false; } public static TRtAlterTable Create() { TRtAlterTable Result; Result = new TRtAlterTable(); Result.runCreate(); return Result; } public void ExecuteStep(int aStep, int aInitSubStep) { ExecuteStepEx(aStep, 0, aInitSubStep); } public void ExecuteStep(int aStep) { ExecuteStep(aStep, 0); } public void ExecuteStepEx(int aStep, int ASeq, int aInitSubStep) { ExecuteStepEx_Context ctx = new ExecuteStepEx_Context(aStep, ASeq, aInitSubStep); ctx.execute(); } public void ExecuteStepEx(int aStep, int ASeq) { ExecuteStepEx(aStep, ASeq, 0); } public void ExecuteUpd() { String ASql = ""; String ALastSQLs = ""; String ExceptMessage = ""; boolean LRetry; DoOnBeforeDDLStep(); ASql = GenSQL(); while (true) { try { ALastSQLs = ExecuteMultipleSQLs(ASql, 0, ALastSQLs); UpdatePhyDatabase(); break; } catch (DelphiException E) { LRetry = DoOnDDLError(); if (LRetry) { continue; } else { ExceptMessage = TransStrFmt("TC3297", "Mensagem: %0:s%1:sComando: %2:s%3:s%4:s%5:sGrupo de comandos relacionados:%6:s%7:s", new Object[] { GetATOperation(atsAlterTable, new Object[] { GetTableName() }), EOL, StrBreakLine(StrReplaceStr(FSql, SQLEOC_SEP, EOL), " ", 80, 4, kblNone), EOL, StrBreakLine(E.getMessage(), " ", 80, 4, kblNone), EOL, EOL, StrBreakLine(StrReplaceStr(ALastSQLs, SQLEOC_SEP, EOL), " ", 80, 4, kblNone) }, true); E.setMessage(ExceptMessage); throw wrap(E); } } } } public final DelphiSet AssignFromTableDef(TRtTableDef _NewTableDef, DelphiSet _AAssOpt) { DelphiSet Result = DelphiSet.get(); boolean LModify; boolean LEvent; TBoolean xForceDrop = new TBoolean(); int AOrder; int AOption; int i; int c; TRtTableDef OldTblDef; TRtFieldDef aNewFldDef; TRtFieldDef aOldFldDef; TRtIndexDef ANdxDef; TRtUniqueConstraintDef AUniqueDef; TRtIndexItem NdxItem; TRtSingleIndexItem UniqueItem; TRtAddColumnsList vColumns; TStringList xForceDropList; TString xKindName = new TString(); TString xLength = new TString(); TString xPrecision = new TString(); TString xNull = new TString(); boolean xGenOldStrKind; boolean xGenNewStrKind; OldTblDef = CheckGetDatabaseDef().CheckTableByName(_NewTableDef.GetName()); Clear(); Result = DelphiSet.get(); FTableName = _NewTableDef.GetName(); if (!GetOwnerConnection().FDisableEvents && GetOwnerConnection().FOnBeforeAssignFromTableDef != null) { GetOwnerConnection().FOnBeforeAssignFromTableDef.run(this, OldTblDef, _NewTableDef); } xForceDropList = TStringList.Create(); try { if (_AAssOpt.contains(raaColumns)) { for (i = 0; i <= OldTblDef.GetFieldCount() - 1; ++i) { xForceDrop.v = false; if (GetOwnerConnection().getOnVerifyAssignObjectDef() != null) { GetOwnerConnection().getOnVerifyAssignObjectDef().run(OldTblDef.GetField(i), xForceDrop); if (xForceDrop.v) { xForceDropList.Add(OldTblDef.GetField(i).GetName()); } } if (_NewTableDef.FieldByName(OldTblDef.GetField(i).GetName()) == null || xForceDrop.v) { GetColumn().DropColumn(OldTblDef.GetField(i).GetName()); } } vColumns = TRtAddColumnsList.Create(); vColumns.SetFOwner(this); vColumns.FDBVersionKind = FColumns.FDBVersionKind; try { for (i = 0; i <= _NewTableDef.GetFieldCount() - 1; ++i) { aNewFldDef = _NewTableDef.GetField(i); if (xForceDropList.IndexOf(aNewFldDef.GetName()) == -1) { aOldFldDef = OldTblDef.FieldByName(aNewFldDef.GetName()); if (aOldFldDef != null) { xGenNewStrKind = aNewFldDef.GetPhyNativeStrFullKind().equals(""); if (xGenNewStrKind) { vColumns.AddColumn(aNewFldDef.GetName(), aNewFldDef.GetFullKind().GetEnumType(), aNewFldDef.GetLength(), aNewFldDef.GetPrecision(), aNewFldDef.getNotNull()).GenSqlKind(_NewTableDef.GetDatabase(), xKindName, xLength, xPrecision, xNull); aNewFldDef.SetPhyNativeStrKind(xKindName.v, xLength.v, xPrecision.v, xNull.v); vColumns.Clear(); } xGenOldStrKind = aOldFldDef.GetPhyNativeStrFullKind().equals(""); if (xGenOldStrKind) { vColumns.AddColumn(aOldFldDef.GetName(), aOldFldDef.GetFullKind().GetEnumType(), aOldFldDef.GetLength(), aOldFldDef.GetPrecision(), aOldFldDef.getNotNull()).GenSqlKind(_NewTableDef.GetDatabase(), xKindName, xLength, xPrecision, xNull); aOldFldDef.SetPhyNativeStrKind(xKindName.v, xLength.v, xPrecision.v, xNull.v); vColumns.Clear(); } if (CompareText(aNewFldDef.GetPhyNativeStrFullKind(), aOldFldDef.GetPhyNativeStrFullKind()) != 0) { GetColumn().ModifyColumn(aNewFldDef.GetName(), aNewFldDef.GetName(), aNewFldDef.GetFullKind().GetEnumType(), aNewFldDef.GetLength(), aNewFldDef.GetPrecision(), aNewFldDef.getNotNull(), aNewFldDef.getNotNull() != aOldFldDef.getNotNull()); } if (xGenNewStrKind) { aNewFldDef.SetPhyNativeStrKind("", "", "", ""); } if (xGenOldStrKind) { aOldFldDef.SetPhyNativeStrKind("", "", "", ""); } } else { GetColumn().AddColumn(aNewFldDef.GetName(), aNewFldDef.GetFullKind().GetEnumType(), aNewFldDef.GetLength(), aNewFldDef.GetPrecision(), aNewFldDef.getNotNull()); } } } } finally { vColumns.Free(); } if (GetColumn().GetCount() > 0) { Result = Result.add(DelphiSet.get(raaColumns)); } } xForceDropList.Clear(); for (i = 0; i <= OldTblDef.GetIndexCount() - 1; ++i) { { TRtIndexDef context_GetIndex = (TRtIndexDef) OldTblDef.GetIndex(i); if (context_GetIndex.getUnique()) { if (!_AAssOpt.contains(raaUniqueKeys)) { continue; } } else if (!_AAssOpt.contains(raaIndexes)) { continue; } xForceDrop.v = false; if (GetOwnerConnection().getOnVerifyAssignObjectDef() != null) { GetOwnerConnection().getOnVerifyAssignObjectDef().run((TObject) OldTblDef.GetIndex(i), xForceDrop); if (xForceDrop.v) { xForceDropList.Add(OldTblDef.GetIndex(i).GetName()); } } if (_NewTableDef.IndexByName(context_GetIndex.GetName()) == null || xForceDrop.v) { FIndexes.AddIndex(context_GetIndex.GetName(), context_GetIndex.getUnique()).FOption = rcaDrop; } } } for (i = 0; i <= _NewTableDef.GetIndexCount() - 1; ++i) { { TRtIndexDef context_GetIndex = (TRtIndexDef) _NewTableDef.GetIndex(i); if (xForceDropList.IndexOf(context_GetIndex.GetName()) == -1) { if (context_GetIndex.getUnique()) { if (!_AAssOpt.contains(raaUniqueKeys)) { continue; } } else if (!_AAssOpt.contains(raaIndexes)) { continue; } ANdxDef = OldTblDef.IndexByName(context_GetIndex.GetName()); LModify = false; if (ANdxDef != null) { LModify = context_GetIndex.getUnique() != ANdxDef.getUnique() || context_GetIndex.GetFieldCount() != ANdxDef.GetFieldCount(); if (!LModify) { for (c = 0; c <= context_GetIndex.GetFieldCount() - 1; ++c) { LModify = CompareText(context_GetIndex.GetField(c).getField().GetName(), ANdxDef.GetField(c).getField().GetName()) != 0 || context_GetIndex.GetField(c).getDescendent() != ANdxDef.GetField(c).getDescendent(); if (LModify) { break; } } } } AOption = rcaModify; if (!LModify) { if (ANdxDef != null) { continue; } AOption = rcaAdd; } NdxItem = FIndexes.AddIndex(context_GetIndex.GetName(), context_GetIndex.getUnique()); NdxItem.FOption = AOption; for (c = 0; c <= context_GetIndex.GetFieldCount() - 1; ++c) { { TRtIndexFieldDef context_GetField = context_GetIndex.GetField(c); if (context_GetField.getDescendent()) { AOrder = risDesc; } else { AOrder = risAsc; } NdxItem.AddColumnOrdered(context_GetField.getField().GetName(), AOrder); } } } } } if (FIndexes.GetCount() > 0) { for (i = 0; i <= FIndexes.GetCount() - 1; ++i) { if (FIndexes.GetItem(i).getUnique()) { Result = Result.add(DelphiSet.get(raaUniqueKeys)); } else { Result = Result.add(DelphiSet.get(raaIndexes)); } } } xForceDropList.Clear(); if (_AAssOpt.contains(raaUniqueConstraints)) { for (i = 0; i <= OldTblDef.GetUniqueConstraintCount() - 1; ++i) { AUniqueDef = OldTblDef.GetUniqueConstraint(i); if (_NewTableDef.UniqueConstraintByName(AUniqueDef.GetName()) == null) { UniqueItem = FUniqueConstraints.AddUniqueConstraint(AUniqueDef.GetName()); UniqueItem.FOption = rcaDrop; for (c = 0; c <= AUniqueDef.GetFieldCount() - 1; ++c) { { TRtUniqueConstraintFieldDef context_GetField = AUniqueDef.GetField(c); UniqueItem.AddColumn(context_GetField.getField().GetName()); } } } } for (i = 0; i <= _NewTableDef.GetUniqueConstraintCount() - 1; ++i) { { TRtUniqueConstraintDef context_GetUniqueConstraint = _NewTableDef.GetUniqueConstraint(i); AUniqueDef = OldTblDef.UniqueConstraintByName(context_GetUniqueConstraint.GetName()); LModify = false; if (AUniqueDef != null) { LModify = context_GetUniqueConstraint.GetFieldCount() != AUniqueDef.GetFieldCount(); if (!LModify) { for (c = 0; c <= context_GetUniqueConstraint.GetFieldCount() - 1; ++c) { LModify = CompareText(context_GetUniqueConstraint.GetField(c).getField().GetName(), AUniqueDef.GetField(c).getField().GetName()) != 0; if (LModify) { break; } } } } AOption = rcaModify; if (!LModify) { if (AUniqueDef != null) { continue; } AOption = rcaAdd; } UniqueItem = FUniqueConstraints.AddUniqueConstraint(context_GetUniqueConstraint.GetName()); UniqueItem.FOption = AOption; for (c = 0; c <= context_GetUniqueConstraint.GetFieldCount() - 1; ++c) { { TRtUniqueConstraintFieldDef context_GetField = context_GetUniqueConstraint.GetField(c); UniqueItem.AddColumn(context_GetField.getField().GetName()); } } } } if (FUniqueConstraints.GetCount() > 0) { Result = Result.add(DelphiSet.get(raaUniqueConstraints)); } } if (_AAssOpt.contains(raaTriggers)) { LEvent = GetOwnerConnection().getDisableEvents(); try { GetOwnerConnection().setDisableEvents(true); if (AssignTriggersFromTableDef(_NewTableDef, rcaModify)) { Result = Result.add(DelphiSet.get(raaTriggers)); } } finally { GetOwnerConnection().setDisableEvents(LEvent); } } if (_AAssOpt.contains(raaForeignKeys)) { LEvent = GetOwnerConnection().getDisableEvents(); try { GetOwnerConnection().setDisableEvents(true); if (AssignFksFromTableDef(_NewTableDef, rcaModify)) { Result = Result.add(DelphiSet.get(raaForeignKeys)); } } finally { GetOwnerConnection().setDisableEvents(LEvent); } } if (_AAssOpt.contains(raaPrimaryKey)) { if (CompareText(_NewTableDef.GetPrimaryKeyStr(), OldTblDef.GetPrimaryKeyStr()) != 0) { if (_NewTableDef.GetKeyCount() > 0) { for (i = 0; i <= _NewTableDef.GetKeyCount() - 1; ++i) { FPrimaryKey.AddColumn(_NewTableDef.GetPrimaryKeyField(i).GetName()); } if (OldTblDef.GetKeyCount() > 0) { FPrimaryKey.FOption = rcaModify; } else { FPrimaryKey.FOption = rcaAdd; } FPrimaryKey.SetName(_NewTableDef.GetPrimaryKeyName()); Result = Result.add(DelphiSet.get(raaPrimaryKey)); } else if (OldTblDef.GetKeyCount() > 0) { FPrimaryKey.FOption = rcaDrop; FPrimaryKey.SetName(OldTblDef.GetPrimaryKeyName()); Result = Result.add(DelphiSet.get(raaPrimaryKey)); } } } } finally { xForceDropList.Destroy(); } FAssignConsistent = true; if (!GetOwnerConnection().FDisableEvents && GetOwnerConnection().FOnAfterAssignFromTableDef != null) { GetOwnerConnection().FOnAfterAssignFromTableDef.run(this, OldTblDef, _NewTableDef); } return Result; } public final void AssignToTableDef(TRtTableDef ATblDef, DelphiSet AAssOpt) { _AssignToTableDef(ATblDef, AAssOpt, true); } public final void AssignToCreateTable(TRtCreateTable ACreateTbl, DelphiSet AAssOpt) { TRtTableDef ATblDef; int i; String s = ""; TRtModifyColumnItem SColItem; TRtAddColumnItem DColItem; TRtIndexItem SNdxItem; TRtIndexItem DNdxItem; TRtSingleIndexItem SUniqueItem; TRtSingleIndexItem DUniqueItem; TRtTriggerItem STriggerItem; TRtTriggerItem DTriggerItem; TRtForeignKeyItem SFkItem; TRtForeignKeyItem DFkItem; ATblDef = CheckGetDatabaseDef().TableByName(FTableName); ACreateTbl.AssignFromTableDef(ATblDef, AAssOpt); if (AAssOpt.contains(raaColumns)) { for (i = 0; i <= FColumns.GetCount() - 1; ++i) { SColItem = GetColumn().GetItem(i); if (SColItem.GetIsRenamingCol()) { s = SColItem.getOldColName(); } else { s = SColItem.getColName(); } if (SColItem.getOption() == rcaDrop) { ACreateTbl.FColumns.RemoveByColumnName(s); continue; } DColItem = ACreateTbl.FColumns.ItemByColumnName(s); if (DColItem == null) { ACreateTbl.FColumns.AddColumn(SColItem.FColName, SColItem.FColType, SColItem.FColLen, SColItem.FColPrec, SColItem.getNotNull()); } else { DColItem.Assign(SColItem); DColItem.FOption = rcaAdd; } } } for (i = 0; i <= FIndexes.GetCount() - 1; ++i) { SNdxItem = FIndexes.GetItem(i); if (SNdxItem.getUnique()) { if (!AAssOpt.contains(raaUniqueKeys)) { continue; } } else if (!AAssOpt.contains(raaIndexes)) { continue; } ACreateTbl.FIndexes.RemoveByName(SNdxItem.GetName()); if (SNdxItem.getOption() == rcaDrop) { continue; } DNdxItem = ACreateTbl.FIndexes.AddIndex(SNdxItem.GetName(), SNdxItem.getUnique()); DNdxItem.Assign(SNdxItem); DNdxItem.FOption = rcaAdd; } if (AAssOpt.contains(raaPrimaryKey)) { s = ""; if (FPrimaryKey.getOption() != rcaDrop) { if (FPrimaryKey.getColumns().GetCount() > 0) { ACreateTbl.FPrimaryKey.Assign(FPrimaryKey); ACreateTbl.FPrimaryKey.FOption = rcaAdd; } } else { ACreateTbl.FPrimaryKey.SetName(""); ACreateTbl.FPrimaryKey.getColumns().Clear(); } } if (AAssOpt.contains(raaUniqueConstraints)) { for (i = 0; i <= FUniqueConstraints.GetCount() - 1; ++i) { SUniqueItem = FUniqueConstraints.GetItem(i); ACreateTbl.FUniqueConstraints.RemoveByName(SUniqueItem.GetName()); if (SUniqueItem.getOption() == rcaDrop) { continue; } DUniqueItem = ACreateTbl.FUniqueConstraints.AddUniqueConstraint(SUniqueItem.GetName()); DUniqueItem.Assign(SUniqueItem); DUniqueItem.FOption = rcaAdd; } } if (AAssOpt.contains(raaTriggers)) { for (i = 0; i <= FTriggers.GetCount() - 1; ++i) { STriggerItem = FTriggers.GetItem(i); ACreateTbl.FTriggers.RemoveByName(STriggerItem.GetName()); if (STriggerItem.getOption() == rcaDrop) { continue; } DTriggerItem = ACreateTbl.FTriggers.AddTrigger(STriggerItem.GetName(), "", STriggerItem.getForEachRow()); DTriggerItem.Assign(STriggerItem); DTriggerItem.FOption = rcaAdd; } } if (AAssOpt.contains(raaForeignKeys)) { for (i = 0; i <= FForeignKeys.GetCount() - 1; ++i) { SFkItem = FForeignKeys.GetItem(i); ACreateTbl.FForeignKeys.RemoveByName(SFkItem.GetName()); if (SFkItem.getOption() == rcaDrop) { continue; } DFkItem = ACreateTbl.FForeignKeys.AddForeignKey(SFkItem.GetName(), SFkItem.getReferenceTable()); DFkItem.Assign(SFkItem); DFkItem.FOption = rcaAdd; } } } public final void AssignToCreateTable(TRtCreateTable ACreateTbl) { AssignToCreateTable(ACreateTbl, DelphiSet.getRange(raaColumns, raaForeignKeys)); } public final void FixRenameColumn(String OldColName, String NewColName) { TRtModifyColumnItem OldCol; TRtModifyColumnItem NewCol; OldCol = GetColumn().ItemByColumnName(OldColName); NewCol = GetColumn().ItemByColumnName(NewColName); if (NewCol != null) { if (OldCol != null) { OldCol.Free(); } if (NewCol.getOption() != rcaModify) { NewCol.SetOption(rcaModify); NewCol.SetOldColName(OldColName); } } else { if (OldCol != null) { GetColumn().ModifyColumn(OldColName, NewColName, OldCol.FColType, OldCol.FColLen, OldCol.FColPrec, OldCol.FNotNull, OldCol.FNotNullChanged); OldCol.Free(); } else { GetColumn().ModifyColumn(OldColName, NewColName, rftUnknown, 0, 0, false, false); } } } public TContainerItem Creator(TPersistent AOwner, TContainerItemClass AType) { return ClassType().Creator(AOwner, AType); } public TRtAlterTableClass ClassType() { return TRtAlterTableClass.SINGLETON; } public void setKeepPKInOLDTable(boolean value) { FKeepPKInOLDTable = value; } public boolean getKeepPKInOLDTable() { return FKeepPKInOLDTable; } public void setLevelAlterTableMode(int value) { FLevelAlterTableMode = value; } public int getLevelAlterTableMode() { return FLevelAlterTableMode; } public void setUseNewOperationKind(boolean value) { FUseNewOperationKind = value; } public void setOnCommitMoveData(TNotifyEvent value) { FOnCommitMoveData = value; } public TNotifyEvent getOnCommitMoveData() { return FOnCommitMoveData; } public void setOnStoredProcMoveData(TRtOnStoredProcMoveData value) { FOnStoredProcMoveData = value; } public TRtOnStoredProcMoveData getOnStoredProcMoveData() { return FOnStoredProcMoveData; } public void setOnBeforeExecStoredProcMoveData(TRtOnExecStoredProcMoveData value) { FOnBeforeExecStoredProcMoveData = value; } public TRtOnExecStoredProcMoveData getOnBeforeExecStoredProcMoveData() { return FOnBeforeExecStoredProcMoveData; } public void setOnCustomAlterTableUpdateData(TRtOnCustomAlterTableUpdateData value) { FOnCustomAlterTableUpdateData = value; } public TRtOnCustomAlterTableUpdateData getOnCustomAlterTableUpdateData() { return FOnCustomAlterTableUpdateData; } } public static class TRtCreateIndexClass extends TRtCustomDDLTableClass { public static final TRtCreateIndexClass SINGLETON = new TRtCreateIndexClass(); public TRtCreateIndex Create() { return TRtCreateIndex.Create(); } public final TRtCreateIndex CreateSQL(TRtDBConnection AConn, String ATableName, String AIndexName, boolean LUnique) { return TRtCreateIndex.CreateSQL(AConn, ATableName, AIndexName, LUnique); } public Class ClassInfo() { return TRtCreateIndex.class; } } public static class TRtCreateIndex extends TRtCustomDDLTable { private String FIndexTableSpace; private TRtIndexItem FIndex; public boolean GetHasOperation() { return super.GetHasOperation() && !StrIsBlank(FIndex.GetName()) && FIndex.GetColumns().GetCount() > 0; } public final void SetIndexTableSpace(String Value) { CheckUnprepare(); FIndexTableSpace = Value; } protected void UpdatePhyDatabase() { TRtDatabaseDef ADbDef; TRtTableDef ATblDef; TRtIndexDef ANdxDef; int c; ADbDef = GetDatabaseDef(); if (ADbDef != null && !GetNotUpdatePhyDatabase()) { ATblDef = ADbDef.TableByName(FTableName); if (ATblDef != null) { { TRtIndexItem context_FIndex = FIndex; ATblDef.DropIndexDef(context_FIndex.GetName()); ANdxDef = ATblDef.NewIndexDef(context_FIndex.GetName(), ""); try { for (c = 0; c <= context_FIndex.GetColumns().GetCount() - 1; ++c) { { TRtIndexColumnItem context_GetItem = context_FIndex.GetColumns().GetItem(c); ANdxDef.NewFieldDef(context_GetItem.getColName(), context_GetItem.getOrder() == risDesc); } } } catch (Throwable any) { ATblDef.DropIndexDef(context_FIndex.GetName()); } } } } } public final String GetIndexTableSpace() { String Result = ""; if (StrIsBlank(FIndexTableSpace)) { Result = TrimRight(GetOwnerConnection().GetIndexTableSpace()); } else { Result = TrimRight(FIndexTableSpace); } return Result; } public String GetName() { return FIndex.GetName(); } public void runCreate() { super.runCreate(); FIndex = ((TRtIndexItem) Creator(this, TRtIndexItemClass.SINGLETON)); } public static TRtCreateIndex Create() { TRtCreateIndex Result; Result = new TRtCreateIndex(); Result.runCreate(); return Result; } public final void runCreateSQL(TRtDBConnection AConn, String ATableName, String AIndexName, boolean LUnique) { super.runCreateSQL(AConn, ATableName); FIndex = ((TRtIndexItem) Creator(this, TRtIndexItemClass.SINGLETON)); FIndex.Init(null, AIndexName, LUnique); } public static TRtCreateIndex CreateSQL(TRtDBConnection AConn, String ATableName, String AIndexName, boolean LUnique) { TRtCreateIndex Result; Result = new TRtCreateIndex(); Result.runCreateSQL(AConn, ATableName, AIndexName, LUnique); return Result; } public void Destroy() { FIndex.Free(); super.Destroy(); } public void ExecuteUpd() { String ExceptMessage = ""; try { super.ExecuteUpd(); } catch (DelphiException E) { ExceptMessage = TransStrFmt("TC3298", "Não foi possível criar o índice para a tabela: %0:s - [%1:s] - \"%2:s\"", new Object[] { GetTableName(), StrReplaceStr(FSql, SQLEOC_SEP, EOL), E.getMessage() }, true); E.setMessage(ExceptMessage); throw wrap(E); } } public void Assign(TPersistent Source) { FAssigning++; try { super.Assign(Source); if (Source instanceof TRtCreateIndex) { FIndex.Assign(((TRtCreateIndex) Source).FIndex); } } finally { FAssigning--; } } public void ReadData(TReader Reader) { FAssigning++; try { super.ReadData(Reader); FIndex.ReadData(Reader); FIndexTableSpace = Reader.ReadString(); } finally { FAssigning--; } } public void WriteData(TWriter Writer) { super.WriteData(Writer); FIndex.WriteData(Writer); Writer.WriteString(FIndexTableSpace); } public TRtCreateIndexClass ClassType() { return TRtCreateIndexClass.SINGLETON; } public TRtIndexItem getIndex() { return FIndex; } } public static class TRtDropIndexClass extends TRtCustomDDLTableClass { public static final TRtDropIndexClass SINGLETON = new TRtDropIndexClass(); public final TRtDropIndex CreateSQL(TRtDBConnection AConn, String ATableName, String AIndexName) { return TRtDropIndex.CreateSQL(AConn, ATableName, AIndexName); } public Class ClassInfo() { return TRtDropIndex.class; } } public static class TRtDropIndex extends TRtCustomDDLTable { private String FIndexName; public boolean GetHasOperation() { return super.GetHasOperation() && !StrIsBlank(getIndexName()); } public final void SetIndexName(String Value) { CheckUnprepare(); FIndexName = Value; } protected void UpdatePhyDatabase() { TRtTableDef ATblDef; if (!GetNotUpdatePhyDatabase()) { ATblDef = CheckGetDatabaseDef().TableByName(FTableName); if (ATblDef != null) { ATblDef.DropIndexDef(FIndexName); } } } public String GetName() { return FIndexName; } public final void runCreateSQL(TRtDBConnection AConn, String ATableName, String AIndexName) { super.runCreateSQL(AConn, ATableName); FIndexName = AIndexName; } public static TRtDropIndex CreateSQL(TRtDBConnection AConn, String ATableName, String AIndexName) { TRtDropIndex Result; Result = new TRtDropIndex(); Result.runCreateSQL(AConn, ATableName, AIndexName); return Result; } public void ExecuteUpd() { String ExceptMessage = ""; try { super.ExecuteUpd(); } catch (DelphiException E) { ExceptMessage = TransStrFmt("TC3299", "Não foi possível excluir o índice %0:s da tabela: %1:s - [%2:s] - \"%3:s\"", new Object[] { getIndexName(), GetTableName(), StrReplaceStr(FSql, SQLEOC_SEP, EOL), E.getMessage() }, true); E.setMessage(ExceptMessage); throw wrap(E); } } public void Assign(TPersistent Source) { FAssigning++; try { super.Assign(Source); if (Source instanceof TRtDropIndex) { FIndexName = ((TRtDropIndex) Source).FIndexName; } } finally { FAssigning--; } } public void ReadData(TReader Reader) { FAssigning++; try { super.ReadData(Reader); FIndexName = Reader.ReadString(); } finally { FAssigning--; } } public void WriteData(TWriter Writer) { super.WriteData(Writer); Writer.WriteString(FIndexName); } public TRtDropIndexClass ClassType() { return TRtDropIndexClass.SINGLETON; } public String getIndexName() { return FIndexName; } } public static class TRtCreateTriggerClass extends TRtCustomDDLTableClass { public static final TRtCreateTriggerClass SINGLETON = new TRtCreateTriggerClass(); public TRtCreateTrigger Create() { return TRtCreateTrigger.Create(); } public final TRtCreateTrigger CreateSQL(TRtDBConnection AConn, String ACode) { return TRtCreateTrigger.CreateSQL(AConn, ACode); } public Class ClassInfo() { return TRtCreateTrigger.class; } } public static class TRtCreateTrigger extends TRtCustomDDLTable { private TRtTriggerItem FTrigger; public boolean GetHasOperation() { return !StrIsBlank(FTrigger.getCode()); } protected void UpdatePhyDatabase() { TRtDatabaseDef ADbDef; TRtTableDef ATblDef; ADbDef = GetDatabaseDef(); if (ADbDef != null && !GetNotUpdatePhyDatabase()) { ATblDef = ADbDef.TableByName(FTableName); if (ATblDef != null) { ATblDef.DropTriggerDef(FTrigger.GetName()); ATblDef.NewTriggerDef(FTrigger.getCode()); } } } public String GetName() { return FTrigger.GetName(); } protected void InternalPrepareUpdate() { if (!GetPrepared()) { CheckConnected(); FUpdate.SetCommand(FSql); FUpdate.Prepare(); } } public void runCreate() { super.runCreate(); FTrigger = ((TRtTriggerItem) Creator(this, TRtTriggerItemClass.SINGLETON)); } public static TRtCreateTrigger Create() { TRtCreateTrigger Result; Result = new TRtCreateTrigger(); Result.runCreate(); return Result; } public final void runCreateSQL(TRtDBConnection AConn, String ACode) { super.runCreateSQL(AConn, ""); FTrigger = ((TRtTriggerItem) Creator(this, TRtTriggerItemClass.SINGLETON)); FTrigger.SetCode(ACode); } public static TRtCreateTrigger CreateSQL(TRtDBConnection AConn, String ACode) { TRtCreateTrigger Result; Result = new TRtCreateTrigger(); Result.runCreateSQL(AConn, ACode); return Result; } public void Destroy() { FTrigger.Free(); super.Destroy(); } public void ExecuteUpd() { String ExceptMessage = ""; try { super.ExecuteUpd(); } catch (DelphiException E) { ExceptMessage = TransStrFmt("TC3300", "Não foi possível criar a trigger para a tabela: %0:s - [Trigger: %1:s] - \"%2:s\"", new Object[] { GetTableName(), GetName(), E.getMessage() }, true); E.setMessage(ExceptMessage); throw wrap(E); } } public void Assign(TPersistent Source) { FAssigning++; try { super.Assign(Source); if (Source instanceof TRtCreateTrigger) { FTrigger.Assign(((TRtCreateTrigger) Source).FTrigger); } } finally { FAssigning--; } } public void ReadData(TReader Reader) { FAssigning++; try { super.ReadData(Reader); FTrigger.ReadData(Reader); } finally { FAssigning--; } } public void WriteData(TWriter Writer) { FAssigning++; try { super.WriteData(Writer); FTrigger.WriteData(Writer); } finally { FAssigning--; } } public TRtCreateTriggerClass ClassType() { return TRtCreateTriggerClass.SINGLETON; } public TRtTriggerItem getTrigger() { return FTrigger; } } public static class TRtDropTriggerClass extends TRtCustomDDLTableClass { public static final TRtDropTriggerClass SINGLETON = new TRtDropTriggerClass(); public final TRtDropTrigger CreateSQL(TRtDBConnection AConn, String ATableName, String ATriggerName) { return TRtDropTrigger.CreateSQL(AConn, ATableName, ATriggerName); } public Class ClassInfo() { return TRtDropTrigger.class; } } public static class TRtDropTrigger extends TRtCustomDDLTable { private String FTriggerName; public boolean GetHasOperation() { return super.GetHasOperation() && !StrIsBlank(GetName()); } public final void SetTriggerName(String Value) { CheckUnprepare(); FTriggerName = Value; } protected void UpdatePhyDatabase() { TRtTableDef ATblDef; if (!GetNotUpdatePhyDatabase()) { ATblDef = CheckGetDatabaseDef().TableByName(FTableName); if (ATblDef != null) { ATblDef.DropTriggerDef(FTriggerName); } } } public String GetName() { return FTriggerName; } public final void runCreateSQL(TRtDBConnection AConn, String ATableName, String ATriggerName) { super.runCreateSQL(AConn, ATableName); FTriggerName = ATriggerName; } public static TRtDropTrigger CreateSQL(TRtDBConnection AConn, String ATableName, String ATriggerName) { TRtDropTrigger Result; Result = new TRtDropTrigger(); Result.runCreateSQL(AConn, ATableName, ATriggerName); return Result; } public void ExecuteUpd() { String ExceptMessage = ""; try { super.ExecuteUpd(); } catch (DelphiException E) { ExceptMessage = TransStrFmt("TC3301", "Não foi possível excluir a trigger %0:s da tabela: %1:s - [%2:s] - \"%3:s\"", new Object[] { GetName(), GetTableName(), StrReplaceStr(FSql, SQLEOC_SEP, EOL), E.getMessage() }, true); E.setMessage(ExceptMessage); throw wrap(E); } } public void Assign(TPersistent Source) { FAssigning++; try { super.Assign(Source); if (Source instanceof TRtDropTrigger) { FTriggerName = ((TRtDropTrigger) Source).FTriggerName; } } finally { FAssigning--; } } public void ReadData(TReader Reader) { FAssigning++; try { super.ReadData(Reader); FTriggerName = Reader.ReadString(); } finally { FAssigning--; } } public void WriteData(TWriter Writer) { super.WriteData(Writer); Writer.WriteString(FTriggerName); } public TRtDropTriggerClass ClassType() { return TRtDropTriggerClass.SINGLETON; } } public static class TRtCreateProcedureClass extends TRtCustomDDLClass { public static final TRtCreateProcedureClass SINGLETON = new TRtCreateProcedureClass(); public final TRtCreateProcedure CreateSQL(TRtDBConnection AConn, String ACode) { return TRtCreateProcedure.CreateSQL(AConn, ACode); } public Class ClassInfo() { return TRtCreateProcedure.class; } } public static class TRtCreateProcedure extends TRtCustomDDL { private String FProcedureName; private TRtCCompiledNodeList FCompiledCode; public final String GetCode() { String Result = ""; if (!FSpecificCode) { Result = FCode; } else { Result = ""; } return Result; } public final void SetCode(String Value) { TString AName = new TString(); TString Dummy = new TString(); TRtCCompiledNodeList ACCode; CheckUnprepare(); if (StrIsBlank(Value)) { if (FCompiledCode != null) { FCompiledCode.Free(); } FCompiledCode = null; FProcedureName = ""; } else if (FSpecificCode || CompareText(Value, FCode) != 0 || FCompiledCode == null) { ACCode = StoredProcedureCreatorFunc(Value, AName, Dummy); FProcedureName = AName.v; if (FCompiledCode != null) { FCompiledCode.Free(); } FCompiledCode = ACCode; } FCode = Value; FSpecificCode = false; } protected boolean FSpecificCode; protected String FCode; protected void UpdatePhyDatabase() { TRtDatabaseDef ADbDef; ADbDef = GetDatabaseDef(); if (ADbDef != null && !GetNotUpdatePhyDatabase()) { ADbDef.DropStoredProcDef(FProcedureName); ADbDef.NewStoredProcDef(FCode); } } public String GetName() { return FProcedureName; } protected void InternalPrepareUpdate() { if (!GetPrepared()) { CheckConnected(); FUpdate.SetCommand(FSql); FUpdate.Prepare(); } } public final void runCreateSQL(TRtDBConnection AConn, String ACode) { super.runCreateSQL(AConn); SetCode(ACode); } public static TRtCreateProcedure CreateSQL(TRtDBConnection AConn, String ACode) { TRtCreateProcedure Result; Result = new TRtCreateProcedure(); Result.runCreateSQL(AConn, ACode); return Result; } public void Destroy() { if (FCompiledCode != null) { FCompiledCode.Free(); FCompiledCode = null; } super.Destroy(); } public void ExecuteUpd() { String ExceptMessage = ""; try { super.ExecuteUpd(); } catch (DelphiException E) { ExceptMessage = TransStrFmt("TC3302", "Não foi possível criar a procedure %0:s - \"%1:s\"", new Object[] { FProcedureName, E.getMessage() }, true); E.setMessage(ExceptMessage); throw wrap(E); } } public void Assign(TPersistent Source) { FAssigning++; try { super.Assign(Source); if (Source instanceof TRtCreateProcedure) { FCode = ((TRtCreateProcedure) Source).FCode; FProcedureName = ((TRtCreateProcedure) Source).FProcedureName; if (((TRtCreateProcedure) Source).FCompiledCode != null) { if (FCompiledCode == null) { FCompiledCode = TRtCCompiledNodeList.Create(); } FCompiledCode.Assign(((TRtCreateProcedure) Source).FCompiledCode); } else if (FCompiledCode != null) { FCompiledCode.Free(); FCompiledCode = null; } } } finally { FAssigning--; } } public void ReadData(TReader Reader) { boolean LHasCompiledCode; FAssigning++; try { super.ReadData(Reader); FCode = Reader.ReadString(); FProcedureName = Reader.ReadString(); LHasCompiledCode = Reader.ReadBoolean(); if (LHasCompiledCode) { if (FCompiledCode == null) { FCompiledCode = TRtCCompiledNodeList.Create(); } FCompiledCode.ReadData(Reader); } else if (FCompiledCode != null) { FCompiledCode.Free(); FCompiledCode = null; } } finally { FAssigning--; } } public void WriteData(TWriter Writer) { boolean LHasCompiledCode; FAssigning++; try { super.WriteData(Writer); Writer.WriteString(FCode); Writer.WriteString(FProcedureName); LHasCompiledCode = FCompiledCode != null; Writer.WriteBoolean(LHasCompiledCode); if (LHasCompiledCode) { FCompiledCode.WriteData(Writer); } } finally { FAssigning--; } } public boolean GetHasOperation() { return !StrIsBlank(FCode); } public final void AssignFromStoredProcDef(TRtStoredProcDef ASPDef) { AssignFromStoredProcItem(ASPDef.GetSpecificCodes(GetDBNameSpecificSPByDBVersionKind(GetOwnerConnection().FDBVersionKind), ASPDef.GetDatabase().getCustomerCode())); } public final void AssignFromStoredProcItem(TRtStoredProcItem ASPItem) { CheckUnprepare(); if (FCompiledCode != null) { FCompiledCode.Free(); } FCompiledCode = null; FCode = ASPItem.getCode(); FProcedureName = ASPItem.GetOwnerStoredProcDef().GetName(); FSpecificCode = !ASPItem.GetDatabaseName().equals(cdbspSenior); } public final void CheckCompiledCode() { if (FCompiledCode == null && !FSpecificCode) { SetCode(FCode); } } public final String GetSpecificCode() { String Result = ""; if (FSpecificCode) { Result = FCode; } else { Result = ""; } return Result; } public final void SetSpecificCode(String AProcName, String AProcCode) { CheckUnprepare(); if (FCompiledCode != null) { FCompiledCode.Free(); } FCompiledCode = null; FProcedureName = AProcName; FCode = AProcCode; FSpecificCode = true; } public TRtCreateProcedureClass ClassType() { return TRtCreateProcedureClass.SINGLETON; } public TRtCCompiledNodeList getCompiledCode() { return FCompiledCode; } } public static class TRtDropProcedureClass extends TRtCustomDDLClass { public static final TRtDropProcedureClass SINGLETON = new TRtDropProcedureClass(); public final TRtDropProcedure CreateSQL(TRtDBConnection AConn, String AProcedureName) { return TRtDropProcedure.CreateSQL(AConn, AProcedureName); } public Class ClassInfo() { return TRtDropProcedure.class; } } public static class TRtDropProcedure extends TRtCustomDDL { private String FProcedureName; public boolean GetHasOperation() { return !StrIsBlank(FProcedureName); } public final void SetProcedureName(String Value) { CheckUnprepare(); FProcedureName = Value; } protected void UpdatePhyDatabase() { TRtDatabaseDef ADbDef; ADbDef = GetDatabaseDef(); if (ADbDef != null && !GetNotUpdatePhyDatabase()) { ADbDef.DropStoredProcDef(FProcedureName); } } public String GetName() { return FProcedureName; } public final void runCreateSQL(TRtDBConnection AConn, String AProcedureName) { super.runCreateSQL(AConn); FProcedureName = AProcedureName; } public static TRtDropProcedure CreateSQL(TRtDBConnection AConn, String AProcedureName) { TRtDropProcedure Result; Result = new TRtDropProcedure(); Result.runCreateSQL(AConn, AProcedureName); return Result; } public void ExecuteUpd() { String ExceptMessage = ""; try { super.ExecuteUpd(); } catch (DelphiException E) { ExceptMessage = TransStrFmt("TC3303", "Não foi possível excluir a procedure %0:s - [%1:s] - \"%2:s\"", new Object[] { FProcedureName, StrReplaceStr(FSql, SQLEOC_SEP, EOL), E.getMessage() }, true); E.setMessage(ExceptMessage); throw wrap(E); } } public void Assign(TPersistent Source) { FAssigning++; try { super.Assign(Source); if (Source instanceof TRtDropProcedure) { FProcedureName = ((TRtDropProcedure) Source).FProcedureName; } } finally { FAssigning--; } } public void ReadData(TReader Reader) { FAssigning++; try { super.ReadData(Reader); FProcedureName = Reader.ReadString(); } finally { FAssigning--; } } public void WriteData(TWriter Writer) { super.WriteData(Writer); Writer.WriteString(FProcedureName); } public TRtDropProcedureClass ClassType() { return TRtDropProcedureClass.SINGLETON; } } public static final class TRtCreateViewClass extends TRtCustomDDLClass { public static final TRtCreateViewClass SINGLETON = new TRtCreateViewClass(); public final TRtCreateView CreateSQL(TRtDBConnection AConn, String AViewName) { return TRtCreateView.CreateSQL(AConn, AViewName); } public Class ClassInfo() { return TRtCreateView.class; } } public static final class TRtCreateView extends TRtCustomDDL { protected String FViewName; protected TRtSelect FSelect_SeniorSQL_1; protected TSQLStatement FSelect_SeniorSQL_2; protected String FSelect_NativeSQL; protected void UpdatePhyDatabase() { TRtDatabaseDef ADbDef; ADbDef = GetDatabaseDef(); if (ADbDef != null && !GetNotUpdatePhyDatabase()) { ADbDef.DropViewDef(FViewName); if (FSelect_SeniorSQL_1 != null) { ADbDef.NewViewDef(GetOwnerConnection(), FViewName, FSelect_SeniorSQL_1.GenBaseSQL(), skSenior1); } else if (FSelect_SeniorSQL_2 != null) { ADbDef.NewViewDef(GetOwnerConnection(), FViewName, TRtSeniorSqlGeneratorClass.SINGLETON.GenerateStatement(FSelect_SeniorSQL_2.getStatement()), skSenior2); } else { ADbDef.NewViewDef(GetOwnerConnection(), FViewName, FSelect_NativeSQL, skNative); } } } public String GetName() { return FViewName; } public final void SetSelect_SeniorSQL_1(TRtSelect Value) { CheckUnprepare(); FreeAndNil(AsVar(FSelect_SeniorSQL_2)); if (FSelect_SeniorSQL_1 == null) { if (Value != null) { FSelect_SeniorSQL_1 = ((TRtSelect) TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(sckSelect, getDBVersionKind())); FSelect_SeniorSQL_1.SetFOwner(this); } } if (Value == null) { FreeAndNil(AsVar(FSelect_SeniorSQL_1)); } else { FSelect_SeniorSQL_1.Assign(Value); FSelectParams.Assign(Value.GetSelectParams()); FParams.Assign(Value.GetParams()); } } public final void SetSelect_SeniorSQL_2(TSQLStatement aValue) { FreeAndNil(AsVar(FSelect_SeniorSQL_1)); FreeAndNil(AsVar(FSelect_SeniorSQL_2)); FSelect_SeniorSQL_2 = aValue; } protected String GenAliasList() { String Result = ""; TSelectColumn xPColumn = null; int i; Result = ""; if (FSelect_SeniorSQL_1 != null) { if (FSelect_SeniorSQL_1.FColumns.GetCount() > 0) { Result = FSelect_SeniorSQL_1.FColumns.GetItem(0).CalculatedAsName(); for (i = 1; i <= FSelect_SeniorSQL_1.FColumns.GetCount() - 1; ++i) { Result = Result + SQL_Comma + FSelect_SeniorSQL_1.FColumns.GetItem(i).CalculatedAsName(); } } } else { xPColumn = FSelect_SeniorSQL_2.getStatement().Select.FirstSelect.FirstColumn; while (xPColumn != null) { Result = Result + xPColumn.Alias + ToStr(SQL_Comma); xPColumn = xPColumn.Next; } Result = Delete(Result, Length(Result), 1); } return Result; } protected String GenViewDef() { return SQL_Create + SQL_Space + SQL_View + SQL_Space + FViewName + SQL_Space + SQL_LParenthesis + GenAliasList() + SQL_RParenthesis + SQL_Space + SQL_As + SQL_EOL; } protected String GenNativeCreateViewCmd() { return SQL_Create + SQL_Space + SQL_View + SQL_Space + FViewName + SQL_Space + SQL_As + SQL_Space + FSelect_NativeSQL; } protected String GenSQL() { String Result = ""; if (FSelect_SeniorSQL_1 == null && FSelect_SeniorSQL_2 == null && Trim(FSelect_NativeSQL).equals("")) { throw DelphiException.Create(TransStr("TC666", "Seleção para view não definida.", true)); } if (FSelect_SeniorSQL_1 != null) { Result = GenViewDef(); if (!getUsesScriptTerminator()) { Result = Result + FSelect_SeniorSQL_1.GetSQL(); } else { Result = Result + FSelect_SeniorSQL_1.GenSQLScript(); } } else if (FSelect_SeniorSQL_2 != null) { Result = Result + GetOwnerConnection().SeniorSqlToNativeSql(FSelect_SeniorSQL_2.getStatement()); if (getUsesScriptTerminator()) { Result = StrBreakLine(Result, "", 250, 0, kblNone); } } else { Result = Result + GenNativeCreateViewCmd(); } return Result; } protected void InternalPrepareUpdate() { if (!GetPrepared()) { CheckConnected(); FUpdate.SetCommand(FSql); FUpdate.Prepare(); } } public final void runCreateSQL(TRtDBConnection AConn, String AViewName) { super.runCreateSQL(AConn); FViewName = AViewName; } public static TRtCreateView CreateSQL(TRtDBConnection AConn, String AViewName) { TRtCreateView Result; Result = new TRtCreateView(); Result.runCreateSQL(AConn, AViewName); return Result; } public void ExecuteUpd() { String ExceptMessage = ""; try { super.ExecuteUpd(); } catch (DelphiException E) { ExceptMessage = TransStrFmt("TC3304", "Não foi possível criar a view %0:s - [%1:s] - \"%2:s\"", new Object[] { FViewName, StrReplaceStr(FSql, SQLEOC_SEP, EOL), E.getMessage() }, true); E.setMessage(ExceptMessage); throw wrap(E); } } public void Destroy() { FreeAndNil(AsVar(FSelect_SeniorSQL_1)); FreeAndNil(AsVar(FSelect_SeniorSQL_2)); super.Destroy(); } public void Assign(TPersistent Source) { super.Assign(Source); if (Source instanceof TRtCreateView) { FViewName = ((TRtCreateView) Source).FViewName; SetSelect_SeniorSQL_1(((TRtCreateView) Source).FSelect_SeniorSQL_1); SetSelect_SeniorSQL_2(null); if (((TRtCreateView) Source).FSelect_SeniorSQL_2 != null) { throw DelphiException.Create(TransStr("TC667", " não implementado para SeniorSQL_2", true)); } } } public void ReadData(TReader Reader) { super.ReadData(Reader); FViewName = Reader.ReadString(); if (Reader.ReadBoolean()) { if (FSelect_SeniorSQL_1 == null) { FSelect_SeniorSQL_1 = ((TRtSelect) TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(sckSelect, getDBVersionKind())); FSelect_SeniorSQL_1.SetFOwner(this); } FSelect_SeniorSQL_1.ReadData(Reader); } else if (FSelect_SeniorSQL_1 != null) { FSelect_SeniorSQL_1.Free(); FSelect_SeniorSQL_1 = null; } } public void WriteData(TWriter Writer) { boolean HasSelect; super.WriteData(Writer); Writer.WriteString(FViewName); HasSelect = FSelect_SeniorSQL_1 != null; Writer.WriteBoolean(HasSelect); if (HasSelect) { FSelect_SeniorSQL_1.WriteData(Writer); } } public boolean GetHasOperation() { return !StrIsBlank(FViewName) && FSelect_SeniorSQL_1 != null && FSelect_SeniorSQL_1.GetHasOperation(); } public final void AssignFromViewDef(TRtViewDef AViewDef) { TRtSelect ASel; setViewName(AViewDef.GetName()); switch (AViewDef.getSQLKind()) { case skSenior2: SetSelect_SeniorSQL_2(CompileViewSelect(AViewDef.GetDatabase(), AViewDef.GetName(), AViewDef.getSelectSQL())); break; case skSenior1: ASel = ((TRtSelect) GetOwnerConnection().SQLObjectFrom(AViewDef.getSelectSQL())); try { SetSelect_SeniorSQL_1(ASel); } finally { ASel.Free(); } break; case skNative: FSelect_NativeSQL = AViewDef.getSelectSQL(); break; default: break; } } public TRtCreateViewClass ClassType() { return TRtCreateViewClass.SINGLETON; } public void setViewName(String value) { FViewName = value; } public String getViewName() { return FViewName; } public TRtSelect getSelect_SeniorSQL_1() { return FSelect_SeniorSQL_1; } public TSQLStatement getSelect_SeniorSQL_2() { return FSelect_SeniorSQL_2; } public void setSelect_NativeSQL(String value) { FSelect_NativeSQL = value; } public String getSelect_NativeSQL() { return FSelect_NativeSQL; } } public static class TRtDropViewClass extends TRtCustomDDLClass { public static final TRtDropViewClass SINGLETON = new TRtDropViewClass(); public final TRtDropView CreateSQL(TRtDBConnection AConn, String AViewName) { return TRtDropView.CreateSQL(AConn, AViewName); } public Class ClassInfo() { return TRtDropView.class; } } public static class TRtDropView extends TRtCustomDDL { private String FViewName; protected void UpdatePhyDatabase() { TRtDatabaseDef ADbDef; ADbDef = GetDatabaseDef(); if (ADbDef != null && !GetNotUpdatePhyDatabase()) { ADbDef.DropViewDef(FViewName); } } public String GetName() { return FViewName; } protected String GenSQL() { return SQL_Drop + SQL_Space + SQL_View + SQL_Space + GetViewName(); } public String GetViewName() { return FViewName; } public final void runCreateSQL(TRtDBConnection AConn, String AViewName) { super.runCreateSQL(AConn); FViewName = AViewName; } public static TRtDropView CreateSQL(TRtDBConnection AConn, String AViewName) { TRtDropView Result; Result = new TRtDropView(); Result.runCreateSQL(AConn, AViewName); return Result; } public void ExecuteUpd() { String ExceptMessage = ""; try { super.ExecuteUpd(); } catch (DelphiException E) { ExceptMessage = TransStrFmt("TC3305", "Não foi possível excluir a view %0:s - [%1:s] - \"%2:s\"", new Object[] { FViewName, StrReplaceStr(FSql, SQLEOC_SEP, EOL), E.getMessage() }, true); E.setMessage(ExceptMessage); throw wrap(E); } } public void Assign(TPersistent Source) { FAssigning++; try { super.Assign(Source); if (Source instanceof TRtDropView) { FViewName = ((TRtDropView) Source).FViewName; } } finally { FAssigning--; } } public void ReadData(TReader Reader) { FAssigning++; try { super.ReadData(Reader); FViewName = Reader.ReadString(); } finally { FAssigning--; } } public void WriteData(TWriter Writer) { super.WriteData(Writer); Writer.WriteString(FViewName); } public boolean GetHasOperation() { return !StrIsBlank(FViewName); } public TRtDropViewClass ClassType() { return TRtDropViewClass.SINGLETON; } public void setViewName(String value) { FViewName = value; } } public static class TRtDropTableClass extends TRtCustomDDLTableClass { public static final TRtDropTableClass SINGLETON = new TRtDropTableClass(); public TRtDropTable Create() { return TRtDropTable.Create(); } public final TRtDropTable CreateSQL(TRtDBConnection AConn, String ATableName, int ARIntOpt) { return TRtDropTable.CreateSQL(AConn, ATableName, ARIntOpt); } public Class ClassInfo() { return TRtDropTable.class; } } public static class TRtDropTable extends TRtCustomDDLTable { private int FRIntOpt; public final void SetRIntOpt(int Value) { CheckUnprepare(); FRIntOpt = Value; } protected void UpdatePhyDatabase() { if (!GetNotUpdatePhyDatabase()) { CheckGetDatabaseDef().DropTableDef(FTableName); } } public void runCreate() { super.runCreate(); } public static TRtDropTable Create() { TRtDropTable Result; Result = new TRtDropTable(); Result.runCreate(); return Result; } public final void runCreateSQL(TRtDBConnection AConn, String ATableName, int ARIntOpt) { super.runCreateSQL(AConn, ATableName); FRIntOpt = ARIntOpt; } public static TRtDropTable CreateSQL(TRtDBConnection AConn, String ATableName, int ARIntOpt) { TRtDropTable Result; Result = new TRtDropTable(); Result.runCreateSQL(AConn, ATableName, ARIntOpt); return Result; } public void ExecuteUpd() { String ExceptMessage = ""; try { super.ExecuteUpd(); } catch (DelphiException E) { ExceptMessage = TransStrFmt("TC3306", "Não foi possível apagar a tabela: %0:s - [%1:s] - \"%2:s\"", new Object[] { GetTableName(), StrReplaceStr(FSql, SQLEOC_SEP, EOL), E.getMessage() }, true); E.setMessage(ExceptMessage); throw wrap(E); } } public void Assign(TPersistent Source) { FAssigning++; try { super.Assign(Source); if (Source instanceof TRtDropTable) { FRIntOpt = ((TRtDropTable) Source).FRIntOpt; } } finally { FAssigning--; } } public void ReadData(TReader Reader) { FAssigning++; try { super.ReadData(Reader); Reader.Read(AsVar(FRIntOpt), SizeOf(FRIntOpt)); } finally { FAssigning--; } } public void WriteData(TWriter Writer) { super.WriteData(Writer); Writer.Write(AsConst(FRIntOpt), SizeOf(FRIntOpt)); } public TRtDropTableClass ClassType() { return TRtDropTableClass.SINGLETON; } public int getRIntOpt() { return FRIntOpt; } } public static class TRtRenameTableClass extends TRtCustomDDLTableClass { public static final TRtRenameTableClass SINGLETON = new TRtRenameTableClass(); public TRtRenameTable Create() { return TRtRenameTable.Create(); } public final TRtRenameTable CreateSQL(TRtDBConnection AConn, String AOldTblName, String ANewTblNAme) { return TRtRenameTable.CreateSQL(AConn, AOldTblName, ANewTblNAme); } public Class ClassInfo() { return TRtRenameTable.class; } } public static class TRtRenameTable extends TRtCustomDDLTable { private String FNewTableName; public final void SetNewTableName(String Value) { CheckUnprepare(); FNewTableName = Value; } public boolean GetHasOperation() { return super.GetHasOperation() && !StrIsBlank(GetNewTableName()); } protected void UpdatePhyDatabase() { TRtTableDef ATblDef; if (!GetNotUpdatePhyDatabase()) { ATblDef = CheckGetDatabaseDef().TableByName(FTableName); if (ATblDef != null) { ATblDef.SetName(FNewTableName); } } } public String GetNewTableName() { return FNewTableName; } public void runCreate() { super.runCreate(); } public static TRtRenameTable Create() { TRtRenameTable Result; Result = new TRtRenameTable(); Result.runCreate(); return Result; } public final void runCreateSQL(TRtDBConnection AConn, String AOldTblName, String ANewTblNAme) { super.runCreateSQL(AConn, AOldTblName); FNewTableName = ANewTblNAme; } public static TRtRenameTable CreateSQL(TRtDBConnection AConn, String AOldTblName, String ANewTblNAme) { TRtRenameTable Result; Result = new TRtRenameTable(); Result.runCreateSQL(AConn, AOldTblName, ANewTblNAme); return Result; } public void ExecuteUpd() { String ExceptMessage = ""; try { super.ExecuteUpd(); } catch (DelphiException E) { ExceptMessage = TransStrFmt("TC3307", "Não foi possível renomear a tabela: %0:s - [%1:s] - \"%2:s\"", new Object[] { GetTableName(), StrReplaceStr(FSql, SQLEOC_SEP, EOL), E.getMessage() }, true); E.setMessage(ExceptMessage); throw wrap(E); } } public void Assign(TPersistent Source) { FAssigning++; try { super.Assign(Source); if (Source instanceof TRtRenameTable) { FNewTableName = ((TRtRenameTable) Source).FNewTableName; } } finally { FAssigning--; } } public void ReadData(TReader Reader) { FAssigning++; try { super.ReadData(Reader); FNewTableName = Reader.ReadString(); } finally { FAssigning--; } } public void WriteData(TWriter Writer) { super.WriteData(Writer); Writer.WriteString(FNewTableName); } public TRtRenameTableClass ClassType() { return TRtRenameTableClass.SINGLETON; } } public static final class TRtSQLFunctionTableItemClass extends TNamedContainerItemClass { public static final TRtSQLFunctionTableItemClass SINGLETON = new TRtSQLFunctionTableItemClass(); public TRtSQLFunctionTableItem Create() { return TRtSQLFunctionTableItem.Create(); } public Class ClassInfo() { return TRtSQLFunctionTableItem.class; } } public static final class TRtSQLFunctionTableItem extends TNamedContainerItem { private TList FList; public final int GetCount() { return FList.getCount(); } public final int GetTypes(int Index) { return (int) (GetIntegers(Index) & ~RT_OPTIONAL_PARAM); } public final void SetTypes(int Index, int Value) { FList.Put(Index, (Object) (int) Value); } public final int GetIntegers(int Index) { return ((Number) FList.Get(Index)).intValue(); } public final void SetIntegers(int Index, int Value) { FList.Put(Index, (Object) Value); } public final boolean GetOptionals(int Index) { return (GetIntegers(Index) | RT_OPTIONAL_PARAM) != 0; } public void runCreate() { super.runCreate(); FList = TList.Create(); } public static TRtSQLFunctionTableItem Create() { TRtSQLFunctionTableItem Result; Result = new TRtSQLFunctionTableItem(); Result.runCreate(); return Result; } public void Destroy() { FList.Free(); super.Destroy(); } public void Assign(TPersistent Source) { int i; super.Assign(Source); if (Source instanceof TRtSQLFunctionTableItem) { FList.Clear(); for (i = 0; i <= ((TRtSQLFunctionTableItem) Source).FList.getCount() - 1; ++i) { FList.Add(((TRtSQLFunctionTableItem) Source).FList.Get(i)); } } } public void ReadData(TReader Reader) { super.ReadData(Reader); { TReader context_Reader = Reader; FList.Clear(); context_Reader.ReadListBegin(); while (!context_Reader.EndOfList()) { FList.Add(((Object) context_Reader.ReadInteger())); } context_Reader.ReadListEnd(); } } public void WriteData(TWriter Writer) { int i; super.WriteData(Writer); { TWriter context_Writer = Writer; FList.Clear(); context_Writer.WriteListBegin(); for (i = 0; i <= FList.getCount() - 1; ++i) { context_Writer.WriteInteger(((Number) FList.Get(i)).intValue()); } context_Writer.WriteListEnd(); } } public final int AddType(int Value) { return AddInteger((int) Value); } public final void AddTypes(int[] AValues) { int i; for (i = 0; i <= AValues.length - 1; ++i) { AddType(AValues[i]); } } public final int AddInteger(int Value) { return FList.Add((Object) Value); } public final void AddIntegers(int[] AValues) { int i; for (i = 0; i <= AValues.length - 1; ++i) { AddInteger(AValues[i]); } } public final void Delete(int Index) { FList.Delete(Index); } public final void Clear() { FList.Clear(); } public TRtSQLFunctionTableItemClass ClassType() { return TRtSQLFunctionTableItemClass.SINGLETON; } } public static final class TRtSQLFunctionTableListClass extends TNamedListOwnerClass { public static final TRtSQLFunctionTableListClass SINGLETON = new TRtSQLFunctionTableListClass(); public TRtSQLFunctionTableList Create() { return TRtSQLFunctionTableList.Create(); } public Class ClassInfo() { return TRtSQLFunctionTableList.class; } } public static final class TRtSQLFunctionTableList extends TNamedListOwner { protected TContainerItemClass AllocItemType() { return TRtSQLFunctionTableItemClass.SINGLETON; } public final TRtSQLFunctionTableItem GetItem(int Index) { return ((TRtSQLFunctionTableItem) Get(Index)); } public static TRtSQLFunctionTableList Create() { TRtSQLFunctionTableList Result; Result = new TRtSQLFunctionTableList(); Result.runCreate(); return Result; } public TRtSQLFunctionTableListClass ClassType() { return TRtSQLFunctionTableListClass.SINGLETON; } } public static class TRtWhereItemClass extends TSQLContainerItemClass { public static final TRtWhereItemClass SINGLETON = new TRtWhereItemClass(); public TRtWhereItem Create() { return TRtWhereItem.Create(); } public final TRtWhereItem CreateParented(TContainerItem AOwner) { return TRtWhereItem.CreateParented(AOwner); } public Class ClassInfo() { return TRtWhereItem.class; } } public static class TRtWhereItem extends TSQLContainerItem { public final String GetWhereSeniorSQL() { String Result = ""; TRtCustomSQL xRootSQL; xRootSQL = GetRootSQL(); if (xRootSQL != null) { Result = GetWhere(xRootSQL, this); } else { Result = ""; } return Result; } protected String FExpression; protected TRtSQLTokenList FTokens; protected String FParamList; public final String GetExpression() { String Result = ""; String STmp = ""; Result = FExpression; if (StrIsBlank(Result)) { STmp = FTokens.GetAsString(); Result = Trim(STmp); } return Result; } public void SetExpression(String Value) { _SetExpression(Value, true); } protected final void _SetExpression(String Value, boolean LCondition) { TRtSQLTokenList ATokens; CheckUnprepare(); DropParamsFromOwnerSQLClass(null); TString temp = new TString(""); ATokens = CompileSQLExp(Value, temp, LCondition); FParamList = temp.v; if (ATokens != null) { try { FTokens.Assign(ATokens); AddParamsToOwnerSQLClass(null); } finally { ATokens.Free(); } } FExpression = Value; } public void SetTokens(TRtSQLTokenList Value) { TRtCustomSQL ARootSQL; boolean LRootAssigning; CheckUnprepare(); ARootSQL = GetRootSQL(); LRootAssigning = ARootSQL != null && ARootSQL.FAssigning > 0; if (Value == null) { throw DelphiException.Create(TransStr("TC537", "Parâmetro nulo.", true)); } if (!LRootAssigning) { DropParamsFromOwnerSQLClass(null); } FParamList = Value.GetEncodedParams(); FTokens.Assign(Value); if (!LRootAssigning) { AddParamsToOwnerSQLClass(null); } FExpression = Value.GetAsString(); } protected final void AddParamsToOwnerSQLClass(TRtCustomSQL ASql) { String AParamDef = ""; String AName = ""; int AType; int ALen; TInt p = new TInt(); TInt p1 = new TInt(); if (ASql == null) { ASql = GetRootSQL(); } if (ASql == null) { return; } p.v = 0; AParamDef = StrGetNextToken(FParamList, p, ';'); while (!AParamDef.equals("")) { p1.v = 0; AName = StrGetNextToken(AParamDef, p1, ','); AType = ((int) StrToInt(StrGetNextToken(AParamDef, p1, ','))); ALen = StrToInt(StrGetNextToken(AParamDef, p1, ',')); if (AType == rdtObject) { if (ASql.FSelectParams.ItemByName(AName) == null) { ASql.FSelectParams.AddNewItem(AName); } } else { if (ASql.GetParams().ItemByName(AName) == null) { ASql.GetParams().AddNewItem(AName, AType, ALen); } } AParamDef = StrGetNextToken(FParamList, p, ';'); } } protected final void DropParamsFromOwnerSQLClass(TRtCustomSQL ASql) { String AParamDef = ""; String AName = ""; int AType; TInt p = new TInt(); TInt p1 = new TInt(); int i; if (ASql == null) { ASql = GetRootSQL(); } if (ASql == null) { return; } p.v = 0; AParamDef = StrGetNextToken(FParamList, p, ';'); while (!AParamDef.equals("")) { p1.v = 0; AName = StrGetNextToken(AParamDef, p1, ','); AType = StrToInt(StrGetNextToken(AParamDef, p1, ',')); if (AType == rdtObject) { i = ASql.FSelectParams.IndexByName(AName); if (i >= 0) { ASql.FSelectParams.ClearItem(i); } } else { ASql.GetParams().RemoveItemByName(AName); } AParamDef = StrGetNextToken(FParamList, p, ';'); } } protected final TRtCustomSQL GetRootSQL() { TRtCustomSQL Result; TRtCustomSQL ASql; Result = ((TRtCustomSQL) GetTypedOwner(TRtCustomSQLClass.SINGLETON)); ASql = Result; while (ASql != null) { ASql = ((TRtCustomSQL) ASql.GetTypedOwner(TRtCustomSQLClass.SINGLETON)); if (ASql != null) { Result = ASql; } } return Result; } public void runCreate() { super.runCreate(); FTokens = ((TRtSQLTokenList) Creator(this, TRtSQLTokenListClass.SINGLETON)); } public static TRtWhereItem Create() { TRtWhereItem Result; Result = new TRtWhereItem(); Result.runCreate(); return Result; } public final void runCreateParented(TContainerItem AOwner) { super.runCreate(); SetFOwner(AOwner); FTokens = ((TRtSQLTokenList) Creator(this, TRtSQLTokenListClass.SINGLETON)); } public static TRtWhereItem CreateParented(TContainerItem AOwner) { TRtWhereItem Result; Result = new TRtWhereItem(); Result.runCreateParented(AOwner); return Result; } public void Destroy() { FTokens.Free(); super.Destroy(); } public void Assign(TPersistent Source) { if (Source instanceof TRtWhereItem) { SetTokens(((TRtWhereItem) Source).FTokens); FExpression = ((TRtWhereItem) Source).FExpression; } else { super.Assign(Source); } } public void ReadData(TReader Reader) { TRtSQLTokenList ATokens; ATokens = TRtSQLTokenList.Create(); try { ATokens.ReadData(Reader); FExpression = Reader.ReadString(); SetTokens(ATokens); } finally { ATokens.Free(); } } public void WriteData(TWriter Writer) { FTokens.WriteData(Writer); Writer.WriteString(FExpression); } public TRtWhereItemClass ClassType() { return TRtWhereItemClass.SINGLETON; } public TRtSQLTokenList getTokens() { return FTokens; } } public static final class TRtExpressionItemClass extends TRtWhereItemClass { public static final TRtExpressionItemClass SINGLETON = new TRtExpressionItemClass(); public Class ClassInfo() { return TRtExpressionItem.class; } } public static final class TRtExpressionItem extends TRtWhereItem { public void SetExpression(String Value) { _SetExpression(Value, false); } public TRtExpressionItemClass ClassType() { return TRtExpressionItemClass.SINGLETON; } } public static final class TRtExpressionListClass extends TSQLTypedListOwnerClass { public static final TRtExpressionListClass SINGLETON = new TRtExpressionListClass(); public Class ClassInfo() { return TRtExpressionList.class; } } public static final class TRtExpressionList extends TSQLTypedListOwner { protected TContainerItemClass AllocItemType() { return TRtExpressionItemClass.SINGLETON; } public final TRtExpressionItem GetItems(int Index) { return ((TRtExpressionItem) Get(Index)); } public final TRtExpressionItem AddVariable(String AExp) { TRtExpressionItem Result; CheckUnprepare(); Result = ((TRtExpressionItem) Creator(null, AllocItemType())); try { Result.SetExpression(AExp); if (Result.getTokens().GetCount() == 1 && Result.getTokens().GetItem(0).getTokType() == rstIdColumn) { AExp = Result.getTokens().GetItem(0).getToken(); Result.getTokens().Delete(0); Result.getTokens().AddTokenTyped(AExp, rstIdVariable, rssLValue); } Add(Result); } catch (Throwable any) { Result.SetFOwner(null); Result.Destroy(); throw wrap(any); } return Result; } public TRtExpressionListClass ClassType() { return TRtExpressionListClass.SINGLETON; } } public static final class TRtWhereCurrentOfItemClass extends TRtWhereItemClass { public static final TRtWhereCurrentOfItemClass SINGLETON = new TRtWhereCurrentOfItemClass(); public Class ClassInfo() { return TRtWhereCurrentOfItem.class; } } public static final class TRtWhereCurrentOfItem extends TRtWhereItem { public final void SetCurrentOf(String Value) { CheckUnprepare(); FTokens.Clear(); FExpression = Value; } public final String GetCurrentOf() { String Result = ""; if (FTokens.GetCount() > 0) { Result = ""; } else { Result = FExpression; } return Result; } public TRtWhereCurrentOfItemClass ClassType() { return TRtWhereCurrentOfItemClass.SINGLETON; } } public static final class TRtBeginTranClass extends TRtCustomUpdateSQLClass { public static final TRtBeginTranClass SINGLETON = new TRtBeginTranClass(); public Class ClassInfo() { return TRtBeginTran.class; } } public static final class TRtBeginTran extends TRtCustomUpdateSQL { public void ExecuteUpd() { throw DelphiException.Create(STORED_PROC_ERR_MESS); } public TRtBeginTranClass ClassType() { return TRtBeginTranClass.SINGLETON; } } public static class TRtSetTransactionClass extends TRtCustomUpdateSQLClass { public static final TRtSetTransactionClass SINGLETON = new TRtSetTransactionClass(); public final TRtSetTransaction CreateSQL(TRtDBConnection AConn, int AIsolationLevel) { return TRtSetTransaction.CreateSQL(AConn, AIsolationLevel); } public TRtSetTransaction Create() { return TRtSetTransaction.Create(); } public Class ClassInfo() { return TRtSetTransaction.class; } } public static class TRtSetTransaction extends TRtCustomUpdateSQL { private int FIsolationLevel; public final void SetIsolationLevel(int Value) { CheckUnprepare(); FIsolationLevel = Value; } public final void runCreateSQL(TRtDBConnection AConn, int AIsolationLevel) { super.runCreateSQL(AConn); FIsolationLevel = AIsolationLevel; } public static TRtSetTransaction CreateSQL(TRtDBConnection AConn, int AIsolationLevel) { TRtSetTransaction Result; Result = new TRtSetTransaction(); Result.runCreateSQL(AConn, AIsolationLevel); return Result; } public void ExecuteUpd() { throw DelphiException.Create(STORED_PROC_ERR_MESS); } public void Assign(TPersistent Source) { FAssigning++; try { super.Assign(Source); if (Source instanceof TRtSetTransaction) { FIsolationLevel = ((TRtSetTransaction) Source).FIsolationLevel; } } finally { FAssigning--; } } public void ReadData(TReader Reader) { FAssigning++; try { super.ReadData(Reader); Reader.Read(AsVar(FIsolationLevel), SizeOf(FIsolationLevel)); } finally { FAssigning--; } } public void WriteData(TWriter Writer) { super.WriteData(Writer); Writer.Write(AsConst(FIsolationLevel), SizeOf(FIsolationLevel)); } public static TRtSetTransaction Create() { TRtSetTransaction Result; Result = new TRtSetTransaction(); Result.runCreate(); return Result; } public TRtSetTransactionClass ClassType() { return TRtSetTransactionClass.SINGLETON; } public int getIsolationLevel() { return FIsolationLevel; } } public static class TRtSavePointClass extends TRtCustomUpdateSQLClass { public static final TRtSavePointClass SINGLETON = new TRtSavePointClass(); public final TRtSavePoint CreateSQL(TRtDBConnection AConn, String ASavePoint) { return TRtSavePoint.CreateSQL(AConn, ASavePoint); } public TRtSavePoint Create() { return TRtSavePoint.Create(); } public Class ClassInfo() { return TRtSavePoint.class; } } public static class TRtSavePoint extends TRtCustomUpdateSQL { private String FSavePoint; public final void SetSavePoint(String Value) { CheckUnprepare(); FSavePoint = Value; } public boolean GetHasOperation() { return !StrIsBlank(getSavePoint()); } public final void runCreateSQL(TRtDBConnection AConn, String ASavePoint) { super.runCreateSQL(AConn); FSavePoint = ASavePoint; } public static TRtSavePoint CreateSQL(TRtDBConnection AConn, String ASavePoint) { TRtSavePoint Result; Result = new TRtSavePoint(); Result.runCreateSQL(AConn, ASavePoint); return Result; } public void ExecuteUpd() { throw DelphiException.Create(STORED_PROC_ERR_MESS); } public void Assign(TPersistent Source) { FAssigning++; try { super.Assign(Source); if (Source instanceof TRtSavePoint) { FSavePoint = ((TRtSavePoint) Source).FSavePoint; } } finally { FAssigning--; } } public void ReadData(TReader Reader) { FAssigning++; try { super.ReadData(Reader); FSavePoint = Reader.ReadString(); } finally { FAssigning--; } } public void WriteData(TWriter Writer) { super.WriteData(Writer); Writer.WriteString(FSavePoint); } public static TRtSavePoint Create() { TRtSavePoint Result; Result = new TRtSavePoint(); Result.runCreate(); return Result; } public TRtSavePointClass ClassType() { return TRtSavePointClass.SINGLETON; } public String getSavePoint() { return FSavePoint; } } public static class TRtRollBackClass extends TRtSavePointClass { public static final TRtRollBackClass SINGLETON = new TRtRollBackClass(); public TRtRollBack Create() { return TRtRollBack.Create(); } public Class ClassInfo() { return TRtRollBack.class; } } public static class TRtRollBack extends TRtSavePoint { public boolean GetHasOperation() { return true; } public void ExecuteUpd() { throw DelphiException.Create(STORED_PROC_ERR_MESS); } public static TRtRollBack Create() { TRtRollBack Result; Result = new TRtRollBack(); Result.runCreate(); return Result; } public TRtRollBackClass ClassType() { return TRtRollBackClass.SINGLETON; } } public static class TRtCommitClass extends TRtCustomUpdateSQLClass { public static final TRtCommitClass SINGLETON = new TRtCommitClass(); public TRtCommit Create() { return TRtCommit.Create(); } public Class ClassInfo() { return TRtCommit.class; } } public static class TRtCommit extends TRtCustomUpdateSQL { public boolean GetHasOperation() { return true; } public void ExecuteUpd() { throw DelphiException.Create(STORED_PROC_ERR_MESS); } public static TRtCommit Create() { TRtCommit Result; Result = new TRtCommit(); Result.runCreate(); return Result; } public TRtCommitClass ClassType() { return TRtCommitClass.SINGLETON; } } public static class TRtDeleteFromClass extends TRtTableSQLClass { public static final TRtDeleteFromClass SINGLETON = new TRtDeleteFromClass(); public TRtDeleteFrom Create() { return TRtDeleteFrom.Create(); } public final TRtDeleteFrom CreateSQL(TRtDBConnection AConn, String ATableName) { return TRtDeleteFrom.CreateSQL(AConn, ATableName); } public Class ClassInfo() { return TRtDeleteFrom.class; } } public static class TRtDeleteFrom extends TRtTableSQL { protected TRtWhereCurrentOfItem FWhere; protected String GenSQL() { String Result = ""; String s = ""; Result = SQL_DeleteFrom + GetName(); s = BreakLine(GetWhere(this, getWhere())); if (!StrIsBlank(s)) { Result = Result + SQL_Space + SQL_Where + s; } if (getUsesScriptTerminator()) { Result = Result + ToStr(SQL_ScriptTerminator); } return Result; } public void runCreate() { super.runCreate(); FWhere = ((TRtWhereCurrentOfItem) Creator(this, TRtWhereCurrentOfItemClass.SINGLETON)); } public static TRtDeleteFrom Create() { TRtDeleteFrom Result; Result = new TRtDeleteFrom(); Result.runCreate(); return Result; } public final void runCreateSQL(TRtDBConnection AConn, String ATableName) { super.runCreateSQL(AConn, ATableName); FWhere = ((TRtWhereCurrentOfItem) Creator(this, TRtWhereCurrentOfItemClass.SINGLETON)); } public static TRtDeleteFrom CreateSQL(TRtDBConnection AConn, String ATableName) { TRtDeleteFrom Result; Result = new TRtDeleteFrom(); Result.runCreateSQL(AConn, ATableName); return Result; } public void Destroy() { FWhere.Free(); super.Destroy(); } public void ExecuteUpd() { if (!StrIsBlank(FWhere.GetCurrentOf())) { throw DelphiException.Create(STORED_PROC_ERR_MESS); } super.ExecuteUpd(); } public void Assign(TPersistent Source) { FAssigning++; try { super.Assign(Source); if (Source instanceof TRtDeleteFrom) { FWhere.Assign(((TRtDeleteFrom) Source).FWhere); } } finally { FAssigning--; } } public void ReadData(TReader Reader) { FAssigning++; try { super.ReadData(Reader); FWhere.ReadData(Reader); } finally { FAssigning--; } } public void WriteData(TWriter Writer) { super.WriteData(Writer); FWhere.WriteData(Writer); } public TRtDeleteFromClass ClassType() { return TRtDeleteFromClass.SINGLETON; } public TRtWhereCurrentOfItem getWhere() { return FWhere; } } public static final class TRtSetColumnValueClass extends TSQLNamedContainerItemClass { public static final TRtSetColumnValueClass SINGLETON = new TRtSetColumnValueClass(); public TRtSetColumnValue Create() { return TRtSetColumnValue.Create(); } public final TRtSetColumnValue CreateSetValue(TRtSetColumnList AOwner, String AColName, Object AValue) { return TRtSetColumnValue.CreateSetValue(AOwner, AColName, AValue); } public final TRtSetColumnValue CreateSetExp(TRtSetColumnList AOwner, String AColName, String AExp) { return TRtSetColumnValue.CreateSetExp(AOwner, AColName, AExp); } public Class ClassInfo() { return TRtSetColumnValue.class; } } public static final class TRtSetColumnValue extends TSQLNamedContainerItem { private Object FValue; private TRtExpressionItem FExp; public final void SetValue(Object Value) { CheckUnprepare(); FValue = Value; } public void SetName(String Value) { if (StrIsBlank(GetName())) { super.SetName(Value); } } public final boolean GetIsExp() { return FExp.getTokens().GetCount() != 0; } public void runCreate() { super.runCreate(); FExp = ((TRtExpressionItem) Creator(this, TRtExpressionItemClass.SINGLETON)); } public static TRtSetColumnValue Create() { TRtSetColumnValue Result; Result = new TRtSetColumnValue(); Result.runCreate(); return Result; } public final void runCreateSetValue(TRtSetColumnList AOwner, String AColName, Object AValue) { super.runCreate(); SetName(AColName); FValue = AValue; FExp = ((TRtExpressionItem) Creator(this, TRtExpressionItemClass.SINGLETON)); AOwner.AddItem(this); } public static TRtSetColumnValue CreateSetValue(TRtSetColumnList AOwner, String AColName, Object AValue) { TRtSetColumnValue Result; Result = new TRtSetColumnValue(); Result.runCreateSetValue(AOwner, AColName, AValue); return Result; } public final void runCreateSetExp(TRtSetColumnList AOwner, String AColName, String AExp) { super.runCreate(); SetName(AColName); FExp = ((TRtExpressionItem) Creator(this, TRtExpressionItemClass.SINGLETON)); AOwner.AddItem(this); if (!StrIsBlank(AExp)) { FExp.SetExpression(AExp); } } public static TRtSetColumnValue CreateSetExp(TRtSetColumnList AOwner, String AColName, String AExp) { TRtSetColumnValue Result; Result = new TRtSetColumnValue(); Result.runCreateSetExp(AOwner, AColName, AExp); return Result; } public void Destroy() { if (FExp != null) { FExp.Free(); } super.Destroy(); } public void Assign(TPersistent Source) { super.Assign(Source); if (Source instanceof TRtSetColumnValue) { FExp.Assign(((TRtSetColumnValue) Source).FExp); FValue = ((TRtSetColumnValue) Source).FValue; } } public void ReadData(TReader Reader) { super.ReadData(Reader); FExp.ReadData(Reader); byte[] tmp = new byte[SizeOf_Variant]; Reader.Read(tmp, tmp.length); FValue = ToVariant(tmp); } public void WriteData(TWriter Writer) { super.WriteData(Writer); { TWriter context_Writer = Writer; FExp.WriteData(Writer); context_Writer.Write(VarToBytes(FValue), SizeOf_Variant); } } public TRtSetColumnValueClass ClassType() { return TRtSetColumnValueClass.SINGLETON; } public Object getValue() { return FValue; } public TRtExpressionItem getExp() { return FExp; } } public static final class TRtSetColumnListClass extends TSQLNamedListOwnerClass { public static final TRtSetColumnListClass SINGLETON = new TRtSetColumnListClass(); public final TRtSetColumnList CreateParented(TRtCustomSQL AOwner) { return TRtSetColumnList.CreateParented(AOwner); } public Class ClassInfo() { return TRtSetColumnList.class; } } public static final class TRtSetColumnList extends TSQLNamedListOwner { protected TContainerItemClass AllocItemType() { return TRtSetColumnValueClass.SINGLETON; } public final TRtSetColumnValue GetItem(int Index) { return ((TRtSetColumnValue) Get(Index)); } public final void runCreateParented(TRtCustomSQL AOwner) { super.runCreate(); SetFOwner(AOwner); } public static TRtSetColumnList CreateParented(TRtCustomSQL AOwner) { TRtSetColumnList Result; Result = new TRtSetColumnList(); Result.runCreateParented(AOwner); return Result; } public final void SetColumnValue(String AColName, Object AValue) { CheckUnprepare(); TRtSetColumnValue.CreateSetValue(this, AColName, AValue); } public final void SetColumnExp(String AColName, String AExp) { CheckUnprepare(); TRtSetColumnValue.CreateSetExp(this, AColName, AExp); } public TRtSetColumnListClass ClassType() { return TRtSetColumnListClass.SINGLETON; } } public static class TRtInsertSelectIntoClass extends TRtTableSQLClass { public static final TRtInsertSelectIntoClass SINGLETON = new TRtInsertSelectIntoClass(); public TRtInsertSelectInto Create() { return TRtInsertSelectInto.Create(); } public final TRtInsertSelectInto CreateSQL(TRtDBConnection AConn, String ATableName) { return TRtInsertSelectInto.CreateSQL(AConn, ATableName); } public Class ClassInfo() { return TRtInsertSelectInto.class; } } public static class TRtInsertSelectInto extends TRtTableSQL { private final class GenSQL_Context { private String Result = ""; private String GetColumnsIdentifier() { String Result = ""; int i; Result = ""; if (getColumns().GetCount() > 0) { Result = getColumns().Get(0); for (i = 1; i <= getColumns().GetCount() - 1; ++i) { Result = Result + SQL_Comma + getColumns().Get(i); } } if (!StrIsBlank(Result)) { Result = "" + SQL_Space + SQL_LParenthesis + Result + ToStr(SQL_RParenthesis); } return Result; } private String GetQuerySpecification() { String Result = ""; if (getSelect() == null) { Result = ""; } else { Result = "" + SQL_Space + SQL_LParenthesis + getSelect().GetSQL() + ToStr(SQL_RParenthesis); } return Result; } public GenSQL_Context() { } public String execute() { Result = SQL_InsertInto + GetName() + SQL_Space + BreakLine(GetColumnsIdentifier()) + BreakLine(GetQuerySpecification()); if (getUsesScriptTerminator()) { Result = Result + ToStr(SQL_ScriptTerminator); } return Result; } } public boolean GetHasOperation() { return super.GetHasOperation() && FSelect != null && FSelect.GetHasOperation(); } protected TStringListOwner FColumns; protected TRtSelect FSelect; protected final void Init() { FSelect = ((TRtSelect) TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(sckSelect, getDBVersionKind())); FSelect.SetFOwner(this); FColumns = TStringListOwner.Create(); FColumns.setDuplicates(dupError); } public final void SetSelect(TRtSelect Value) { CheckUnprepare(); FSelect.Assign(Value); } protected String GenSQL() { GenSQL_Context ctx = new GenSQL_Context(); return ctx.execute(); } public void runCreate() { super.runCreate(); Init(); } public static TRtInsertSelectInto Create() { TRtInsertSelectInto Result; Result = new TRtInsertSelectInto(); Result.runCreate(); return Result; } public final void runCreateSQL(TRtDBConnection AConn, String ATableName) { super.runCreateSQL(AConn, ATableName); Init(); } public static TRtInsertSelectInto CreateSQL(TRtDBConnection AConn, String ATableName) { TRtInsertSelectInto Result; Result = new TRtInsertSelectInto(); Result.runCreateSQL(AConn, ATableName); return Result; } public void Destroy() { FSelect.Free(); FColumns.Free(); super.Destroy(); } public void Assign(TPersistent Source) { FAssigning++; try { super.Assign(Source); if (Source instanceof TRtInsertSelectInto) { FColumns.Assign(((TRtInsertSelectInto) Source).FColumns); FSelect.Assign(((TRtInsertSelectInto) Source).FSelect); } } finally { FAssigning--; } } public void ReadData(TReader Reader) { FAssigning++; try { super.ReadData(Reader); FColumns.ReadData(Reader); FSelect.ReadData(Reader); } finally { FAssigning--; } } public void WriteData(TWriter Writer) { super.WriteData(Writer); FColumns.WriteData(Writer); FSelect.WriteData(Writer); } public TRtInsertSelectIntoClass ClassType() { return TRtInsertSelectIntoClass.SINGLETON; } public TStringListOwner getColumns() { return FColumns; } public TRtSelect getSelect() { return FSelect; } } public static class TRtInsertIntoClass extends TRtTableSQLClass { public static final TRtInsertIntoClass SINGLETON = new TRtInsertIntoClass(); protected final String GetColumnValue(TRtSetColumnValue Column, TRtDatabaseDef DataBaseDef) { String Result = ""; TRtTableDef TableDef; String Aux = ""; TRtSetColumnList ListOwner; TRtFieldDef FieldDef; int AFldType; ListOwner = ((TRtSetColumnList) Column.GetTypedOwner(TRtSetColumnListClass.SINGLETON)); Aux = (((TRtTableSQL) ListOwner.GetTypedOwner(TRtTableSQLClass.SINGLETON))).GetName(); TableDef = DataBaseDef.TableByName(Aux); if (TableDef != null) { FieldDef = TableDef.FieldByName(Column.GetName()); } else { FieldDef = null; } if (FieldDef != null) { AFldType = FieldDef.GetFullKind().GetEnumType(); } else { AFldType = rftUnknown; } Aux = VarToStr(Column.getValue()); switch (AFldType) { case rftString: Result = SQL_Quotes + Aux + ToStr(SQL_Quotes); break; case rftNumber: while (Pos(',', Aux) != 0) { Aux = Util.setChar(Aux, Pos(",", Aux), SQL_DecimalSeparator); } Result = Aux; break; case rftBoolean: if (VarToBoolean(VarAsType(Column.getValue(), varBoolean))) { Result = SQL_True; } else { Result = SQL_FALSE; } break; case rftDate: Result = FormatDateTime("dd;mm;yyyy,hh:nn:ss", ((Number) Column.getValue()).doubleValue()); break; case rftTime: Result = Aux; break; case rftBlob: case rftText: case rftImage: Result = ToStr(SQL_Quotes) + SQL_Quotes; break; default: Result = Aux; break; } return Result; } public TRtInsertInto Create() { return TRtInsertInto.Create(); } public final TRtInsertInto CreateSQL(TRtDBConnection AConn, String ATableName) { return TRtInsertInto.CreateSQL(AConn, ATableName); } public Class ClassInfo() { return TRtInsertInto.class; } } public static class TRtInsertInto extends TRtTableSQL { private final class GenSQL_Context { private String Result = ""; private String GetColumnsIdentifier() { String Result = ""; int i; Result = ""; if (getColumns().GetCount() > 0) { Result = getColumns().GetItem(0).GetName(); for (i = 1; i <= getColumns().GetCount() - 1; ++i) { Result = Result + SQL_Comma + getColumns().GetItem(i).GetName(); } } if (!StrIsBlank(Result)) { Result = "" + SQL_Space + SQL_LParenthesis + Result + ToStr(SQL_RParenthesis); } return Result; } private String GetInsertValues() { String Result = ""; int i; Result = ToStr(SQL_LParenthesis); for (i = 0; i <= getColumns().GetCount() - 1; ++i) { if (!getColumns().GetItem(i).GetIsExp()) { Result = Result + TRtInsertIntoClass.SINGLETON.GetColumnValue(getColumns().GetItem(i), CheckGetDatabaseDef()); } else { Result = Result + TranslateExpression(TRtInsertInto.this, getColumns().GetItem(i).getExp().getTokens()); } if (i < getColumns().GetCount() - 1) { Result = Result + ToStr(SQL_Comma); } } Result = Result + ToStr(SQL_RParenthesis); if (Length(Result) == 2) { Result = ""; } return Result; } public GenSQL_Context() { } public String execute() { Result = SQL_InsertInto + GetName() + BreakLine(GetColumnsIdentifier()) + SQL_Values + BreakLine(GetInsertValues()); if (getUsesScriptTerminator()) { Result = Result + ToStr(SQL_ScriptTerminator); } return Result; } } public boolean GetHasOperation() { return super.GetHasOperation() && FColumns != null && FColumns.GetCount() > 0; } protected TRtSetColumnList FColumns; protected final String GetColumnValue(TRtSetColumnValue Column, TRtDatabaseDef DataBaseDef) { return ClassType().GetColumnValue(Column, DataBaseDef); } protected String GenSQL() { GenSQL_Context ctx = new GenSQL_Context(); return ctx.execute(); } public void runCreate() { super.runCreate(); FColumns = ((TRtSetColumnList) Creator(this, TRtSetColumnListClass.SINGLETON)); } public static TRtInsertInto Create() { TRtInsertInto Result; Result = new TRtInsertInto(); Result.runCreate(); return Result; } public final void runCreateSQL(TRtDBConnection AConn, String ATableName) { super.runCreateSQL(AConn, ATableName); FColumns = ((TRtSetColumnList) Creator(this, TRtSetColumnListClass.SINGLETON)); } public static TRtInsertInto CreateSQL(TRtDBConnection AConn, String ATableName) { TRtInsertInto Result; Result = new TRtInsertInto(); Result.runCreateSQL(AConn, ATableName); return Result; } public void Destroy() { FColumns.Free(); super.Destroy(); } public void Assign(TPersistent Source) { FAssigning++; try { super.Assign(Source); if (Source instanceof TRtInsertInto) { FColumns.Assign(((TRtInsertInto) Source).FColumns); } } finally { FAssigning--; } } public void ReadData(TReader Reader) { FAssigning++; try { super.ReadData(Reader); FColumns.ReadData(Reader); } finally { FAssigning--; } } public void WriteData(TWriter Writer) { super.WriteData(Writer); FColumns.WriteData(Writer); } public TRtInsertIntoClass ClassType() { return TRtInsertIntoClass.SINGLETON; } public TRtSetColumnList getColumns() { return FColumns; } } public static final class TRtUpdateClass extends TRtAliasedTableSQLClass { public static final TRtUpdateClass SINGLETON = new TRtUpdateClass(); public TRtUpdate Create() { return TRtUpdate.Create(); } public final TRtUpdate CreateSQL(TRtDBConnection AConn, String ATableName, String AAlias) { return TRtUpdate.CreateSQL(AConn, ATableName, AAlias); } public Class ClassInfo() { return TRtUpdate.class; } } public static final class TRtUpdate extends TRtAliasedTableSQL { private final class GenSQL_Context { private String Result = ""; private String GetExpression() { String Result = ""; int I; Result = ""; for (I = 0; I <= getColumns().GetCount() - 1; ++I) { if (!getColumns().GetItem(I).GetIsExp()) { Result = Result + getColumns().GetItem(I).GetName() + '=' + TRtInsertIntoClass.SINGLETON.GetColumnValue(getColumns().GetItem(I), CheckGetDatabaseDef()); } else { Result = Result + getColumns().GetItem(I).GetName() + '=' + TranslateExpression(TRtUpdate.this, getColumns().GetItem(I).getExp().getTokens()); } if (I < getColumns().GetCount() - 1) { Result = Result + ToStr(SQL_Comma); } } return Result; } public GenSQL_Context() { } public String execute() { Result = SQL_Update + GetName(); if (!StrIsBlank(getAlias())) { Result = Result + SQL_Space + getAlias(); } Result = Result + SQL_Set + BreakLine(GetExpression()) + BreakLine(GetWhere(TRtUpdate.this, getWhere())); if (getUsesScriptTerminator()) { Result = Result + ToStr(SQL_ScriptTerminator); } return Result; } } public boolean GetHasOperation() { return super.GetHasOperation() && FColumns != null && FColumns.GetCount() > 0; } protected TRtSetColumnList FColumns; protected TRtWhereCurrentOfItem FWhere; protected final void Init() { FColumns = ((TRtSetColumnList) Creator(this, TRtSetColumnListClass.SINGLETON)); FWhere = ((TRtWhereCurrentOfItem) Creator(this, TRtWhereCurrentOfItemClass.SINGLETON)); } protected String GenSQL() { GenSQL_Context ctx = new GenSQL_Context(); return ctx.execute(); } public void runCreate() { super.runCreate(); Init(); } public static TRtUpdate Create() { TRtUpdate Result; Result = new TRtUpdate(); Result.runCreate(); return Result; } public final void runCreateSQL(TRtDBConnection AConn, String ATableName, String AAlias) { super.runCreateSQL(AConn, ATableName, AAlias); Init(); } public static TRtUpdate CreateSQL(TRtDBConnection AConn, String ATableName, String AAlias) { TRtUpdate Result; Result = new TRtUpdate(); Result.runCreateSQL(AConn, ATableName, AAlias); return Result; } public void ExecuteUpd() { if (!StrIsBlank(FWhere.GetCurrentOf())) { throw DelphiException.Create(STORED_PROC_ERR_MESS); } super.ExecuteUpd(); } public void Destroy() { FWhere.Free(); FColumns.Free(); super.Destroy(); } public void Assign(TPersistent Source) { FAssigning++; try { super.Assign(Source); if (Source instanceof TRtUpdate) { FWhere.Assign(((TRtUpdate) Source).FWhere); FColumns.Assign(((TRtUpdate) Source).FColumns); } } finally { FAssigning--; } } public void ReadData(TReader Reader) { FAssigning++; try { super.ReadData(Reader); FWhere.ReadData(Reader); FColumns.ReadData(Reader); } finally { FAssigning--; } } public void WriteData(TWriter Writer) { super.WriteData(Writer); FWhere.WriteData(Writer); FColumns.WriteData(Writer); } public TRtUpdateClass ClassType() { return TRtUpdateClass.SINGLETON; } public TRtSetColumnList getColumns() { return FColumns; } public TRtWhereCurrentOfItem getWhere() { return FWhere; } } public static final class TRtSelColumnsItemClass extends TSQLNamedContainerItemClass { public static final TRtSelColumnsItemClass SINGLETON = new TRtSelColumnsItemClass(); public final TRtSelColumnsItem CreateColumnAs(TRtSelColumnsList AOwner, String AAlias, String AColName, String AAsName, boolean LGroupBy) { return TRtSelColumnsItem.CreateColumnAs(AOwner, AAlias, AColName, AAsName, LGroupBy); } public final TRtSelColumnsItem CreateExpAs(TRtSelColumnsList AOwner, TRtSQLTokenList AExpTokens, String AAsName, boolean LGroupBy) { return TRtSelColumnsItem.CreateExpAs(AOwner, AExpTokens, AAsName, LGroupBy); } public final TRtSelColumnsItem CreateEnumDescription(TRtSelColumnsList AOwner, TRtSelColumnsItem AEnumKey, String AEnumName) { return TRtSelColumnsItem.CreateEnumDescription(AOwner, AEnumKey, AEnumName); } public Class ClassInfo() { return TRtSelColumnsItem.class; } } public static final class TRtSelColumnsItem extends TSQLNamedContainerItem { protected String FColName; protected TRtSQLTokenList FExpTokens; protected boolean FIsGroupBy; protected String FFromAlias; protected TRtSelTableItem FFromItem; protected TRtSelColumnsItem FEnumKey; protected String FEnumName; public void SetName(String Value) { if (StrIsBlank(GetName())) { super.SetName(Value); } } public final boolean GetIsExp() { return FExpTokens != null; } protected final TRtSelect CheckOwnerSelect() { return ((TRtSelect) CheckTypedOwner(TRtSelectClass.SINGLETON)); } public final boolean GetIsEnumDescription() { return !StrIsBlank(FEnumName); } public final String GetBaseColumnName() { String Result = ""; int APos; APos = Pos(".", FColName); if (APos > 0) { Result = Copy(FColName, APos + 1, Length(FColName) - APos); } else { Result = FColName; } return Result; } public final void runCreateColumnAs(TRtSelColumnsList AOwner, String AAlias, String AColName, String AAsName, boolean LGroupBy) { super.runCreate(); FColName = AColName; FIsGroupBy = LGroupBy; SetName(AAsName); FFromAlias = AAlias; AOwner.AddItem(this); } public static TRtSelColumnsItem CreateColumnAs(TRtSelColumnsList AOwner, String AAlias, String AColName, String AAsName, boolean LGroupBy) { TRtSelColumnsItem Result; Result = new TRtSelColumnsItem(); Result.runCreateColumnAs(AOwner, AAlias, AColName, AAsName, LGroupBy); return Result; } public final void runCreateExpAs(TRtSelColumnsList AOwner, TRtSQLTokenList AExpTokens, String AAsName, boolean LGroupBy) { super.runCreate(); FExpTokens = AExpTokens; FExpTokens.SetFOwner(this); FIsGroupBy = LGroupBy; SetName(AAsName); AOwner.AddItem(this); } public static TRtSelColumnsItem CreateExpAs(TRtSelColumnsList AOwner, TRtSQLTokenList AExpTokens, String AAsName, boolean LGroupBy) { TRtSelColumnsItem Result; Result = new TRtSelColumnsItem(); Result.runCreateExpAs(AOwner, AExpTokens, AAsName, LGroupBy); return Result; } public final void runCreateEnumDescription(TRtSelColumnsList AOwner, TRtSelColumnsItem AEnumKey, String AEnumName) { super.runCreate(); FIsGroupBy = false; FEnumKey = AEnumKey; FEnumName = AEnumName; SetName(AEnumName + '_' + AEnumKey.GetName()); AOwner.AddItem(this); } public static TRtSelColumnsItem CreateEnumDescription(TRtSelColumnsList AOwner, TRtSelColumnsItem AEnumKey, String AEnumName) { TRtSelColumnsItem Result; Result = new TRtSelColumnsItem(); Result.runCreateEnumDescription(AOwner, AEnumKey, AEnumName); return Result; } public void Destroy() { int i; TRtSelect AOwner; TRtSelColumnsList AList; TRtSelColumnsItem AItem; if (FExpTokens != null) { FExpTokens.Free(); } if (GetFOwner() instanceof TRtSelColumnsList) { AOwner = CheckOwnerSelect(); i = 0; while (i < AOwner.FOrderBy.GetCount()) { if (AOwner.FOrderBy.GetItem(i).FColItem == this) { AOwner.FOrderBy.GetItem(i).Free(); } else { i++; } } if (StrIsBlank(FEnumName)) { AList = ((TRtSelColumnsList) GetFOwner()); i = 0; while (i < AList.GetCount()) { AItem = AList.GetItem(i); if (AItem != null && AItem.FEnumKey == this) { AItem.FEnumKey = null; } i++; } } } super.Destroy(); } public void Assign(TPersistent Source) { super.Assign(Source); if (Source instanceof TRtSelColumnsItem) { FColName = ((TRtSelColumnsItem) Source).FColName; FIsGroupBy = ((TRtSelColumnsItem) Source).FIsGroupBy; if (((TRtSelColumnsItem) Source).FExpTokens != null) { if (FExpTokens == null) { FExpTokens = ((TRtSQLTokenList) ((TRtSelColumnsItem) Source).FExpTokens.CloneParented(this)); } else { FExpTokens.Assign(((TRtSelColumnsItem) Source).FExpTokens); } } else if (FExpTokens != null) { FExpTokens.Free(); FExpTokens = null; } FFromAlias = ((TRtSelColumnsItem) Source).FFromAlias; FFromItem = null; if (((TRtSelColumnsItem) Source).FEnumKey != null) { FEnumKey = (((TRtSelColumnsList) GetFOwner())).ItemByAsName(((TRtSelColumnsItem) Source).FEnumKey.GetName()); } else { FEnumKey = null; } FEnumName = ((TRtSelColumnsItem) Source).FEnumName; } } public void ReadData(TReader Reader) { String AEnumAsName = ""; super.ReadData(Reader); { TReader context_Reader = Reader; FColName = context_Reader.ReadString(); FIsGroupBy = context_Reader.ReadBoolean(); if (context_Reader.ReadBoolean()) { if (FExpTokens == null) { FExpTokens = ((TRtSQLTokenList) Creator(this, TRtSQLTokenListClass.SINGLETON)); } FExpTokens.ReadData(Reader); } else if (FExpTokens != null) { FExpTokens.Free(); FExpTokens = null; } FFromAlias = context_Reader.ReadString(); FFromItem = null; AEnumAsName = context_Reader.ReadString(); if (!StrIsBlank(AEnumAsName)) { FEnumKey = (((TRtSelColumnsList) GetFOwner())).ItemByAsName(AEnumAsName); } else { FEnumKey = null; } FEnumName = context_Reader.ReadString(); } } public void WriteData(TWriter Writer) { String AEnumAsName = ""; boolean LExp; super.WriteData(Writer); { TWriter context_Writer = Writer; context_Writer.WriteString(FColName); context_Writer.WriteBoolean(FIsGroupBy); LExp = FExpTokens != null; context_Writer.WriteBoolean(LExp); if (LExp) { FExpTokens.WriteData(Writer); } context_Writer.WriteString(FFromAlias); if (FEnumKey != null) { AEnumAsName = FEnumKey.GetName(); } else { AEnumAsName = ""; } context_Writer.WriteString(AEnumAsName); context_Writer.WriteString(FEnumName); } } public final String CalculatedAsName() { String Result = ""; TRtSelect OwnerSelect; boolean LSingleTable; Result = ""; OwnerSelect = CheckOwnerSelect(); if (OwnerSelect.getFrom().GetCount() == 1 && !StrIsBlank(OwnerSelect.getFrom().GetItem(0).getTableName())) { LSingleTable = true; } else { LSingleTable = false; } if (FFromItem != null) { if (!LSingleTable) { Result = FFromItem.GetName(); } } if (!StrIsBlank(GetName())) { if (CompareText(GetName(), getColumnName()) == 0) { Result = Result + GetName(); } else { Result = GetName(); } } else { Result = Result + getColumnName(); } return Result; } public TRtSelColumnsItemClass ClassType() { return TRtSelColumnsItemClass.SINGLETON; } public String getFromAlias() { return FFromAlias; } public TRtSelTableItem getFromItem() { return FFromItem; } public String getColumnName() { return FColName; } public TRtSelColumnsItem getEnumKey() { return FEnumKey; } public String getEnumName() { return FEnumName; } public boolean getIsGroupBy() { return FIsGroupBy; } public TRtSQLTokenList getExpTokens() { return FExpTokens; } } public static final class TRtSelColumnsListClass extends TSQLNamedListOwnerClass { public static final TRtSelColumnsListClass SINGLETON = new TRtSelColumnsListClass(); public final TRtSelColumnsList CreateParented(TRtSelect AOwner) { return TRtSelColumnsList.CreateParented(AOwner); } public Class ClassInfo() { return TRtSelColumnsList.class; } } public static final class TRtSelColumnsList extends TSQLNamedListOwner { protected TContainerItemClass AllocItemType() { return TRtSelColumnsItemClass.SINGLETON; } public final TRtSelColumnsItem GetItem(int Index) { return ((TRtSelColumnsItem) Get(Index)); } protected final TRtSelect CheckOwnerSelect() { return ((TRtSelect) CheckTypedOwner(TRtSelectClass.SINGLETON)); } public final int GetGroupByCount() { int Result; Result = 0; while (Result < GetCount() && this.GetItem(Result).FIsGroupBy) { Result++; } return Result; } protected final void CheckCanGroupBy() { if (GetCount() != 0) { if (!this.GetItem(GetCount() - 1).getIsGroupBy()) { throw DelphiException.Create(TransStr("TC670", "Tentativa de agrupamento colunas fora de sequência.", true)); } } } protected final TRtSelColumnsItem ItemByFromAlias(String AFromAlias) { TRtSelColumnsItem Result; int i; for (i = 0; i <= GetCount() - 1; ++i) { if (CompareText(this.GetItem(i).FFromAlias, AFromAlias) == 0) { Result = this.GetItem(i); return Result; } } return null; } public final void runCreateParented(TRtSelect AOwner) { super.runCreate(); SetFOwner(AOwner); } public static TRtSelColumnsList CreateParented(TRtSelect AOwner) { TRtSelColumnsList Result; Result = new TRtSelColumnsList(); Result.runCreateParented(AOwner); return Result; } public final void AddAllColumns(String ATblName, String AAlias) { TRtSelect OwnerSelect; TRtSelTableItem ATblItem; TRtTableDef ATblDef; TRtDatabaseDef ADbDef; int i; String AColName = ""; String AAsName = ""; boolean LSingleAsName; CheckUnprepare(); OwnerSelect = CheckOwnerSelect(); ATblItem = OwnerSelect.FFrom.NewTableAs(ATblName, AAlias); LSingleAsName = GetCount() == 0 && OwnerSelect.FFrom.GetCount() <= 1; AAlias = ATblItem.GetName(); ADbDef = OwnerSelect.GetDatabaseDef(); if (ADbDef != null) { ATblDef = ADbDef.TableByName(ATblItem.getTableName()); } else { ATblDef = null; } if (ATblDef != null) { for (i = 0; i <= ATblDef.GetFieldCount() - 1; ++i) { AColName = AAlias + '.' + ATblDef.GetField(i).GetName(); if (LSingleAsName) { AAsName = ATblDef.GetField(i).GetName(); } else { AAsName = AAlias + '_' + ATblDef.GetField(i).GetName(); AAsName = StrReplaceStr(AAsName, "\"", ""); } if (ItemByName(AColName) == null) { TRtSelColumnsItem.CreateColumnAs(this, AAlias, AColName, AAsName, false); } } } else { TRtSelColumnsItem.CreateColumnAs(this, AAlias, AAlias + ".*", "", false); } } public final void AddPrimaryKeyColumns(String ATblName, String AAlias) { TRtSelect OwnerSelect; TRtSelTableItem ATblItem; TRtTableDef ATblDef; int i; String AColName = ""; String AAsName = ""; boolean LSingleAsName; CheckUnprepare(); OwnerSelect = CheckOwnerSelect(); ATblItem = OwnerSelect.FFrom.NewTableAs(ATblName, AAlias); LSingleAsName = GetCount() == 0 && OwnerSelect.FFrom.GetCount() <= 1; AAlias = ATblItem.GetName(); ATblDef = OwnerSelect.CheckGetDatabaseDef().CheckTableByName(ATblItem.getTableName()); for (i = 0; i <= ATblDef.GetKeyCount() - 1; ++i) { AColName = AAlias + '.' + ATblDef.GetPrimaryKeyField(i).GetName(); if (LSingleAsName) { AAsName = ATblDef.GetPrimaryKeyField(i).GetName(); } else { AAsName = AAlias + '_' + ATblDef.GetPrimaryKeyField(i).GetName(); AAsName = StrReplaceStr(AAsName, "\"", ""); } if (ItemByName(AColName) == null) { TRtSelColumnsItem.CreateColumnAs(this, AAlias, AColName, AAsName, false); } } } public final TRtSelColumnsItem AddColumn(String AColName) { return AddColumnAs(AColName, AColName); } public final TRtSelColumnsItem AddColumnAs(String AColName, String AAsName) { TRtSelColumnsItem Result; TString AAlias = new TString(); TRtSQLTokenList ATokens; TRtSelFromItem FFrom; int APos; CheckUnprepare(); if (StrIsBlank(AAsName)) { AAsName = AColName; } APos = Pos(".", AAsName); while (APos > 0) { AAsName = Util.setChar(AAsName, APos, '_'); APos = Pos(".", AAsName); } AAsName = StrReplaceStr(AAsName, "\"", ""); ATokens = null; ParseColName(AColName, AAlias, ATokens); FFrom = CheckOwnerSelect().FFrom; if (!StrIsBlank(AAlias.v)) { FFrom.NewTableAs(AAlias.v, AAlias.v); } else if (FFrom.GetCount() > 0) { AAlias.v = FFrom.GetItem(0).GetName(); } if (ATokens == null) { Result = TRtSelColumnsItem.CreateColumnAs(this, AAlias.v, AColName, AAsName, false); } else { if (CompareText(AColName, AAsName) == 0) { AAsName = TempExp(); } Result = TRtSelColumnsItem.CreateExpAs(this, ATokens, AAsName, false); } return Result; } public final TRtSelColumnsItem AddEnumDescription(String AKeyAsName, String AEnumName) { TRtSelect OwnerSelect; TRtSelTableItem AFromItem; TRtSelColumnsItem AEnumKey; TRtEnumerationDef AEnumDef; TRtDatabaseDef ADbDef; TRtTableDef ATblDef; TRtFieldDef AFldDef; String ATblAlias = ""; String ATblName = ""; CheckUnprepare(); OwnerSelect = CheckOwnerSelect(); ADbDef = OwnerSelect.CheckGetDatabaseDef(); AEnumKey = ItemByAsName(AKeyAsName); if (AEnumKey == null) { AEnumKey = ItemByColumnName(AKeyAsName); } if (AEnumKey == null) { throw DelphiException.CreateFmt(TransStr("TC668", "Coluna não encontrada: \"%s\".", true), new Object[] { AKeyAsName }); } if (StrIsBlank(AEnumName) && !AEnumKey.GetIsExp()) { ATblAlias = AEnumKey.FFromAlias; ATblName = ""; if (StrIsBlank(ATblAlias)) { if (OwnerSelect.FFrom.GetCount() == 1) { ATblName = OwnerSelect.FFrom.GetItem(0).FTableName; } } else { AFromItem = OwnerSelect.FFrom.ItemByAlias(ATblAlias); if (AFromItem == null) { AFromItem = OwnerSelect.FFrom.ItemByTableName(ATblAlias); } if (AFromItem != null) { ATblName = AFromItem.FTableName; } } if (!StrIsBlank(ATblName)) { ATblDef = ADbDef.TableByName(ATblName); if (ATblDef != null) { AFldDef = ATblDef.FieldByName(AEnumKey.GetBaseColumnName()); if (AFldDef != null) { AEnumName = AFldDef.GetKindName(); } } } } AEnumDef = null; if (!StrIsBlank(AEnumName)) { AEnumDef = ADbDef.EnumerationByName(AEnumName); } if (AEnumDef == null) { throw DelphiException.Create(TransStr("TC669", "Não foi possível encontrar um tipo Enumeração.", true)); } return TRtSelColumnsItem.CreateEnumDescription(this, AEnumKey, AEnumName); } public final void SetGroupByColumns(int NCols) { int i; CheckUnprepare(); for (i = 0; i <= GetCount() - 1; ++i) { this.GetItem(i).FIsGroupBy = i < NCols; } } public final TRtSelColumnsItem ItemByAsName(String AName) { return ((TRtSelColumnsItem) ItemByName(AName)); } public final TRtSelColumnsItem ItemByColumnName(String AName) { TRtSelColumnsItem Result; int i; for (i = 0; i <= GetCount() - 1; ++i) { if (CompareText(this.GetItem(i).getColumnName(), AName) == 0 || CompareText(this.GetItem(i).getColumnName(), this.GetItem(i).FFromAlias + '.' + AName) == 0) { Result = this.GetItem(i); return Result; } } return null; } public final int RemoveByAsName(String AName) { return RemoveByName(AName); } public final int RemoveByColumnName(String AName) { int Result; Result = IndexOf(ItemByColumnName(AName)); if (Result >= 0) { Delete(Result); } return Result; } public TRtSelColumnsListClass ClassType() { return TRtSelColumnsListClass.SINGLETON; } } public static final class TRtOuterJoinItemClass extends TSQLContainerItemClass { public static final TRtOuterJoinItemClass SINGLETON = new TRtOuterJoinItemClass(); public TRtOuterJoinItem Create() { return TRtOuterJoinItem.Create(); } public final TRtOuterJoinItem CreateOuterJoin(TRtSelTableItem AOwner, TRtSelTableItem ARightTable, String ALeftFields, String ARightFields, int aOuterJoinOption) { return TRtOuterJoinItem.CreateOuterJoin(AOwner, ARightTable, ALeftFields, ARightFields, aOuterJoinOption); } public Class ClassInfo() { return TRtOuterJoinItem.class; } } public static final class TRtOuterJoinItem extends TSQLContainerItem { private final class GetFieldsAsExprString_Context { private final String SJoinOp; private String Result = ""; private String TableRef(int ATable) { String Result = ""; TRtSelTableItem ASelItem; if (ATable == 0) { ASelItem = ((TRtSelTableItem) GetFOwner()); } else { ASelItem = FRightTableItem; } if (!StrIsBlank(ASelItem.GetName())) { Result = ASelItem.GetName(); } else { Result = ASelItem.FTableName; } return Result; } private int i; private String LTbl = ""; private String RTbl = ""; public GetFieldsAsExprString_Context(String SJoinOp) { this.SJoinOp = SJoinOp; } public String execute() { LTbl = TableRef(0); RTbl = TableRef(1); if (FLeftFields.GetCount() > 0) { Result = LTbl + '.' + FLeftFields.Get(0) + SJoinOp + "= " + RTbl + '.' + FRightFields.Get(0); for (i = 1; i <= FLeftFields.GetCount() - 1; ++i) { Result = Result + " AND " + LTbl + '.' + FLeftFields.Get(i) + SJoinOp + "= " + RTbl + '.' + FRightFields.Get(i); } } else { Result = ""; } return Result; } } protected int FOuterJoinOption; protected TRtSelTableItem FRightTableItem; protected TStringListOwner FLeftFields; protected TStringListOwner FRightFields; public final int GetFieldCount() { return FLeftFields.GetCount(); } public final String GetLeftFields(int Index) { return FLeftFields.Get(Index); } public final String GetRightFields(int Index) { return FRightFields.Get(Index); } public void runCreate() { super.runCreate(); FLeftFields = TStringListOwner.Create(); FRightFields = TStringListOwner.Create(); FOuterJoinOption = ojLeft; } public static TRtOuterJoinItem Create() { TRtOuterJoinItem Result; Result = new TRtOuterJoinItem(); Result.runCreate(); return Result; } public final void runCreateOuterJoin(TRtSelTableItem AOwner, TRtSelTableItem ARightTable, String ALeftFields, String ARightFields, int aOuterJoinOption) { runCreate(); if (AOwner.FOuterJoin != null) { AOwner.FOuterJoin.Free(); } AOwner.FOuterJoin = this; FRightTableItem = ARightTable; if (!StrIsBlank(ALeftFields) && !StrIsBlank(ARightFields)) { AddAllFields(ALeftFields, ARightFields); } FOuterJoinOption = aOuterJoinOption; } public static TRtOuterJoinItem CreateOuterJoin(TRtSelTableItem AOwner, TRtSelTableItem ARightTable, String ALeftFields, String ARightFields, int aOuterJoinOption) { TRtOuterJoinItem Result; Result = new TRtOuterJoinItem(); Result.runCreateOuterJoin(AOwner, ARightTable, ALeftFields, ARightFields, aOuterJoinOption); return Result; } public void Destroy() { FLeftFields.Free(); FRightFields.Free(); super.Destroy(); } public String GetFieldsAsExprString(String SJoinOp) { GetFieldsAsExprString_Context ctx = new GetFieldsAsExprString_Context(SJoinOp); return ctx.execute(); } public void Assign(TPersistent Source) { TRtSelFromItem OwnerFromItem; if (Source instanceof TRtOuterJoinItem) { OwnerFromItem = ((TRtSelFromItem) CheckTypedOwner(TRtSelFromItemClass.SINGLETON)); if (!StrIsBlank(((TRtOuterJoinItem) Source).FRightTableItem.GetName())) { FRightTableItem = OwnerFromItem.ItemByAlias(((TRtOuterJoinItem) Source).FRightTableItem.GetName()); } else { FRightTableItem = OwnerFromItem.ItemByTableName(((TRtOuterJoinItem) Source).FRightTableItem.getTableName()); } FLeftFields.Assign(((TRtOuterJoinItem) Source).FLeftFields); FRightFields.Assign(((TRtOuterJoinItem) Source).FRightFields); } else { super.Assign(Source); } } public void ReadData(TReader Reader) { TRtSelFromItem OwnerFromItem; String STable = ""; super.ReadData(Reader); STable = Reader.ReadString(); OwnerFromItem = ((TRtSelFromItem) CheckTypedOwner(TRtSelFromItemClass.SINGLETON)); FRightTableItem = OwnerFromItem.ItemByAlias(STable); if (FRightTableItem == null) { FRightTableItem = OwnerFromItem.ItemByTableName(STable); } FLeftFields.ReadData(Reader); FRightFields.ReadData(Reader); } public void WriteData(TWriter Writer) { super.WriteData(Writer); if (!StrIsBlank(FRightTableItem.GetName())) { Writer.WriteString(FRightTableItem.GetName()); } else { Writer.WriteString(FRightTableItem.getTableName()); } FLeftFields.WriteData(Writer); FRightFields.WriteData(Writer); } public final void AddFields(String ALeftField, String ARightField) { int pl; int pr; CheckUnprepare(); pl = StrRScan(ALeftField, 0, '.'); if (pl != -1) { pl++; } else { pl = 0; } pr = StrRScan(ARightField, 0, '.'); if (pr != -1) { pr++; } else { pr = 0; } if (FLeftFields.IndexOf(StrPas(ALeftField, pl)) >= 0) { throw DelphiException.CreateFmt(TransStr("TC4932", "Campo \"%0:s\" da tabela \"%1:s\" já foi incluso na cláusula OUTER JOIN.", true), new Object[] { pl, (((TRtSelTableItem) CheckTypedOwner(TRtSelTableItemClass.SINGLETON))).getTableName() }); } if (FRightFields.IndexOf(StrPas(ARightField, pr)) >= 0) { throw DelphiException.CreateFmt(TransStr("TC4932", "Campo \"%0:s\" da tabela \"%1:s\" já foi incluso na cláusula OUTER JOIN.", true), new Object[] { pr, FRightTableItem.getTableName() }); } FLeftFields.Add(StrPas(ALeftField, pl)); FRightFields.Add(StrPas(ARightField, pl)); } public final void AddAllFields(String ALeftFields, String ARightFields) { TInt pl = new TInt(); TInt pr = new TInt(); String sl = ""; String sr = ""; pl.v = 0; pr.v = 0; while (true) { sl = StrGetNextToken(ALeftFields, pl, ";"); sr = StrGetNextToken(ARightFields, pr, ";"); if (StrIsBlank(sl) || StrIsBlank(sr)) { break; } AddFields(sl, sr); } } public final void DeleteFields(int Index) { CheckUnprepare(); FLeftFields.Delete(Index); FRightFields.Delete(Index); } public TRtOuterJoinItemClass ClassType() { return TRtOuterJoinItemClass.SINGLETON; } public TRtSelTableItem getRightTableItem() { return FRightTableItem; } public int getOuterJoinOption() { return FOuterJoinOption; } } public static final class TRtSelTableItemClass extends TSQLNamedContainerItemClass { public static final TRtSelTableItemClass SINGLETON = new TRtSelTableItemClass(); public final TRtSelTableItem CreateAddTable(TRtSelFromItem AOwner, String ATblName, String AAlias) { return TRtSelTableItem.CreateAddTable(AOwner, ATblName, AAlias); } public Class ClassInfo() { return TRtSelTableItem.class; } } public static final class TRtSelTableItem extends TSQLNamedContainerItem { protected TRtOuterJoinItem FOuterJoin; protected String FTableName; protected final TRtSelect CheckOwnerSelect() { return ((TRtSelect) CheckTypedOwner(TRtSelectClass.SINGLETON)); } protected final void FreeOuterJoin() { if (FOuterJoin != null) { FOuterJoin.Free(); FOuterJoin = null; } } public final void runCreateAddTable(TRtSelFromItem AOwner, String ATblName, String AAlias) { FTableName = ATblName; if (StrIsBlank(AAlias)) { SetName(ATblName); } else { SetName(AAlias); } AOwner.AddItem(this); } public static TRtSelTableItem CreateAddTable(TRtSelFromItem AOwner, String ATblName, String AAlias) { TRtSelTableItem Result; Result = new TRtSelTableItem(); Result.runCreateAddTable(AOwner, ATblName, AAlias); return Result; } public void Destroy() { int i; TRtSelColumnsList ACols; TRtSelFromItem ATbls; TRtSelTableItem ASelTbl; ACols = CheckOwnerSelect().FColumns; for (i = 0; i <= ACols.GetCount() - 1; ++i) { if (ACols.GetItem(i).FFromItem == this) { ACols.GetItem(i).FFromItem = null; } } ATbls = CheckOwnerSelect().FFrom; for (i = 0; i <= ATbls.GetCount() - 1; ++i) { ASelTbl = ATbls.GetItem(i); if (ASelTbl != null && ASelTbl.FOuterJoin != null && ASelTbl.FOuterJoin.FRightTableItem == this) { ASelTbl.FreeOuterJoin(); } } FreeOuterJoin(); super.Destroy(); } public void Assign(TPersistent Source) { super.Assign(Source); if (Source instanceof TRtSelTableItem) { FTableName = ((TRtSelTableItem) Source).FTableName; FreeOuterJoin(); } } public void ReadData(TReader Reader) { super.ReadData(Reader); { TReader context_Reader = Reader; FTableName = context_Reader.ReadString(); FreeOuterJoin(); } } public void WriteData(TWriter Writer) { super.WriteData(Writer); { TWriter context_Writer = Writer; context_Writer.WriteString(FTableName); } } public TRtSelTableItemClass ClassType() { return TRtSelTableItemClass.SINGLETON; } public String getTableName() { return FTableName; } public TRtOuterJoinItem getOuterJoin() { return FOuterJoin; } } public static final class TRtSelFromItemClass extends TSQLNamedListOwnerClass { public static final TRtSelFromItemClass SINGLETON = new TRtSelFromItemClass(); public final TRtSelFromItem CreateParented(TRtSelect AOwner) { return TRtSelFromItem.CreateParented(AOwner); } public Class ClassInfo() { return TRtSelFromItem.class; } } public static final class TRtSelFromItem extends TSQLNamedListOwner { protected TContainerItemClass AllocItemType() { return TRtSelTableItemClass.SINGLETON; } public final TRtSelTableItem GetItem(int Index) { return ((TRtSelTableItem) Get(Index)); } protected final TRtSelTableItem NewTableAs(String ATblName, String AAlias) { TRtSelTableItem Result; CheckUnprepare(); if (!StrIsBlank(AAlias)) { Result = ItemByAlias(AAlias); if (Result == null) { if (StrIsBlank(ATblName)) { ATblName = AAlias; } Result = TRtSelTableItem.CreateAddTable(this, ATblName, AAlias); } } else { AAlias = ATblName; Result = ItemByAlias(AAlias); if (Result == null) { Result = ItemByTableName(ATblName); if (Result == null) { Result = TRtSelTableItem.CreateAddTable(this, ATblName, AAlias); } } } return Result; } public final void runCreateParented(TRtSelect AOwner) { super.runCreate(); SetFOwner(AOwner); } public static TRtSelFromItem CreateParented(TRtSelect AOwner) { TRtSelFromItem Result; Result = new TRtSelFromItem(); Result.runCreateParented(AOwner); return Result; } public void Assign(TPersistent Source) { int i; super.Assign(Source); if (Source instanceof TRtSelFromItem) { for (i = 0; i <= GetCount() - 1; ++i) { if (((TRtSelFromItem) Source).GetItem(i).FOuterJoin != null) { GetItem(i).FOuterJoin = TRtOuterJoinItem.Create(); GetItem(i).FOuterJoin.Assign(((TRtSelFromItem) Source).GetItem(i).FOuterJoin); } } } } public void ReadData(TReader Reader) { int i; super.ReadData(Reader); for (i = 0; i <= GetCount() - 1; ++i) { if (Reader.ReadBoolean()) { GetItem(i).FOuterJoin = TRtOuterJoinItem.Create(); GetItem(i).FOuterJoin.ReadData(Reader); } } } public void WriteData(TWriter Writer) { int i; boolean LOJ; super.WriteData(Writer); for (i = 0; i <= GetCount() - 1; ++i) { LOJ = GetItem(i).FOuterJoin != null; Writer.WriteBoolean(LOJ); if (LOJ) { GetItem(i).FOuterJoin.WriteData(Writer); } } } public final void AddTableAs(String ATblName, String AAlias) { NewTableAs(ATblName, AAlias); } public final void AddTable(String ATblName) { NewTableAs(ATblName, ATblName); } public final TRtOuterJoinItem OuterJoinTables(String ALeftAlias, String ARightAlias, String ALeftFields, String ARightFields, int aOuterJoinOption) { TRtSelTableItem ALeftTbl; TRtSelTableItem ARightTbl; CheckUnprepare(); ALeftTbl = ItemByAlias(ALeftAlias); if (ALeftTbl == null) { throw DelphiException.CreateFmt(TransStr("TC430", "Tabela \"%s\" não encontrada na clausula FROM.", true), new Object[] { ALeftAlias }); } ARightTbl = ItemByAlias(ARightAlias); if (ARightTbl == null) { throw DelphiException.CreateFmt(TransStr("TC430", "Tabela \"%s\" não encontrada na clausula FROM.", true), new Object[] { ARightAlias }); } return TRtOuterJoinItem.CreateOuterJoin(ALeftTbl, ARightTbl, ALeftFields, ARightFields, aOuterJoinOption); } public final TRtSelTableItem ItemByAlias(String AName) { return ((TRtSelTableItem) ItemByName(AName)); } public final TRtSelTableItem ItemByTableName(String AName) { TRtSelTableItem Result; int i; for (i = 0; i <= GetCount() - 1; ++i) { if (CompareText(this.GetItem(i).getTableName(), AName) == 0) { Result = this.GetItem(i); return Result; } } return null; } public final int RemoveByAlias(String AName) { return RemoveByName(AName); } public final int RemoveByTableName(String AName) { int Result; Result = IndexOf(ItemByTableName(AName)); if (Result >= 0) { Delete(Result); } return Result; } public TRtSelFromItemClass ClassType() { return TRtSelFromItemClass.SINGLETON; } } public static final class TRtSelUnionItemClass extends TSQLNamedContainerItemClass { public static final TRtSelUnionItemClass SINGLETON = new TRtSelUnionItemClass(); public final TRtSelUnionItem CreateParented(TRtSelect AOwner) { return TRtSelUnionItem.CreateParented(AOwner); } public Class ClassInfo() { return TRtSelUnionItem.class; } } public static final class TRtSelUnionItem extends TSQLNamedContainerItem { private boolean FAll; private TRtSelect FSelect; public final void SetAll(boolean Value) { CheckUnprepare(); FAll = Value; } public final void SetSelect(TRtSelect Value) { int xDBVersionKind; CheckUnprepare(); if (FSelect == null) { if (Value != null) { xDBVersionKind = CheckOwnerSelect().getDBVersionKind(); if (xDBVersionKind == dbvkSenior && CheckOwnerSelect().GetOwnerConnection() != null) { xDBVersionKind = CheckOwnerSelect().GetOwnerConnection().getDBVersionKind(); } FSelect = ((TRtSelect) TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(sckSelect, xDBVersionKind)); FSelect.SetFOwner(this); } } if (Value == null) { if (FSelect != null) { FSelect.Free(); FSelect = null; } } else { FSelect.Assign(Value); } } protected final TRtSelect CheckOwnerSelect() { return ((TRtSelect) CheckTypedOwner(TRtSelectClass.SINGLETON)); } public final void runCreateParented(TRtSelect AOwner) { super.runCreate(); SetFOwner(AOwner); } public static TRtSelUnionItem CreateParented(TRtSelect AOwner) { TRtSelUnionItem Result; Result = new TRtSelUnionItem(); Result.runCreateParented(AOwner); return Result; } public void Destroy() { if (FSelect != null) { FSelect.Free(); } super.Destroy(); } public void Assign(TPersistent Source) { super.Assign(Source); if (Source instanceof TRtSelUnionItem) { FAll = ((TRtSelUnionItem) Source).FAll; SetSelect(((TRtSelUnionItem) Source).FSelect); } } public void ReadData(TReader Reader) { super.ReadData(Reader); { TReader context_Reader = Reader; FAll = context_Reader.ReadBoolean(); if (context_Reader.ReadBoolean()) { if (FSelect == null) { FSelect = ((TRtSelect) TRtDatabaseServerClass.SINGLETON.GlobalInstance().InstanceOfSQLClass(sckSelect, CheckOwnerSelect().getDBVersionKind())); FSelect.SetFOwner(this); } FSelect.ReadData(Reader); } else if (FSelect != null) { FSelect.Free(); FSelect = null; } } } public void WriteData(TWriter Writer) { boolean HasSelect; super.WriteData(Writer); { TWriter context_Writer = Writer; context_Writer.WriteBoolean(FAll); HasSelect = FSelect != null; context_Writer.WriteBoolean(HasSelect); if (HasSelect) { FSelect.WriteData(Writer); } } } public TRtSelUnionItemClass ClassType() { return TRtSelUnionItemClass.SINGLETON; } public boolean getAll() { return FAll; } public TRtSelect getSelect() { return FSelect; } } public static final class TRtSelOrderByItemClass extends TSQLKeyedContainerItemClass { public static final TRtSelOrderByItemClass SINGLETON = new TRtSelOrderByItemClass(); protected String GetKeyAsString(Object AKey) { return ((TRtSelColumnsItem) AKey).GetName(); } public final TRtSelOrderByItem CreateOrderByName(TRtSelOrderByList AOwner, String AColName, int AOrder) { return TRtSelOrderByItem.CreateOrderByName(AOwner, AColName, AOrder); } public final TRtSelOrderByItem CreateOrderByNumber(TRtSelOrderByList AOwner, int AColNumber, int AOrder) { return TRtSelOrderByItem.CreateOrderByNumber(AOwner, AColNumber, AOrder); } public Class ClassInfo() { return TRtSelOrderByItem.class; } } public static final class TRtSelOrderByItem extends TSQLKeyedContainerItem { protected int FOrder; protected TRtSelColumnsItem FColItem; protected final TRtSelColumnsItem GetItemByName(String AColName) { TRtSelColumnsItem Result; Result = CheckOwnerSelect().FColumns.ItemByAsName(AColName); if (Result == null) { Result = CheckOwnerSelect().FColumns.ItemByColumnName(AColName); } return Result; } protected String GetKeyAsString(Object AKey) { return ClassType().GetKeyAsString(AKey); } protected Object GetKey() { return FColItem; } public final int GetColumnNumber() { return CheckOwnerSelect().FColumns.IndexOf(FColItem) + 1; } protected final TRtSelect CheckOwnerSelect() { return ((TRtSelect) CheckTypedOwner(TRtSelectClass.SINGLETON)); } public final void runCreateOrderByName(TRtSelOrderByList AOwner, String AColName, int AOrder) { super.runCreate(); AOwner.AddItem(this); FColItem = GetItemByName(AColName); if (FColItem == null) { throw DelphiException.CreateFmt(TransStr("TC671", "Não existe coluna com este nome: \"%s\".", true), new Object[] { AColName }); } FOrder = AOrder; } public static TRtSelOrderByItem CreateOrderByName(TRtSelOrderByList AOwner, String AColName, int AOrder) { TRtSelOrderByItem Result; Result = new TRtSelOrderByItem(); Result.runCreateOrderByName(AOwner, AColName, AOrder); return Result; } public final void runCreateOrderByNumber(TRtSelOrderByList AOwner, int AColNumber, int AOrder) { super.runCreate(); if (AColNumber <= 0 || AColNumber > AOwner.CheckOwnerSelect().FColumns.GetCount()) { throw DelphiException.Create(TransStrFmt("TC3308", "Número de coluna fora dos limites: \"%d\".", new Object[] { AColNumber }, true)); } FColItem = AOwner.CheckOwnerSelect().FColumns.GetItem(AColNumber - 1); FOrder = AOrder; AOwner.AddItem(this); } public static TRtSelOrderByItem CreateOrderByNumber(TRtSelOrderByList AOwner, int AColNumber, int AOrder) { TRtSelOrderByItem Result; Result = new TRtSelOrderByItem(); Result.runCreateOrderByNumber(AOwner, AColNumber, AOrder); return Result; } public void Assign(TPersistent Source) { super.Assign(Source); if (Source instanceof TRtSelOrderByItem) { FColItem = GetItemByName(((TRtSelOrderByItem) Source).FColItem.GetName()); FOrder = ((TRtSelOrderByItem) Source).FOrder; } } public void ReadData(TReader Reader) { super.ReadData(Reader); { TReader context_Reader = Reader; FColItem = GetItemByName(context_Reader.ReadString()); context_Reader.Read(AsVar(FOrder), SizeOf(FOrder)); } } public void WriteData(TWriter Writer) { super.WriteData(Writer); { TWriter context_Writer = Writer; context_Writer.WriteString(FColItem.GetName()); context_Writer.Write(AsConst(FOrder), SizeOf(FOrder)); } } public TRtSelOrderByItemClass ClassType() { return TRtSelOrderByItemClass.SINGLETON; } public TRtSelColumnsItem getColumnItem() { return FColItem; } public int getOrder() { return FOrder; } } public static final class TRtSelOrderByListClass extends TSQLKeyedListOwnerClass { public static final TRtSelOrderByListClass SINGLETON = new TRtSelOrderByListClass(); public final TRtSelOrderByList CreateParented(TRtSelect AOwner) { return TRtSelOrderByList.CreateParented(AOwner); } public Class ClassInfo() { return TRtSelOrderByList.class; } } public static final class TRtSelOrderByList extends TSQLKeyedListOwner { protected TContainerItemClass AllocItemType() { return TRtSelOrderByItemClass.SINGLETON; } public final TRtSelOrderByItem GetItem(int Index) { return ((TRtSelOrderByItem) Get(Index)); } protected final TRtSelect CheckOwnerSelect() { return ((TRtSelect) CheckTypedOwner(TRtSelectClass.SINGLETON)); } public final void runCreateParented(TRtSelect AOwner) { super.runCreate(); SetFOwner(AOwner); } public static TRtSelOrderByList CreateParented(TRtSelect AOwner) { TRtSelOrderByList Result; Result = new TRtSelOrderByList(); Result.runCreateParented(AOwner); return Result; } public final void AddColumnByName(String AColName, int AOrder) { CheckUnprepare(); TRtSelOrderByItem.CreateOrderByName(this, AColName, AOrder); } public final void AddColumnByNumber(int AColNum, int AOrder) { CheckUnprepare(); TRtSelOrderByItem.CreateOrderByNumber(this, AColNum, AOrder); } public final void AddColumnsByNames(String AColNames, int AOrder) { TInt p = new TInt(); String s = ""; p.v = 0; s = StrGetNextToken(AColNames, p, ";"); while (!StrIsBlank(s)) { AddColumnByName(s, AOrder); s = StrGetNextToken(AColNames, p, ";"); } } public final void AddColumnsByNumbers(String AColNums, int AOrder) { TInt p = new TInt(); String s = ""; p.v = 0; s = StrGetNextToken(AColNums, p, ";"); while (!StrIsBlank(s)) { AddColumnByNumber(StrToInt(s), AOrder); s = StrGetNextToken(AColNums, p, ";"); } } public final TRtSelOrderByItem ItemByName(String AColName) { TRtSelOrderByItem Result; int i; for (i = 0; i <= GetCount() - 1; ++i) { if (CompareText(this.GetItem(i).FColItem.GetName(), AColName) == 0) { Result = this.GetItem(i); return Result; } } return null; } public final TRtSelOrderByItem ItemByNumber(int AColNum) { TRtSelOrderByItem Result; int i; for (i = 0; i <= GetCount() - 1; ++i) { if (this.GetItem(i).GetColumnNumber() == AColNum) { Result = this.GetItem(i); return Result; } } return null; } public final int RemoveByName(String AColName) { int Result; Result = IndexOf(ItemByName(AColName)); if (Result >= 0) { Delete(Result); } return Result; } public final int RemoveByNumber(int AColNum) { int Result; Result = IndexOf(ItemByNumber(AColNum)); if (Result >= 0) { Delete(Result); } return Result; } public TRtSelOrderByListClass ClassType() { return TRtSelOrderByListClass.SINGLETON; } } public static class TRtSelectClass extends TRtCustomSelectSQLClass { public static final TRtSelectClass SINGLETON = new TRtSelectClass(); public TRtSelect Create() { return TRtSelect.Create(); } public final TRtSelect CreateSQL(TRtDBConnection AConn) { return TRtSelect.CreateSQL(AConn); } public Class ClassInfo() { return TRtSelect.class; } } public static class TRtSelect extends TRtCustomSelectSQL { private final class GenBaseSQL_Context { private String Result = ""; private String ListColumns() { String Result = ""; int LastBreak; int I; String TableName = ""; String AsName = ""; String ColumnName = ""; Result = ""; LastBreak = 0; for (I = 0; I <= getColumns().GetCount() - 1; ++I) { if (LastBreak < I / 10 && I < getColumns().GetCount() - 1) { LastBreak = I / 10; Result = Result + SQL_EOL; } TableName = ""; ColumnName = ""; AsName = ""; if (!getColumns().GetItem(I).GetIsEnumDescription()) { if (!getColumns().GetItem(I).GetIsExp()) { if (!StrIsBlank(getColumns().GetItem(I).getFromItem().GetName())) { TableName = getColumns().GetItem(I).getFromItem().GetName(); } else { TableName = getColumns().GetItem(I).getFromItem().GetName(); } ColumnName = getColumns().GetItem(I).getColumnName(); AsName = getColumns().GetItem(I).GetName(); if (Pos(SQL_Point, ColumnName) == 0) { Result = Result + TableName + SQL_Point + ColumnName + SQL_Space + AsName; } else { Result = Result + ColumnName + SQL_Space + AsName; } } else { AsName = getColumns().GetItem(I).GetName(); ColumnName = TranslateExpression(TRtSelect.this, getColumns().GetItem(I).getExpTokens()); Result = Result + ColumnName + SQL_Space + AsName; } Result = TrimRight(Result) + ToStr(SQL_Comma); } } if (!Result.equals("")) { Result = Delete(Result, Length(Result), 1); } return Result; } private String ListVariables() { String Result = ""; int I; Result = ""; if (FInto.GetCount() > 0) { for (I = 0; I <= FInto.GetCount() - 1; ++I) { Result = Result + TranslateExpression(TRtSelect.this, FInto.GetItems(I).getTokens()) + ToStr(SQL_Comma); } Result = Delete(Result, Length(Result), 1); Result = SQL_Space + SQL_Into + Result; } return Result; } private String GetFrom() { String Result = ""; int I; Result = ""; for (I = 0; I <= getFrom().GetCount() - 1; ++I) { Result = Result + getFrom().GetItem(I).getTableName() + SQL_Space + getFrom().GetItem(I).GetName(); Result = TrimRight(Result) + ToStr(SQL_Comma); } if (Length(Result) > 0) { Result = Delete(Result, Length(Result), 1); Result = SQL_Space + SQL_From + Result; } return Result; } private String GetGroupByColumns() { String Result = ""; int I; String s = ""; Result = ""; for (I = 0; I <= getColumns().GetCount() - 1; ++I) { if (getColumns().GetItem(I).getIsGroupBy()) { Result = Result + getColumns().GetItem(I).getColumnName() + ToStr(SQL_Comma); } } if (Length(Result) != 0) { Result = Delete(Result, Length(Result), 1); Result = SQL_Space + SQL_GroupBy + Result; s = BreakLine(GetWhere(TRtSelect.this, getHaving())); if (!StrIsBlank(s)) { Result = Result + SQL_Space + SQL_Having + s; } } return Result; } private String GetUnionClause() { String Result = ""; Result = ""; if (getUnion().getSelect() != null) { Result = SQL_Union; if (getUnion().getAll()) { Result = Result + SQL_All; } Result = Result + SQL_LParenthesis + getUnion().getSelect().GetSQL() + ToStr(SQL_RParenthesis); } return Result; } private String GetOrderByColumns() { String Result = ""; int I; Result = ""; for (I = 0; I <= getOrderBy().GetCount() - 1; ++I) { if (getOrderBy().GetItem(I).GetColumnNumber() != -1) { Result = Result + IntToStr(getOrderBy().GetItem(I).GetColumnNumber()); } else if (Length(getOrderBy().GetItem(I).getColumnItem().GetName()) != 0) { Result = Result + getOrderBy().GetItem(I).getColumnItem().GetName(); } else { Result = Result + getOrderBy().GetItem(I).getColumnItem().getColumnName(); } if (getOrderBy().GetItem(I).getOrder() != risDesc) { Result = Result + SQL_Space + SQL_ASC; } else { Result = Result + SQL_Space + SQL_DESC; } Result = Result + ToStr(SQL_Comma); } if (Length(Result) != 0) { Result = Delete(Result, Length(Result), 1); Result = SQL_Space + SQL_OrderBy + Result; } return Result; } private String s = ""; public GenBaseSQL_Context() { } public String execute() { FixUnresolvedRefs(); Result = SQL_Select + BreakLine(ListColumns()) + BreakLine(ListVariables()) + BreakLine(GetFrom()); s = BreakLine(GetWhere(TRtSelect.this, getWhere())); if (!StrIsBlank(s)) { Result = Result + SQL_Space + SQL_Where + s; } Result = Result + BreakLine(GetGroupByColumns()) + BreakLine(GetUnionClause()) + BreakLine(GetOrderByColumns()); if (getForUpdate()) { Result = Result + SQL_Space + SQL_ForUpdate; } if (getUsesScriptTerminator()) { Result = Result + ToStr(SQL_ScriptTerminator); } return Result; } } private boolean FDistinct; public final void SetDistinct(boolean Value) { CheckUnprepare(); FDistinct = Value; } public boolean GetHasOperation() { return FColumns.GetCount() > 0 && FInto.GetCount() > 0; } protected TRtSelColumnsList FColumns; protected TRtExpressionList FInto; protected TRtSelFromItem FFrom; protected TRtWhereItem FWhere; protected TRtWhereItem FHaving; protected TRtSelUnionItem FUnion; protected TRtSelOrderByList FOrderBy; protected boolean FForUpdate; protected final void Init() { FColumns = ((TRtSelColumnsList) Creator(this, TRtSelColumnsListClass.SINGLETON)); FInto = ((TRtExpressionList) Creator(this, TRtExpressionListClass.SINGLETON)); FFrom = ((TRtSelFromItem) Creator(this, TRtSelFromItemClass.SINGLETON)); FWhere = ((TRtWhereItem) Creator(this, TRtWhereItemClass.SINGLETON)); FHaving = ((TRtWhereItem) Creator(this, TRtWhereItemClass.SINGLETON)); FUnion = ((TRtSelUnionItem) Creator(this, TRtSelUnionItemClass.SINGLETON)); FOrderBy = ((TRtSelOrderByList) Creator(this, TRtSelOrderByListClass.SINGLETON)); } protected final void AddParamsToOwnerSQLClass(TRtCustomSQL ASql) { int i; for (i = 0; i <= FInto.GetCount() - 1; ++i) { FInto.GetItems(i).AddParamsToOwnerSQLClass(ASql); } FWhere.AddParamsToOwnerSQLClass(ASql); FHaving.AddParamsToOwnerSQLClass(ASql); if (FUnion.getSelect() != null) { FUnion.getSelect().AddParamsToOwnerSQLClass(ASql); } } protected final void DropParamsFromOwnerSQLClass(TRtCustomSQL ASql) { int i; for (i = 0; i <= FInto.GetCount() - 1; ++i) { FInto.GetItems(i).DropParamsFromOwnerSQLClass(ASql); } FWhere.DropParamsFromOwnerSQLClass(ASql); FHaving.DropParamsFromOwnerSQLClass(ASql); if (FUnion.getSelect() != null) { FUnion.getSelect().DropParamsFromOwnerSQLClass(ASql); } } protected final void _CheckUnresolvedRefs(boolean LFix) { int i; i = 0; while (i < FColumns.GetCount()) { { TRtSelColumnsItem context_GetItem = FColumns.GetItem(i); if (context_GetItem.GetIsExp() || context_GetItem.GetIsEnumDescription()) { i++; continue; } context_GetItem.FFromItem = FFrom.ItemByAlias(context_GetItem.FFromAlias); if (context_GetItem.FFromItem == null) { context_GetItem.FFromItem = FFrom.ItemByTableName(context_GetItem.FFromAlias); } if (context_GetItem.FFromItem == null) { if (LFix) { FColumns.GetItem(i).Free(); } else { ErrRef(context_GetItem.FFromAlias); } } else { i++; } } } if (LFix) { _CheckForOuterJoins(); } } protected void _CheckForOuterJoins() { int i; TRtSQLTokenList ATokens; boolean LeftOJoin; boolean xTokenTypeIsConst; ATokens = FWhere.getTokens(); i = 0; while (i < ATokens.GetCount()) { if (ATokens.GetItem(i).getTokType() == rstOpSQLJoin) { if (ATokens.GetItem(i - 1).getTokType() == rstOpSQLOuterJoin) { SetOuterJoinForField(ATokens.GetItem(i - 2).getToken(), ATokens.GetItem(i - 2).getTokType(), ATokens.GetItem(i + 1).getToken(), ATokens.GetItem(i + 1).getTokType(), ojLeft); } if (i + 2 < ATokens.GetCount() && ATokens.GetItem(i + 2).getTokType() == rstOpSQLOuterJoin) { SetOuterJoinForField(ATokens.GetItem(i + 1).getToken(), ATokens.GetItem(i + 1).getTokType(), ATokens.GetItem(i - 1).getToken(), ATokens.GetItem(i - 1).getTokType(), ojRight); } } i++; } i = 0; while (i < ATokens.GetCount()) { xTokenTypeIsConst = i < ATokens.GetCount() - 1 && DelphiSet.get(rstConstBoolean, rstConstInt, rstConstFloat, rstConstDate, rstConstTime, rstConstDateTime, rstConstString, rstConstNull).contains(ATokens.GetItem(i + 1).getTokType()); if (ATokens.GetItem(i).getTokType() == rstOpSQLJoin && ATokens.GetItem(i - 1).getTokType() != rstOpSQLOuterJoin && (i + 2 >= ATokens.GetCount() || ATokens.GetItem(i + 2).getTokType() != rstOpSQLOuterJoin) && !xTokenTypeIsConst) { if (IsOuterJoinField(ATokens.GetItem(i - 1).getToken(), ATokens.GetItem(i - 1).getTokType())) { ATokens.InsertOuterJoin(i); i++; LeftOJoin = true; } else { LeftOJoin = false; } if (IsOuterJoinField(ATokens.GetItem(i + 1).getToken(), ATokens.GetItem(i + 1).getTokType())) { if (LeftOJoin) { throw DelphiException.Create(TransStr("TC672", "\"OUTER JOIN\" circular não suportado.", true)); } ATokens.InsertOuterJoin(i + 2); i++; } } i++; } } protected final TRtSelTableItem TableOfColumnRef(String aToken, int ATokType) { TRtSelTableItem Result; TRtSelColumnsItem ASelColItem; String s = ""; int APos; Result = null; s = ""; if (ATokType == rstIdColumn) { ASelColItem = FColumns.ItemByAsName(aToken); if (ASelColItem == null) { ASelColItem = FColumns.ItemByColumnName(aToken); } if (ASelColItem != null) { Result = ASelColItem.FFromItem; if (Result == null) { s = ASelColItem.FFromAlias; } else { return Result; } } else { return Result; } } else { APos = Pos(".", aToken); s = Copy(aToken, 1, APos - 1); } Result = FFrom.ItemByAlias(s); if (Result == null) { Result = FFrom.ItemByTableName(s); } return Result; } protected final boolean IsOuterJoinField(String aToken, int ATokType) { TRtSelTableItem ASelTblItem; ASelTblItem = TableOfColumnRef(aToken, ATokType); return ASelTblItem != null && ASelTblItem.FOuterJoin != null; } protected final void SetOuterJoinForField(String ALeftToken, int ALeftTokType, String ARightToken, int ARightTokType, int aOuterJoinOption) { TRtSelTableItem aLSelTblItem; TRtSelTableItem aRSelTblItem; aLSelTblItem = TableOfColumnRef(ALeftToken, ALeftTokType); aRSelTblItem = TableOfColumnRef(ARightToken, ARightTokType); if (aLSelTblItem != null && aLSelTblItem.getOuterJoin() == null && aRSelTblItem != null) { (((TRtSelFromItem) aLSelTblItem.GetFOwner())).OuterJoinTables(aLSelTblItem.GetName(), aRSelTblItem.GetName(), ALeftToken, ARightToken, aOuterJoinOption); } } protected final void _CheckUnresolvedRefsOnExpressions(TRtWhereItem AWhere, boolean LFix) { int i; TInt p = new TInt(); String AName = ""; i = 0; while (i < AWhere.FTokens.GetCount()) { { TRtSQLTokenItem context_GetItem = AWhere.FTokens.GetItem(i); if (context_GetItem.getTokType() == rstIdTableColumn) { p.v = 0; AName = StrGetNextToken(context_GetItem.getToken(), p, '.'); if (FFrom.ItemByAlias(AName) == null && FFrom.ItemByTableName(AName) == null && OwnerSQLToAlias(AName) == null) { ErrRef(AName); } else { i++; } } else { i++; } } } } protected final TRtCustomSQL OwnerSQLToAlias(String AAlias) { TRtCustomSQL Result; TRtCustomSQL AOwner; Result = null; AOwner = ((TRtCustomSQL) GetTypedOwner(TRtCustomSQLClass.SINGLETON)); if (AOwner instanceof TRtSelect) { if (((TRtSelect) AOwner).FFrom.ItemByAlias(AAlias) != null || ((TRtSelect) AOwner).FFrom.ItemByTableName(AAlias) != null) { Result = AOwner; } else { Result = ((TRtSelect) AOwner).OwnerSQLToAlias(AAlias); } } else if (AOwner instanceof TRtAliasedTableSQL) { if (CompareText(((TRtAliasedTableSQL) AOwner).getAlias(), AAlias) == 0 || CompareText(((TRtAliasedTableSQL) AOwner).GetName(), AAlias) == 0) { Result = AOwner; } } else if (AOwner instanceof TRtAliasedTableSQL) { if (CompareText(((TRtAliasedTableSQL) AOwner).GetName(), AAlias) == 0) { Result = AOwner; } } return Result; } protected final void ErrRef(String AName) { throw DelphiException.CreateFmt(TransStr("TC673", "Referência para \"%s\", não encontrada.", true), new Object[] { AName }); } protected String GenSQL() { return GenBaseSQL(); } public String GenBaseSQL() { GenBaseSQL_Context ctx = new GenBaseSQL_Context(); return ctx.execute(); } public final void SetForUpdate(boolean Value) { CheckUnprepare(); if (GetTypedOwner(TRtCustomSQLClass.SINGLETON) != null) { FForUpdate = false; } else { FForUpdate = Value; } } public final boolean GetIsSubQuery() { return GetRootSQL() != null; } protected String GetDistinct() { String Result = ""; if (FDistinct) { Result = "DISTINCT"; } else { Result = ""; } return Result; } public void runCreate() { super.runCreate(); Init(); } public static TRtSelect Create() { TRtSelect Result; Result = new TRtSelect(); Result.runCreate(); return Result; } public final void runCreateSQL(TRtDBConnection AConn) { super.runCreateSQL(AConn); Init(); } public static TRtSelect CreateSQL(TRtDBConnection AConn) { TRtSelect Result; Result = new TRtSelect(); Result.runCreateSQL(AConn); return Result; } public void Destroy() { FFrom.Free(); FColumns.Free(); FInto.Free(); FWhere.Free(); FHaving.Free(); FUnion.Free(); FOrderBy.Free(); super.Destroy(); } public final void CheckUnresolvedRefs() { _CheckUnresolvedRefs(false); } public final void FixUnresolvedRefs() { _CheckUnresolvedRefs(true); } public void Assign(TPersistent Source) { FAssigning++; try { super.Assign(Source); if (Source instanceof TRtSelect) { FDistinct = ((TRtSelect) Source).FDistinct; FFrom.Assign(((TRtSelect) Source).FFrom); FWhere.Assign(((TRtSelect) Source).FWhere); FColumns.Assign(((TRtSelect) Source).FColumns); FInto.Assign(((TRtSelect) Source).FInto); FUnion.Assign(((TRtSelect) Source).FUnion); FOrderBy.Assign(((TRtSelect) Source).FOrderBy); SetForUpdate(((TRtSelect) Source).FForUpdate); } } finally { FAssigning--; } } public void ReadData(TReader Reader) { FAssigning++; try { super.ReadData(Reader); FDistinct = Reader.ReadBoolean(); FFrom.ReadData(Reader); FWhere.ReadData(Reader); FColumns.ReadData(Reader); FInto.ReadData(Reader); FUnion.ReadData(Reader); FOrderBy.ReadData(Reader); SetForUpdate(Reader.ReadBoolean()); } finally { FAssigning--; } } public void WriteData(TWriter Writer) { super.WriteData(Writer); Writer.WriteBoolean(FDistinct); FFrom.WriteData(Writer); FWhere.WriteData(Writer); FColumns.WriteData(Writer); FInto.WriteData(Writer); FUnion.WriteData(Writer); FOrderBy.WriteData(Writer); AddParamsToOwnerSQLClass(null); Writer.WriteBoolean(FForUpdate); } public TRtSelectClass ClassType() { return TRtSelectClass.SINGLETON; } public boolean getDistinct() { return FDistinct; } public TRtSelColumnsList getColumns() { return FColumns; } public TRtExpressionList getInto() { return FInto; } public TRtSelFromItem getFrom() { return FFrom; } public TRtWhereItem getWhere() { return FWhere; } public TRtWhereItem getHaving() { return FHaving; } public TRtSelUnionItem getUnion() { return FUnion; } public TRtSelOrderByList getOrderBy() { return FOrderBy; } public boolean getForUpdate() { return FForUpdate; } } public static class TRtCustomStorageClass extends TClass { public static final TRtCustomStorageClass SINGLETON = new TRtCustomStorageClass(); public TRtCustomStorage Create(TRtCustomStorageList _Owner) { return TRtCustomStorage.Create(_Owner); } public Class ClassInfo() { return TRtCustomStorage.class; } } public static class TRtCustomStorage extends TObject { private TRtCustomStorageList FOwner; public final String GetName() { String Result = ""; int i; Result = ""; if (FOwner != null) { i = FOwner.FStorageList.IndexOfObject(this); if (i >= 0) { Result = FOwner.FStorageList.Get(i); } } return Result; } public String GetGeneralInfo() { return ""; } public void runCreate(TRtCustomStorageList _Owner) { super.runCreate(); FOwner = _Owner; } public static TRtCustomStorage Create(TRtCustomStorageList _Owner) { TRtCustomStorage Result; Result = new TRtCustomStorage(); Result.runCreate(_Owner); return Result; } public TRtCustomStorageClass ClassType() { return TRtCustomStorageClass.SINGLETON; } } public static final class TRtCustomStorageListClass extends TClass { public static final TRtCustomStorageListClass SINGLETON = new TRtCustomStorageListClass(); public TRtCustomStorageList Create(TRtDBConnection _Owner) { return TRtCustomStorageList.Create(_Owner); } public Class ClassInfo() { return TRtCustomStorageList.class; } } public static final class TRtCustomStorageList extends TObject { TStringList FStorageList; public final TRtCustomStorage GetStorages(int _index) { return ((TRtCustomStorage) FStorageList.GetObject(_index)); } public final int GetCount() { return FStorageList.GetCount(); } public void runCreate(TRtDBConnection _Owner) { super.runCreate(); FStorageList = TStringList.Create(); FStorageList.SetSorted(true); FStorageList.setDuplicates(dupError); } public static TRtCustomStorageList Create(TRtDBConnection _Owner) { TRtCustomStorageList Result; Result = new TRtCustomStorageList(); Result.runCreate(_Owner); return Result; } public void Destroy() { super.Destroy(); ClearStorageList(); FStorageList.Free(); } public final TRtCustomStorage StorageByName(String _name) { TRtCustomStorage Result; int i; i = FStorageList.IndexOf(_name); if (i < 0) { Result = null; } else { Result = ((TRtCustomStorage) FStorageList.GetObject(i)); } return Result; } public final int Add(String _identity, TRtCustomStorage _CustomStorage) { int Result; try { Result = FStorageList.AddObject(_identity, _CustomStorage); } catch (DelphiException e) { throw DelphiException.Create(TransStrFmt("TC6907", "Erro ao carregar storage do objeto %s: %s", new Object[] { _identity, e.getMessage() })); } return Result; } public final void Delete(String _identity) { int i; i = FStorageList.IndexOf(_identity); if (i > -1) { FStorageList.Delete(i); } } public final void ClearStorageList() { int i; for (i = 0; i <= FStorageList.GetCount() - 1; ++i) { ((TObject) FStorageList.GetObject(i)).Free(); } FStorageList.Clear(); } public final boolean HasStorage() { return FStorageList.GetCount() > 0; } public TRtCustomStorageListClass ClassType() { return TRtCustomStorageListClass.SINGLETON; } } public static class TRtCustomTablePrivilegesClass extends TClass { public static final TRtCustomTablePrivilegesClass SINGLETON = new TRtCustomTablePrivilegesClass(); public final TRtCustomTablePrivileges Create(TRtCustomTablePrivilegesList aOwner) { return TRtCustomTablePrivileges.Create(aOwner); } public Class ClassInfo() { return TRtCustomTablePrivileges.class; } } public static class TRtCustomTablePrivileges extends TObject { private TRtCustomTablePrivilegesList FOwner; public final String GetName() { String Result = ""; int xIndex; Result = ""; if (FOwner != null) { xIndex = FOwner.FPrivilegesList.IndexOfObject(this); if (xIndex >= 0) { Result = FOwner.FPrivilegesList.Get(xIndex); } } return Result; } public final void runCreate(TRtCustomTablePrivilegesList aOwner) { super.runCreate(); FOwner = aOwner; } public static TRtCustomTablePrivileges Create(TRtCustomTablePrivilegesList aOwner) { TRtCustomTablePrivileges Result; Result = new TRtCustomTablePrivileges(); Result.runCreate(aOwner); return Result; } public TRtCustomTablePrivilegesClass ClassType() { return TRtCustomTablePrivilegesClass.SINGLETON; } } public static final class TRtCustomTablePrivilegesListClass extends TClass { public static final TRtCustomTablePrivilegesListClass SINGLETON = new TRtCustomTablePrivilegesListClass(); public final TRtCustomTablePrivilegesList Create() { return TRtCustomTablePrivilegesList.Create(); } public Class ClassInfo() { return TRtCustomTablePrivilegesList.class; } } public static final class TRtCustomTablePrivilegesList extends TObject { TStringList FPrivilegesList; public final void runCreate() { super.Create(); FPrivilegesList = TStringList.Create(); FPrivilegesList.SetSorted(true); FPrivilegesList.setDuplicates(dupError); } public static TRtCustomTablePrivilegesList Create() { TRtCustomTablePrivilegesList Result; Result = new TRtCustomTablePrivilegesList(); Result.runCreate(); return Result; } public void Destroy() { ClearPrivilegesList(); FPrivilegesList.Destroy(); super.Destroy(); } public final void ClearPrivilegesList() { int i; for (i = 0; i <= FPrivilegesList.GetCount() - 1; ++i) { ((TObject) FPrivilegesList.GetObject(i)).Free(); } FPrivilegesList.Clear(); } public final int Add(String aTableName, TRtCustomTablePrivileges aCustomPrivileges) { return FPrivilegesList.AddObject(aTableName, aCustomPrivileges); } public final TRtCustomTablePrivileges PrivilegesByTableName(String aTableName) { TRtCustomTablePrivileges Result; int i; i = FPrivilegesList.IndexOf(aTableName); if (i < 0) { Result = null; } else { Result = ((TRtCustomTablePrivileges) FPrivilegesList.GetObject(i)); } return Result; } public TRtCustomTablePrivilegesListClass ClassType() { return TRtCustomTablePrivilegesListClass.SINGLETON; } } private static final class CompileViewSelect_Context { private final TRtDatabaseDef aDataBaseDef; private final String aViewName; private final String aSelect_SeniorSQL_2; private TSQLStatement Result; private final static String cCreateView = "CREATE VIEW %s AS %s"; private TSQLWorks xSQLWorks; public CompileViewSelect_Context(TRtDatabaseDef aDataBaseDef, String aViewName, String aSelect_SeniorSQL_2) { this.aDataBaseDef = aDataBaseDef; this.aViewName = aViewName; this.aSelect_SeniorSQL_2 = aSelect_SeniorSQL_2; } public TSQLStatement execute() { xSQLWorks = TSQLWorks.Create(aDataBaseDef); try { Result = xSQLWorks.CompileStatement(Format(cCreateView, new Object[] { aViewName, aSelect_SeniorSQL_2 })); } finally { xSQLWorks.Free(); } return Result; } } private static final class TInsSelFieldPairsClass extends TClass { public static final TInsSelFieldPairsClass SINGLETON = new TInsSelFieldPairsClass(); public final TInsSelFieldPairs Create() { return TInsSelFieldPairs.Create(); } public Class ClassInfo() { return TInsSelFieldPairs.class; } } private static final class TInsSelFieldPairs extends TObject { public TStringList Ins; public TStringList Sel; public final void runCreate() { super.runCreate(); Ins = TStringList.Create(); Sel = TStringList.Create(); } public static TInsSelFieldPairs Create() { TInsSelFieldPairs Result; Result = new TInsSelFieldPairs(); Result.runCreate(); return Result; } public void Destroy() { Ins.Free(); Sel.Free(); super.Destroy(); } public TInsSelFieldPairsClass ClassType() { return TInsSelFieldPairsClass.SINGLETON; } } static final class TAuxAddField { public TList List; public TRtDatabaseDef Database; final void assign(TAuxAddField other) { List = other.List; Database = other.Database; } public TAuxAddField(TList List, TRtDatabaseDef Database) { this.List = List; this.Database = Database; } public TAuxAddField() { } } private static final class DoVisitFindFields_Context { private final TAuxAddField aAuxAddField; private final int aObjType; private final Object aObj; private void AddField(TRtFieldDef aField) { if (aAuxAddField.List.IndexOf(aField) == -1) { aAuxAddField.List.Add(aField); } } public DoVisitFindFields_Context(TAuxAddField aAuxAddField, int aObjType, Object aObj) { this.aAuxAddField = aAuxAddField; this.aObjType = aObjType; this.aObj = aObj; } public void execute() { switch (aObjType) { case cST_NameExpr: AddField(aAuxAddField.Database.CheckRowSetByName(((TNameExpr) aObj).Table.Name).CheckFieldByName(((TNameExpr) aObj).Name)); break; case cST_QualifiedNameExpr: AddField(aAuxAddField.Database.CheckRowSetByName(((TQualifiedNameExpr) aObj).Table.Name).CheckFieldByName(((TQualifiedNameExpr) aObj).Name)); break; default: break; } } } private static final class TranslateExpression_Context { private final TRtCustomSQL SQL; private final TRtSQLTokenList TokenList; private String Result = ""; private String TranslateToken(TRtSQLTokenList TokenList, int i) { String Result = ""; TRtSQLTokenItem AToken; AToken = TokenList.GetItem(i); Result = ""; long switcher = AToken.getTokType(); if (switcher >= rstOpLogOr && switcher <= rstOpLogNot) { Result = EOL + AToken.getToken(); } else if (switcher == rstIdParamSubQuery) { Result = ToStr(SQL_Space) + SQL.GetSelectParams().ItemByName(AToken.getToken()).GetSelect().GetSQL(); } else if (switcher == rstConstString) { Result = '\'' + AToken.getToken() + "'"; } else if (switcher == rstConstDate) { Result = SQL_Convert + SQL_LParenthesis + SQLCharToDate + SQL_Comma + SQL_Quotes + AToken.getToken() + SQL_Quotes + ToStr(SQL_RParenthesis); } else if (switcher == rstOpColon) { if (i + 1 >= TokenList.GetCount() || TokenList.GetItem(i).getTokType() != rstOpGroupLeft) { Result = ToStr(SQL_Space) + AToken.getToken(); } } else { Result = ToStr(SQL_Space) + AToken.getToken(); } return Result; } private int i; public TranslateExpression_Context(TRtCustomSQL SQL, TRtSQLTokenList TokenList) { this.SQL = SQL; this.TokenList = TokenList; } public String execute() { Result = ""; for (i = 0; i <= TokenList.GetCount() - 1; ++i) { Result = Result + TranslateToken(TokenList, i); } return TrimLeft(Result); } } static final class TParallelTimerClass extends TClass { public static final TParallelTimerClass SINGLETON = new TParallelTimerClass(); final TParallelTimer CreateTimer(TRtDBConnection aConnection) { return TParallelTimer.CreateTimer(aConnection); } public Class ClassInfo() { return TParallelTimer.class; } } static final class TParallelTimer extends TObject { private TRtDBConnection FConnection; protected final void runCreateTimer(TRtDBConnection aConnection) { // super.runCreate(Application); // SetEnabled(true); // SetInterval(StrToInt(aConnection.getParam().GetValues(cParallelConTimmer)) * 1000); // FConnection = aConnection; // SetOnTimer(FreeConn); throw pending(); } static TParallelTimer CreateTimer(TRtDBConnection aConnection) { TParallelTimer Result; Result = new TParallelTimer(); Result.runCreateTimer(aConnection); return Result; } final void FreeConn(TObject Sender) { FConnection.FParallelTimer = null; FConnection.FParallelConn = null; Destroy(); } public TParallelTimerClass ClassType() { return TParallelTimerClass.SINGLETON; } } public final static String cREPLG6Prefix = "REPL_G6_"; public final static byte cReplG6OpInsert = 0; public final static byte cReplG6OpUpdate = 1; public final static byte cReplG6OpDelete = 2; public final static int rroNone = 0; public final static int rroCascade = 1; public final static int rroRestrict = 2; public final static int Low_TRtRIntOtion = 0; public final static int High_TRtRIntOtion = 2; public final static int rcaAdd = 0; public final static int rcaModify = 1; public final static int rcaDrop = 2; public final static int Low_TRtCrtAltOption = 0; public final static int High_TRtCrtAltOption = 2; public final static int raaColumns = 0; public final static int raaPrimaryKey = 1; public final static int raaUniqueKeys = 2; public final static int raaIndexes = 3; public final static int raaUniqueConstraints = 4; public final static int raaTriggers = 5; public final static int raaForeignKeys = 6; public final static int raaViews = 7; public final static int raaStoredProcedures = 8; public final static int Low_TRtCrtAltAssignOption = 0; public final static int High_TRtCrtAltAssignOption = 8; public final static int tilDirtyRead = 0; public final static int tilReadCommitted = 1; public final static int tilRepeatableRead = 2; public final static int Low_TRtTransIsolationLevel = 0; public final static int High_TRtTransIsolationLevel = 2; public final static int spmIndividual = 0; public final static int spmGroup = 1; public final static int Low_TRtSQLProcessMode = 0; public final static int High_TRtSQLProcessMode = 1; public final static int atmAlterTable = 0; public final static int atmInsertIntoSelect = 1; public final static int atmCustomDB = 2; public final static int atmCursor = 3; public final static int Low_TRtAlterTableMode = 0; public final static int High_TRtAlterTableMode = 3; public final static int latmDefault = 0; public final static int latmMaxRestriction = 1; public final static int Low_TRtLevelAlterTableMode = 0; public final static int High_TRtLevelAlterTableMode = 1; public final static int atsNone = 0; public final static int atsDropTriggers = 1; public final static int atsDropFks = 2; public final static int atsRenameTable = 3; public final static int atsRecreateTable = 4; public final static int atsMoveData = 5; public final static int atsDropOldTable = 6; public final static int atsCreatePkIdxInNewTable = 7; public final static int atsRecreateFks = 8; public final static int atsRecreateTriggers = 9; public final static int atsCustomAlterTable_1 = 10; public final static int atsCustomAlterTable_Data = 11; public final static int atsCustomAlterTable_3 = 12; public final static int atsAlterTable = 13; public final static int atsAllSteps = 14; public final static int Low_TRtAlterTableStep = 0; public final static int High_TRtAlterTableStep = 14; public final static int cgsoColumnName = 0; public final static int cgsoColumnType = 1; public final static int cgsoColumnNotNull = 2; public final static int cgsoColumnStorage = 3; public final static int Low_TRtColumnGenSqlOption = 0; public final static int High_TRtColumnGenSqlOption = 3; public final static int sckCreateTable = 0; public final static int sckAlterTable = 1; public final static int sckCreateIndex = 2; public final static int sckDropIndex = 3; public final static int sckCreateTrigger = 4; public final static int sckDropTrigger = 5; public final static int sckCreateProcedure = 6; public final static int sckDropProcedure = 7; public final static int sckCreateView = 8; public final static int sckDropView = 9; public final static int sckDropTable = 10; public final static int sckRenameTable = 11; public final static int sckBeginTran = 12; public final static int sckSetTransaction = 13; public final static int sckSavePoint = 14; public final static int sckRollBack = 15; public final static int sckCommit = 16; public final static int sckDeleteFrom = 17; public final static int sckInsertSelectInto = 18; public final static int sckInsertInto = 19; public final static int sckUpdate = 20; public final static int sckSelect = 21; public final static int Low_TRtSQLClassesKind = 0; public final static int High_TRtSQLClassesKind = 21; public final static int soValid = 0; public final static int soInvalid = 1; public final static int soInexist = 2; public final static int Low_TDBStatusObjects = 0; public final static int High_TDBStatusObjects = 2; public final static int otStoredProc = 0; public final static int otTrigger = 1; public final static int otView = 2; public final static int Low_TDBObjectType = 0; public final static int High_TDBObjectType = 2; public final static int cpiUseNewOperationKind = 0; public final static int cpiKeepTablesPrivileges = 1; public final static int cpiNeedRecreateSPs = 2; public final static int cpiInConsistBase = 3; public final static int Low_TCnvPropIDs = 0; public final static int High_TCnvPropIDs = 3; public final static int ojLeft = 0; public final static int ojRight = 1; public final static int ojFull = 2; public final static int Low_TOuterJoinOption = 0; public final static int High_TOuterJoinOption = 2; public static TRtDBConnection GetDefaultDatabaseConnection() { TRtDBConnection Result; TRtDatabaseServer xServer; Result = null; xServer = TRtDatabaseServerClass.SINGLETON.GlobalInstance(); if (xServer != null && xServer.FDBConnections.GetCount() > 0) { Result = ((TRtDBConnection) xServer.FDBConnections.Get(0)); } Assert(Result != null, "GetDefaultDatabaseConnection = nil"); return Result; } public static TRtFullSessionDef GetDefaultSessionDef() { return ((TRtFullSessionDef) GetDefaultDatabaseConnection().getPhyDatabase().GetSession()); } public static TRtFullDatabaseDef GetDefaultDatabaseDef() { return ((TRtFullDatabaseDef) GetDefaultDatabaseConnection().getPhyDatabase()); } public static TRtFullDatabaseDef GetDefaultNewDatabaseDef() { return ((TRtFullDatabaseDef) GetDefaultDatabaseConnection().GetNewDatabase()); } public static void LoadReferencedFieldListFromSelectStmt(TRtDatabaseDef aDatabaseDef, TSelect aSelect, TList aFieldList) { TAuxAddField xAuxAddField = new TAuxAddField(); xAuxAddField.List = aFieldList; xAuxAddField.Database = aDatabaseDef; TVisitProc proc = new TVisitProc() { public void run(Object aData, int aObjType, Object aObj, TBoolean aGoDown) { DoVisitFindFields((TAuxAddField) aData, aObjType, aObj); } }; VisitSelect(aSelect, proc, xAuxAddField); } public static TSQLStatement CompileViewSelect(TRtDatabaseDef aDataBaseDef, String aViewName, String aSelect_SeniorSQL_2) { CompileViewSelect_Context ctx = new CompileViewSelect_Context(aDataBaseDef, aViewName, aSelect_SeniorSQL_2); return ctx.execute(); } public static TSQLStatement CompileViewSelectWithUpdSelect(TRtDatabaseDef aDataBaseDef, String aViewName, TString aSelect_SeniorSQL_2) { TSQLStatement Result; TStatement aStatement = new TStatement(); Result = CompileViewSelect(aDataBaseDef, aViewName, aSelect_SeniorSQL_2.v); try { aStatement.Kind = skSelect; aStatement.Select = Result.getStatement().CreateView.Select; aSelect_SeniorSQL_2.v = TRtSeniorSqlGeneratorClass.SINGLETON.GenerateStatement(aStatement); } catch (Throwable any) { Result.Free(); throw wrap(any); } return Result; } public static int OptionalType(int AType) { return (int) ((int) AType | RT_OPTIONAL_PARAM); } public static String GetStrFromListWithZeros(TStrings List) { String Result = ""; int i; Result = List.GetTextStr(); i = Pos("\0", Result); while (i > 0) { Result = Delete(Result, i, 1); i = Pos("\0", Result); } return Result; } public static void SetSessIdParam(IRtDBParam aParam, double aValue) { if (Frac(aValue) == 0 && aValue < MaxInt) { aParam.SetAsInteger((int) Trunc(aValue)); } else { aParam.SetAsFloat(aValue); } } public static TOnNotifyDBConnection vOnCreateDBConnection = null; public static TOnNotifyDBConnection vOnDestroyDBConnection = null; public final static String cDefaultDbConnectionName = "DefaultDbConnecion"; public final static String cDefaultDatabaseDefName = "Base_Padrao"; public final static String cParamNameErrorLineCountInSPMoveData = "aErrorLineCount"; public final static String SQLYearPart = "yy"; public final static String SQLMonthPart = "mm"; public final static String SQLDayPart = "dd"; public final static String SQLHourPart = "hh"; public final static String SQLMinutePart = "mi"; public final static String SQLSecondsPart = "ss"; public final static String SQLCharToNumber = "CHAR_TO_NUMBER"; public final static String SQLCharToDate = "CHAR_TO_DATE"; public final static String SQLNumberToChar = "NUMBER_TO_CHAR"; public final static String SQLDateToChar = "DATE_TO_CHAR"; public final static String SQL_Convert = "CONVERT"; public final static String SQLEOC_SEP = "\u0001"; private final static int NUM_DATA_VERSION1 = 0x19980330; private final static int CUR_DATA_VERSION = NUM_DATA_VERSION1; private final static int WRITE_VERSION = CUR_DATA_VERSION; private final static String STORED_PROC_ERR_MESS = "Atualmente, este comando só é suportado dentro de STORED PROCEDURES!"; private final static String EOL = "\r\n"; private final static String SQL_EOL = "\r\n "; private final static char SQL_Space = ' '; private final static char SQL_LParenthesis = '('; private final static char SQL_RParenthesis = ')'; private final static char SQL_Comma = ','; private final static char SQL_Quotes = '\''; private final static String SQL_True = "TRUE"; private final static String SQL_FALSE = "FALSE"; private final static char SQL_ScriptTerminator = ';'; private final static char SQL_DecimalSeparator = '.'; private final static char SQL_Point = '.'; private final static String SQL_DeleteFrom = "DELETE FROM "; private final static String SQL_InsertInto = "INSERT INTO "; private final static String SQL_Update = "UPDATE "; private final static String SQL_Select = "SELECT "; private final static String SQL_Set = " SET "; private final static String SQL_Values = " VALUES "; private final static String SQL_CurrentOf = "CURRENT OF "; private final static String SQL_Where = "WHERE "; private final static String SQL_Having = "HAVING "; private final static String SQL_From = "FROM "; private final static String SQL_Into = "INTO "; private final static String SQL_GroupBy = "GROUP BY "; private final static String SQL_OrderBy = "ORDER BY "; private final static String SQL_ForUpdate = "FOR UPDATE"; private final static String SQL_Union = "UNION "; private final static String SQL_All = "ALL "; private final static String SQL_ASC = "ASC"; private final static String SQL_DESC = "DESC"; private final static String SQL_Create = "CREATE"; private final static String SQL_View = "VIEW"; private final static String SQL_As = "AS"; private final static String SQL_Drop = "DROP"; private final static String SQL_NULL = "NULL"; private final static String SQL_NOT = "NOT"; private final static String SQL_NOTNULL = SQL_NOT + SQL_Space + SQL_NULL; static TRtDatabaseServer vDBServer = null; private final static int RT_OPTIONAL_PARAM = 0x8000; static String GetATOperation(int aAlterTableStep, Object[] aNames) { String Result = ""; switch (aAlterTableStep) { case atsNone: Result = ""; break; case atsDropTriggers: Result = TransStrFmt("TC3284", "Apagando triggers(s) da tabela %s", aNames); break; case atsDropFks: Result = TransStrFmt("TC3285", "Apagando chave(s) estrangeira(s) da tabela %s", aNames); break; case atsRenameTable: Result = TransStrFmt("TC3286", "Renomeando tabela %s", aNames); break; case atsRecreateTable: Result = TransStrFmt("TC3287", "Criando nova tabela %s", aNames); break; case atsMoveData: Result = TransStrFmt("TC3288", "Movendo dados da tabela %s", aNames); break; case atsDropOldTable: Result = TransStrFmt("TC3289", "Apagando tabela %s", aNames); break; case atsCreatePkIdxInNewTable: Result = TransStrFmt("TC5144", "Criando chave primária e índice(s) na tabela %s", aNames); break; case atsRecreateFks: Result = TransStrFmt("TC3290", "Criando chave(s) estrangeira(s) da tabela %s", aNames); break; case atsRecreateTriggers: Result = TransStrFmt("TC3291", "Criando triggers(s) da tabela %s", aNames); break; case atsCustomAlterTable_1: case atsCustomAlterTable_Data: case atsCustomAlterTable_3: Result = TransStrFmt("TC427", "Alteração personalizada pelo banco na tabela %s", aNames); break; case atsAlterTable: Result = TransStrFmt("TC3292", "Alterando tabela %s", aNames); break; case atsAllSteps: Result = TransStrFmt("TC3292", "Alterando tabela %s", aNames); break; default: break; } return Result; } static void DoVisitFindFields(TAuxAddField aAuxAddField, int aObjType, Object aObj) { DoVisitFindFields_Context ctx = new DoVisitFindFields_Context(aAuxAddField, aObjType, aObj); ctx.execute(); } public static TRtSQLTokenList CompileSQLExp(String AExp, TString AParams, boolean LCondition) { TRtSQLTokenList ATokens; TRtSQLCompiler AC; AC = TRtSQLCompiler.Create(); try { ATokens = null; try { if (!LCondition) { ATokens = AC.CompileExpression(AExp); } else { ATokens = AC.CompileCondition(AExp); } if (ATokens != null && AParams != null) { AParams.v = ATokens.GetEncodedParams(); } } catch (Throwable any) { ATokens.Free(); throw wrap(any); } } finally { AC.Free(); } return ATokens; } static void ParseColName(String ASrcName, TString ATblName, TRtSQLTokenList ATokens) { TInt p = new TInt(); String AColName = ""; ATokens = CompileSQLExp(ASrcName, null, false); if (ATokens != null) { if (ATokens.GetCount() == 1) { { TRtSQLTokenItem context_GetItem = ATokens.GetItem(0); if (context_GetItem.getTokType() == rstIdColumn) { ATblName.v = ""; ATokens.Free(); ATokens = null; } else if (DelphiSet.get(rstIdTableColumn, rstIdSchemaTableColumn).contains(context_GetItem.getTokType())) { AColName = context_GetItem.getToken(); p.v = 0; if (context_GetItem.getTokType() == rstIdSchemaTableColumn) { StrGetNextToken(AColName, p, '.'); } ATblName.v = StrGetNextToken(AColName, p, '.'); ATokens.Free(); ATokens = null; } } } } else { AColName = ASrcName; if (Pos('.', AColName) > 0) { p.v = 0; ATblName.v = StrGetNextToken(AColName, p, '.'); ASrcName = StrGetNextToken(AColName, p, '.'); if (!StrIsBlank(ASrcName) && p.v != -1) { ATblName.v = ASrcName; } } else { ATblName.v = ""; } } } private static TRtSQLFunctionTableList GetSQL92FunctionList() { TRtSQLFunctionTableList Result; Result = TRtSQLFunctionTableList.Create(); try { (((TRtSQLFunctionTableItem) Result.AddNewItem("MAX"))).AddTypes(new int[] { rftUnknown, rftUnknown }); (((TRtSQLFunctionTableItem) Result.AddNewItem("MIN"))).AddTypes(new int[] { rftUnknown, rftUnknown }); (((TRtSQLFunctionTableItem) Result.AddNewItem("COUNT"))).AddTypes(new int[] { rftUnknown, rftUnknown }); (((TRtSQLFunctionTableItem) Result.AddNewItem("AVG"))).AddTypes(new int[] { rftUnknown, rftUnknown }); (((TRtSQLFunctionTableItem) Result.AddNewItem("SUM"))).AddTypes(new int[] { rftUnknown, rftUnknown }); (((TRtSQLFunctionTableItem) Result.AddNewItem("CONCAT"))).AddTypes(new int[] { rftString, rftString, rftString }); (((TRtSQLFunctionTableItem) Result.AddNewItem("DIFFERENCE"))).AddTypes(new int[] { rftString, rftString, rftString }); (((TRtSQLFunctionTableItem) Result.AddNewItem("INSERT"))).AddTypes(new int[] { rftString, rftString, rftNumber, rftNumber, rftString }); (((TRtSQLFunctionTableItem) Result.AddNewItem("LCASE"))).AddTypes(new int[] { rftString, rftString }); (((TRtSQLFunctionTableItem) Result.AddNewItem("LEFT"))).AddTypes(new int[] { rftString, rftString, rftNumber }); (((TRtSQLFunctionTableItem) Result.AddNewItem("LENGTH"))).AddTypes(new int[] { rftNumber, rftString }); (((TRtSQLFunctionTableItem) Result.AddNewItem("LOCATE"))).AddTypes(new int[] { rftNumber, rftString, rftString, OptionalType(rftNumber) }); (((TRtSQLFunctionTableItem) Result.AddNewItem("LTRIM"))).AddTypes(new int[] { rftString, rftString }); (((TRtSQLFunctionTableItem) Result.AddNewItem("REPEAT"))).AddTypes(new int[] { rftString, rftString, rftNumber }); (((TRtSQLFunctionTableItem) Result.AddNewItem("REPLACE"))).AddTypes(new int[] { rftString, rftString, rftString, rftString }); (((TRtSQLFunctionTableItem) Result.AddNewItem("RIGHT"))).AddTypes(new int[] { rftString, rftString, rftNumber }); (((TRtSQLFunctionTableItem) Result.AddNewItem("RTRIM"))).AddTypes(new int[] { rftString, rftString }); (((TRtSQLFunctionTableItem) Result.AddNewItem("SPACE"))).AddTypes(new int[] { rftString, rftNumber }); (((TRtSQLFunctionTableItem) Result.AddNewItem("SUBSTRING"))).AddTypes(new int[] { rftString, rftString, rftNumber, rftNumber }); (((TRtSQLFunctionTableItem) Result.AddNewItem("UCASE"))).AddTypes(new int[] { rftString, rftString }); (((TRtSQLFunctionTableItem) Result.AddNewItem("ABS"))).AddTypes(new int[] { rftNumber, rftNumber }); (((TRtSQLFunctionTableItem) Result.AddNewItem("ACOS"))).AddTypes(new int[] { rftNumber, rftNumber }); (((TRtSQLFunctionTableItem) Result.AddNewItem("ASIN"))).AddTypes(new int[] { rftNumber, rftNumber }); (((TRtSQLFunctionTableItem) Result.AddNewItem("ATAN"))).AddTypes(new int[] { rftNumber, rftNumber }); (((TRtSQLFunctionTableItem) Result.AddNewItem("ATAN2"))).AddTypes(new int[] { rftNumber, rftNumber, rftNumber }); (((TRtSQLFunctionTableItem) Result.AddNewItem("CELING"))).AddTypes(new int[] { rftNumber, rftNumber }); (((TRtSQLFunctionTableItem) Result.AddNewItem("COS"))).AddTypes(new int[] { rftNumber, rftNumber }); (((TRtSQLFunctionTableItem) Result.AddNewItem("COT"))).AddTypes(new int[] { rftNumber, rftNumber }); (((TRtSQLFunctionTableItem) Result.AddNewItem("EXP"))).AddTypes(new int[] { rftNumber, rftNumber }); (((TRtSQLFunctionTableItem) Result.AddNewItem("FLOOR"))).AddTypes(new int[] { rftNumber, rftNumber }); (((TRtSQLFunctionTableItem) Result.AddNewItem("LOG"))).AddTypes(new int[] { rftNumber, rftNumber }); (((TRtSQLFunctionTableItem) Result.AddNewItem("LOG10"))).AddTypes(new int[] { rftNumber, rftNumber }); (((TRtSQLFunctionTableItem) Result.AddNewItem("MOD"))).AddTypes(new int[] { rftNumber, rftNumber, rftNumber }); (((TRtSQLFunctionTableItem) Result.AddNewItem("PI"))).AddTypes(new int[] { rftNumber }); (((TRtSQLFunctionTableItem) Result.AddNewItem("POWER"))).AddTypes(new int[] { rftNumber, rftNumber, rftNumber }); (((TRtSQLFunctionTableItem) Result.AddNewItem("RADIANS"))).AddTypes(new int[] { rftNumber, rftNumber }); (((TRtSQLFunctionTableItem) Result.AddNewItem("DEGREES"))).AddTypes(new int[] { rftNumber, rftNumber }); (((TRtSQLFunctionTableItem) Result.AddNewItem("RAND"))).AddTypes(new int[] { rftNumber, OptionalType(rftNumber) }); (((TRtSQLFunctionTableItem) Result.AddNewItem("ROUND"))).AddTypes(new int[] { rftNumber, rftNumber, rftNumber }); (((TRtSQLFunctionTableItem) Result.AddNewItem("SIGN"))).AddTypes(new int[] { rftNumber, rftNumber }); (((TRtSQLFunctionTableItem) Result.AddNewItem("SIN"))).AddTypes(new int[] { rftNumber, rftNumber }); (((TRtSQLFunctionTableItem) Result.AddNewItem("SQRT"))).AddTypes(new int[] { rftNumber, rftNumber }); (((TRtSQLFunctionTableItem) Result.AddNewItem("TAN"))).AddTypes(new int[] { rftNumber, rftNumber }); (((TRtSQLFunctionTableItem) Result.AddNewItem("TRUNCATE"))).AddTypes(new int[] { rftNumber, rftNumber, rftNumber }); (((TRtSQLFunctionTableItem) Result.AddNewItem("CURDATE"))).AddTypes(new int[] { rftDate }); (((TRtSQLFunctionTableItem) Result.AddNewItem("CURTIME"))).AddTypes(new int[] { rftTime }); (((TRtSQLFunctionTableItem) Result.AddNewItem("DAYNAME"))).AddTypes(new int[] { rftString, rftDate }); (((TRtSQLFunctionTableItem) Result.AddNewItem("DAYOFMONTH"))).AddTypes(new int[] { rftNumber, rftDate }); (((TRtSQLFunctionTableItem) Result.AddNewItem("DAYOFWEEK"))).AddTypes(new int[] { rftNumber, rftDate }); (((TRtSQLFunctionTableItem) Result.AddNewItem("HOUR"))).AddTypes(new int[] { rftNumber, rftTime }); (((TRtSQLFunctionTableItem) Result.AddNewItem("MINUTE"))).AddTypes(new int[] { rftNumber, rftTime }); (((TRtSQLFunctionTableItem) Result.AddNewItem("MONTH"))).AddTypes(new int[] { rftNumber, rftDate }); (((TRtSQLFunctionTableItem) Result.AddNewItem("MONTHNAME"))).AddTypes(new int[] { rftString, rftDate }); (((TRtSQLFunctionTableItem) Result.AddNewItem("NOW"))).AddTypes(new int[] { rftTime }); (((TRtSQLFunctionTableItem) Result.AddNewItem("QUARTER"))).AddTypes(new int[] { rftNumber, rftDate }); (((TRtSQLFunctionTableItem) Result.AddNewItem("SECOND"))).AddTypes(new int[] { rftNumber, rftTime }); (((TRtSQLFunctionTableItem) Result.AddNewItem("YEAR"))).AddTypes(new int[] { rftNumber, rftDate }); (((TRtSQLFunctionTableItem) Result.AddNewItem("DATETIME"))).AddTypes(new int[] { rftDate, rftNumber, rftNumber, rftNumber, rftNumber, rftNumber, rftNumber }); (((TRtSQLFunctionTableItem) Result.AddNewItem("DATETIMEADD"))).AddTypes(new int[] { rftDate, rftUnknown, rftNumber, rftDate }); (((TRtSQLFunctionTableItem) Result.AddNewItem("DATETIMEDIF"))).AddTypes(new int[] { rftNumber, rftUnknown, rftDate, rftDate }); (((TRtSQLFunctionTableItem) Result.AddNewItem("CONVERT"))).AddTypes(new int[] { rftUnknown, rftUnknown, rftUnknown }); (((TRtSQLFunctionTableItem) Result.AddNewItem("IFNULL"))).AddTypes(new int[] { rftUnknown, rftUnknown, rftUnknown }); (((TRtSQLFunctionTableItem) Result.AddNewItem("USER"))).AddTypes(new int[] { rftString }); } catch (Throwable any) { Result.Free(); Result = null; } return Result; } static String TempName() { Randomize(); return "X" + IntToStr(Random(MaxInt)); } static String TempExp() { Randomize(); return "EXP" + IntToStr(Random(MaxInt)); } static String BreakLine(String s) { String Result = ""; if (!StrIsBlank(s)) { Result = SQL_EOL + s; } else { Result = ""; } return Result; } static String TranslateExpression(TRtCustomSQL SQL, TRtSQLTokenList TokenList) { TranslateExpression_Context ctx = new TranslateExpression_Context(SQL, TokenList); return ctx.execute(); } static String GetWhere(TRtCustomSQL SQL, TRtWhereItem Where) { String Result = ""; Result = ""; if (Where instanceof TRtWhereCurrentOfItem) { if (!StrIsBlank(((TRtWhereCurrentOfItem) Where).GetCurrentOf())) { Result = SQL_CurrentOf + ((TRtWhereCurrentOfItem) Where).GetCurrentOf(); } else { Result = TranslateExpression(SQL, Where.getTokens()); } } else { Result = TranslateExpression(SQL, Where.getTokens()); } return Result; } private static void IncompatibleDataError(Object aValue, TTypeDesc aTypeDesc) { String xStr = ""; xStr = VarToString(aValue); throw DelphiException.Create("O valor " + xStr + " não é compatível com o typedesc " + TypeDescName(aTypeDesc)); } private static String IntValAsTypeDesc(int aVal, TTypeDesc aTypeDesc) { String Result = ""; if (TypeDescIsNumeric(aTypeDesc)) { Result = IntToStr(aVal); } else if (TypeDescIsAlphaNumeric(aTypeDesc)) { Result = QuotedStr(IntToStr(aVal)); } else { IncompatibleDataError(VarFromInt(aVal), aTypeDesc); } return Result; } private static String StrValAsTypeDesc(String aVal, TTypeDesc aTypeDesc) { String Result = ""; if (TypeDescIsNumeric(aTypeDesc)) { Result = IntToStr(StrToInt(aVal)); } else if (TypeDescIsAlphaNumeric(aTypeDesc)) { Result = QuotedStr(aVal); } else { IncompatibleDataError(VarFromString(aVal), aTypeDesc); } return Result; } private static String FloatToDotStr(double aValue) { String Result = ""; char xOldDecimal; xOldDecimal = DecimalSeparator; try { DecimalSeparator = '.'; Result = FloatToStr(aValue); } finally { DecimalSeparator = xOldDecimal; } return Result; } private static String ExtendedValToStr(double aValue, TTypeDesc aTypeDesc) { String Result = ""; if (TypeDescIsFloatPoint(aTypeDesc)) { Result = FloatToDotStr(aValue); } else if (TypeDescIsDateTime(aTypeDesc)) { Result = DateToSQLSenior2DateConst(aValue); } else if (TypeDescIsAlphaNumeric(aTypeDesc)) { Result = QuotedStr(FloatToDotStr(aValue)); } else { IncompatibleDataError(aValue, aTypeDesc); } return Result; } private static String TVarRecToKeyString(TVarRec aValue, TTypeDesc aTypeDesc) { String Result = ""; switch (aValue.VType) { case vtInteger: Result = IntValAsTypeDesc(aValue.VInteger, aTypeDesc); break; case vtChar: Result = StrValAsTypeDesc("" + aValue.VChar, aTypeDesc); break; case vtString: Result = StrValAsTypeDesc(aValue.VString, aTypeDesc); break; case vtPChar: Result = StrValAsTypeDesc(StrPas(aValue.VPChar), aTypeDesc); break; case vtAnsiString: Result = StrValAsTypeDesc(aValue.VAnsiString, aTypeDesc); break; case vtExtended: Result = ExtendedValToStr(((Number) aValue.VExtended).doubleValue(), aTypeDesc); break; default: throw DelphiException.Create("Tipo de const não suportado"); } return Result; } static String[] GenerateNextValueStrKeyValues(IRtIndexDef aIndexDef, Object[] aValues) { String[] Result = null; int i; if (aIndexDef.GetIndexFieldCount() - 2 != aValues.length - 1) { throw DelphiException.Create("A Quantidade de valores passados para a tabela " + aIndexDef.GetTableDef().GetName() + " está incorreta!"); } Result = SetLength(Result, aValues.length - 1 + 1); for (i = 0; i <= aValues.length - 1; ++i) { Result[i] = TVarRecToKeyString(GetTVarRec(aValues[i]), aIndexDef.GetIndexFieldDef(i).GetFieldDef().GetTypeDesc()); } return Result; } static String GenerateNextValueKey(String aTableName, String[] aValues) { String Result = ""; int i; Result = aTableName; for (i = 0; i <= High(aValues); ++i) { Result = Result + '#' + aValues[i]; } return Result; } static IRtIndexDef GetPKFromTable(TRtDBConnection aConn, String aTableName) { IRtIndexDef Result; Result = aConn.GetDatabaseDef().TableByName(aTableName).GetPrimaryKey(); if (Result == null) { throw DelphiException.Create("A Tabela " + aTableName + " não possui chave primária"); } return Result; } static void _CheckUnprepare(TContainerItem AItem) { TRtCustomSQL sql; TRtCustomSQL sql2; if (AItem instanceof TRtCustomSQL) { sql = (TRtCustomSQL) AItem; } else { sql = ((TRtCustomSQL) AItem.GetTypedOwner(TRtCustomSQLClass.SINGLETON)); } if (sql != null) { sql2 = sql.GetRootSQL(); if (sql2 != null) { sql = sql2; } } else { return; } if (sql != null) { sql.UnPrepare(); } } static boolean HasDropTable(TRtDBConnection DBConn, String ATableName) { boolean Result; TRtCustomSQL AObj; int i; if (DBConn.getSQLProcessMode() == spmGroup) { for (i = 0; i <= DBConn.FSQLList.GetCount() - 1; ++i) { AObj = ((TRtCustomSQL) DBConn.FSQLList.Get(i)); Result = AObj instanceof TRtDropTable && CompareText(ATableName, ((TRtDropTable) AObj).GetTableName()) == 0; if (Result) { return Result; } } } return false; } private static final TRtSqlDriver vSqlDriver = new TRtSqlDriver(); private static TDBParamStrings vSeniorPadraoDBParams; private static void RegisterSeniorPadraoDBParams() { vSeniorPadraoDBParams = TDBParamStrings.Create(); TRtDatabaseServerClass.SINGLETON.GlobalInstance().RegisterConnectionParams(dbakPadrao, dbvkSenior, vSeniorPadraoDBParams); } //private static void UnregisterSeniorPadraoDBParams() { // TRtDatabaseServerClass.SINGLETON.GlobalInstance().UnregisterConnectionParams(dbakPadrao, dbvkSenior); // FreeAndNil(AsVar(vSeniorPadraoDBParams)); //} private static void RegisterSeniorSqlDriver() { vSqlDriver.SQLClasses[sckCreateTable] = TRtCreateTableClass.SINGLETON; vSqlDriver.SQLClasses[sckAlterTable] = TRtAlterTableClass.SINGLETON; vSqlDriver.SQLClasses[sckCreateIndex] = TRtCreateIndexClass.SINGLETON; vSqlDriver.SQLClasses[sckDropIndex] = TRtDropIndexClass.SINGLETON; vSqlDriver.SQLClasses[sckCreateTrigger] = TRtCreateTriggerClass.SINGLETON; vSqlDriver.SQLClasses[sckDropTrigger] = TRtDropTriggerClass.SINGLETON; vSqlDriver.SQLClasses[sckCreateProcedure] = TRtCreateProcedureClass.SINGLETON; vSqlDriver.SQLClasses[sckDropProcedure] = TRtDropProcedureClass.SINGLETON; vSqlDriver.SQLClasses[sckCreateView] = TRtCreateViewClass.SINGLETON; vSqlDriver.SQLClasses[sckDropView] = TRtDropViewClass.SINGLETON; vSqlDriver.SQLClasses[sckDropTable] = TRtDropTableClass.SINGLETON; vSqlDriver.SQLClasses[sckRenameTable] = TRtRenameTableClass.SINGLETON; vSqlDriver.SQLClasses[sckBeginTran] = TRtBeginTranClass.SINGLETON; vSqlDriver.SQLClasses[sckSetTransaction] = TRtSetTransactionClass.SINGLETON; vSqlDriver.SQLClasses[sckSavePoint] = TRtSavePointClass.SINGLETON; vSqlDriver.SQLClasses[sckRollBack] = TRtRollBackClass.SINGLETON; vSqlDriver.SQLClasses[sckCommit] = TRtCommitClass.SINGLETON; vSqlDriver.SQLClasses[sckDeleteFrom] = TRtDeleteFromClass.SINGLETON; vSqlDriver.SQLClasses[sckInsertSelectInto] = TRtInsertSelectIntoClass.SINGLETON; vSqlDriver.SQLClasses[sckInsertInto] = TRtInsertIntoClass.SINGLETON; vSqlDriver.SQLClasses[sckUpdate] = TRtUpdateClass.SINGLETON; vSqlDriver.SQLClasses[sckSelect] = TRtSelectClass.SINGLETON; vSqlDriver.DBCatalogsClass = TRtDbCatalogsClass.SINGLETON; vSqlDriver.ColumnSqlGeneratorClass = TRtColumnSqlGeneratorClass.SINGLETON; vSqlDriver.DBInitProc = null; vSqlDriver.FuncList = GetSQL92FunctionList(); vSqlDriver.PLGenerator = null; vSqlDriver.DBGenericFunctionsClass = TRtDBGenericFunctionsClass.SINGLETON; vSqlDriver.ReplG6FunctionsClass = TRtReplG6FunctionsClass.SINGLETON; TRtDatabaseServerClass.SINGLETON.GlobalInstance().RegisterSqlDriver(dbvkSenior, vSqlDriver); } //private static void UnregisterSeniorSqlDriver() { // TRtDatabaseServerClass.SINGLETON.GlobalInstance().UnregisterSqlDriver(dbvkSenior); // FreeAndNil(AsVar(vSqlDriver.FuncList)); //} private static void RegisterSeniorPadraoKernel() { TRtDatabaseServerClass.SINGLETON.GlobalInstance().RegisterSqlKnl(dbakPadrao, TRtDBKernelClass.SINGLETON); } //private static void UnregisterSeniorPadraoKernel() { // TRtDatabaseServerClass.SINGLETON.GlobalInstance().UnregisterSqlKnl(dbakPadrao); //} private static void InitRtSql() { vDBServer = TRtDatabaseServer.Create(); RegisterSeniorPadraoDBParams(); RegisterSeniorSqlDriver(); RegisterSeniorPadraoKernel(); } //private static void FinalizeRtSql() { // UnregisterSeniorPadraoDBParams(); // UnregisterSeniorSqlDriver(); // UnregisterSeniorPadraoKernel(); // FreeAndNil(AsVar(vDBServer)); //} static { InitRtSql(); } }