{*******************************************************}
{                                                       }
{                     EhLib v4.0                        }
{                                                       }
{         TADODataDriverEh component (Build 4.2.23)     }
{                                                       }
{     Copyright (c) 2004-2007 by Dmitry V. Bolshakov    }
{                                                       }
{*******************************************************}

unit ADODataDriverEh;

{$I EHLIB.INC}

interface

uses Windows, SysUtils, Classes, Controls, DB,
{$IFDEF EH_LIB_6} Variants, {$ENDIF}
{$IFDEF EH_LIB_5} Contnrs, {$ENDIF}
  ToolCtrlsEh, MemTableDataEh, DataDriverEh, ADODB;

type

  TADODataDriverEh = class;
  TADOCommandEh = class;

  TAssignParameterEhEvent = procedure (DataDriver: TADODataDriverEh;
    Command: TADOCommandEh; MemRecord: TMemoryRecordEh;
    DataValueVersion: TDataValueVersionEh; Parameter: TParameter) of object;
  TADODataDriverExecuteCommandEhEvent = function (DataDriver: TADODataDriverEh;
    Command: TADOCommandEh; var Cursor: TDataSet; var FreeOnEof: Boolean): Integer of object;
  TADODataDriverGetBackUpdatedValuesEhEvent = procedure (DataDriver: TADODataDriverEh;
    MemRec: TMemoryRecordEh; Command: TADOCommandEh; ResDataSet: TDataSet) of object;

  TADODBCommandEh = class(TADOCommand)
  protected
    property ComponentRef;
  end;

{ TADOCommandEh }

  TADOCommandEh = class(TCustomSQLCommandEh)
  private
    FOnAssignParameter: TAssignParameterEhEvent;
    FCommand: TADODBCommandEh;
    FParams: TParams;
    function GetParamCheck: Boolean;
    function GetParameters: TParameters;
    function GetDataDriver: TADODataDriverEh;
  protected
    procedure CommandTextChanged(Sender: TObject); override;
    procedure SetParamCheck(const Value: Boolean); virtual;
    procedure SetParameters(const Value: TParameters); virtual;
  public
    constructor Create(ADataDriver: TADODataDriverEh);
    destructor Destroy; override;
    function Execute(var Cursor: TDataSet; var FreeOnEof: Boolean): Integer; override;
    function GetParams: TParams; override;
    procedure Assign(Source: TPersistent); override;
    procedure DefaultRefreshParameter(MemRecord: TMemoryRecordEh;
      DataValueVersion: TDataValueVersionEh; Parameter: TParameter); virtual;
    procedure RefreshParams(MemRecord: TMemoryRecordEh; DataValueVersion: TDataValueVersionEh); override;
    procedure SetParams(AParams: TParams); override;

    property DataDriver: TADODataDriverEh read GetDataDriver;
    property OnAssignParameter: TAssignParameterEhEvent read FOnAssignParameter write FOnAssignParameter;
  published
    property CommandText;
    property CommandType;
    property Parameters: TParameters read GetParameters write SetParameters;
    property ParamCheck: Boolean read GetParamCheck write SetParamCheck default True;
  end;

{ TADODataDriverEh }

  TADODataDriverEh = class(TCustomSQLDataDriverEh)
  private
    FADOConnection: TADOConnection;
    FConnectionString: WideString;
    FOnAssignCommandParameter: TAssignParameterEhEvent;
    FOnExecuteCommand: TADODataDriverExecuteCommandEhEvent;
    FOnGetBackUpdatedValues: TADODataDriverGetBackUpdatedValuesEhEvent;
    function GetDeleteCommand: TADOCommandEh;
    function GetGetrecCommand: TADOCommandEh;
    function GetInsertCommand: TADOCommandEh;
    function GetSelectCommand: TADOCommandEh;
    function GetUpdateCommand: TADOCommandEh;
    procedure SetConnection(const Value: TADOConnection);
    procedure SetConnectionString(const Value: WideString);
    procedure SetDeleteCommand(const Value: TADOCommandEh);
    procedure SetGetrecCommand(const Value: TADOCommandEh);
    procedure SetInsertCommand(const Value: TADOCommandEh);
    procedure SetSelectCommand(const Value: TADOCommandEh);
    procedure SetUpdateCommand(const Value: TADOCommandEh);
  protected
    function CreateCommand: TCustomSQLCommandEh; override;
    procedure AssignCommandParameter(Command: TADOCommandEh;
      MemRecord: TMemoryRecordEh; DataValueVersion: TDataValueVersionEh; Parameter: TParameter); virtual;
    procedure Notification(AComponent: TComponent; Operation: TOperation); override;
    procedure SetAutoIncFields(Fields: TFields; DataStruct: TMTDataStructEh); override;
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
    function CreateDesignCopy: TCustomSQLDataDriverEh; override;
    function ExecuteCommand(Command: TCustomSQLCommandEh; var Cursor: TDataSet; var FreeOnEof: Boolean): Integer; override;
    function HaveDataConnection(): Boolean; override;
    procedure DefaultAssignCommandParameter(Command: TADOCommandEh;
      MemRecord: TMemoryRecordEh; DataValueVersion: TDataValueVersionEh; Parameter: TParameter); virtual;
    procedure GetBackUpdatedValues(MemRec: TMemoryRecordEh; Command: TCustomSQLCommandEh; ResDataSet: TDataSet); override;
  published
    property ADOConnection: TADOConnection read FADOConnection write SetConnection;
    property ConnectionString: WideString read FConnectionString write SetConnectionString;
    property SelectCommand: TADOCommandEh read GetSelectCommand write SetSelectCommand;
    property SelectSQL;
    property UpdateCommand: TADOCommandEh read GetUpdateCommand write SetUpdateCommand;
    property UpdateSQL;
    property InsertCommand: TADOCommandEh read GetInsertCommand write SetInsertCommand;
    property InsertSQL;
    property DeleteCommand: TADOCommandEh read GetDeleteCommand write SetDeleteCommand;
    property DeleteSQL;
    property GetrecCommand: TADOCommandEh read GetGetrecCommand write SetGetrecCommand;
    property GetrecSQL;
    property DynaSQLParams;
    property ProviderDataSet;
    property KeyFields;
    property SpecParams;

    property OnAssignCommandParameter: TAssignParameterEhEvent read FOnAssignCommandParameter write FOnAssignCommandParameter;
    property OnAssignFieldValue;
    property OnBuildDataStruct;
    property OnExecuteCommand: TADODataDriverExecuteCommandEhEvent read FOnExecuteCommand write FOnExecuteCommand;
    property OnGetBackUpdatedValues: TADODataDriverGetBackUpdatedValuesEhEvent read FOnGetBackUpdatedValues write FOnGetBackUpdatedValues;
    property OnProduceDataReader;
    property OnReadRecord;
    property OnRefreshRecord;
    property OnUpdateError;
    property OnUpdateRecord;
  end;

function DefaultExecuteADOCommandEh(SQLDataDriver: TCustomSQLDataDriverEh;
    Command: TCustomSQLCommandEh; var Cursor: TDataSet; var FreeOnEof: Boolean;
    var Processed: Boolean; ADOConnection: TADOConnection;
    ConnectionString: WideString): Integer;

type TGetADODataDriverServerSpecOperations = function (DataDriver: TADODataDriverEh): TServerSpecOperationsEh;

function RegisterGetADODataDriverServerSpecOperationsPrg(Prg: TGetADODataDriverServerSpecOperations): TGetADODataDriverServerSpecOperations;

implementation

var
  FGetADODataDriverServerSpecOperationsPrg: TGetADODataDriverServerSpecOperations;

function RegisterGetADODataDriverServerSpecOperationsPrg(Prg: TGetADODataDriverServerSpecOperations): TGetADODataDriverServerSpecOperations;
begin
  Result := FGetADODataDriverServerSpecOperationsPrg;
  FGetADODataDriverServerSpecOperationsPrg := Prg;
end;

function DefaultExecuteADOCommandEh(SQLDataDriver: TCustomSQLDataDriverEh;
    Command: TCustomSQLCommandEh; var Cursor: TDataSet; var FreeOnEof: Boolean;
    var Processed: Boolean; ADOConnection: TADOConnection;
    ConnectionString: WideString): Integer;
var
  ACursor: TDataSet;
begin
  Result := -1;
  Cursor := nil;
  FreeOnEof := False;
  ACursor := nil;
  Processed := True;
  try
    case Command.CommandType of
      cthSelectQuery, cthUpdateQuery:
        begin
          ACursor := TADOQuery.Create(nil);
          with ACursor as TADOQuery do
          begin
            Connection := ADOConnection;
            ConnectionString := ConnectionString;
            SQL.Text := Command.CommandText.Text;
            Parameters.Assign(TBaseSQLCommandEh(Command).Params);
            if Command.CommandType = cthSelectQuery then
              Open
            else
            begin
              ExecSQL;
              Result := RowsAffected;
            end;
            TBaseSQLCommandEh(Command).Params.Assign(Parameters);
          end;
        end;
      cthTable:
        begin
          ACursor := TADOTable.Create(nil);
          with ACursor as TADOTable do
          begin
            Connection := ADOConnection;
            ConnectionString := ConnectionString;
            TableName := Command.CommandText.Text;
//            Parameters.Assign(TBaseSQLCommandEh(Command).Params);
            Open;
//            TBaseSQLCommandEh(Command).Params.Assign(Parameters);
          end;
        end;
      cthStoredProc:
        begin
          ACursor := TADOStoredProc.Create(nil);
          with ACursor as TADOStoredProc do
          begin
            Connection := ADOConnection;
            ConnectionString := ConnectionString;
            ProcedureName := Command.CommandText.Text;
            Parameters.Assign(TBaseSQLCommandEh(Command).Params);
            ExecProc;
//??            Result := RowsAffected;
            TBaseSQLCommandEh(Command).Params.Assign(Parameters);
          end;
        end;
    end;
    if ACursor.Active then
    begin
      Cursor := ACursor;
      FreeOnEof := True;
      ACursor := nil;
    end
  finally
    if ACursor <> nil then
      ACursor.Free;
  end;
end;

{ TADOCommandEh }

constructor TADOCommandEh.Create(ADataDriver: TADODataDriverEh);
begin
  inherited Create(ADataDriver);
  FCommand := TADODBCommandEh.Create(ADataDriver);
  FCommand.ComponentRef := ADataDriver;
end;

destructor TADOCommandEh.Destroy;
begin
  FCommand.Free;
  FParams.Free;
  inherited Destroy;
end;

procedure TADOCommandEh.Assign(Source: TPersistent);
begin
  inherited Assign(Source);
  if Source is TADOCommandEh then
    with (Source as TADOCommandEh) do
    begin
      Self.ParamCheck := ParamCheck;
      Self.Parameters := Parameters;
    end
  else if Source is TBaseSQLCommandEh then
    with (Source as TBaseSQLCommandEh) do
    begin
      Self.ParamCheck := ParamCheck;
      Self.Parameters.Assign(GetParams);
    end;
end;

procedure TADOCommandEh.CommandTextChanged(Sender: TObject);
begin
  inherited CommandTextChanged(Sender);
  if (DataDriver <> nil) then
  begin
    FCommand.Connection := DataDriver.ADOConnection;
    FCommand.ConnectionString := DataDriver.ConnectionString;
  end;
  FCommand.CommandText := CommandText.Text;
//  if not (csReading in DataDriver.ComponentState) then
//    if ParamCheck then
//      Parameters.ParseSQL(CommandText.Text, True);
end;

procedure TADOCommandEh.RefreshParams(MemRecord: TMemoryRecordEh;
  DataValueVersion: TDataValueVersionEh);
var
  I: Integer;
begin
  for I := 0 to Parameters.Count - 1 do
  begin
    if Assigned(OnAssignParameter)
      then OnAssignParameter(DataDriver, Self, MemRecord, DataValueVersion, Parameters[I])
      else DefaultRefreshParameter(MemRecord, DataValueVersion, Parameters[I]);
  end;
end;

procedure TADOCommandEh.DefaultRefreshParameter(MemRecord: TMemoryRecordEh;
  DataValueVersion: TDataValueVersionEh; Parameter: TParameter);
begin
  DataDriver.AssignCommandParameter(Self, MemRecord, DataValueVersion, Parameter);
end;

function TADOCommandEh.Execute(var Cursor: TDataSet; var FreeOnEof: Boolean): Integer;
var
  ACursor: TDataSet;
begin
  Result := -1;
  Cursor := nil;
  FreeOnEof := False;
  ACursor := nil;
  try
    case CommandType of
      cthSelectQuery, cthUpdateQuery:
        begin
          ACursor := TADOQuery.Create(nil);
          with ACursor as TADOQuery do
          begin
            Connection := DataDriver.ADOConnection;
            ConnectionString := DataDriver.ConnectionString;
            SQL.Text := Self.CommandText.Text;
            Parameters.Assign(Self.Parameters);
            if CommandType = cthSelectQuery then
              Open
            else
            begin
              ExecSQL;
              Result := RowsAffected;
            end;
            Self.Parameters.Assign(Parameters);
          end;
        end;
      cthTable:
        begin
          ACursor := TADOTable.Create(nil);
          with ACursor as TADOTable do
          begin
            Connection := DataDriver.ADOConnection;
            ConnectionString := DataDriver.ConnectionString;
            TableName := Self.CommandText.Text;
            Parameters.Assign(Self.Parameters);
            Open;
            Self.Parameters.Assign(Parameters);
          end;
        end;
      cthStoredProc:
        begin
          ACursor := TADOStoredProc.Create(nil);
          with ACursor as TADOStoredProc do
          begin
            Connection := DataDriver.ADOConnection;
            ConnectionString := DataDriver.ConnectionString;
            ProcedureName := Self.CommandText.Text;
            Parameters.Assign(Self.Parameters);
            ExecProc;
//??            Result := RowsAffected;
            Self.Parameters.Assign(Parameters);
          end;
        end;
    end;
    if ACursor.Active then
    begin