jvquibmetadata.pas

East make Tray Icon in delphi

        QNames.Next;
      end;
    end;

    // PROCEDURE
    if OIDProcedure in FOIDDatabases then
    begin
      FNodeItems[Ord(OIDProcedure)].Childs.Clear;
      QNames.SQL.Text := QRYProcedures;
      QFields.SQL.Text := QRYProcFields;
      QNames.Open;
      while not QNames.Eof do
      begin
        with TMetaProcedure.Create(Self, Ord(OIDProcedure)) do
          LoadFromQuery(QNames, QFields, QCharset, FOIDProcedures);
        QNames.Next;
      end;
    end;

    // EXCEPTION
    if OIDException in FOIDDatabases then
    begin
      FNodeItems[Ord(OIDException)].Childs.Clear;
      QNames.SQL.Text := QRYExceptions;
      QNames.Open;
      while not QNames.Eof do
      begin
        TMetaException.Create(Self, Ord(OIDException)).LoadFromQuery(QNames);
        QNames.Next;
      end;
    end;

    // UDF
    if OIDUDF in FOIDDatabases then
    begin
      FNodeItems[Ord(OIDUDF)].Childs.Clear;
      QNames.SQL.Text := QRYUDF;
      QFields.SQL.Text := QRYUDFFields;
      QNames.Open;
      while not QNames.Eof do
      begin
        TMetaUDF.Create(Self, Ord(OIDUDF)).LoadFromQuery(QNames, QFields, QCharset, FOIDUDFs);
        QNames.Next;
      end;
    end;

    // ROLES
    if OIDRole in FOIDDatabases then
    begin
      FNodeItems[Ord(OIDRole)].Childs.Clear;
      QNames.SQL.Text := QRYRoles;
      QNames.Open;
      while not QNames.Eof do
      begin
        TMetaRole.Create(Self, Ord(OIDRole)).LoadFromQuery(QNames);
        QNames.Next;
      end;
    end;
  finally
    QNames.Free;
    QCharset.Free;
    QFields.Free;
    QPrimary.Free;
    QIndex.Free;
    QForeign.Free;
    QCheck.Free;
    QTrigger.Free;
  end;
end;

procedure TMetaDataBase.SaveToDDL(Stream: TStringStream);
var
  I: Integer;

  procedure SaveChildNodes(comment: string; OIDParent, OIDChild: Integer;
    Separator: string = BreakLine);
  var
    I, J: Integer;
  begin
    if TablesCount > 0 then
    begin
      Stream.WriteString(NewLine);
      Stream.WriteString(Format('/* %s */', [comment]));
      Stream.WriteString(BreakLine);
      for I := 0 to FNodeItems[OIDParent].Childs.Count - 1 do
        for J := 0 to GetItems(OIDParent, I).FNodeItems[OIDChild].Childs.Count - 1 do
        begin
          Stream.WriteString(Separator);
          TMetaNode(GetItems(OIDParent, I).FNodeItems[OIDChild].Childs[J]).SaveToDDL(Stream);
        end;
    end;
  end;

  procedure SaveMainNodes(Comment: string; OID: Integer;
    Separator: string = NewLine);
  var
    I: Integer;
  begin
    if FNodeItems[OID].Childs.Count > 0 then
    begin
      Stream.WriteString(NewLine);
      Stream.WriteString(Format('/* %s */', [comment]));
      for I := 0 to FNodeItems[OID].Childs.Count - 1 do
      begin
        if I = 0 then
          Stream.WriteString(NewLine)
        else
          Stream.WriteString(Separator);
        if GetItems(OID, I) is TMetaProcedure then
          TMetaProcedure(GetItems(OID, I)).SaveToPostDDL(Stream)
        else
          GetItems(OID, I).SaveToDDLNode(Stream);
      end;
    end;
  end;

begin
  SaveMainNodes('ROLES', Ord(OIDRole), NewLine);
  SaveMainNodes('FUNCTIONS', Ord(OIDUDF), NewLine);
  SaveMainNodes('DOMAINS', Ord(OIDDomain), BreakLine);
  SaveMainNodes('GENERATORS', Ord(OIDGenerator));
  SaveMainNodes('EXEPTIONS', Ord(OIDException), BreakLine);
  SaveMainNodes('PROCEDURES', Ord(OIDProcedure));
  SaveMainNodes('TABLES', Ord(OIDTable));
  SaveMainNodes('VIEWS', Ord(OIDView));

  SaveChildNodes('UNIQUE', Ord(OIDTable), Ord(OIDUnique));
  SaveChildNodes('PRIMARY', Ord(OIDTable), Ord(OIDPrimary));
  SaveChildNodes('FOREIGN', Ord(OIDTable), Ord(OIDForeign));
  SaveChildNodes('INDICES', Ord(OIDTable), Ord(OIDIndex));
  SaveChildNodes('CHECKS', Ord(OIDTable), Ord(OIDCheck), NewLine);
  SaveChildNodes('TRIGGERS', Ord(OIDTable), Ord(OIDTableTrigger), NewLine);
  SaveChildNodes('TRIGGERS (Views)', Ord(OIDView), Ord(OIDViewTrigers), NewLine);

  if ProceduresCount > 0 then
  begin
    Stream.WriteString(NewLine);
    Stream.WriteString('/* PROCEDURES */');
    for I := 0 to ProceduresCount - 1 do
    begin
      Stream.WriteString(NewLine);
      Procedures[I].SaveToAlterDDL(Stream);
    end;
  end;

end;

function TMetaDataBase.GetGenerators(const Index: Integer): TMetaGenerator;
begin
  Result := TMetaGenerator(GetItems(Ord(OIDGenerator), Index));
end;

function TMetaDataBase.GetGeneratorsCount: Integer;
begin
  Result := FNodeItems[Ord(OIDGenerator)].Childs.Count
end;

function TMetaDataBase.GetTables(const Index: Integer): TMetaTable;
begin
  Result := TMetaTable(GetItems(Ord(OIDTable), Index));
end;

function TMetaDataBase.GetTablesCount: Integer;
begin
  Result := FNodeItems[Ord(OIDTable)].Childs.Count
end;

function TMetaDataBase.FindTableName(const TableName: string): TMetaTable;
var
  I: Integer;
begin
  Result := nil;
  for I := 0 to TablesCount - 1 do
    if Tables[I].Name = TableName then
    begin
      Result := Tables[I];
      Exit;
    end;
end;

function TMetaDataBase.FindTableIndex(const TableName: string): Integer;
begin
  for Result := 0 to TablesCount - 1 do
    if Tables[Result].Name = TableName then
      Exit;
  raise Exception.CreateFmt(EUIB_TABLESTRNOTFOUND, [TableName]);
end;

function TMetaDataBase.FindDomainIndex(const DomainName: string): Integer;
begin
  for Result := 0 to DomainsCount - 1 do
    if Domains[Result].Name = DomainName then
      Exit;
  raise Exception.CreateFmt(EUIB_DOMAINSTRNOTFOUND, [DomainName]);
end;

procedure TMetaDataBase.LoadFromStream(Stream: TStream);
begin
  ReadString(Stream, FName);
end;

function TMetaDataBase.GetViews(const Index: Integer): TMetaView;
begin
  Result := TMetaView(GetItems(Ord(OIDView), Index));
end;

function TMetaDataBase.GetViewsCount: Integer;
begin
  Result := FNodeItems[Ord(OIDView)].Childs.Count
end;

function TMetaDataBase.GetDomains(const Index: Integer): TMetaDomain;
begin
  Result := TMetaDomain(GetItems(Ord(OIDDomain), Index));
end;

function TMetaDataBase.GetDomainsCount: Integer;
begin
  Result := FNodeItems[Ord(OIDDomain)].Childs.Count
end;

function TMetaDataBase.GetProcedures(const Index: Integer): TMetaProcedure;
begin
  Result := TMetaProcedure(GetItems(Ord(OIDProcedure), Index));
end;

function TMetaDataBase.GetProceduresCount: Integer;
begin
  Result := FNodeItems[Ord(OIDProcedure)].Childs.Count
end;

function TMetaDataBase.GetExceptions(const Index: Integer): TMetaException;
begin
  Result := TMetaException(GetItems(Ord(OIDException), Index));
end;

function TMetaDataBase.GetExceptionsCount: Integer;
begin
  Result := FNodeItems[Ord(OIDException)].Childs.Count
end;

function TMetaDataBase.GetUDFS(const Index: Integer): TMetaUDF;
begin
  Result := TMetaUDF(GetItems(Ord(OIDUDF), Index));
end;

function TMetaDataBase.GetUDFSCount: Integer;
begin
  Result := FNodeItems[Ord(OIDUDF)].Childs.Count
end;

class function TMetaDataBase.NodeClass: string;
begin
  Result := 'Database';
end;

procedure TMetaDataBase.SaveToStream(Stream: TStream);
begin
  WriteString(Stream, FName);
  inherited SaveToStream(Stream);
end;

function TMetaDataBase.GetRoles(const Index: Integer): TMetaRole;
begin
  Result := TMetaRole(GetItems(Ord(OIDRole), Index));
end;

function TMetaDataBase.GetRolesCount: Integer;
begin
  Result := FNodeItems[Ord(OIDRole)].Childs.Count
end;

class function TMetaDataBase.NodeType: TMetaNodeType;
begin
  Result := MetaDatabase;
end;

function TMetaDataBase.FindProcName(const ProcName: string): TMetaProcedure;
var
  I: Integer;
begin
  for I := 0 to ProceduresCount - 1 do
    if Procedures[I].Name = ProcName then
    begin
      Result := Procedures[I];
      Exit;
    end;
  raise Exception.CreateFmt(EUIB_PROCSTRNOTFOUND, [ProcName]);
end;

//=== { TMetaConstraint } ====================================================

function TMetaConstraint.GetFields(const Index: Word): TMetaTableField;
begin
  Assert((FieldsCount > 0) and (Index < FieldsCount), IntToStr(Index) + ' ' + ClassName);
  Result := TMetaTable(FOwner).Fields[FFields[Index]];
end;

function TMetaConstraint.GetFieldsCount: Word;
begin
  Result := Length(FFields);
end;

class function TMetaConstraint.NodeClass: string;
begin
  Result := 'Constraint'
end;

procedure TMetaConstraint.LoadFromStream(Stream: TStream);
var
  I: Integer;
begin
  Stream.Read(I, SizeOf(I));
  SetLength(FFields, I);
  if I > 0 then
  begin
    ReadString(Stream, FName);
    for I := 0 to I - 1 do
    begin
      Stream.Read(FFields[I], SizeOf(FFields[I]));
      case NodeType of
        MetaForeign:
          Include(TMetaTable(FOwner).Fields[FFields[I]].FInfos, fForeign);
        MetaIndex:
          Include(TMetaTable(FOwner).Fields[FFields[I]].FInfos, fIndice);
        MetaPrimary:
          Include(TMetaTable(FOwner).Fields[FFields[I]].FInfos, fPrimary);
        MetaUnique:
          Include(TMetaTable(FOwner).Fields[FFields[I]].FInfos, fPrimary);
      end;
    end;
  end;
end;

procedure TMetaConstraint.SaveToStream(Stream: TStream);
var
  I: Integer;
begin
  I := FieldsCount;
  Stream.Write(I, SizeOf(I));
  if I > 0 then
  begin
    WriteString(Stream, FName);
    for I := 0 to I - 1 do
      Stream.Write(FFields[I], SizeOf(FFields[I]));
  end;
end;

class function TMetaConstraint.NodeType: TMetaNodeType;
begin
  Result := MetaConstraint;
end;

//=== { TMetaUnique } ========================================================

class function TMetaUnique.NodeClass: string;
begin
  Result := 'Unique';
end;

class function TMetaUnique.NodeType: TMetaNodeType;
begin
  Result := MetaUnique;
end;

procedure TMetaUnique.SaveToDDL(Stream: TStringStream);
var
  I: Integer;
begin
  Stream.WriteString(Format('ALTER TABLE %s ADD UNIQUE (',
    [TMetaTable(FOwner).FName]));
  for I := 0 to FieldsCount - 1 do
  begin
    Stream.WriteString(Fields[I].Name);
    if I <> FieldsCount - 1 then
      Stream.WriteString(', ');
  end;
  Stream.WriteString(');');
end;

//=== { TMetaPrimary } =======================================================

class function TMetaPrimary.NodeClass: string;
begin
  Result := 'Primary key';
end;

procedure TMetaPrimary.LoadFromQuery(Q: TJvUIBStatement);
var
  I: Integer;
begin
  FName := Trim(Q.Fields.AsString[0]);
  Q.FetchAll;
  SetLength(FFields, Q.Fields.RecordCount);
  for I := 0 to Q.Fields.RecordCount - 1 do
  begin
    Q.Fields.GetRecord(I);
    FFields[I] := TMetaTable(FOwner).Fin