rmd_dbwrap.pas

这是一个功能强大

        else
        begin
          lParamText := ParamText[i];
          if (lParamText <> '') or (VarType(ParamValue[i]) = varEmpty) then
            ParamValue[i] := ParentReport.Parser.Calc(lParamText);
        end;
      end;
      Inc(i);
    end;
  except
    Memo.Clear;
    Memo.Add(ParamText[i]);
    //    raise;
  end;
end;

{------------------------------------------------------------------------------}
{------------------------------------------------------------------------------}
type
  TSQLBuilderEditor = class(TELStringPropEditor)
  protected
    function GetAttrs: TELPropAttrs; override;
    procedure Edit; override;
  end;

  TQueryParamsEditor = class(TELStringPropEditor)
  protected
    function GetAttrs: TELPropAttrs; override;
    procedure Edit; override;
  end;

  TDataSourceEditor = class(TELStringPropEditor)
  protected
    function GetAttrs: TELPropAttrs; override;
    procedure GetValues(AValues: TStrings); override;
  end;

  TMasterFieldsEditor = class(TRMDFieldLinkProperty)
  protected
    function GetMasterFields: string; override;
    procedure SetMasterFields(const Value: string); override;
    function GetIndexFieldNames: string; override;
    procedure SetIndexFieldNames(const Value: string); override;

    procedure Edit; override;
  end;

  TRMDQuery_DataSourceEditor = class(TELStringPropEditor)
  protected
    function GetAttrs: TELPropAttrs; override;
    procedure GetValues(AValues: TStrings); override;
  end;

  {------------------------------------------------------------------------------}
  {------------------------------------------------------------------------------}
  { TSQLBuilderEditor }

function TSQLBuilderEditor.GetAttrs: TELPropAttrs;
begin
  Result := [praDialog, praReadOnly];
end;

procedure TSQLBuilderEditor.Edit;
var
  tmp: TRMDQueryDesignerForm;
begin
  tmp := TRMDQueryDesignerForm.Create(nil);
  try
    tmp.Query := TRMDQuery(GetInstance(0));
    if tmp.ShowModal = mrOK then
    begin
      RMDesigner.BeforeChange;
      //      RMDesigner.AfterChange;
    end;
  finally
    tmp.Free;
  end;
end;

{------------------------------------------------------------------------------}
{------------------------------------------------------------------------------}
{ TQueryParamsEditor }

function TQueryParamsEditor.GetAttrs: TELPropAttrs;
begin
  Result := [praDialog, praReadOnly];
end;

procedure TQueryParamsEditor.Edit;
var
  liQuery: TRMDQuery;
  tmp: TRMDParamsForm;
begin
  liQuery := TRMDQuery(GetInstance(0));
  if liQuery.ParamCount > 0 then
  begin
    tmp := TRMDParamsForm.Create(nil);
    try
      tmp.Query := liQuery;
      tmp.Caption := liQuery.Name + ' ' + RMLoadStr(SParams);
      if tmp.ShowModal = mrOk then
      begin
        RMDesigner.BeforeChange;
      end;
    finally
      tmp.Free;
    end;
  end;
end;

{------------------------------------------------------------------------------}
{------------------------------------------------------------------------------}
{ TDataSourceEditor }

function TDataSourceEditor.GetAttrs: TELPropAttrs;
begin
  Result := [praValueList, praSortList];
end;

procedure TDataSourceEditor.GetValues(AValues: TStrings);
var
  liDataSet: TDataSet;
begin
  liDataSet := TRMDDataSet(GetInstance(0)).FDataSet;
  RMGetComponents(liDataSet.Owner, TDataSet, AValues, liDataSet);
end;

{------------------------------------------------------------------------------}
{------------------------------------------------------------------------------}
{ TMasterFieldsEditor }

procedure TMasterFieldsEditor.Edit;
begin
  inherited Edit;
  if Changed then
  begin
    if FullIndexName <> '' then
    begin
      TRMDTable(DataSet).IndexName := IndexName;
    end
    else
    begin
      TRMDTable(DataSet).IndexFieldNames := IndexFieldNames;
    end;  
  end;
end;

function TMasterFieldsEditor.GetMasterFields: string;
begin
  Result := TRMDTable(DataSet).MasterFields;
end;

procedure TMasterFieldsEditor.SetMasterFields(const Value: string);
begin
  TRMDTable(DataSet).MasterFields := Value;
end;

function TMasterFieldsEditor.GetIndexFieldNames: string;
begin
  Result := TRMDTable(DataSet).IndexFieldNames;
end;

procedure TMasterFieldsEditor.SetIndexFieldNames(const Value: string);
begin
  TRMDTable(DataSet).IndexFieldNames := Value;
end;

{------------------------------------------------------------------------------}
{------------------------------------------------------------------------------}
{ TRMDQuery_DataSourceEditor }

function TRMDQuery_DataSourceEditor.GetAttrs: TELPropAttrs;
begin
  Result := [praValueList, praSortList];
end;

procedure TRMDQuery_DataSourceEditor.GetValues(AValues: TStrings);
var
  liDataSet: TDataSet;
begin
  liDataSet := TRMDDataSet(GetInstance(0)).FDataSet;
  RMGetComponents(liDataSet.Owner, TDataSet, AValues, liDataSet);
end;

{------------------------------------------------------------------------------}
{------------------------------------------------------------------------------}

procedure TRMDDataset_FieldByName(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TRMDDataSet(Args.Obj).DataSet.FieldByName(Args.Values[0]));
end;

procedure TRMDDataset_FieldByVariant(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TRMDDataSet(Args.Obj).DataSet.FieldByName(Args.Values[0]).AsVariant;
end;

procedure TRMDDataset_FieldByString(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TRMDDataSet(Args.Obj).DataSet.Fields[Args.Values[0]].AsString;
end;

procedure TRMDDataset_FieldByNumber(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TRMDDataSet(Args.Obj).DataSet.Fields[Args.Values[0]].AsVariant;
end;

procedure TRMDDataset_FieldByBoolean(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TRMDDataSet(Args.Obj).DataSet.Fields[Args.Values[0]].AsBoolean;
end;

procedure TRMDDataset_FieldByDateTime(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TRMDDataSet(Args.Obj).DataSet.Fields[Args.Values[0]].AsDateTime;
end;

procedure TRMDDataset_Open(var Value: Variant; Args: TJvInterpreterArgs);
var
  liDataSet: TRMDDataSet;
  liComponent: TComponent;
  liDataSource: TDataSource;
begin
  liDataSet := TRMDDataSet(Args.Obj);
  if liDataSet is TRMDQuery then
  begin
    liComponent := RMFindComponent(liDataSet.DataSet.Owner, TRMDQuery(liDataSet).DataSource);
    if liComponent <> nil then
    begin
      liDataSource := RMGetDataSource(liDataSet.DataSet.Owner, TDataSet(liComponent));
      if (liDataSource <> nil) and (liDataSource.DataSet <> nil) then
        liDataSource.DataSet.Open;
    end;
  end;
  liDataSet.DataSet.Open;
end;

procedure TRMDDataset_Close(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TRMDDataSet(Args.Obj).DataSet.Close;
end;

procedure TRMDDataset_Next(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TRMDDataSet(Args.Obj).DataSet.Next;
end;

procedure TRMDDataset_Prior(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TRMDDataSet(Args.Obj).DataSet.Prior;
end;

procedure TRMDDataset_First(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TRMDDataSet(Args.Obj).DataSet.First;
end;

procedure TRMDDataset_Last(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TRMDDataSet(Args.Obj).DataSet.Last;
end;

procedure TRMDDataset_MoveBy(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TRMDDataSet(Args.Obj).DataSet.MoveBy(Args.Values[0]);
end;

procedure TRMDDataset_Locate(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TRMDDataSet(Args.Obj).DataSet.Locate(Args.Values[0], Args.Values[1], TLocateOptions(Byte(V2S(Args.Values[2]))));
end;

procedure TRMDDataset_Bof(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TRMDDataSet(Args.Obj).DataSet.Bof;
end;

procedure TRMDDataset_Eof(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TRMDDataSet(Args.Obj).DataSet.Eof;
end;

procedure TRMDQuery_SetParamValue(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TRMDQuery(Args.Obj).ParamValue[Args.Values[0]] := Args.Values[1];
end;

procedure TRMDQuery_SetParamValueByName(var Value: Variant; Args: TJvInterpreterArgs);
var
  i: Integer;
begin
  for i := 0 to TRMDQuery(Args.Obj).ParamCount - 1 do
  begin
    if AnsiCompareText(Args.Values[0], TRMDQuery(Args.Obj).ParamName[i]) = 0 then
    begin
      TRMDQuery(Args.Obj).ParamValue[i] := Args.Values[1];
      Break;
    end;
  end;
end;

const
  cReportMachine = 'RMD_DBWrap';

procedure RM_RegisterRAI2Adapter(RAI2Adapter: TJvInterpreterAdapter);
begin
  with RAI2Adapter do
  begin
    AddClass(cReportMachine, TRMDDataset, 'TRMDDataset');
    AddClass(cReportMachine, TRMDQuery, 'TRMDQuery');

    // TRMParamKind
    AddConst(cReportMachine, 'rmpkValue', rmpkValue);
    AddConst(cReportMachine, 'rmpkAssignFromMaster', rmpkAssignFromMaster);

    AddGet(TRMDDataset, 'FieldByName', TRMDDataset_FieldByName, 1, [0], varEmpty);
    AddGet(TRMDDataset, 'FieldByVariant', TRMDDataset_FieldByVariant, 1, [0], varEmpty);
    AddGet(TRMDDataset, 'FieldByString', TRMDDataset_FieldByString, 1, [0], varEmpty);
    AddGet(TRMDDataset, 'FieldByNumber', TRMDDataset_FieldByNumber, 1, [0], varEmpty);
    AddGet(TRMDDataset, 'FieldByBoolean', TRMDDataset_FieldByBoolean, 1, [0], varEmpty);
    AddGet(TRMDDataset, 'FieldByDateTime', TRMDDataset_FieldByDateTime, 1, [0], varEmpty);

    AddGet(TRMDDataset, 'Fields', TRMDDataset_FieldByName, 1, [0], varEmpty);
    AddGet(TRMDDataset, 'Open', TRMDDataset_Open, 0, [0], varEmpty);
    AddGet(TRMDDataset, 'Close', TRMDDataset_Close, 0, [0], varEmpty);
    AddGet(TRMDDataset, 'Next', TRMDDataset_Next, 0, [0], varEmpty);
    AddGet(TRMDDataset, 'Prior', TRMDDataset_Prior, 0, [0], varEmpty);
    AddGet(TRMDDataset, 'First', TRMDDataset_First, 0, [0], varEmpty);
    AddGet(TRMDDataset, 'Last', TRMDDataset_Last, 0, [0], varEmpty);
    AddGet(TRMDDataset, 'Last', TRMDDataset_MoveBy, 1, [0], varEmpty);
    AddGet(TRMDDataset, 'Locate', TRMDDataset_Locate, 3, [0], varEmpty);
    AddGet(TRMDDataset, 'Bof', TRMDDataset_Bof, 0, [0], varEmpty);
    AddGet(TRMDDataset, 'Eof', TRMDDataset_Eof, 0, [0], varEmpty);

    AddGet(TRMDQuery, 'SetParamValue', TRMDQuery_SetParamValue, 2, [0], varEmpty);
    AddGet(TRMDQuery, 'SetParamValueByName', TRMDQuery_SetParamValueByName, 2, [0], varEmpty);
  end;
end;

initialization
  RMRegisterPropEditor(TypeInfo(string), TRMDDataSet, 'MasterSource', TDataSourceEditor);

  RMRegisterPropEditor(TypeInfo(string), TRMDTable, 'MasterFields', TMasterFieldsEditor);

  RMRegisterPropEditor(TypeInfo(string), TRMDQuery, 'Datasource', TRMDQuery_DataSourceEditor);
  RMRegisterPropEditor(TypeInfo(string), TRMDQuery, 'SQL', TSQLBuilderEditor);
  RMRegisterPropEditor(TypeInfo(string), TRMDQuery, 'Parameters', TQueryParamsEditor);

  RM_RegisterRAI2Adapter(GlobalJvInterpreterAdapter);

end.