{-----------------------------------------------------------------------------
 Unit Name: UCMidasConn
 Author   : Luiz Benevenuto
 Date     : 31/07/2005
 Purpose  : Midas Suporte ( DataSnap )
 E-mail   : luiz@siffra.com
 URL      : www.siffra.com
 UC       : www.usercontrol.com.br
 Forum    : http://www.usercontrol.com.br/modules.php?name=Forums

 registered in UCMidasConnReg.pas
-----------------------------------------------------------------------------}

unit uUCROConn;

interface

//{$I 'UserControl.inc'}

uses
  Classes,
  DB,
  DBClient,
  SysUtils,
  UCDataConnector,
  uRORemoteService,
  uDADataStreamer,
  uDABin2DataStreamer,
  uDARemoteDataAdapter;

type
  TUCROConn = class(TUCDataConnector)
  private
    FRemoteService: TRORemoteService;
    FDataAdapter : TDARemoteDataAdapter;
    FDataStreamer : TDABin2DataStreamer;
    procedure SetRemoteService(const Value: TRORemoteService);
  protected
    procedure Notification(AComponent: TComponent; Operation: TOperation); override;
  public
    function GetDBObjectName: String; override;
    function GetTransObjectName: String; override;
    function UCFindDataConnection: Boolean; override;
    function UCFindTable(const Tablename: String): Boolean; override;
    function UCGetSQLDataset(FSQL: String): TDataset; override;
    procedure UCExecSQL(FSQL: String); override;
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
  published
    property RemoteService : TRORemoteService read FRemoteService write SetRemoteService;
  end;

const
  // Select para as tabelas de sistema !!! Para outro tipo de banco implemente aqui !!!!!

  // Para banco novo !!!
  // Não esquecer de colocar em TBancoDados, o tipo de banco !!!!!!
  // Não esquecer de colocar no 'case' de UCFindTable

  SQL_Firebird =
    'SELECT ' +
    '  UPPER(RDB$RELATIONS.RDB$RELATION_NAME) RDB$RELATION_NAME ' +
    'FROM ' +
    '  RDB$RELATIONS ' +
    'WHERE ' +
    '  RDB$RELATIONS.RDB$FLAGS = 1 AND UPPER(RDB$RELATIONS.RDB$RELATION_NAME) = ' +
    '  UPPER(''%s'')';

  SQL_MSSQL = '';

  SQL_Oracle = '';

  SQL_PostgreSQL =
    'SELECT ' +
    '  UPPER(PG_CLASS.RELNAME) ' +
    'FROM ' +
    '  PG_CLASS ' +
    'WHERE ' +
    '  PG_CLASS.RELKIND = ''r'' AND ' +
    '  UPPER(PG_CLASS.RELNAME) LIKE UPPER(''%s'')';

  SQL_MySQL = '';

  SQL_Paradox = '';

implementation

uses
  FactuGES_Intf, uROTypes, uDAClasses, uDADataTable;

{ TUCROConn }

constructor TUCROConn.Create(AOwner: TComponent);
begin
  inherited;
  FDataStreamer := TDABin2DataStreamer.Create(nil);
  FDataAdapter := TDARemoteDataAdapter.Create(nil);
  FDataAdapter.DataStreamer := FDataStreamer;
  FDataAdapter.SetupDefaultRequest;
end;

destructor TUCROConn.Destroy;
begin
  FreeAndNil(FDataAdapter);
  FreeAndNil(FDataStreamer);
  inherited;
end;

function TUCROConn.GetDBObjectName: String;
begin
  if Assigned(FRemoteService) then
  begin
    if Owner = FRemoteService.Owner then
      Result := FRemoteService.Name
    else
      Result := FRemoteService.Owner.Name + '.' + FRemoteService.Name;
  end
  else
    Result := '';
end;

function TUCROConn.GetTransObjectName: String;
begin
  Result := '';
end;

procedure TUCROConn.Notification(AComponent: TComponent; Operation: TOperation);
begin
  if (Operation = opRemove) and (AComponent = FRemoteService) then
  begin
    FreeAndNil(FDataAdapter);
    FRemoteService := nil;
  end;
  inherited Notification(AComponent, Operation);
end;

procedure TUCROConn.SetRemoteService(const Value: TRORemoteService);
begin
  FRemoteService := Value;
  if Assigned(FRemoteService) then
  begin
    with FDataAdapter do
    begin
      RemoteService := FRemoteService;
      GetSchemaCall.RemoteService := FRemoteService;
      GetDataCall.RemoteService := FRemoteService;
      UpdateDataCall.RemoteService := FRemoteService;
      GetScriptsCall.RemoteService := FRemoteService;
    end;
  end;
end;

procedure TUCROConn.UCExecSQL(FSQL: String);
begin
  (FRemoteService as IsrvUsuarios).SQLExecuteCommand(FSQL);
end;

function TUCROConn.UCFindDataConnection: Boolean;
begin
  Result := False;
  if Assigned(FRemoteService) then
  begin
    FRemoteService.CheckCanConnect;
    Result := True;
  end;
end;

function TUCROConn.UCFindTable(const Tablename: String): Boolean;
var
  ASchema : TDASchema;
begin
  ASchema := FDataAdapter.ReadSchema;
  try
    Result := Assigned(ASchema.FindDataset(TableName));
  finally
    FreeAndNil(ASchema);
  end;
end;

function TUCROConn.UCGetSQLDataset(FSQL: String): TDataset;
var
  AStream : Binary;
  ADataTable : TDADataTable;
begin
  Result := NIL;
  AStream := (FRemoteService as IsrvUsuarios).SQLGetData(FSQL, True, -1);
  if Assigned(AStream) then
  begin
    ADataTable := TDADataTable.Create(NIL);
    ADataTable.LoadFromStream(AStream);
    Result := ADataTable.Dataset;
  end;
end;

end.