unit uDASQLMemoryTable;

interface

uses SysUtils,Classes, DB, uDAInterfaces, uDADataTable, SQLMemMain;

type
  TDASQLMemDataset = class(TSQLMemTable, IDADataTableDataset)
  private
    function GetActive: boolean;

  protected
    function  GetDataTable: TDADataTable; safecall;
    procedure InternalRefresh; override;

  published
    property Active: boolean read GetActive;
  end;

  TDASQLMemTable = class(TDADataTable)
  private
    fMasterSource : TDADataSource;
    fSQLMemDataset: TDASQLMemdataset;

  protected
    function  GetDatasetClass: TDatasetClass; override;
    procedure CreateInternalFields(aDataset: TDataset; someFieldDefinitions: TDAFieldCollection); override;
    procedure DoSort(const FieldNames: array of string; const Directions: array of TDASortDirection); override;

    procedure DoBeforeOpenDataset; override;
    procedure DoAfterCloseDataset; override;

    procedure SetMasterSource(const Value: TDADataSource); override;
    function  GetMasterSource: TDADataSource; override;
    procedure SetDetailsFields(const Value: string); override;
    procedure SetMasterFields(const Value: string); override;
    function  GetDetailFields: string; override;
    function  GetMasterFields: string; override;

    function  GetIndexDefs: TIndexDefs;
    procedure SetIndexDefs(const Value: TIndexDefs);
    function  GetIndexName: string;
    procedure SetIndexName(const Value: string);

    function  GetFilter: string; override;
    function  GetFiltered: boolean; override;
    procedure SetFilter(const Value: string); override;
    procedure SetFiltered(const Value: boolean); override;

  public
    constructor Create(aOwner: TComponent); override;

  published
    property IndexDefs: TIndexDefs read GetIndexDefs write SetIndexDefs;
    property IndexName: string read GetIndexName write SetIndexName;
  end;

implementation

uses Variants;

constructor TDASQLMemTable.Create(aOwner: TComponent);
begin
  inherited;
  fSQLMemDataset := TDASqlMemDataset(Dataset);
  fSQLMemDataset.FilterOptions :=  [foCaseInsensitive];
end;

procedure TDASQLMemTable.CreateInternalFields(aDataset: TDataset; someFieldDefinitions: TDAFieldCollection);
  var tblName : String;
begin
  inherited;
  if fSQLMemDataset.TableName = '' then begin
    tblname := formatdatetime('ddddmmmmdyyyyhhmmsz',now);
    fSQLMemDataset.TableName := 'tbl'+tblname;
    fSQLMemDataset.CreateTable;
  end else begin
     fSQLMemDataset.close;
     fSQLMemDataset.EmptyTable;
     fSQLMemDataset.FieldDefs.clear;
     fSQLMemDataset.IndexDefs.Clear;
     fSQLMemDataset.RestructureFieldDefs.Clear;
     fSQLMemDataset.RestructureIndexDefs.Clear;
     fSQLMemDataset.ImportTable(dataset);
  end;
end;

procedure TDASQLMemTable.DoSort(const FieldNames: array of string; const Directions: array of TDASortDirection);
const
  DirectionStr: array[TDASortDirection] of string = ('ASC', 'DESC');
var
  ascfields, descfields,
  idxname: string;
  i: integer;
  idx: TIndexDef;
begin
  with fSQLMemDataset do begin
    if (Length(FieldNames) = 0) then begin
      IndexName := '';
      Exit;
    end;

    idxname := '';
    for i := 0 to Length(FieldNames) - 1 do
      idxname := idxname + FieldNames[i] + '_' + DirectionStr[Directions[i]];

    idx := TDefCollection(IndexDefs).Find(idxname) as TIndexDef;
    if (idx = nil) then begin
      ascfields := '';
      descfields := '';

      for i := 0 to Length(Directions) - 1 do
        case Directions[i] of
          sdAscending: ascfields := ascfields + FieldNames[i] + ';';
          sdDescending: descfields := descfields + FieldNames[i] + ';';
        end;

      if (descfields='')
        then fSQLMemDataset.AddIndex(idxname, ascfields, [])
        else fSQLMemDataset.AddIndex(idxname, descfields, [ixDescending]);
    end;

    IndexName := idxname;
  end;
end;

function TDASQLMemTable.GetDatasetClass: TDatasetClass;
begin
  result := TDASQLMemDataset;
end;

function TDASQLMemTable.GetMasterSource: TDADataSource;
begin
  result := fMasterSource;
end;

procedure TDASQLMemTable.DoAfterCloseDataset;
begin
  inherited;
  fSQLMemDataset.close;
end;

function TDASQLMemTable.GetFilter: string;
begin
  result := fSQLMemDataset.Filter
end;

procedure TDASQLMemTable.DoBeforeOpenDataset;
begin
  inherited;
end;

procedure TDASQLMemTable.SetMasterSource(const Value: TDADataSource);
begin
  fSQLMemDataset.MasterSource := Value;
  fMasterSource := Value;

  inherited SetMasterSource(Value);
end;

procedure TDASQLMemTable.SetMasterFields(const Value: string);
begin
  fSQLMemDataset.MasterFields := Value;
  inherited;
end;

procedure TDASQLMemTable.SetDetailsFields(const Value: string);
begin
  fSQLMemDataset.IndexFieldNames := Value
end;

function TDASQLMemTable.GetDetailFields: string;
begin
  result := fSQLMemDataset.IndexFieldNames
end;

function TDASQLMemTable.GetMasterFields: string;
begin
  result := fSQLMemDataset.MasterFields
end;

function TDASQLMemTable.GetFiltered: boolean;
begin
  result := fSQLMemDataset.Filtered
end;

procedure TDASQLMemTable.SetFilter(const Value: string);
begin
  fSQLMemDataset.Filter := Value
end;

procedure TDASQLMemTable.SetFiltered(const Value: boolean);
begin
  fSQLMemDataset.Filtered := Value
end;

function TDASQLMemTable.GetIndexDefs: TIndexDefs;
begin
  result := fSQLMemDataset.IndexDefs
end;

procedure TDASQLMemTable.SetIndexDefs(const Value: TIndexDefs);
begin
  fSQLMemDataset.IndexDefs.Assign(Value);
end;

function TDASQLMemTable.GetIndexName: string;
begin
  result := fSQLMemDataset.IndexName
end;

procedure TDASQLMemTable.SetIndexName(const Value: string);
begin
  fSQLMemDataset.IndexName := Value
end;

function TDASQLMemdataset.GetActive: boolean;
begin
  result := inherited Active;
end;

function TDASQLMemdataset.GetDataTable: TDADataTable;
begin
  result := TDADataTable(Owner);
end;

procedure TDASQLMemdataset.InternalRefresh;
begin

end;

end.