sdreg.pas

SQLDirect Component Library is a light-weight Borland Database Engine replacement for Borland Delphi

{ TSDUpdateSQLEditor }
procedure TSDUpdateSQLEditor.Edit;
begin
  ExecuteVerb(2);
end;

procedure TSDUpdateSQLEditor.ExecuteVerb(Index: Integer);
begin
  case Index of
    0: ShowAboutBox;
    2: ShowUpdateSQLDesigner(Designer, TSDUpdateSQL(Component));
  end;
end;

function TSDUpdateSQLEditor.GetVerb(Index: Integer): string;
begin
  case Index of
    0: Result := GetAboutVerbName;
    1: Result := '-';
    2: Result := SUpdateSQLEditor;
  end;
end;

function TSDUpdateSQLEditor.GetVerbCount: Integer;
begin
  Result := 3;
end;

{ TSDScriptEditor }
procedure TSDScriptEditor.ExecuteVerb(Index: Integer);
begin
  case Index of
    0: ShowAboutBox;
  end;
end;

function TSDScriptEditor.GetVerb(Index: Integer): string;
begin
  case Index of
    0: Result := GetAboutVerbName;
  end;
end;

function TSDScriptEditor.GetVerbCount: Integer;
begin
  Result := 1;
end;


{ TSDStringProperty }
function TSDStringProperty.GetAttributes: TPropertyAttributes;
begin
  Result := [paValueList, paSortList, paMultiSelect];
end;

procedure TSDStringProperty.GetValues(Proc: TGetStrProc);
var
  I: Integer;
  Values: TStringList;
begin
  Values := TStringList.Create;
  try
    GetValueList(Values);
    for I := 0 to Values.Count - 1 do Proc(Values[I]);
  finally
    Values.Free;
  end;
end;


{ TSDSessionNameProperty }
procedure TSDSessionNameProperty.GetValueList(List: TStrings);
var
  i: Integer;
begin
  for i:=0 to Sessions.Count-1 do
    List.Add( Sessions[i].SessionName );
end;

{ TSDDatabaseNameProperty }
procedure TSDDatabaseNameProperty.GetValueList(List: TStrings);
var
  cmp: TPersistent;
begin
  cmp := GetComponent(0);
  if cmp is TSDScript then
    TSDScript(cmp).DBSession.GetDatabaseNames(List)
  else
    (cmp as TSDDataSet).DBSession.GetDatabaseNames(List);
end;

{ TSDStoredProcNameProperty }
procedure TSDStoredProcNameProperty.GetValueList(List: TStrings);
var
  sp: TSDStoredProc;
  db: TSDDatabase;
begin
  sp := (GetComponent(0) as TSDStoredProc);

  db := Sessions.FindDatabase( sp.DatabaseName );

  if (db = nil) and ((sp.Database = nil) or (not sp.Database.Connected)) then
    db := sp.OpenDatabase;      // it will raise 'Invalid session' exception, if session name is unknown
  if Assigned( db ) then
    Sessions.List[db.SessionName].GetStoredProcNames( db.DatabaseName, List );
end;


{ TSDParamsProperty }
function TSDParamsProperty.GetValue: string;
begin
  Result := Format('(%s)', [TSDHelperParams.ClassName]);
end;

function TSDParamsProperty.GetAttributes: TPropertyAttributes;
begin
  Result := [paMultiSelect, paDialog];
end;


{ TSDQueryParamsProperty }
procedure TSDQueryParamsProperty.Edit;
var
  q: TSDQuery;
begin
  q := GetComponent(0) as TSDQuery;
  if ShowQueryParamsEditor(Designer, q) then
    Modified;
end;

{ TSDStoredParamsProperty }
procedure TSDStoredProcParamsProperty.Edit;
var
  sp: TSDStoredProc;
begin
  sp := GetComponent(0) as TSDStoredProc;
  if ShowStoredProcParamsEditor(Designer, sp) then
    Modified;
end;

{ TSDTableNameProperty }

function TSDTableNameProperty.AutoFill: Boolean;
begin
  Result := IsDatabaseOpen(GetComponent(0) as TSDDataSet);
end;

procedure TSDTableNameProperty.GetValueList(AList: TStrings);
begin
  with GetComponent(0) as TSDTable do
    Session.GetTableNames(DatabaseName, '', False, AList);
end;

{$IFDEF SD_VCL5}

{ TSDTableFieldLinkProperty }

procedure TSDTableFieldLinkProperty.Edit;
var
  Table: TSDTable;
begin
  Table := DataSet as TSDTable;
  FTable := TSDTable.Create(nil);
  try
    FTable.SessionName := Table.SessionName;
    FTable.DatabaseName := Table.DatabaseName;
    FTable.TableName := Table.TableName;
    if Table.IndexFieldNames <> '' then
      FTable.IndexFieldNames := Table.IndexFieldNames
    else
      FTable.IndexName := Table.IndexName;
    FTable.MasterFields := Table.MasterFields;
    FTable.Open;
    inherited Edit;
    if Changed then begin
      Table.MasterFields := FTable.MasterFields;
      if FTable.IndexFieldNames <> '' then
        Table.IndexFieldNames := FTable.IndexFieldNames
      else
        Table.IndexName := FTable.IndexName;
    end;
  finally
    FTable.Free;
  end;
end;

procedure TSDTableFieldLinkProperty.GetFieldNamesForIndex(List: TStrings);
var
  i: Integer;
begin
  for i := 0 to FTable.IndexFieldCount - 1 do
    List.Add(FTable.IndexFields[i].FieldName);
end;

function TSDTableFieldLinkProperty.GetIndexBased: Boolean;
begin
  Result := not IProviderSupport(FTable).PSIsSQLBased;
end;

function TSDTableFieldLinkProperty.GetIndexDefs: TIndexDefs;
begin
  Result := FTable.IndexDefs;
end;

function TSDTableFieldLinkProperty.GetIndexFieldNames: string;
begin
  Result := FTable.IndexFieldNames;
end;

function TSDTableFieldLinkProperty.GetIndexName: string;
begin
  Result := FTable.IndexName;
end;

function TSDTableFieldLinkProperty.GetMasterFields: string;
begin
  Result := FTable.MasterFields;
end;

procedure TSDTableFieldLinkProperty.SetIndexFieldNames(const Value: string);
begin
  FTable.IndexFieldNames := Value;
end;

procedure TSDTableFieldLinkProperty.SetIndexName(const Value: string);
begin
  if Value = SPrimary then
    FTable.IndexName := '' else
    FTable.IndexName := Value;
end;

procedure TSDTableFieldLinkProperty.SetMasterFields(const Value: string);
begin
  FTable.MasterFields := Value;
end;

{ TSDSessionSprig }
(*
function TSDSessionSprig.Name: string;
begin
  Result := TSDSession(Item).SessionName;
end;

function TSDSessionSprig.AnyProblems: Boolean;
begin
  Result := TSDSession(Item).SessionName = '';
end;

function TSDSessionSprig.Caption: string;
begin
  Result := CaptionFor(Name, UniqueName);
end;

{ TSDDatabaseSprig }

function TSDDatabaseSprig.Name: string;
begin
  Result := TSDDatabase(Item).DatabaseName;
end;

function TSDDatabaseSprig.AnyProblems: Boolean;
begin
  Result := TSDDatabase(Item).DatabaseName = '';
end;

function TSDDatabaseSprig.Caption: string;
var
  vName: string;
begin
  vName := Name;
  if TSDDatabase(Item).DatabaseName <> '' then
    Result := Format('%s:%s', [vName, TSDDatabase(Item).DatabaseName]); { Do not localize }
  Result := CaptionFor(vName, UniqueName);
end;
 {
procedure TDatabaseSprig.FigureParent;
var
  vSessionName: string;
  vSession: TSprig;
begin
  with TDatabase(Item) do
  begin
    // find real or default session
    vSessionName := SprigBDESessionName(SessionName);
    vSession := Root.Find(vSessionName, False);

    // if not found see if its the default session
    if (vSession = nil) and
       (vSessionName = cDefaultSessionSprigName) then
      vSession := Root.Add(TDefaultSessionSprig.Create(nil));

    // still not found, try for an implied session
    if vSession = nil then
    begin
      vSession := Root.Find(SprigBDEImpliedSessionName(SessionName), False);

      // if not make an implied session
      if vSession = nil then
      begin
        vSession := Root.Add(TImpliedSessionSprig.Create(nil));
        TImpliedSessionSprig(vSession).FSessionName := SessionName;
      end;
    end;

    // well put it
    vSession.Add(Self);
  end;
end;

function TDatabaseSprig.DragDropTo(AItem: TSprig): Boolean;
begin
  if AItem is TSessionSprig then
  begin
    Result := not AnsiSameText(TSession(AItem.Item).SessionName, TDatabase(Item).SessionName);
    if Result then
      TDatabase(Item).SessionName := TSession(AItem.Item).SessionName;
  end
  else if AItem is TImpliedSessionSprig then
  begin
    Result := not AnsiSameText(TImpliedSessionSprig(AItem).FSessionName, TDatabase(Item).SessionName);
    if Result then
      TDatabase(Item).SessionName := TImpliedSessionSprig(AItem).FSessionName;
  end
  else if AItem is TDefaultSessionSprig then
  begin
    Result := not AnsiSameText(TDatabase(Item).SessionName, Session.SessionName) or
              (TDatabase(Item).SessionName <> '');
    if Result then
      TDatabase(Item).SessionName := '';
  end
  else
    Result := False;
  ReparentChildren;
end;

function TDatabaseSprig.DragOverTo(AItem: TSprig): Boolean;
begin
  Result := ((AItem is TSessionSprig) and (TSession(AItem.Item).SessionName <> '')) or
            (AItem is TImpliedSessionSprig) or
            (AItem is TDefaultSessionSprig);
end;

class function TDatabaseSprig.PaletteOverTo(AParent: TSprig; AClass: TClass): Boolean;
begin
  Result := ((AParent is TSessionSprig) and (TSession(AParent.Item).SessionName <> '')) or
            (AParent is TImpliedSessionSprig) or
            (AParent is TDefaultSessionSprig);
end;
}
{ TSDDataSetSprig }

function TSDDataSetSprig.AnyProblems: Boolean;
begin
  Result := inherited AnyProblems or
            (TSDDataSet(Item).DatabaseName = '');
end;

{ TSDTableSprig }

function TSDTableSprig.AnyProblems: Boolean;
begin
  Result := inherited AnyProblems or
            (TSDTable(Item).TableName = '');
end;

function TSDTableSprig.Caption: string;
begin
  Result := CaptionFor(TSDTable(Item).TableName, UniqueName);
end;

{ TSDQuerySprig }

function TSDQuerySprig.AnyProblems: Boolean;
begin
  Result := inherited AnyProblems or
            (TSDQuery(Item).SQL.Count = 0);
end;

{ TSDStoredProcSprig }

function TSDStoredProcSprig.AnyProblems: Boolean;
begin
  Result := inherited AnyProblems or
            (TSDStoredProc(Item).StoredProcName = '');
end;

function TSDStoredProcSprig.Caption: string;
begin
  Result := CaptionFor(TSDStoredProc(Item).StoredProcName, UniqueName);
end;

{ TSDUpdateSQLSprig }

function TSDUpdateSQLSprig.AnyProblems: Boolean;
begin
  with TSDUpdateSQL(Item) do
    Result := (ModifySQL.Count = 0) and
              (InsertSQL.Count = 0) and
              (DeleteSQL.Count = 0);
end;

{ TSDQueryMasterDetailBridge }

function TSDQueryMasterDetailBridge.Caption: string;
begin
  Result := SParamsFields;
end;

class function TSDQueryMasterDetailBridge.GetOmegaSource(
  AItem: TPersistent): TDataSource;
begin
  Result := TSDQuery(AItem).DataSource;
end;

class function TSDQueryMasterDetailBridge.OmegaIslandClass: TIslandClass;
begin
  Result := TSDQueryIsland;
end;

class function TSDQueryMasterDetailBridge.RemoveMasterFieldsAsWell: Boolean;
begin
  Result := False;
end;

class procedure TSDQueryMasterDetailBridge.SetOmegaSource(AItem: TPersistent;
  ADataSource: TDataSource);
begin
  TSDQuery(AItem).DataSource := ADataSource;
end;

{ TSDTableMasterDetailBridge }

class function TSDTableMasterDetailBridge.GetOmegaSource(
  AItem: TPersistent): TDataSource;
begin
  Result := TSDTable(AItem).MasterSource;
end;

class function TSDTableMasterDetailBridge.OmegaIslandClass: TIslandClass;
begin
  Result := TSDTableIsland;
end;

class procedure TSDTableMasterDetailBridge.SetOmegaSource(AItem: TPersistent;
  ADataSource: TDataSource);
begin
  TSDTable(AItem).MasterSource := ADataSource;
end;

function TSDTableMasterDetailBridge.CanEdit: Boolean;
begin
  Result := True;
end;

function TSDTableMasterDetailBridge.Edit: Boolean;
var
  vPropEd: TSDTableFieldLinkProperty;
begin
  vPropEd := TSDTableFieldLinkProperty.CreateWith(TDataSet(Omega.Item));
  try
    vPropEd.Edit;
    Result := vPropEd.Changed;
  finally
    vPropEd.Free;
  end;
end;

function TSDTableMasterDetailBridge.Caption: string;
begin
  if TSDTable(Omega.Item).MasterFields = '' then
    Result := SNoMasterFields
  else
    Result := TSDTable(Omega.Item).MasterFields;
end;
 *)
{$ENDIF}

procedure Register;
begin
{$IFDEF EVAL}
  ShowReminderBox;
{$ENDIF}

  RegisterComponents(srSQLDirect, [TSDSession, TSDDatabase, TSDQuery, TSDMacroQuery, TSDStoredProc, TSDTable, TSDUpdateSQL, TSDScript, TSDSQLBaseServer]);

  RegisterPropertyEditor(TypeInfo(string),	TSDDatabase, 'SessionName', TSDSessionNameProperty);
  RegisterPropertyEditor(TypeInfo(string),	TSDDataSet, 'DatabaseName', TSDDatabaseNameProperty);
  RegisterPropertyEditor(TypeInfo(string),	TSDDataSet, 'SessionName', TSDSessionNameProperty);
  RegisterPropertyEditor(TypeInfo(string),	TSDScript, 'DatabaseName', TSDDatabaseNameProperty);
  RegisterPropertyEditor(TypeInfo(string),	TSDScript, 'SessionName', TSDSessionNameProperty);
  RegisterPropertyEditor(TypeInfo(string), 	TSDStoredProc, 'StoredProcName', TSDStoredProcNameProperty);
  RegisterPropertyEditor(TypeInfo(string), 	TSDTable, 'TableName', TSDTableNameProperty);
{$IFDEF SD_VCL5}
  RegisterPropertyEditor(TypeInfo(string), 	TSDTable, 'IndexName', TIndexNameProperty);
  RegisterPropertyEditor(TypeInfo(string), 	TSDTable, 'IndexFieldNames', TIndexFieldNamesProperty);
  RegisterPropertyEditor(TypeInfo(string), 	TSDTable, 'MasterFields', TSDTableFieldLinkProperty);
{$ENDIF}

{$IFDEF SD_VCL4}
  RegisterPropertyEditor(TypeInfo(TParams),	TSDQuery, 'Params', TSDQueryParamsProperty);
  RegisterPropertyEditor(TypeInfo(TParams),	TSDStoredProc, 'Params', TSDStoredProcParamsProperty);
{$ELSE}
  RegisterPropertyEditor(TypeInfo(TSDParams),	TSDQuery, 'Params', TSDQueryParamsProperty);
  RegisterPropertyEditor(TypeInfo(TSDParams),	TSDStoredProc, 'Params', TSDStoredProcParamsProperty);
{$ENDIF}
  RegisterComponentEditor(TSDSession, TSDDefaultEditor);
  RegisterComponentEditor(TSDDatabase, TSDDefaultEditor);

  RegisterComponentEditor(TSDDataSet, TSDDataSetEditor);
  RegisterComponentEditor(TSDQuery, TSDQueryEditor);
  RegisterComponentEditor(TSDStoredProc, TSDStoredProcEditor);
  RegisterComponentEditor(TSDUpdateSQL, TSDUpdateSQLEditor);
  RegisterComponentEditor(TSDScript, TSDScriptEditor);  

  RegisterComponentEditor(TSDSQLBaseServer, TSDDefaultEditor);

{$IFDEF SD_VCL5}
    { Property Category registration }
  RegisterPropertiesInCategory(
        {$IFDEF SD_VCL6}sDatabaseCategoryName{$ELSE}TDatabaseCategory{$ENDIF},
        TSDDatabase,
        ['ServerType', 'SessionName', 'DatabaseName', 'RemoteDatabase']);

  RegisterPropertiesInCategory(
        {$IFDEF SD_VCL6}sDatabaseCategoryName{$ELSE}TDatabaseCategory{$ENDIF},
        TSDDataSet,
        ['DatabaseName']);

  RegisterPropertiesInCategory(
        {$IFDEF SD_VCL6}sDatabaseCategoryName{$ELSE}TDatabaseCategory{$ENDIF},
        TSDDataSetUpdateObject,
        ['*SQL']);

(* implement later
	{ Register leaf types in Delphi's Object Treeview (TreeIntf.pas) }
  RegisterSprigType(TSDSession, TSDSessionSprig);
  RegisterSprigType(TSDDatabase, TSDDatabaseSprig);
  RegisterSprigType(TSDDataSet, TSDDataSetSprig);
  RegisterSprigType(TSDTable, TSDTableSprig);
  RegisterSprigType(TSDQuery, TSDQuerySprig);
  RegisterSprigType(TSDStoredProc, TSDStoredProcSprig);
  RegisterSprigType(TSDUpdateSQL, TSDUpdateSQLSprig);
	{ (DiagramSupport.pas) }
  RegisterIslandType(TSDDataSetSprig, TSDDataSetIsland);
  RegisterIslandType(TSDTableSprig, TSDTableIsland);
  RegisterIslandType(TSDQuerySprig, TSDQueryIsland);

  RegisterBridgeType(TDataSetIsland, TSDQueryIsland, TSDQueryMasterDetailBridge);
  RegisterBridgeType(TDataSetIsland, TSDTableIsland, TSDTableMasterDetailBridge);
*)
{$ENDIF}
end;

end.