//////////////////////////////////////////////////

//  Oracle Data Access Components

//  Copyright (c) 1998-2006 Core Lab. All right reserved.

//  Oracle DataSet

//  Created:            05.03.98

//  Last modified:      21.02.03

//////////////////////////////////////////////////



{$IFNDEF CLR}

{$I Odac.inc}

{$R-} // for ftBFile

unit Ora;

{$ENDIF}



interface

uses

{$IFDEF CLR}

  Windows, SysUtils, Classes, Variants, System.IO, System.XML, System.Text,

{$ENDIF}

{$IFDEF WIN32}

  Windows, SysUtils, Classes, StdVcl, CLRClasses, CRXml,

{$ENDIF}

{$IFDEF LINUX}

  SysUtils, Classes, CLRClasses, CRXml,

{$ENDIF}

{$IFDEF NET}OraNet, {$ENDIF}

{$IFDEF VER6P}SqlTimSt, {$ENDIF}

  MemUtils, DB, MemData, MemDS, CRAccess, DBAccess, CRConnectionPool, OraCall, OraClasses,

  OraError, OraObjects, OraConnectionPool;



{$IFDEF NET}

  {$NOINCLUDE OraNet}

{$ENDIF}







{$I OdacVer.inc}



const

  ftObject = ftADT;

  ftTable = ftDataSet;

  ftBFile = 100;

  ftLabel = 101;

{$IFNDEF VER6P}

  ftTimeStamp = 102;

{$ENDIF}

  ftIntervalYM = 103;

  ftIntervalDS = 104;



  ftTimeStampTZ = 105;

  ftTimeStampLTZ = 106;



  ftNumber = 107;



  ftXML = 108;

  ftFixedWideChar = 109;



  DEFAULT_TRACE_FILE_SIZE = 0;

  UNLIMITED_TRACE_FILE_SIZE = -1;



type

  TOraSession = class;

  TOraDataSet = class;

  TOraSQL = class;

  TOraUpdateSQL = class;

  TOraParam = class;

  TOraParams = class;



  TSubFieldType = (stNone, stOraBlob, stOraClob);

  TCharLength = 0..6;



{ TOraSession }



  TConnectChangeEvent = procedure (Sender: TObject; Connected: boolean) of object;



  TFailoverState = (fsEnd, fsAbort, fsReauth, fsBegin, fsError);

  TFailoverType = (ftNone, ftSession, ftSelect, ftTransaction);

  TFailoverEvent = procedure (Sender: TObject; FailoverState: TFailoverState; FailoverType: TFailoverType; var Retry: boolean) of object;

  TOptimizerMode = (omDefault, omFirstRows1000, omFirstRows100, omFirstRows10, omFirstRows1, omFirstRows, omAllRows, omChoose, omRule);



  TOraSessionOptions = class (TDAConnectionOptions)

  private

    FUseOCI7: boolean;

    FDirect: boolean;

    FEnableIntegers: boolean;

    FIsDateLanguageStored: boolean;

    FIsDateFormatStored: boolean;

    FEnableNumbers: boolean;

    FCharLength: TCharLength;

    FCharset: string;

    FUseUnicode: boolean;

    FDateFormat: string;

    FDateLanguage: string;

    FOptimizerMode: TOptimizerMode;

    FConnectionTimeout: integer;

    FStatementCache: boolean;

    FStatementCacheSize: integer;

    FClientIdentifier: string;



    function GetCharLength: TCharLength;

    procedure SetCharLength(Value: TCharLength);

    procedure SetCharset(Value: string);

    procedure SetUseUnicode(Value: boolean);

    function GetDateLanguage: string;

    procedure SetDateLanguage(Value: string);

    function GetDateFormat: string;

    procedure SetDateFormat(Value: string);

    procedure SetEnableIntegers(Value: boolean);

    procedure SetEnableNumbers(Value: boolean);

    function GetConvertEOL: boolean;

    procedure SetConvertEOL(Value: boolean);

    procedure SetNeverConnect(Value: boolean);

    function GetNeverConnect: boolean;

    procedure SetUseOCI7(Value: boolean);

    function GetNet: boolean;

    procedure SetNet(Value: boolean);

    procedure SetDirect(Value: boolean);

    procedure SetOptimizerMode(Value: TOptimizerMode);

    procedure SetStatementCache(Value: boolean);

    procedure SetStatementCacheSize(Value: integer);

    procedure SetClientIdentifier(const Value: string);

  protected

    procedure AssignTo(Dest: TPersistent); override;

    procedure SetDisconnectedMode(Value: boolean); override;



  public

    constructor Create(Owner: TCustomDAConnection);

  {$IFNDEF NET}

    property Net: boolean read GetNet write SetNet default False;  // obsolete

    property Direct: boolean read FDirect write SetDirect default False;

  {$ENDIF}



  published

    property CharLength: TCharLength read GetCharLength write SetCharLength default 1;

    property Charset: string read FCharset write SetCharset;

    property UseUnicode: boolean read FUseUnicode write SetUseUnicode default False;

    property ConvertEOL: boolean read GetConvertEOL write SetConvertEOL default False;

    property DateFormat: string read GetDateFormat write SetDateFormat stored FIsDateFormatStored;

    property DateLanguage: string read GetDateLanguage write SetDateLanguage stored FIsDateLanguageStored;

    property EnableIntegers: boolean read FEnableIntegers write SetEnableIntegers default True;

    property EnableNumbers: boolean read FEnableNumbers write SetEnableNumbers default False;

    property NeverConnect: boolean read GetNeverConnect write SetNeverConnect stored False default False;// obsolete

    property UseOCI7: boolean read FUseOCI7 write SetUseOCI7 default False;

    property DisconnectedMode;

    property KeepDesignConnected;

    property LocalFailover;

    property OptimizerMode: TOptimizerMode read FOptimizerMode write SetOptimizerMode default omDefault;

    property ConnectionTimeout: integer read FConnectionTimeout write FConnectionTimeout default 0;

    property StatementCache: boolean read FStatementCache write SetStatementCache default False;

    property StatementCacheSize: integer read FStatementCacheSize write SetStatementCacheSize default 20;

    property ClientIdentifier: string read FClientIdentifier write SetClientIdentifier;

  {$IFDEF NET}

    property Net: boolean read GetNet write SetNet stored False default False;  // obsolete

    property Direct: boolean read FDirect write SetDirect default False;

  {$ENDIF}

  end;



  TOraPoolingOptions = class(TPoolingOptions)

  private

    FPoolingType: TOraPoolingType;

    FProxyUsername: string;

    FProxyPassword: string;



    procedure SetPoolingType(Value: TOraPoolingType);

    procedure SetProxyUsername(Value: string);

    procedure SetProxyPassword(Value: string);

  public

    constructor Create(Owner: TCustomDAConnection); override;

  published

    property PoolType: TOraPoolingType read FPoolingType write SetPoolingType default optLocal;

    property ProxyUsername: string read FProxyUsername write SetProxyUsername;

    property ProxyPassword: string read FProxyPassword write SetProxyPassword;

  end;



{ TOraTrace }  



{$IFNDEF STD}

  TSqlTraceMode = set of (smBasicStatistics, smTypicalStatistics, smAllStatistics,

    smBindVariables, smWaitEvents, smTimedStatistics);

  TPlSqlTraceMode = set of (pmAllCalls, pmEnabledCalls, pmAllExceptions, pmEnabledExceptions,

    pmAllSql, pmEnabledSql, pmAllLines, pmEnabledLines);

  TTraceState = set of (tsSqlTrace, tsPlSqlTrace);



  TOraTrace = class(TComponent)

  private

    FSession: TOraSession;

    FEnabled: boolean;

    FPlSqlTraceMode: TPlSqlTraceMode;

    FSqlTraceMode: TSqlTraceMode;

    FPlSqlTraceActive: boolean;

    FSqlTraceActive: boolean;

    FTraceFileIdentifier: string;

    FMaxTraceFileSize: integer;



    function GetState: TTraceState;

    procedure SetSession(Value: TOraSession);

    procedure SetEnabled(Value: boolean);

    procedure SetTraceFileIdentifier(const Value: string);

    procedure SetMaxTraceFileSize(Value: integer);

    procedure SetSqlTraceMode(Value: TSqlTraceMode);



  protected

    FDesignCreate: boolean;



    procedure Loaded; override;

    procedure InternalSetTraceFileIdentifier;

    procedure InternalSetMaxTraceFileSize;

    procedure InternalSetSqlTraceMode;

    procedure StartTrace;

    procedure StopTrace;



  public

    constructor Create(AOwner: TComponent); override;

    destructor Destroy; override;



    //DbmsTrace

    procedure PlSqlTraceStart;

    procedure PlSqlTraceStop;

    procedure PlSqlTracePause;

    procedure PlSqlTraceResume;

    procedure PlSqlTraceComment(const Comment: string);

    procedure PlSqlTraceLimit(Limit: integer = 8192);

    function PlSqlTraceRunNumber: integer;

    //SQLTrace

    procedure SqlTraceStart;

    procedure SqlTraceStop;

    function GetTraceFileName: string;

    function GetSessionPID: integer;



    property State: TTraceState read GetState;



  published

    property Session: TOraSession read FSession write SetSession;

    property Enabled: boolean read FEnabled write SetEnabled default True;

    property SqlTraceMode: TSqlTraceMode read FSqlTraceMode write SetSqlTraceMode

      default [smTypicalStatistics, smTimedStatistics];

    property PlSqlTraceMode: TPlSqlTraceMode read FPlSqlTraceMode write FPlSqlTraceMode default [];

    property TraceFileIdentifier: string read FTraceFileIdentifier write SetTraceFileIdentifier;

    property MaxTraceFileSize: integer read FMaxTraceFileSize write SetMaxTraceFileSize default DEFAULT_TRACE_FILE_SIZE;

  end;

{$ENDIF}  



  TOraSession = class (TCustomDAConnection)

  private

    FDebug: boolean;

    FOraSQL: TOraSQL;

    FOptions: TOraSessionOptions;

    FPoolingOptions: TOraPoolingOptions;

    FHomeName: string;

    FThreadSafety: boolean;

    FConnectMode: TConnectMode;

    FOCICallStyle: TOCICallStyle;



    FOnConnectChange: TConnectChangeEvent;  // obsolete

    FInternalName: string;

    FFailoverEvent: TFailoverEvent;

    FSchema : string;

    FCachedSchema: string;

    FProxySession : TOraSession;

  {$IFNDEF STD}

    FTrace: TOraTrace;

  {$ENDIF}



    procedure SetThreadSafety(Value: boolean);

    function GetOracleVersion: string;

    function GetSQL: TOraSQL; virtual;

    procedure SetDebug(Value: boolean);

    function GetLDA: PLDA;

    function GetOCISvcCtx: pOCISvcCtx;

    procedure SetOCISvcCtx(Value: pOCISvcCtx);

    function GetOCICallStyle: TOCICallStyle;

    procedure SetOCICallStyle(Value: TOCICallStyle);

    procedure SetOptions(Value: TOraSessionOptions);

    procedure SetPoolingOptions(Value: TOraPoolingOptions);

    function GetLastError: integer;

    procedure SetLastError(Value: integer);

    procedure SetHomeName(Value: string);

    function GetHome: TOracleHome;

    procedure SetHome(Value: TOracleHome);

    function GetConnectPrompt: boolean;

    procedure SetConnectPrompt(Value: boolean);

    procedure SetConnectMode(Value: TConnectMode);



    function GetSchema : string;

    procedure SetSchema (Value : string);

    procedure SetCurrentSchema(SchemaName : string);

    function GetCurrentSchema : string;

    function GetDefaultSchema : string;

    function IsSchemaStored : boolean;



    function GetProxySession : TOraSession;

    procedure SetProxySession (Value : TOraSession);



    procedure SetInternalName(const AValue: string);



    procedure GetObjectList(List: TStrings; SQL: string);

    procedure CheckDirect;

    procedure SetClientIdentifier(const Value: string);

  {$IFNDEF STD}

    procedure SetTrace(Value: TOraTrace);

  {$ENDIF}  



  protected

    FIConnection: TOCIConnection;

  {$IFDEF MSWINDOWS}

    FChangeNotifications: TDAList;

  {$ENDIF}



    procedure CreateIConnection; override;

    function GetIConnectionClass: TCRConnectionClass; override;

    function GetICommandClass: TCRCommandClass; override;

    function GetIRecordSetClass: TCRRecordSetClass; override;



    function GetOCIConnection: TOCIConnection;

    procedure SetIConnection(Value: TCRConnection); override;



    procedure DoConnect; override;

    procedure DoDisconnect; override;



    procedure AssignTo(Dest: TPersistent); override;





    function IsFatalError(E: EDAError): boolean; override;

    function IsKeyViolation(E: EDAError): boolean; override;

    function GetCompilationError(SQL: string): string;





    function SQLMonitorClass: TClass; override;

    function ConnectDialogClass: TConnectDialogClass; override;



    function CreateOptions: TDAConnectionOptions; override;

    function CreatePoolingOptions: TPoolingOptions; override;



    function GetTransactionID: string; override;

    function LocalTransactionId(CreateTransaction: boolean = False): string;

    function GetInTransaction: boolean; override;



    procedure SetConnected(Value: boolean); override;

    function GetConnectString: string; override;

    procedure SetConnectString(Value: string); override;

    procedure DoOnFailover(FailoverState: cardinal; FailoverType: cardinal; var Retry: boolean);



    function GetCachedSchema: string;



    procedure Notification(AComponent: TComponent; Operation: TOperation); override;



    procedure SetOptimizerMode(Value: TOptimizerMode);

  {$IFNDEF STD}

    property Trace: TOraTrace read FTrace write SetTrace;

  {$ENDIF}    

  public

    constructor Create(Owner: TComponent); override;

    destructor Destroy; override;



  { Transaction control }

    procedure StartTransaction; overload; override;

    procedure StartTransaction(IsolationLevel: TOraIsolationLevel; const RollbackSegment: string = ''; const Name: string = ''); reintroduce; overload;

    procedure Savepoint(const Savepoint: string);

    procedure RollbackToSavepoint(const Savepoint: string);



    function ParamByName(Name: string): TOraParam;



    function ExecSQL(Text: string; const Params: array of variant): variant; override;

    function ExecProc(Name: string; const Params: array of variant): variant;



    function ExecSQLEx(Text: string; const Params: array of variant): variant;

    function ExecProcEx(Name: string; const Params: array of variant): variant;



    procedure Ping;

    procedure ClearStatementCache;



    procedure AssignConnect(Source: TOraSession);



    function CreateDataSet: TCustomDADataSet; override;

    function CreateSQL: TCustomDASQL; override;



    procedure ChangePassword(NewPassword: string);



    procedure GetTableNames(List: TStrings); overload; override;

    procedure GetTableNames(List: TStrings; AllTables: boolean); reintroduce; overload;

    procedure GetStoredProcNames(List: TStrings); overload; override;

    procedure GetStoredProcNames(List: TStrings; AllProcs: boolean); reintroduce; overload;

    procedure GetSequenceNames(List: TStrings);





    property LDA: PLDA read GetLDA;

    property OCISvcCtx: pOCISvcCtx read GetOCISvcCtx write SetOCISvcCtx;

    property OCICallStyle: TOCICallStyle read GetOCICallStyle write SetOCICallStyle;

    property LastError: integer read GetLastError write SetLastError;

    property OracleVersion: string read GetOracleVersion;



    property SQL: TOraSQL read GetSQL;

    property OraSQL: TOraSQL read GetSQL;  // for back compatibility

    property InternalName: string read FInternalName write SetInternalName;

    property ProxySession : TOraSession read GetProxySession write SetProxySession;

  published

    property Debug: boolean read FDebug write SetDebug default False;

    property ThreadSafety: boolean read FThreadSafety write SetThreadSafety default True;

    property ConnectPrompt: boolean read GetConnectPrompt write SetConnectPrompt stored False default True; //obsolette

    property ConnectMode: TConnectMode read FConnectMode write SetConnectMode default cmNORMAL;

    property Options: TOraSessionOptions read FOptions write SetOptions;



    property PoolingOptions: TOraPoolingOptions read FPoolingOptions write SetPoolingOptions;

    property Pooling;



    property Username;

    property Password;

    property Server;

    property ConnectString;

    property AutoCommit;

    property Connected stored IsConnectedStored;

    property ConnectDialog;

    property LoginPrompt;    



    property AfterConnect;

    property BeforeConnect;

    property AfterDisconnect;

    property BeforeDisconnect;

    property OnLogin;

    property OnError;

    property OnConnectionLost;



  // obsolete

    property OnConnectChange: TConnectChangeEvent read FOnConnectChange write FOnConnectChange;

    property OnFailover: TFailoverEvent read FFailoverEvent write FFailoverEvent;



    property Home: TOracleHome read GetHome write SetHome stored False default ohDefault;

    property HomeName: string read FHomeName write SetHomeName;



    property Schema : string read GetSchema write SetSchema stored IsSchemaStored;

  end;



{ TSessionList }

  TSessionList = class (TThreadList)

  private

    function GetCount: integer;

    function GetSession(i: integer): TOraSession;

  public

    property Count: integer read GetCount;

    property Items[i: integer]: TOraSession read GetSession; default;

  end;



{ TOraParam }

{$IFNDEF CLR}

  VariantPtr = ^variant;

{$ENDIF}



  TOraParam = class (TDAParam)

  private

    FTable: boolean;

    FNational : boolean;

    FDataPtr: Variant;

    FParamDescRef: TOraParamDesc;



{$IFNDEF CLR}

    function GetVarArrayPtr : VariantPtr;

{$ENDIF}

    procedure CheckIndex(Index: integer);



    function GetTable: boolean;

    procedure SetTable(Value: boolean);

    function GetNational: boolean;

    procedure SetNational(Value: boolean);

    function GetTableLength: integer;

    procedure SetTableLength(Value: integer);



    function GetAsCursor: TOraCursor;

    procedure SetAsCursor(Value: TOraCursor);

    function GetAsOraBlob: TOraLob;

    procedure SetAsOraBlob(Value: TOraLob);

    function GetAsOraClob: TOraLob;

    procedure SetAsOraClob(Value: TOraLob);

    function GetAsBFile: TOraFile;

    procedure SetAsBFile(Value: TOraFile);

    function GetAsObject: TOraObject;

    procedure SetAsObject(Value: TOraObject);

    function GetAsXML: TOraXML;

    procedure SetAsXML(Value: TOraXML);

    function GetAsRef: TOraRef;

    procedure SetAsRef(Value: TOraRef);

    function GetAsArray: TOraArray;

    procedure SetAsArray(Value: TOraArray);

    function GetAsTable: TOraNestTable;

    procedure SetAsTable(Value: TOraNestTable);

    function GetAsTimeStamp: TOraTimeStamp;

    procedure SetAsTimeStamp(Value: TOraTimeStamp);

    function GetAsInterval: TOraInterval;

    procedure SetAsInterval(Value: TOraInterval);

    function GetAsNumber: TOraNumber;

    procedure SetAsNumber(Value: TOraNumber);



    function GetItemAsDateTime(Index: integer): TDateTime;

    procedure SetItemAsDateTime(Index: integer; Value: TDateTime);



    function GetItemAsFloat(Index: integer): double;

    procedure SetItemAsFloat(Index: integer; Value: double);



    function GetItemAsInteger(Index: integer): integer;

    procedure SetItemAsInteger(Index: integer; Value: integer);



    function GetItemAsString(Index: integer): string;

    procedure SetItemAsString(Index: integer; Value: string);



    function GetItemAsTimeStamp(Index: integer): TOraTimeStamp;

    procedure SetItemAsTimeStamp(Index: integer; Value: TOraTimeStamp);



    function GetItemAsInterval(Index: integer): TOraInterval;

    procedure SetItemAsInterval(Index: integer; Value: TOraInterval);



    function GetItemAsVariant(Index: integer): variant;

    procedure SetItemAsVariant(Index: integer; Value: variant);



    function GetItemAsObject(Index: integer): TSharedObject;

    procedure SetItemAsObject(Index: integer; Value: TSharedObject);



    function GetItemIsNull(Index: integer): boolean;



    procedure SetItemText(Index: integer; Value: string);



  protected

    function IsObjectDataType(DataType: TFieldType): boolean; overload; override;

    function IsObjectDataType: boolean; overload;

    function IsBlobDataType: boolean; override;

{$IFNDEF CLR}

    function IsArray : boolean; virtual;

{$ENDIF}

    procedure SetDataType(Value: TFieldType); override;



    function GetSize: integer; override;



    function GetAsString: string; override;

    procedure SetAsString(Value: string); override;

    function GetAsInteger: integer; override;

    procedure SetAsInteger(Value: integer); override;

    function GetAsFloat: double; override;

    procedure SetAsFloat(Value: double); override;

    function GetAsVariant: variant; override;

    procedure SetAsVariant(const Value: variant); override;

  {$IFDEF VER6P}

    function GetAsSQLTimeStamp: TSQLTimeStamp; override;

    procedure SetAsSQLTimeStamp(const Value: TSQLTimeStamp); override;

  {$ENDIF}

    function GetIsNull: boolean; override;



    procedure CreateObject; override;

    procedure DisconnectObject;

    procedure FreeItems;



    property ParamObject;

  public

    constructor Create(Collection: TCollection); override;

    destructor Destroy; override;



    procedure Clear; override;

    procedure ItemClear(Index: integer);

    procedure Assign(Source: TPersistent); override;

    procedure AssignFieldValue(Field: TField; const Value: Variant); override;



    procedure SetBlobData(Buffer: IntPtr; Size: integer);



    property AsCursor: TOraCursor read GetAsCursor write SetAsCursor;

    property AsOraBlob: TOraLob read GetAsOraBlob write SetAsOraBlob;

    property AsOraClob: TOraLob read GetAsOraClob write SetAsOraClob;

    property AsBFile: TOraFile read GetAsBFile write SetAsBFile;

    property AsObject: TOraObject read GetAsObject write SetAsObject;

    property AsXML: TOraXML read GetAsXML write SetAsXML;

    property AsRef: TOraRef read GetAsRef write SetAsRef;

    property AsArray: TOraArray read GetAsArray write SetAsArray;

    property AsTable: TOraNestTable read GetAsTable write SetAsTable;

    property AsTimeStamp: TOraTimeStamp read GetAsTimeStamp write SetAsTimeStamp;

    property AsInterval: TOraInterval read GetAsInterval write SetAsInterval;

    property AsNumber: TOraNumber read GetAsNumber write SetAsNumber;



    property ItemAsDateTime[Index: integer]: TDateTime read GetItemAsDateTime write SetItemAsDateTime;

    property ItemAsFloat[Index: integer]: double read GetItemAsFloat write SetItemAsFloat;

    property ItemAsInteger[Index: integer]: integer read GetItemAsInteger write SetItemAsInteger;

    property ItemAsString[Index: integer]: string read GetItemAsString write SetItemAsString;

    property ItemValue[Index: integer]: variant read GetItemAsVariant write SetItemAsVariant;

    property ItemIsNull[Index: integer]: boolean read GetItemIsNull;

    property ItemText[Index: integer]: string read GetItemAsString write SetItemText;

    property ItemAsTimeStamp[Index: integer]: TOraTimeStamp read GetItemAsTimeStamp write SetItemAsTimeStamp;

    property ItemAsInterval[Index: integer]: TOraInterval read GetItemAsInterval write SetItemAsInterval;



  // obsolette

    property AsBLOBLocator: TOraLob read GetAsOraBlob write SetAsOraBlob;

    property AsCLOBLocator: TOraLob read GetAsOraClob write SetAsOraClob;



  published

    property National : boolean read GetNational write SetNational default False;

    property Table: boolean read GetTable write SetTable default False;

    property Length: integer read GetTableLength write SetTableLength default 1;

  end;



{ TOraParams }



  TOraParams = class (TDAParams)

  private

    FOwner: TPersistent;



    procedure ReadBinaryData(Stream: TStream);



    function GetItem(Index: integer): TOraParam;

    procedure SetItem(Index: integer; Value: TOraParam);



  protected

    procedure Disconnect;

    procedure DefineProperties(Filer: TFiler); override;



  public

    constructor Create(Owner: TPersistent);



    function ParamByName(const Value: string): TOraParam;

    function FindParam(const Value: string): TOraParam;

    property Items[Index: integer]: TOraParam read GetItem write SetItem; default;

  end;



{ TCursorField }



  TCursorField = class (TField)

  private

    function GetAsCursor: TOraCursor;

  protected

    function GetValue(var Value: TOraCursor): boolean;



  public

    constructor Create(Owner: TComponent); override;



    property AsCursor: TOraCursor read GetAsCursor;

  end;



{ TBFileField }



  TBFileField = class (TBlobField)

  private

    FAutoRefresh: boolean;



    function GetAsFile: TOraFile;



    function GetBlobType: TBlobType;

    procedure SetBlobType(Value: TBlobType);



    function GetFileDir: string;

    procedure SetFileDir(Value: string);

    function GetFileName: string;

    procedure SetFileName(Value: string);

    function GetExists: boolean;



  protected

    function GetCanModify: boolean; override;

    function GetClassDesc: string; override;

    function GetValue(var Value: TOraFile): boolean;

    function GetIsNull: boolean; override;



  public

    constructor Create(Owner: TComponent); override;



    procedure Refresh;



    property FileDir: string read GetFileDir write SetFileDir;

    property FileName: string read GetFileName write SetFileName;

    property Exists: boolean read GetExists;



    property AsFile: TOraFile read GetAsFile;



  published

    property BlobType: TBlobType read GetBlobType write SetBlobType;

    property AutoRefresh: boolean read FAutoRefresh write FAutoRefresh default True;

  end;



{ TOraDataSetField }



  TOraDataSetField = class (TDataSetField)

  private

    FModified: boolean;



  protected

    procedure FreeBuffers; override;

    function GetAsString: string; override;

  public

    property Modified: boolean read FModified write FModified;

  end;



{ TOraReferenceField }



  TOraReferenceField = class (TReferenceField)

  private

    FModified: boolean;



  protected

    procedure FreeBuffers; override;

    function GetAsString: string; override;

  public

    property Modified: boolean read FModified write FModified;

  end;



{ TLabelField }



  TLabelField = class (TField)

  protected

    function GetAsVariant: variant; override;



  public

    constructor Create(Owner: TComponent); override;

  end;



{ TOraTimeStampField }



  TOraTimeStampField = class (TField)

  private

    FFormat: string;



  protected

    function GetAsDateTime: TDateTime; override;

    procedure SetAsDateTime(Value: TDateTime); override;

    function GetAsString: string; override;

    procedure SetAsString(const Value: string); override;

    function GetAsVariant: variant; override;

    procedure SetVarValue(const Value: Variant); override;

  {$IFDEF VER6P}

    function {$IFDEF CLR}GetAsSqlTimeStamp{$ELSE}GetAsSQLTimeStamp{$ENDIF}: TSQLTimeStamp; override; // anti hint

    procedure SetAsSQLTimeStamp(const Value: TSQLTimeStamp); override;

  {$ENDIF}

    function GetAsTimeStamp: TOraTimeStamp;



    procedure DefineProperties(Filer: TFiler); override;

    procedure ReadDataType(Reader: TReader);

    procedure WriteDataType(Writer: TWriter);



    function GetIsNull: Boolean; override;

  public

    constructor Create(Owner: TComponent); override;

    property AsTimeStamp: TOraTimeStamp read GetAsTimeStamp;

    procedure SetFieldType(Value: TFieldType); override;



  published

    property Format: string read FFormat write FFormat;

  end;



{ TOraIntervalField }



  TOraIntervalField = class (TField)

  private

    FLeadPrecision: integer;

    FFracPrecision: integer;



  protected

    function GetAsString: string; override;

    procedure SetAsString(const Value: string); override;

    function GetAsVariant: variant; override;

    procedure SetVarValue(const Value: Variant); override;

    function GetAsInterval: TOraInterval;



    procedure DefineProperties(Filer: TFiler); override;

    procedure ReadDataType(Reader: TReader);

    procedure WriteDataType(Writer: TWriter);



    function GetIsNull: Boolean; override;

  public

    constructor Create(Owner: TComponent); override;

    procedure SetFieldType(Value: TFieldType); override;

    property AsInterval: TOraInterval read GetAsInterval;



  published

    property LeadPrecision: integer read FLeadPrecision write FLeadPrecision default 2;

    property FracPrecision: integer read FFracPrecision write FFracPrecision default 6;

  end;



{ TOraNumberField }



  TOraNumberField = class (TNumericField)

  private

    function GetAsNumber: TOraNumber;



  protected

    function GetAsVariant: variant; override;

    procedure SetVarValue(const Value: Variant); override;

    function GetAsString: string; override;

    procedure SetAsString(const Value: string); override;

    function GetAsInteger: integer; override;

    procedure SetAsInteger(Value: integer); override;

    function GetAsLargeInt: LargeInt;

    procedure SetAsLargeInt(Value: LargeInt);

    function GetAsFloat: double; override;

    procedure SetAsFloat(Value: double); override;



    procedure DefineProperties(Filer: TFiler); override;

    procedure ReadDataType(Reader: TReader);

    procedure WriteDataType(Writer: TWriter);



    function GetIsNull: Boolean; override;



  public

    constructor Create(Owner: TComponent); override;

    function IsValidChar(InputChar: char): boolean; override;



    property AsNumber: TOraNumber read GetAsNumber;

    property AsLargeInt: LargeInt read GetAsLargeInt write SetAsLargeInt;

  end;



{ TOraXMLField }



  TOraXMLField = class (TField)

  protected

    function GetAsString: string; override;

    procedure SetAsString(const Value: string); override;

    function GetAsVariant: variant; override;

    function GetAsXML: TOraXML;

    procedure GetText(var Text: string; DisplayText: Boolean); override;

    procedure SetText(const Value: string); override;



    procedure DefineProperties(Filer: TFiler); override;

    procedure ReadDataType(Reader: TReader);

    procedure WriteDataType(Writer: TWriter);



    function GetIsNull: Boolean; override;

    function GetClassDesc: string; override;



  public

    constructor Create(Owner: TComponent); override;

    procedure Clear; override;

    class function IsBlob: Boolean; override;

    procedure SetFieldType(Value: TFieldType); override;

    property AsXML: TOraXML read GetAsXML;

  end;



{ TOraDataSet }



  TLockMode = (lmNone, lmLockImmediate, lmLockDelayed);

  TCheckMode = (cmNone, cmException, cmRefresh);



  TRefreshMode = (rmNone, rmAfterInsert, rmAfterUpdate, rmAlways); // obsolete



  // obsolete

  // new options should not be added to TOraDataSetOptionsDS

  TOraDataSetOptionsDS = class (TDADataSetOptions)

  private

    FAutoClose: boolean;

    FFieldsOrigin: boolean;

    FDefaultValues: boolean;

    FFieldsAsString: boolean;

    FDeferredLobRead: boolean;

    FCacheLobs: boolean;

    FScrollableCursor: boolean;

    FRawAsString: boolean;



    function GetKeepPrepared: Boolean;

    procedure SetKeepPrepared(Value: boolean);

    procedure SetAutoClose(Value: boolean);

    procedure SetFieldsAsString(Value: boolean);

    procedure SetDeferredLobRead(Value: boolean);

    procedure SetCacheLobs(Value: boolean);

    procedure SetScrollableCursor(Value: boolean);

    procedure SetRawAsString(Value: boolean);



  protected

    procedure AssignTo(Dest: TPersistent); override;

  public

    constructor Create(Owner: TCustomDADataSet);



  published

    property KeepPrepared: boolean read GetKeepPrepared write SetKeepPrepared stored False;

    property AutoClose: boolean read FAutoClose write SetAutoClose stored False default False;

    property FieldsOrigin: boolean read FFieldsOrigin write FFieldsOrigin stored False default False;

    property DefaultValues: boolean read FDefaultValues write FDefaultValues stored False default False;

    property FieldsAsString: boolean read FFieldsAsString write SetFieldsAsString stored False default False;

    property DeferredLobRead: boolean read FDeferredLobRead write SetDeferredLobRead stored False default False;

    property CacheLobs: boolean read FCacheLobs write SetCacheLobs stored False default True;

    property ScrollableCursor: boolean read FScrollableCursor write SetScrollableCursor stored False default False;

    property RawAsString: boolean read FRawAsString write SetRawAsString stored False default False;



    property RequiredFields stored False;

    property StrictUpdate stored False;

    property NumberRange stored False;

    property QueryRecCount stored False;

    property AutoPrepare stored False;

    property ReturnParams stored False;

    property TrimFixedChar stored False;

    property LongStrings stored False;

    property RemoveOnRefresh stored False;

    property FlatBuffers stored False;

    property DetailDelay stored False;

  end;



  TOraDataSetOptions = class(TOraDataSetOptionsDS)

  private

    FTemporaryLobUpdate: boolean;

    FExtenededFieldsInfo: boolean;

    FReflectChangeNotify: boolean;

    FStatementCache: boolean;



    procedure SetTemporaryLobUpdate(Value: boolean);

    procedure SetExtendedFieldsInfo(Value: boolean);

    procedure SetStatementCache(Value: boolean);



  protected

    procedure AssignTo(Dest: TPersistent); override;



  published

    property AutoClose stored True;

    property FieldsOrigin stored True;

    property DefaultValues stored True;

    property FieldsAsString stored True;

    property DeferredLobRead stored True;

    property CacheLobs stored True;

    property ScrollableCursor stored True;

    property RawAsString stored True;



    property RequiredFields stored True;

    property StrictUpdate stored True;

    property NumberRange stored True;

    property QueryRecCount stored True;

    property AutoPrepare stored True;

    property ReturnParams stored True;

    property TrimFixedChar stored True;

    property LongStrings stored True;

    property RemoveOnRefresh stored True;

    property FlatBuffers stored True;

    property DetailDelay stored True;



    property TemporaryLobUpdate: boolean read FTemporaryLobUpdate write SetTemporaryLobUpdate default False;

    property ExtendedFieldsInfo: boolean read FExtenededFieldsInfo write SetExtendedFieldsInfo default False;

    property ReflectChangeNotify: boolean read FReflectChangeNotify write FReflectChangeNotify default False;

    property StatementCache: boolean read FStatementCache write SetStatementCache default False;



    property SetFieldsReadOnly;

    property LocalMasterDetail;

    property CacheCalcFields;

    property FullRefresh;

  {$IFDEF HAVE_COMPRESS}

    property CompressBlobMode;

  {$ENDIF}

    property UpdateBatchSize;

    property UpdateAllFields;

  end;



  TSequenceMode = (smInsert, smPost);



  TFieldsInfoType = set of (ftFieldOrigin, ftDefaultValues);



  TOraSQLGenerator = class(TDASQLGenerator)

  private

    FSeqReturning: boolean;

    FSeqFieldDesc: TCRFieldDesc;

  protected

    FReturnSB,

    FIntoSB: StringBuilder;



    function IsBlobDataType(DataType: word): boolean; override;

    function FieldIsNull(FieldDesc: TCRFieldDesc; OldValue: boolean; Data: TData; OldRecBuf, NewRecBuf: IntPtr): boolean; override;

    function FieldModified(FieldDesc: TCRFieldDesc): boolean; override;



    function GenerateIndexName(Name: string): string; override;



    function IsSubstituteParamName: boolean; override;

    procedure AddParam(SB: StringBuilder; FieldDesc: TFieldDesc; const StatementType: TStatementType; Index: integer = -1; Old: boolean = False); override;



    procedure AddFieldToInsertSQL(FieldDesc: TCRFieldDesc; const Index: integer = -1); override;



    procedure AddFieldToUpdateSQL(FieldDesc: TCRFieldDesc;

      const ModifiedFieldsOnly: boolean;

      const Index: integer = -1); override;



    procedure GenerateInsertSQL(

      const KeyAndDataFields: TKeyAndDataFields;

      const ModifiedFieldsOnly: boolean;

      const Index: integer = -1); override;



    procedure GenerateUpdateSQL(

      const KeyAndDataFields: TKeyAndDataFields;

      const ModifiedFieldsOnly: boolean;

      const Index: integer = -1); override;



    procedure GenerateRefreshSQL(

      const KeyAndDataFields: TKeyAndDataFields;

      const ModifiedFieldsOnly: boolean); override;



    procedure GenerateLockSQL(

      const KeyAndDataFields: TKeyAndDataFields;

      const Index: integer = -1); override;

  public

    function GenerateSQL(const StatementType: TStatementType;

      const ModifiedFieldsOnly: boolean;

      Params: TDAParams;

      const Index: Integer = -1): string; override;

  end;



{$IFNDEF STD}

{$IFDEF MSWINDOWS}

{ TOraChangeNotification }



  TOraChangeNotificationEvent = procedure(Sender: TObject; NotifyType: TChangeNotifyEventType;

    TableChanges: TNotifyTableChanges) of object;



  TOraChangeNotification = class(TComponent)

  private

    FSession: TOraSession; // used to remove registration in destructor

    FEnabled: boolean;

    FPersistent: boolean;

    FTimeOut: integer;

    FOperations: TChangeNotifyDMLOperations;

    FDatasets: TDAList;

    FOnChange: TOraChangeNotificationEvent;



    procedure SetSession(Value: TOraSession);

    procedure SetEnabled(Value: boolean);

    procedure SetPersistent(Value: boolean);

    procedure SetTimeOut(Value: integer);

    procedure SetOperations(Value: TChangeNotifyDMLOperations);

    function GetActive: boolean;

    function GetPort: integer;

    procedure SetPort(Value: integer);



  protected

    FIChangeNotification: TOCIChangeNotification;



    function UsedConnection(Session: TOraSession): TOraSession;

    procedure BeginConnection(Session: TOraSession);

    procedure EndConnection(Session: TOraSession);

    procedure DoOnChange(NotifyType: TChangeNotifyEventType;

      TableChanges: TNotifyTableChanges);



    property Session: TOraSession read FSession write SetSession;



  public

    constructor Create(AOwner: TComponent); override;

    destructor Destroy; override;



    procedure RemoveRegistration(Session: TOraSession);



    property Active: boolean read GetActive;

    property Port: integer read GetPort write SetPort;



  published

    property Enabled: boolean read FEnabled write SetEnabled default True;

    property Persistent: boolean read FPersistent write SetPersistent default False;

    property TimeOut: integer read FTimeOut write SetTimeOut default 0;

    property Operations: TChangeNotifyDMLOperations read FOperations write SetOperations

      default [cnoInsert, cnoUpdate, cnoDelete];



    property OnChange: TOraChangeNotificationEvent read FOnChange write FOnChange;

  end;

{$ENDIF}

{$ENDIF}



  TOraDataSet = class (TCustomDADataSet)

  private

    FLockMode: TLockMode;

    FCheckMode: TCheckMode;

    FStreamedActive: boolean;

    FKeySequence: string;

    FKeyFields: string;

    FSequenceMode: TSequenceMode;

    FDMLRefresh: boolean;

    FIsUpdatingFields: boolean;

  {$IFNDEF STD}

  {$IFDEF MSWINDOWS}

    FChangeNotification: TOraChangeNotification;

  {$ENDIF}

  {$ENDIF}



  {$IFDEF WIN32}

    FProvIntf: IProvider;

  {$ENDIF}

    FFieldsInfoRequested: boolean; // Is needed to avoid second execution of GetFieldsInfo



    function GetSession: TOraSession;

    procedure SetSession(Value: TOraSession);

    function GetParams: TOraParams;

    procedure SetParams(Value: TOraParams);

    procedure SetNonBlocking(Value: boolean);

    function GetRowsProcessed: integer;

    function GetIsPLSQL: boolean;

    function GetSQLType: integer;

    function GetCursor: TOraCursor;

    function GetOptions: TOraDataSetOptions;

    procedure SetCursor(Value: TOraCursor);

    procedure SetOptions(Value: TOraDataSetOptions);

    procedure SetKeySequence(Value: string);

    procedure SetSequenceMode(const Value: TSequenceMode);

  {$IFNDEF STD}

  {$IFDEF MSWINDOWS}

    procedure SetChangeNotification(Value: TOraChangeNotification);

  {$ENDIF}

  {$ENDIF}



  // obsolete

    function GetStrictUpdate: boolean;

    procedure SetStrictUpdate(Value: boolean);

    function GetReturnParams: boolean;

    procedure SetReturnParams(Value: boolean);

    function GetRefreshMode: TRefreshMode;

    procedure SetRefreshMode(Value: TRefreshMode);

    function GetOptionsDS: TOraDataSetOptionsDS;

    procedure SetOptionsDS(Value: TOraDataSetOptionsDS);



 {$IFDEF WIN32}

    function GetProvider: IProvider;

 {$ENDIF}



  protected

  { IProviderSupport }

    function PreventPSKeyFields(var PSKeyFields: string): boolean; override;  

    function PSGetKeyFields: string; override;

    function PSGetDefaultOrder: TIndexDef; override;



    procedure CheckInactive; override;



  protected

    FIRecordSet: TOCIRecordSet;

    FICommand: TOCICommand;



    FHideRowidField: boolean;

//  FRowIdField: TField;

    FKeyFieldArray: TFieldArray;



    procedure CreateIRecordSet; override;

    procedure SetIRecordSet(Value: TData{TRecordSet}); override;



    procedure CreateCommand; override;



    function CreateOptions: TDADataSetOptions; override;



    procedure Loaded; override;



    function UsedConnection: TCustomDAConnection; override;

    procedure Disconnect; override;



  { Open/Close }

    function IsNeedEditPreconnect: boolean; override;

    function IsNeedInsertPreconnect: boolean; override;

    function IsPreconnected : boolean; override;



  { TablesInfo }

    procedure DetectIdentityField; override;



    procedure OpenCursor(InfoQuery: boolean); override;

    procedure CloseCursor; override;



    procedure InternalExecute; override;

    function GetRecCount: longint; override;

    procedure GetFieldsInfo(FieldsInfoType: TFieldsInfoType); overload;

    procedure GetFieldsInfo(); overload;

    procedure CheckFieldCompatibility(Field: TField; FieldDef: TFieldDef); override;



    procedure DoAfterOpen; override;

    procedure DoAfterScroll; override;



  { Fields }

    function GetFieldClass(FieldType: TFieldType): TFieldClass; override;

    function GetFieldType(DataType: word): TFieldType; override;

    function IsKeyFields: boolean;

    function IsUpdatingFields: boolean;



  { Edit }

    procedure CreateSQLGenerator; override;



    procedure InitRecord(Buffer: TRecordBuffer); override;



    function PerformDelete: boolean; override;

    function PerformUpdate: boolean; override;



    procedure InternalLock; virtual;



    procedure CheckUpdateQuery(const StatementType: TStatementType); override;

    procedure UpdateExecute(const StatementTypes: TStatementTypes); override;

    procedure CheckUpdateSQL(const SQL: string; const StatementTypes: TStatementTypes; out ParamsInfo: TDAParamsInfo); override;

    function PerformSQL(const SQL: string; const StatementTypes: TStatementTypes): boolean; override;

    function PrepareBatch(SQL: string): string; override;

    function RefreshAfterInsertAllowed: boolean; override;



    function ShouldPrepareUpdateSQL: boolean; override;



    procedure SetDefaultExpressionValue(Field: TField); override;

    procedure AssignFieldValue(Param: TDAParam; Field: TField; Old: boolean); override;

    procedure GetIdentityField; override;

    function GetSavepointName: string;



    procedure AssignTo(Dest: TPersistent); override;



    procedure SetActive(Value: boolean); override;



    procedure SetKeyFields(Value: string); virtual;



    function UseAllFields(ForceUseAllKeyFields: boolean): boolean; virtual;

    procedure GetKeyAndDataFields(

                out KeyAndDataFields: TKeyAndDataFields;

                const ForceUseAllKeyFields: boolean); override;

    procedure FillKeyFieldArray(const Value: string);



    function NeedReturnParams: boolean; override;



  { Master/Detail}

    function NeedDetailRefresh(Param: TDAParam; FieldValue: TSharedObject): boolean; override;



  { Filter/Find/Locate }

    procedure CopyFieldValue(const Value: variant; out ValuePtr: IntPtr; out ValueType: integer; FieldDesc: TFieldDesc); override;



  { KeySequence }

    procedure InternalOpen; override;

    procedure InternalClose; override;

    procedure GetSequenceNextVal;

    procedure InternalInsert; override;



    procedure InternalCreateProcCall(Name: string; Overload: integer; NeedDescribe: boolean);



  { SQL modify }

    function SQLAddWhere(SQLText, Condition: string): string; override;

    function SQLDeleteWhere(SQLText: string): string; override;

    function SQLSetOrderBy(SQLText: string; Fields: string): string; override;

    function SQLGetOrderBy(SQLText: string): string; override;



    procedure SetModified(Value: Boolean);

    function GetActiveRecBuf(var RecBuf: TRecordBuffer): boolean;

    function GetData: TData;



  {$IFDEF MSWINDOWS}

    procedure ReflectChanges(TableChanges: TNotifyTableChanges);

  {$ENDIF}



  { XML }

    procedure WriteFieldXMLDataType(Field: TField; FieldDesc: TFieldDesc; const FieldAlias: string;

      XMLWriter: XMLTextWriter); override;

    function GetFieldXMLValue(Field: TField; FieldDesc: TFieldDesc): string; override;



    function GetUpdateObject: TOraUpdateSQL;

    procedure SetUpdateObject(Value: TOraUpdateSQL);



    property IdentityField;

  public

    constructor Create(Owner: TComponent); override;

    destructor Destroy; override;



  { Open/Close }

    procedure BreakExec;



    function Fetched: boolean; override;

    function ErrorOffset: integer;

    procedure GetErrorPos(var Row,Col: integer);



  { Edit }

    procedure Lock;

    procedure Unlock;



    procedure CreateProcCall(Name: string; Overload: integer = 0);

    function GetKeyList(TableName: string; List: TStrings): string;



    function FindParam(const Value: string): TOraParam;

    function ParamByName(const Value: string): TOraParam;



    function CreateBlobStream(Field: TField; Mode: TBlobStreamMode): TStream; override;



  { Additional data types }

    function GetLob(const FieldName: string): TOraLob;

    function GetFile(const FieldName: string): TOraFile;

  {$HPPEMIT '#ifdef GetObject'}

  {$HPPEMIT '#undef GetObject'}

  {$HPPEMIT '#endif'}

    function GetObject(const FieldName: string): TOraObject;

    function GetRef(const FieldName: string): TOraRef;

    function GetArray(const FieldName: string): TOraArray;

    function GetTable(const FieldName: string): TOraNestTable;

    function GetTimeStamp(const FieldName: string): TOraTimeStamp;

    function GetInterval(const FieldName: string): TOraInterval;

    function GetNumber(const FieldName: string): TOraNumber;



    function GetLobLocator(const FieldName: string): TOraLob; // obsolete



    property Session: TOraSession read GetSession write SetSession;

    property Params: TOraParams read GetParams write SetParams stored False;

    property NonBlocking: boolean read FNonBlocking write SetNonBlocking default False;

    property RowsProcessed: integer read GetRowsProcessed;

    property IsQuery: boolean read GetIsQuery;

    property IsPLSQL: boolean read GetIsPLSQL;

    property SQLType: integer read GetSQLType;

    property Cursor: TOraCursor read GetCursor write SetCursor;

    property LockMode: TLockMode read FLockMode write FLockMode;

    property CheckMode: TCheckMode read FCheckMode write FCheckMode;

    property Options: TOraDataSetOptions read GetOptions write SetOptions;

    property KeyFields: string read FKeyFields write SetKeyFields;

    property KeySequence: string read FKeySequence write SetKeySequence;

    property SequenceMode: TSequenceMode read FSequenceMode write SetSequenceMode default smPost;

  {$IFNDEF STD}

  {$IFDEF MSWINDOWS}

    property ChangeNotification: TOraChangeNotification read FChangeNotification write SetChangeNotification;

  {$ENDIF}

  {$ENDIF}



  // obsolete

    property RefreshMode: TRefreshMode read GetRefreshMode write SetRefreshMode stored False;

    property DMLRefresh: boolean read FDMLRefresh write FDMLRefresh default False;

    property StrictUpdate: boolean read GetStrictUpdate write SetStrictUpdate stored False;

    property LocalConstraints stored False;

    property ReturnParams: boolean read GetReturnParams write SetReturnParams stored False;

    property OptionsDS: TOraDataSetOptionsDS read GetOptionsDS write SetOptionsDS stored False; // is Options

    property AutoCommit;



  {$IFDEF WIN32}

    property Provider: IProvider read GetProvider;

  {$ENDIF}

    property UpdateObject: TOraUpdateSQL read GetUpdateObject write SetUpdateObject;

  end;



{ TBFileStream }

  TBFileStream = class(TBlobStream)

  public

    constructor Create(Field: TBlobField; Mode: TBlobStreamMode);

    destructor Destroy; override;

  end;



{ TOraNestedTable }



  TOraNestedTable = class (TMemDataSet)

  private

    function GetTable: TOraNestTable;

    procedure SetTable(Value: TOraNestTable);

    function GetRef: TOraRef;

    procedure SetRef(Value: TOraRef);



  protected

    procedure CreateIRecordSet; override;



  { Open/Close }

    procedure OpenCursor(InfoQuery: boolean); override;

    procedure CloseCursor; override;



    procedure CreateFieldDefs; override;



    procedure DoAfterPost; override;

    procedure DoBeforeInsert; override;

    procedure DoBeforeDelete; override;



    function GetCanModify: boolean; override;

    procedure SetDataSetField(const Value: TDataSetField); override;



  {$IFDEF CLR}

    procedure DataEvent(Event: TDataEvent; Info: TObject); override;

  {$ELSE}

    procedure DataEvent(Event: TDataEvent; Info: longint); override;

  {$ENDIF}



  { Fields }

    function GetFieldClass(FieldType: TFieldType): TFieldClass; override;

    function GetFieldType(DataType: word): TFieldType; override;



  public

    constructor Create(Owner: TComponent); override;



    function GetObject(const FieldName: string): TOraObject;



    property Table: TOraNestTable read GetTable write SetTable;

    property Ref: TOraRef read GetRef write SetRef;



  published

    property DataSetField;



    property Active;

    property AutoCalcFields;

    property Filtered;

    property Filter;

    property FilterOptions;

    property IndexFieldNames;

    property ObjectView default True;



    property BeforeOpen;

    property AfterOpen;

    property BeforeClose;

    property AfterClose;

    property BeforeInsert;

    property AfterInsert;

    property BeforeEdit;

    property AfterEdit;

    property BeforePost;

    property AfterPost;

    property BeforeCancel;

    property AfterCancel;

    property BeforeDelete;

    property AfterDelete;

    property BeforeScroll;

    property AfterScroll;

    property OnCalcFields;

    property OnDeleteError;

    property OnEditError;

    property OnFilterRecord;

    property OnNewRecord;

    property OnPostError;

    property AfterRefresh;

    property BeforeRefresh;

  end;



{ TCustomOraQuery }



  TCustomOraQuery = class (TOraDataSet)

  protected



  { Fields }

    function IsKey: boolean; virtual;



    function GetUpdateStatement(const StatementType: TStatementType): string; override;



  { Edit }



    procedure InternalBeforeEdit; override;

    procedure InternalCancel; override;



    function GetCanModify: boolean; override;



    function PerformAppend: boolean; override;



    function GetUpdateSQLStatementTypes: TStatementTypes; override;



  public

    constructor Create(Owner: TComponent); override;



    procedure ExecSQL;  // for BDE compatibility



    property SQLLock: TStrings index stLock read GetUpdateSQLIndex write SetUpdateSQLIndex;

  end;



{ TOraQuery }



  TOraQuery = class (TCustomOraQuery)

  published

    property UpdatingTable;

    property KeyFields;

    property KeySequence;

    property SequenceMode;

    property SQLInsert;

    property SQLDelete;

    property SQLUpdate;

    property SQLLock;

    property SQLRefresh;

    property LocalUpdate;



    property Session;

    property ParamCheck; // before SQL

    property SQL;

    property MasterSource;

    property MasterFields;

    property DetailFields;

    property Debug;

    property Macros;

    property Params;

    property FetchRows;

    property FetchAll;

    property NonBlocking;

    property ReadOnly;

    property UniDirectional;

    property CachedUpdates;

    property AutoCommit;

    property FilterSQL;

    property LockMode default lmNone;

    property RefreshOptions;

    property Options;

  {$IFNDEF STD}

  {$IFDEF MSWINDOWS}

    property ChangeNotification;

  {$ENDIF}

  {$ENDIF}



    property ReturnParams; // obsolete

    property LocalConstraints; // obsolete

    property RefreshMode;      // obsolete

    property OptionsDS; // obsolete



    property AfterExecute;

    property BeforeUpdateExecute;

    property AfterUpdateExecute;

    property OnUpdateError;

    property OnUpdateRecord;

    property BeforeFetch;

    property AfterFetch;



    property UpdateObject;



    property Active;

    property AutoCalcFields;

    property Filtered;

    property Filter;

    property FilterOptions;

    property IndexFieldNames;

    property ObjectView default False;



    property BeforeOpen;

    property AfterOpen;

    property BeforeClose;

    property AfterClose;

    property BeforeInsert;

    property AfterInsert;

    property BeforeEdit;

    property AfterEdit;

    property BeforePost;

    property AfterPost;

    property BeforeCancel;

    property AfterCancel;

    property BeforeDelete;

    property AfterDelete;

    property BeforeScroll;

    property AfterScroll;

    property OnCalcFields;

    property OnDeleteError;

    property OnEditError;

    property OnFilterRecord;

    property OnNewRecord;

    property OnPostError;

    property AfterRefresh;

    property BeforeRefresh;



    property Fields;

  end;





{ TOraStoredProc }



  TOraStoredProc = class (TCustomOraQuery)

  private

    FStoredProcName: string;

    FOverload: integer;



    procedure SetStoredProcName(Value: string);

    procedure SetOverload(Value: integer);



  protected

  { IProviderSupport }

    procedure PSSetCommandText(const CommandText: string); override;



  protected

    procedure DoBeforeInsert; override;

    procedure DoBeforeDelete; override;

    procedure DoBeforeEdit; override;



    procedure BeforeOpenCursor(InfoQuery: boolean); override;

    procedure BeforeExecute; override;



    procedure AssignTo(Dest: TPersistent); override;

  public

    procedure Prepare; override;

    procedure PrepareSQL;



    procedure ExecProc; // for BDE compatibility



  published

    property StoredProcName: string read FStoredProcName write SetStoredProcName;

    property Overload: integer read FOverload write SetOverload default 0;



    property SQLInsert;

    property SQLDelete;

    property SQLUpdate;

    property SQLLock;

    property SQLRefresh;

    property LocalUpdate;



    property Session;

    property ParamCheck stored False;// before SQL

    property SQL;

    property Debug;

    property Params;

    property FetchRows;

    property FetchAll;

    property NonBlocking;

    //property AutoClose;

    property ReadOnly;

    property UniDirectional;

    property CachedUpdates;

    property AutoCommit;

    property LockMode default lmNone;

    property RefreshOptions;

    property Options;

  {$IFNDEF STD}

  {$IFDEF MSWINDOWS}

    property ChangeNotification;

  {$ENDIF}

  {$ENDIF}



    property ReturnParams; // obsolete

    property LocalConstraints; // obsolete

    property RefreshMode;      // obsolete

    property OptionsDS; // obsolete



    property AfterExecute;

    property BeforeUpdateExecute;

    property AfterUpdateExecute;

    property OnUpdateError;

    property OnUpdateRecord;



    property UpdateObject;



    property Active;

    property AutoCalcFields;

    property Filtered;

    property Filter;

    property FilterOptions;

    property IndexFieldNames;

    property ObjectView default False;

    property BeforeOpen;

    property AfterOpen;

    property BeforeClose;

    property AfterClose;

    property BeforeInsert;

    property AfterInsert;

    property BeforeEdit;

    property AfterEdit;

    property BeforePost;

    property AfterPost;

    property BeforeCancel;

    property AfterCancel;

    property BeforeDelete;

    property AfterDelete;

    property BeforeScroll;

    property AfterScroll;

    property OnCalcFields;

    property OnDeleteError;

    property OnEditError;

    property OnFilterRecord;

    property OnNewRecord;

    property OnPostError;

    property AfterRefresh;

    property BeforeRefresh;



    property Fields;

  end;



{ TOraSQL }



  TOraSQL = class (TCustomDASQL)

  private

    FStatementCache: boolean;



    function GetSession: TOraSession;

    procedure SetSession(Value: TOraSession);

    procedure SetNonBlocking(Value: boolean);

    function GetRowsProcessed: integer;

    function GetText: string;

    procedure SetText(Value: string);

    function GetSQLType: integer;

    procedure SetArrayLength(Value: integer);

    procedure SetStatementCache(Value: boolean);



    function GetParams: TOraParams;

    procedure SetParams(Value: TOraParams);



  protected

    FICommand: TOCICommand;



    procedure CreateICommand; override;

    procedure SetICommand(Value: TCRCommand); override;



    function CreateParamsObject: TDAParams; override;



    function UsedConnection: TCustomDAConnection; override;

    procedure Disconnect; override;



    procedure CreateParams; override;

    procedure WriteParams(WriteValue: boolean = True); override;

    procedure ReadParams; override;



    procedure AssignTo(Dest: TPersistent); override;

    procedure InternalExecute(Iters: integer); override;

    procedure InternalCreateProcCall(const Name: string; Overload: integer = 0;

      ParamCount: integer = -1; ParamNames: TStringList = nil);

    procedure SQLChanged(Sender: TObject); override;



  public

    constructor Create(Owner: TComponent); override;



    procedure BreakExec;



    function ErrorOffset: integer;



    function FindParam(const Value: string): TOraParam;

    function ParamByName(const Value: string): TOraParam;



    procedure CreateProcCall(Name: string; Overload: integer = 0);



    property RowsProcessed: integer read GetRowsProcessed;

    property SQLType: integer read GetSQLType;

    property ArrayLength: integer write SetArrayLength;

    property Text: string read GetText write SetText;



  published

    property Session: TOraSession read GetSession write SetSession;

    property Params: TOraParams read GetParams write SetParams stored False;

    property NonBlocking: boolean read FNonBlocking write SetNonBlocking default False;

    property StatementCache: boolean read FStatementCache write SetStatementCache default False;



    property ParamCheck; // before SQL

    property SQL;

    property Macros;

    property AutoCommit;

    property Debug;



    property AfterExecute;

  end;



{ TOraUpdateSQL }



  TOraUpdateSQL = class (TCustomDAUpdateSQL)

  protected

    function DataSetClass: TCustomDADataSetClass; override;

    function SQLClass: TCustomDASQLClass; override;

  end;



{ TOraDataSource }



  TOraDataSource = class (TCRDataSource)

  end;





  TOraUtils = class

  public

    class function GetIConnection(Obj: TOraSession): TOCIConnection;

    class procedure SetIConnection(Obj: TOraSession; Value: TOCIConnection);

    class procedure GetObjectList(Obj: TOraSession; List: TStrings; SQL: string);

    class function GetCachedSchema(Obj: TOraSession): string;

    class function FOwner(Obj: TOraSessionOptions): TOraSession;

    class function GetICommand(Obj: TOraDataSet): TOCICommand;



    class function GetRowId(Obj: TComponent): string;

  {$IFNDEF STD}

    class procedure SetDesignCreate(Obj: TOraTrace; Value: boolean); overload;

    class function GetDesignCreate(Obj: TOraTrace): boolean; overload;

  {$ENDIF}  

    class procedure SetKeyFields(Obj: TOraDataSet; Value: string);

    class function GetKeyFields(Obj: TOraDataSet): string;

  end;



  function DefaultSession: TOraSession;

  function SessionByName(Name: string): TOraSession;



{ SQL modify}



  function SetWhere(SQL: string; Condition: string): string;

  function AddWhere(SQL: string; Condition: string): string;

  function DeleteWhere(SQL: string): string;

  function SetOrderBy(SQL: string; Fields: string): string;

  function GetOrderBy(SQL: string): string;

  function SetGroupBy(SQL: string; Fields: string): string;

  function SetFieldList(SQL: string; Fields: string): string;

  function SetTableList(SQL: string; Tables: string): string;

  function GetTableList(SQL: string): string;



  function GetFieldType(DataType: word): TFieldType;

  function GetDataType(FieldType: TFieldType): word;



  function IsQuoted(const Value: string): boolean;

  function UnQuote(const Value: string): string;



  function GetSubscriptionPort: integer;

  procedure SetSubscriptionPort(Value: integer);







var

  DefSession: TOraSession;

  UseDefSession: boolean;

  Sessions: TSessionList;

  DefConnectDialogClassProc: function: TClass = nil;

  ShowRefId: boolean;

  OraQueryCompatibilityMode: boolean;



{$IFDEF WIN32}

  CreateProviderProc: function(DataSet: TOraDataSet): IProvider = nil;

{$ENDIF}





implementation

uses

  DBConsts, DAConsts, OraConsts, CRParser, OraParser, TypInfo, OraSQLMonitor, DBMonitorIntf,

{$IFDEF CLR}System.Runtime.InteropServices, System.Reflection,

{$ELSE}

  {$IFDEF VER6P}Variants, {$ENDIF}

{$ENDIF}

  DBCommon, DASQLMonitor;



{$IFDEF MSWINDOWS}

{$R Ora.res}

{$ENDIF}



const

{$IFDEF VER5}

  ODACFieldClasses: array [TFieldType] of TFieldClass = (

    nil,                { ftUnknown }

    TStringField,       { ftString }

    TSmallintField,     { ftSmallint }

    TIntegerField,      { ftInteger }

    TWordField,         { ftWord }

    TBooleanField,      { ftBoolean }

    TFloatField,        { ftFloat }

    TCurrencyField,     { ftCurrency }

    TBCDField,          { ftBCD }

    TDateField,         { ftDate }

    TTimeField,         { ftTime }

    TDateTimeField,     { ftDateTime }

    TBytesField,        { ftBytes }

    TVarBytesField,     { ftVarBytes }

    TAutoIncField,      { ftAutoInc }

    TBlobField,         { ftBlob }

    TMemoField,         { ftMemo }

    TGraphicField,      { ftGraphic }

    TBlobField,         { ftFmtMemo }

    TBlobField,         { ftParadoxOle }

    TBlobField,         { ftDBaseOle }

    TBlobField,         { ftTypedBinary }

    TCursorField,       { ftCursor }

    TStringField,       { ftFixedChar }

    TWideStringField,   { ftWideString }

    TLargeIntField,     { ftLargeInt }

    TADTField,          { ftADT }

    TArrayField,        { ftArray }

    TOraReferenceField, { ftReference }

    TOraDataSetField,   { ftDataSet }

    TBlobField,         { ftOraBlob }

    TMemoField,         { ftOraClob }

    TVariantField,      { ftVariant }

    TInterfaceField,    { ftInterface }

    TIDispatchField,    { ftIDispatch }

    TGuidField          { ftGuid }

  );

{$ENDIF}



{$IFDEF VER6P}

  ODACFieldClasses: array [TFieldType] of TFieldClass = (

    nil,                { ftUnknown }

    TStringField,       { ftString }

    TSmallintField,     { ftSmallint }

    TIntegerField,      { ftInteger }

    TWordField,         { ftWord }

    TBooleanField,      { ftBoolean }

    TFloatField,        { ftFloat }

    TCurrencyField,     { ftCurrency }

    TBCDField,          { ftBCD }

    TDateField,         { ftDate }

    TTimeField,         { ftTime }

    TDateTimeField,     { ftDateTime }

    TBytesField,        { ftBytes }

    TVarBytesField,     { ftVarBytes }

    TAutoIncField,      { ftAutoInc }

    TBlobField,         { ftBlob }

    TMemoField,         { ftMemo }

    TGraphicField,      { ftGraphic }

    TBlobField,         { ftFmtMemo }

    TBlobField,         { ftParadoxOle }

    TBlobField,         { ftDBaseOle }

    TBlobField,         { ftTypedBinary }

    TCursorField,       { ftCursor }

    TStringField,       { ftFixedChar }

    TWideStringField,   { ftWideString }

    TLargeIntField,     { ftLargeInt }

    TADTField,          { ftADT }

    TArrayField,        { ftArray }

    TOraReferenceField, { ftReference }

    TOraDataSetField,   { ftDataSet }

    TBlobField,         { ftOraBlob }

    TMemoField,         { ftOraClob }

{$IFDEF CLR}

    nil,

    nil,

    nil,

{$ELSE}

    TVariantField,      { ftVariant }

    TInterfaceField,    { ftInterface }

    TIDispatchField,    { ftIDispatch }

{$ENDIF}

    TGuidField,         { ftGuid }

    TOraTimeStampField, { ftTimeStamp }

    TFMTBcdField        { ftFMTBcd }

{$IFDEF VER10P}

   ,TWideStringField,   {ftFixedWideChar}

    TWideMemoField,     {ftWideMemo}

    TOraTimeStampField, {ftOraTimeStamp}

    TOraIntervalField   {ftOraInterval}

{$ENDIF}

  );

{$ENDIF}



{$IFDEF VER5}

  OraDataTypeMap: array [TFieldType] of word = (

    dtUnknown, dtString, dtInteger, dtInteger, dtInteger, dtBoolean, dtFloat,

    dtFloat, dtUnknown, dtDateTime, dtDateTime, dtDateTime, dtBytes, dtVarBytes, 0, dtBlob, dtMemo,

    0, 0, 0, 0, 0, dtCursor, dtFixedChar, dtWideString, dtInteger, dtObject, dtArray, dtReference,

    dtTable, dtOraBlob, dtOraClob, 0, 0, 0, 0);

{$ENDIF}

{$IFDEF VER6P}

  OraDataTypeMap: array [TFieldType] of word = (

    dtUnknown, dtString, dtInteger, dtInteger, dtInteger, dtBoolean, dtFloat,

    dtFloat, dtUnknown, dtDateTime, dtDateTime, dtDateTime, dtBytes, dtVarBytes, 0, dtBlob, dtMemo,

    0, 0, 0, 0, 0, dtCursor, dtFixedChar, dtWideString, dtInteger, dtObject, dtArray, dtReference,

    dtTable, dtOraBlob, dtOraClob, 0, 0, 0, 0, dtTimeStamp, 0

    {$IFDEF VER10P}, dtFixedWideChar, dtWideMemo, dtTimeStamp, 0{$ENDIF});

{$ENDIF}



{$IFDEF VER6P}

resourcestring

  SReadError = 'Stream read error';

  SWriteError = 'Stream write erro