else SelectDBService.DBServiceClass := nil;
    SelectDBService.DBName := f.eDataBaseName.Text;
    Result := True;
  end;
  f.Free;

//  Index := SelectFromList(DBServiceList);
//  if Index >=0 then
//    Result := TCustomDBServiceClass(DBServiceList.Objects[Index]);
end;

procedure RegisterDefaultDBService();
begin
//  RegisterDBService('Oracle', TOracleDBService);
  RegisterDBService('Interbase', TInterbaseDBService);
  RegisterDBService('Informix', TInformixDBService);
//  RegisterDBService('MSSQL', TMSSQLDBService);
//  RegisterDBService('MSAccess', TMSAccessDBService);
//  RegisterDBService('MySQL', TMySQLDBService);
end;

{ Engines unils }

procedure InitAccessEngineList();
begin
  if AccessEngineList = nil then
    AccessEngineList := TStringList.Create;
end;

procedure ReleaseAccessEngineList;
var
  i: Integer;
begin
  if AccessEngineList <> nil then
  begin
    for i := 0 to AccessEngineList.Count-1 do
      TAccessEngineEh(AccessEngineList.Objects[i]).Free;
    FreeAndNil(AccessEngineList);
  end;
end;

procedure RegisterAccessEngine(EngineName: String; Engine: TAccessEngineEh);
var
  OldEngine: TAccessEngineEh;
begin
  InitAccessEngineList();
  OldEngine := GetAccessEngineByName(EngineName);
  if OldEngine <> nil then
    UnregisterAccessEngine(EngineName);
  AccessEngineList.AddObject(EngineName, Engine);
//  ShowMessage('AccessEngineList.Count = ' +  IntToStr(AccessEngineList.Count));
end;

procedure UnregisterAccessEngine(EngineName: String);
var
  DBEngineInx: Integer;
begin
// Realy need to release all DesignDataBases for every unit.finalization that have TXXXDesignDataBase.
// but now every unit have UnregisterAccessEngine
  ReleaseDesignDataBaseList;
  if AccessEngineList = nil then
    Exit;
  DBEngineInx := AccessEngineList.IndexOf(EngineName);
  if DBEngineInx > -1 then
  begin
    AccessEngineList.Objects[DBEngineInx].Free;
    AccessEngineList.Delete(DBEngineInx);
  end;
end;

function GetAccessEngineByName(EngineName: String): TAccessEngineEh;
var
  DBEngineInx: Integer;
begin
  Result := nil;
  if AccessEngineList = nil then
    Exit;
  DBEngineInx := AccessEngineList.IndexOf(EngineName);
  if DBEngineInx > -1 then
    Result := TAccessEngineEh(AccessEngineList.Objects[DBEngineInx]);
end;

(*function GUISelectAccessEngine(SelectDBService: TSelectDBService): Boolean;
var
  f: TfSelectFromList;
begin
  Result := False;
  f := TfSelectFromList.Create(Application);
  f.cbEngine.Items := AccessEngineList;
  f.cbDBService.Items := DBServiceList;
  f.eDataBaseName.Text := SelectDBService.DBName;
  if f.ShowModal = mrOk then
  begin
    if f.cbEngine.ItemIndex >= 0
      then SelectDBService.AccessEngine := TAccessEngineEh(AccessEngineList.Objects[f.cbEngine.ItemIndex])
      else SelectDBService.AccessEngine := nil;
    if f.cbDBService.ItemIndex >= 0
      then SelectDBService.DBServiceClass := TCustomDBServiceClass(DBServiceList.Objects[f.cbDBService.ItemIndex])
      else SelectDBService.DBServiceClass := nil;
    SelectDBService.DBName := f.eDataBaseName.Text;
    Result := True;
  end;
  f.Free;
end;*)

function GUISelectAccessEngine(SelectDBService: TSelectDBService): Boolean;
var
  f: TfSelectFromList;
begin
  Result := False;
  f := TfSelectFromList.Create(Application);
  if AccessEngineList <> nil then
    f.cbEngine.Items := AccessEngineList;
  if DBServiceList <> nil then
    f.cbDBService.Items := DBServiceList;
  f.eDataBaseName.Text := SelectDBService.DBName;
  f.DBServiceEngineList := GetDBServiceEngineList;
  if f.ShowModal = mrOk then
  begin
    if f.cbEngine.ItemIndex >= 0
      then SelectDBService.AccessEngine := TAccessEngineEh(AccessEngineList.Objects[f.cbEngine.ItemIndex])
      else SelectDBService.AccessEngine := nil;
    if f.cbDBService.ItemIndex >= 0
      then SelectDBService.DBServiceClass := TCustomDBServiceClass(f.cbDBService.Items.Objects[f.cbDBService.ItemIndex])
//      then SelectDBService.DBServiceClass := TCustomDBServiceClass(DBServiceList.Objects[f.cbDBService.ItemIndex])
      else SelectDBService.DBServiceClass := nil;
    SelectDBService.DBName := f.eDataBaseName.Text;
    Result := True;
  end;
  f.Free;
end;


procedure SetDesignSQLDataBaseProcEh(DataDriver: TCustomSQLDataDriverEh);
var
  sdb: TSelectDBService;
  DesignDataBase: TComponent;
begin
  if DataDriver.DesignDataBase <> nil then Exit;
  if GetDesignDataBaseList.Count > 0 then
  begin
    DesignDataBase := SelectDesignConnectionListEh(DesignDataBaseList);
    if (DesignDataBase <> nil) and (DesignDataBase <> DataDriver.DesignDataBase) then
      DataDriver.DesignDataBase := DesignDataBase;
  end else
  begin
    sdb := TSelectDBService.Create;
    if GUISelectAccessEngine(sdb) and (sdb.AccessEngine <> nil) then
      DataDriver.DesignDataBase := sdb.AccessEngine.CreateDesignDataBase(DataDriver, sdb.DBServiceClass, sdb.DBName);
    sdb.Free;
  end;
end;

{ DBServiceEngines unils }

var
  DBServiceEngineList: TObjectList = nil;

function GetDBServiceEngineList: TObjectList;
begin
  Result := DBServiceEngineList;
end;

procedure RegisterDBServiceEngine(AccessEngine: TAccessEngineEh; DBService: TCustomDBServiceClass);
var
  i: Integer;
begin
  if DBServiceEngineList = nil then
    DBServiceEngineList := TObjectList.Create(True);
  for i := 0 to DBServiceEngineList.Count-1 do
  begin
    if (TDBServiceItem(DBServiceEngineList[i]).AccessEngine = AccessEngine) and
       (TDBServiceItem(DBServiceEngineList[i]).DBService = DBService)
    then
    begin
      TDBServiceItem(DBServiceEngineList[i]).AccessEngine := AccessEngine;
      TDBServiceItem(DBServiceEngineList[i]).DBService := DBService;
      Exit;
    end;
  end;
  DBServiceEngineList.Add(TDBServiceItem.Create);
  TDBServiceItem(DBServiceEngineList[DBServiceEngineList.Count-1]).AccessEngine := AccessEngine;
  TDBServiceItem(DBServiceEngineList[DBServiceEngineList.Count-1]).DBService := DBService;
end;

procedure UnregisterDBServiceEngine(DBService: TCustomDBServiceClass);
var
  i: Integer;
begin
  if DBServiceEngineList = nil then
    DBServiceEngineList := TObjectList.Create(True);
  for i := 0 to DBServiceEngineList.Count-1 do
  begin
    if {(TDBServiceItem(DBServiceEngineList[i]).AccessEngine = AccessEngine) and}
       (TDBServiceItem(DBServiceEngineList[i]).DBService = DBService)
    then
    begin
      TObject(DBServiceEngineList.Extract(DBServiceEngineList[i])).Free;
      Exit;
    end;
  end;
end;

procedure ReleaseDBServiceEngineList;
begin
  if DBServiceEngineList <> nil then
    FreeAndNil(DBServiceEngineList);
end;

{ DesignDataBaseList }

function GetDesignDataBaseList: TObjectList;
begin
  if DesignDataBaseList = nil then
    DesignDataBaseList := TObjectList.Create(False);
  Result := DesignDataBaseList;
end;

procedure ReleaseDesignDataBaseList;
begin
  if DesignDataBaseList = nil then
    Exit;

  while DesignDataBaseList.Count > 0 do
    DesignDataBaseList[0].Free;

//  for i := 0 to DesignDataBaseList.Count-1 do
//    DesignDataBaseList[i] := nil; // Free as
  FreeAndNil(DesignDataBaseList);
end;

{ DesignDataBase unils }

var
  DesignDBClassList: TStringList = nil;

procedure InitDesignDBClassList();
begin
  if DesignDBClassList = nil then
    DesignDBClassList := TStringList.Create;
end;

procedure RegisterDesignDataBaseClass(EngineName: String; DesignDBClass: TDesignDataBaseClassEh);
var
  OldDesignClass: TDesignDataBaseClassEh;
begin
  InitDesignDBClassList();
  OldDesignClass := GetDesignDataBaseClassByName(EngineName);
  if OldDesignClass <> nil then
    UnregisterDesignDataBaseClass(EngineName);
  DesignDBClassList.AddObject(EngineName, TObject(DesignDBClass));
end;

procedure UnregisterDesignDataBaseClass(EngineName: String);
var
  DesignClassIdx: Integer;
begin
  if DesignDBClassList = nil then
    Exit;
  DesignClassIdx := DesignDBClassList.IndexOf(EngineName);
  if DesignClassIdx > -1 then
  begin
    DesignDBClassList.Objects[DesignClassIdx].Free;
    DesignDBClassList.Delete(DesignClassIdx);
  end;
end;

function GetDesignDataBaseClassByName(EngineName: String): TDesignDataBaseClassEh;
var
  DesignClassIdx: Integer;
begin
  Result := nil;
  if DesignDBClassList = nil then
    Exit;
  DesignClassIdx := DesignDBClassList.IndexOf(EngineName);
  if DesignClassIdx > -1 then
    Result := TDesignDataBaseClassEh(DesignDBClassList.Objects[DesignClassIdx]);
end;

function GUISelectDesignDataBaseClass: TDesignDataBaseClassEh;
begin
  Result := nil;
  if DesignDBClassList = nil then
    Exit;
end;

{ TDesignDataBaseEh }

constructor TDesignDataBaseEh.Create;
begin
  inherited Create(nil);
  GetDesignDataBaseList.Add(Self);
  FTreeDataSet := CreateTreeDataSet;
//  FTreeDataSet.Open;
end;

destructor TDesignDataBaseEh.Destroy;
begin
//  ShowMessage('TBDEDesignDataBaseEh.Destring');
  GetDesignDataBaseList.Remove(Self);
  FTreeDataSet.Close;
  FreeAndNil(FTreeDataSet);
  inherited Destroy;
//  ShowMessage('TBDEDesignDataBaseEh.Destred');
end;

{$IFNDEF EH_LIB_6}

function TDesignDataBaseEh.IntfGetComponent: TComponent;
begin
  Result := Self;
end;

{$ENDIF}

{
function TDesignDataBaseEh._AddRef: Integer;
begin
  Result := inherited _AddRef;
end;

function TDesignDataBaseEh._Release: Integer;
//var
//  OldRefCount: Integer;
begin
//  OldRefCount := RefCount;
  Result := inherited _Release;
//  if OldRefCount = 2 then
//    RemoveFromDesignDataBaseList;
end;

function TDesignDataBaseEh.QueryInterface(const IID: TGUID; out Obj): HResult;
begin
  Result := inherited QueryInterface(IID, Obj);
end;
}

procedure TDesignDataBaseEh.RemoveFromDesignDataBaseList;
begin
  GetDesignDataBaseList.Remove(Self);
end;

procedure TDesignDataBaseEh.EditDatabaseParams;
begin

end;

function TDesignDataBaseEh.GetEngineName: String;
begin
  Result := '';
end;

function TDesignDataBaseEh.GetFieldList(const TableName: string; DataSet: TDataSet): Boolean;
begin
  Result := False;
end;

function TDesignDataBaseEh.GetServerTypeName: String;
begin
  Result := '';
end;

procedure TDesignDataBaseEh.BuildQueryPlan(PlanTable: TMemTableEh;
  Command: TCustomSQLCommandEh);
begin
 //
end;

function TDesignDataBaseEh.GetConnected: Boolean;
begin
  Result := False;
end;

procedure TDesignDataBaseEh.SetConnected(const Value: Boolean);
begin
end;

function TDesignDataBaseEh.GetSpecParamsList: String;
begin
  Result := '';
end;

function TDesignDataBaseEh.GetCustomDBService: TCustomDBService;
begin
  Result := nil;
end;

function TDesignDataBaseEh.GetIncrementObjectsList: TStrings;
begin
  Result := nil;
end;