rmd_ado.pas

这是一个功能强大

end;

function TRMDADOQuery.GetParamCount: Integer;
begin
  Result := FQuery.Parameters.Count;
end;

function TRMDADOQuery.GetSQL: string;
begin
  Result := FQuery.SQL.Text;
end;

procedure TRMDADOQuery.SetSQL(Value: string);
begin
  FQuery.SQL.Text := Value;
end;

function TRMDADOQuery.GetDatabaseName: string;
begin
  Result := '';
  if FQuery.Connection <> nil then
  begin
    Result := FQuery.Connection.Name;
      //lxj
    if (FQuery.Connection.Owner <> nil) and (FQuery.Connection.Owner <> FQuery.Owner) then
      Result := FQuery.Connection.Owner.Name + '.' + Result;
  end;
end;

procedure TRMDADOQuery.SetDatabaseName(const Value: string);
var
  liComponent: TComponent;
begin
  FQuery.Close;
  liComponent := RMFindComponent(FQuery.Owner, Value);
    //lxj
  if (liComponent = nil) and (theThirdConnection <> nil) and (theThirdConnection.Name = Value) then
    liComponent := theThirdConnection;

  if (liComponent <> nil) and (liComponent is TADOConnection) then
    FQuery.Connection := TADOConnection(liComponent)
  else
    FQuery.Connection := nil;  
end;

function TRMDADOQuery.GetFilter: string;
begin
  Result := FQuery.Filter;
end;

procedure TRMDADOQuery.SetFilter(Value: string);
begin
  FQuery.Active := False;
  FQuery.Filter := Value;
  FQuery.Filtered := Value <> '';
end;

function TRMDADOQuery.GetDataSource: string;
begin
  Result := RMGetDataSetName(FQuery.Owner, FQuery.DataSource)
end;

procedure TRMDADOQuery.SetDataSource(Value: string);
var
  lComponent: TComponent;
begin
  lComponent := RMFindComponent(FQuery.Owner, Value);
  if (lComponent <> nil) and (lComponent is TDataSet) then
    FQuery.DataSource := RMGetDataSource(FQuery.Owner, TDataSet(lComponent))
  else
    FQuery.DataSource := nil;
end;

procedure TRMDADOQuery.GetDatabases(sl: TStrings);
var
  liStringList: TStringList;
begin
  liStringList := TStringList.Create;
  try
    RMGetComponents(RMDialogForm, TADOConnection, liStringList, nil);
    //lxj
    if theThirdConnection <> nil then
      liStringList.Add(theThirdConnection.Name);
    liStringList.Sort;
    sl.Assign(liStringList);
  finally
    liStringList.Free;
  end;
end;

procedure TRMDADOQuery.GetTableNames(DB: string; Strings: TStrings);
var
  sl: TStringList;
  lConnection: TADOConnection;
begin
  sl := TStringList.Create;
  try
    try
      lConnection := RMFindComponent(FQuery.Owner, DB) as TADOConnection;
      if lConnection = nil then exit;
      if not lConnection.Connected then
        lConnection.Connected := True;
      if lConnection.Connected then
        lConnection.GetTableNames(sl, False);
      sl.Sort;
      Strings.Assign(sl);
    except;
    end;
  finally
    sl.Free;
  end;
end;

procedure TRMDADOQuery.GetTableFieldNames(const DB, TName: string; sl: TStrings);
var
  i: Integer;
  lStrings: TStringList;
  t: TADOTable;
begin
  lStrings := TStringList.Create;
  t := TADOTable.Create(RMDialogForm);
  try
    t.Connection := RMFindComponent(FQuery.Owner, DB) as TADOConnection;
    t.TableName := tName;
    try
      t.FieldDefs.UpDate;
      for i := 0 to t.FieldDefs.Count - 1 do
        lStrings.Add(t.FieldDefs.Items[i].Name);
      lStrings.Sort;
      sl.Assign(lStrings);
    except;
    end;
  finally
    lStrings.Free;
    t.Free;
  end;
end;

function TRMDADOQuery.GetParamName(Index: Integer): string;
begin
  Result := FQuery.Parameters[Index].Name;
end;

function TRMDADOQuery.GetParamType(Index: Integer): TFieldType;
begin
  Result := FQuery.Parameters[Index].DataType;
end;

procedure TRMDADOQuery.SetParamType(Index: Integer; Value: TFieldType);
begin
  FQuery.Parameters[Index].DataType := Value;
end;

function TRMDADOQuery.GetParamKind(Index: Integer): TRMParamKind;
begin
  Result := rmpkValue;
  if not (paNullable in FQuery.Parameters[Index].Attributes) then
    Result := rmpkAssignFromMaster;
end;

procedure TRMDADOQuery.SetParamKind(Index: Integer; Value: TRMParamKind);
begin
  if Value = rmpkAssignFromMaster then
  begin
    FQuery.Parameters[Index].Attributes := [];
    FParams.Delete(FParams.IndexOf(FQuery.Parameters[Index].Name));
  end
  else
  begin
    FQuery.Parameters[Index].Attributes := [paNullable];
    FParams[FQuery.Parameters[Index].Name] := '';
  end;
end;

function TRMDADOQuery.GetParamText(Index: Integer): string;
var
  v: Variant;
begin
  v := '';
  if ParamKind[Index] = rmpkValue then
    v := FParams[FQuery.Parameters[Index].Name];
  if v = Null then
    v := '';
  Result := v;
end;

procedure TRMDADOQuery.SetParamText(Index: Integer; Value: string);
begin
  if ParamKind[Index] = rmpkValue then
    FParams[FQuery.Parameters[Index].Name] := Value;
end;

function TRMDADOQuery.GetParamValue(Index: Integer): Variant;
begin
  Result := FQuery.Parameters[Index].Value;
end;

procedure TRMDADOQuery.SetParamValue(Index: Integer; Value: Variant);
begin
  FQuery.Parameters[Index].Value := Value;
end;


{------------------------------------------------------------------------------}
{------------------------------------------------------------------------------}
{TRNDFormADOConnEdit}

procedure TRMDFormADOConnEdit.Localize;
begin
  Font.Name := RMLoadStr(SRMDefaultFontName);
  Font.Size := StrToInt(RMLoadStr(SRMDefaultFontSize));
  Font.Charset := StrToInt(RMLoadStr(SCharset));

  RMSetStrProp(SourceofConnection, 'Caption', rmRes + 3230);
  RMSetStrProp(UseDataLinkFile, 'Caption', rmRes + 3231);
  RMSetStrProp(UseConnectionString, 'Caption', rmRes + 3232);
  RMSetStrProp(Browse, 'Caption', rmRes + 3249);
  RMSetStrProp(Build, 'Caption', rmRes + 3251);

  btnOk.Caption := RMLoadStr(SOK);
  btnCancel.Caption := RMLoadStr(SCancel);
end;

function TRMDFormADOConnEdit.Edit(var ConnStr: WideString): boolean;
var
  FileName: string;
begin
  UseDataLinkFile.Checked := True;
  if Pos(CT_FILENAME, ConnStr) = 1 then
  begin
    FileName := Copy(ConnStr, Length(CT_FILENAME) + 1, MAX_PATH);
    if ExtractFilePath(FileName) = (DataLinkDir + '\') then
      DataLinkFile.Text := ExtractFileName(FileName)
    else
      DataLinkFile.Text := FileName;
  end
  else
  begin
    ConnectionString.Text := ConnStr;
    UseConnectionString.Checked := True;
  end;

  SourceButtonClick(nil);
  Result := FALSE;
  if ShowModal = mrOk then
  begin
    if UseConnectionString.Checked then
      ConnStr := ConnectionString.Text
    else if DataLinkFile.Text <> '' then
    begin
      if ExtractFilePath(DataLinkFile.Text) = '' then
        ConnStr := CT_FILENAME + DataLinkDir + '\' + DataLinkFile.Text
      else
        ConnStr := CT_FILENAME + DataLinkFile.Text
    end;
    Result := TRUE;
  end;
end;

procedure TRMDFormADOConnEdit.FormCreate(Sender: TObject);
begin
  Localize;
  GetDataLinkFiles(DataLinkFile.Items);
end;

procedure TRMDFormADOConnEdit.BrowseClick(Sender: TObject);
begin
  DataLinkFile.Text := PromptDataLinkFile(Handle, DataLinkFile.Text);
end;

procedure TRMDFormADOConnEdit.BuildClick(Sender: TObject);
begin
  ConnectionString.Text := PromptDataSource(Handle, ConnectionString.Text);
end;

const
  EnabledColor: array[Boolean] of TColor = (clBtnFace, clWindow);

procedure TRMDFormADOConnEdit.SourceButtonClick(Sender: TObject);
begin
  DataLinkFile.Enabled := UseDataLinkFile.Checked;
  DataLinkFile.Color := EnabledColor[DataLinkFile.Enabled];
  Browse.Enabled := DataLinkFile.Enabled;
  ConnectionString.Enabled := UseConnectionString.Checked;
  ConnectionString.Color := EnabledColor[ConnectionString.Enabled];
  Build.Enabled := ConnectionString.Enabled;
  if DataLinkFile.Enabled then
    ActiveControl := DataLinkFile
  else
    ActiveControl := ConnectionString;
end;


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

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

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

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

{------------------------------------------------------------------------------}
{------------------------------------------------------------------------------}
{ TConnectionStringEditor }

function TConnectionStringEditor.GetAttrs: TELPropAttrs;
begin
  Result := [praDialog];
end;

procedure TConnectionStringEditor.Edit;
begin
  TRMDADODatabase(GetInstance(0)).ShowEditor;
end;

{------------------------------------------------------------------------------}
{------------------------------------------------------------------------------}
{ TDatabaseEditor }

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

procedure TDatabaseEditor.GetValues(AValues: TStrings);
begin
  try
    RMGetComponents(RMDialogForm, TADOConnection, AValues, nil);
    //lxj
    if theThirdConnection <> nil then
      AValues.Add(theThirdConnection.Name);
  finally
  end;
end;

{------------------------------------------------------------------------------}
{------------------------------------------------------------------------------}
{ TIndexNameEditor }

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

procedure TIndexNameEditor.GetValues(AValues: TStrings);
var
  liTable: TRMDADOTable;
begin
  liTable := TRMDADOTable(GetInstance(0));
  liTable.GetIndexNames(aValues);
end;

{------------------------------------------------------------------------------}
{------------------------------------------------------------------------------}
{ TTableNameEditor }

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

procedure TTableNameEditor.GetValues(AValues: TStrings);
var
  liTable: TADOTable;
begin
  liTable := TRMDADOTable(GetInstance(0)).FTable;
  if liTable.Connection <> nil then
  begin
    liTable.Connection.GetTableNames(AValues);
  end;
end;

{------------------------------------------------------------------------------}
{------------------------------------------------------------------------------}
procedure TRMDADOQuery_ExecSql(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TRMDADOQuery(Args.Obj).OnBeforeOpenQueryEvent(TRMDADOQuery(Args.Obj).FQuery);
  TRMDADOQuery(Args.Obj).FQuery.ExecSQL;
end;

const
	cReportMachine = 'RMD_ADO';

procedure RM_RegisterRAI2Adapter(RAI2Adapter: TJvInterpreterAdapter);
begin
  with RAI2Adapter do
  begin
    AddClass(cReportMachine, TRMDADODatabase, 'TRMDADODataset');
    AddClass(cReportMachine, TRMDADOTable, 'TRMDADOTable');
    AddClass(cReportMachine, TRMDADOQuery, 'TRMDADOQuery');

    AddGet(TRMDDataset, 'ExecSql', TRMDADOQuery_ExecSql, 0, [0], varEmpty);
  end;
end;

initialization
//  RMRegisterControl(TRMDADODatabase, 'RMD_ADODB', RMLoadStr(SInsertDB) + '(ADO)');
//  RMRegisterControl(TRMDADOTable, 'RMD_ADOTABLE', RMLoadStr(SInsertTable) + '(ADO)');
//  RMRegisterControl(TRMDADOQuery, 'RMD_ADOQUERY', RMLoadStr(SInsertQuery) + '(ADO)');
  RMRegisterControls('ADO', 'RMD_ADOPATH', True,
    [TRMDADODatabase, TRMDADOTable, TRMDADOQuery],
    ['RMD_ADODB', 'RMD_ADOTABLE', 'RMD_ADOQUERY'],
    [RMLoadStr(SInsertDB), RMLoadStr(SInsertTable), RMLoadStr(SInsertQuery)]);

  RMRegisterPropEditor(TypeInfo(WideString), TRMDADODatabase, 'ConnectionString', TConnectionStringEditor);

  RMRegisterPropEditor(TypeInfo(string), TRMDADOTable, 'DatabaseName', TDatabaseEditor);
  RMRegisterPropEditor(TypeInfo(string), TRMDADOTable, 'IndexName', TIndexNameEditor);
  RMRegisterPropEditor(TypeInfo(string), TRMDADOTable, 'TableName', TTableNameEditor);

  RMRegisterPropEditor(TypeInfo(string), TRMDADOQuery, 'DatabaseName', TDatabaseEditor);

  RM_RegisterRAI2Adapter(GlobalJvInterpreterAdapter);

finalization
{$ENDIF}

end.