SQL Dateien als Resource einbinden.

[MaBuSE]

Tutorial
SQL-Dateien als Resource einbinden

http://www.delphipraxis.net/images/common/divider.jpg
Autor: MaBuSE für www.delphipraxis.net
Stand: 12.07.2005
(c) 2004-2005, MaBuSE
Das Tutorial wurde mit Delphi 7 getestet
Mein besonderer Dank für die Arbeit in der DP und Unterstützung für mich geht an:
Daniel, Sakura, Gerome und an alle Moderatoren
http://www.delphipraxis.net/images/common/divider.jpg

Warum dieses Turorial?

• Oft soll es vermieden werden SQL Statements als Harccode fest im Programm zu implementieren.
  z.B.:
  
  Delphi-Quellcode:

  Query1.Close;
  Query1.SQL.Text := 'select * from Tabelle';
  Query1.Open;

  Wenn ein SQL Server benutzt wird, bieten sie so genannte StoredProcs an. Das sind Prozeduren, die in der Datenbank liegen und von Delphi aus aufgerufen werden. Leider benutzt jeder SQL Server eine andere Syntax. (Oracle = PLSQL, MS-SQL = Transact SQL, ...) Wenn nun ein Programm für verschiedene SQL-Server geschrieben wird, hat man ein Problem. Die BDE kann z.B. mit verschiedenen SQL Servern umgehen, aber auch nur wenn nur der SQL Umfang benutzt wird den alle SQL Server können. Sobald einige SQL Server spezifischen Spezialitäten verwendet werden, ist es aus mit der Version für alle Server.
  
  Wenn man grundsätzlich kein SQL im Pascal Quelltext haben möchte, bietet sich folgende Lösung an:
  
  Die SQL Statements werden einfach in eine Resource verpackt und dann zur Laufzeit ausgelesen.
  
  Das kann man natürlich analog auch für alle anderen Dateien machen (*.jpg, *.wav, ...)
  
  Da diese Dateien nun im Ordner \Source\SQL zu finden sind, kann man sich sicher sein, das nach Änderungen an den Statements keine vergessen wurden.
  Früher musste man dazu den kompletten Quelltext durchsuchen und auch in alle *.dfm Dateien schauen.

Wie geht das?

• Das ist sehr einfach.
  
  Wir verwenden z.B. folgende Struktur:
  
  X:\Source - hier liegt der Quelltext der Delphianwendung (*.dpr, *.pas, *.dfm, ...)
  X:\Source\SQL - hier liegen die einzubindenden SQL Dateien (*.sql)
  
  Für jede Query wird ein eigenes SQL-File angelegt.
  In unserem Fall:
  • Query01.sql
    (Inhalt: select * from Tabelle01)
  • Query02.sql
    (Inhalt: select * from Tabelle02)
  Wir legen ein neues Projekt an. (Menü: Datei -> Neu -> Anwendung)
  In der Projektverwaltung klicken wir Project1.exe mit rechts an und wählen "Hinzufügen..."
  In dem Hinzufügen Dialog wählen wir in X:\Source\SQL die Datei Query01.sql aus.
  
  In das Delphi Projekt (Project1.dpr) wird nun folgende Zeile hinzugefügt und die SQL-Datei erscheint in der Projektverwaltung.
  
  Delphi-Quellcode:

  {%File 'SQL\Query01.sql'}

  Ich persönlich schreibe nur die Zeilen in das *.dpr und gehe nicht den visuellen Weg.
  
  Das gleiche machen wir mit der Query02.sql Datei.
  
  Damit sind die Dateien zwar in der IDE dem Projekt zugeordnet, aber der Compiler bindet diese nicht ein.
  
  Dazu muss eine *.res Datei erzeugt werden.
  
  Wir erzeugen eine Textdatei Names X:\Source\SqlDateien.rc
  In diese Datei schreiben wir folgenden Text:
  
  Code:

  // Hier werden die SQL Dateien als Resource eingebunden
  Query01  TEXT  ".\SQL\Query01.sql"
  Query02  TEXT  ".\SQL\Query02.sql"

  Diese Datei binden wir mit einem Rechtsklick in der Projektverwaltung "Hinzufügen..." ein.
  Es wird nun folgende Zeile eingefügt:
  
  Delphi-Quellcode:

  {$R 'SqlDateien.res' 'SqlDateien.rc'}

  Unsere Project1.dpr sieht nun wie folgt aus:
  
  Delphi-Quellcode:

  program Project1;
  
  {%File 'SQL\Query01.sql'}
  {%File 'SQL\Query02.sql'}
  {$R 'SqlDateien.res' 'SqlDateien.rc'}
  
  uses
    Forms,
    Unit1 in 'Unit1.pas' {Form1};
  
  {$R *.res}
  
  begin
    Application.Initialize;
    Application.CreateForm(TForm1, Form1);
    Application.Run;
  end.

  Wenn nun ein Build (Menü: Projekt -> Project1 erzeugen) aufgerufen wird, wird nach dem Kompilieren in der "linken" Phase das *.rc File in ein *.res File umgewandelt.
  Dieses *.res File wird dann in die Exe eingebunden.
  
  Geschafft!

Super, aber wie kommt man nun wieder an den SQL-Text rann?

• Das ist auch ganz einfach.
  
  In das Form1 legen wir nun 2 TButtons und ein TMemo Feld ab.
  Auf den 1. Button legen wir folgenden Quelltext:
  
  Delphi-Quellcode:

  procedure TForm1.Button1Click(Sender: TObject);
  var
    tmpStream: TResourceStream;
  begin
    tmpStream := TResourceStream.Create( HInstance, 'Query01', 'TEXT' );
    try
      Memo1.Lines.LoadFromStream( tmpStream );
    finally
      tmpStream.Free;
    end;
  end;

  Auf den 2. Button analog dazu diesen Quelltext:
  
  Delphi-Quellcode:

  procedure TForm1.Button2Click(Sender: TObject);
  var
    tmpStream: TResourceStream;
  begin
    tmpStream := TResourceStream.Create( HInstance, 'Query02', 'TEXT' );
    try
      Memo1.Lines.LoadFromStream( tmpStream );
    finally
      tmpStream.Free;
    end;
  end;

  Ich laden den Text hier im Beispiel nur in ein Memo, in Eurem Programm müsst Ihr natürlich etwas in folgender Art schreiben:
  
  Delphi-Quellcode:

  procedure TForm1.Button1Click(Sender: TObject);
  var
    tmpStream: TResourceStream;
  begin
    Query1.Close;
    tmpStream := TResourceStream.Create( HInstance, 'Query02', 'TEXT' );
    try
      Query1.SQL.LoadFromStream( tmpStream );
    finally
      tmpStream.Free;
    end;
    Query1.Open;
  end;

  Natürlich können im SQL Text auch Parameter (z.B. ":ParName") definiert werden, die dann im TParams Initialisiert und mit folgenden Delphi Quelltext zugewiesen werden können:
  
  Delphi-Quellcode:

  Query1.ParamByName('paramName').AsString := 'blabla';

Anmerkung / Tipps & Tricks

• Problem: Wenn Änderungen an den SQL-Dateien vorgenommen werden, kann es sein, das Delphi das nicht automatisch erkennt und diese Änderungen nicht in das *.res File aufnimmt.
  Lösung: Einfach das *.res File mit den SQL Dateien löschen, es wird dann beim Build ein Neues angelegt. (Im Beispiel ist das SqlDateien.res)

Ich hoffe dieses Tutorial hilft Euch ein wenig...
mfg
MaBuSE

[shmia]

Ich gebe mal meine Anmerkungen dazu: :zwinker:

Man darf auch Kommentare in den SQL-Dateien einbauen.
Diese Kommentare müssen aber vor dem Öffnen der Query gelöscht werden.
Kommentare sind einzeilig und werden mit -- oder // eingeleitet.
Dazu folgende Procedure:

Delphi-Quellcode:

procedure CleanSqlStrings(SQL:TStrings);
var
   s : string;
   i : Integer;
begin
   Assert(Assigned(SQL));

   for i := SQL.Count-1 downto 0 do
   begin
      s := Copy(SQL[i],1 ,2);
      if (s = '--') or (s='//') then
         // Kommentarzeile entfernen
         SQL.Delete(i);
   end;
end;

Und jetzt noch das Ganze zusammengesetzt:

Delphi-Quellcode:

procedure LoadSQLFromResource(SQL:TStrings; const ResourceName:string);
var 
  tmpStream: TResourceStream; 
begin 
  Assert(Assigned(SQL));
  tmpStream := TResourceStream.Create( HInstance, ResourceName, 'TEXT' ); 
  try 
    SQL.LoadFromStream(tmpStream );  // Laden
    CleanSQLStrings(SQL);            // Kommentare löschen
  finally 
    tmpStream.Free; 
  end; 
end;

[MaBuSE]

Zitat:

Zitat von shmia

Man darf auch Kommentare in den SQL-Dateien einbauen.

Danke für die Ergänzung des Tutorials.

Die Funktionalität kann man noch beliebig erweitern.

Ich habe mal eine relativ komplexe Unit gebaut, in der noch viel mehr gemacht wurde.

• Komentare wurden angepasst (je nach SQL Server -- oder auch was anderes)
• Parameter wurden geparst und in TParams initialisiert (mit Typangabe und InputOutput, ...)
• Scripte wurden in einzelne Statements zerlegt und nacheinander abgearbeitet
• Transaktionshandling
• bestimmte pattern wurden je nach SQL Server in unterschiedliche SQL Statements "übersetzt"
• Macros
• einfache Scriptsprache (in verbindung mit Macros)
• Logging funkionalität zum "debuggen" in der Produktion
• ...

aber ich wollte das Tutorial nicht alzu kompiziert machen

Weitere Ansätze sind, SQL-Resourcen an DLL binden und ein einheitliches Interface schaffen (z.B. getSQL('ResourceName'):string).
Diese *.dll Datei kann von mehrern Anwendungen benutzt werden.
Bei Datenbankänderungen muß "nur" die *.dll Datei angepasst und ausgeliefert werden.
Stichwort: DAL = Data Abstraction Layer

Leider darf ich diesen Quelltext nicht veröffentlichen, da ich nicht die Rechte daran habe. (war Auftragsarbeit für einen Kunden)
...

[Luckie]

Warum über eine Ressourcendatei gehen? Gleiches erreicht man einfacher mit resourcenstrings.

[Flocke]

... oder man schreibt einfach *ALLE* Statements als Konstanten (oder Resourcestring) in eine Unit, da kann man dann sogar mit einem Conditional zwischen den Servern umschalten.

[MaBuSE]

Zitat:

Zitat von Luckie

Warum über eine Ressourcendatei gehen? Gleiches erreicht man einfacher mit resourcenstrings.

Die Dateien liegen einzeln (Pro Statement/Skript in einer *.sql Datei)
Die Dateien liegen wiederum in einer Versionsverwaltung und werden von mehreren Programmierern bearbeitet.
Die SQL Dateien können so sehr leicht in z.B: TOAD benutzt und erweitert werden.
In dem Projekt waren es ca. 2700 SQL Dateien (komplexe Verzeichnisstruktur).
Und ca. 15 Leute die diese Dateien bearbeitet haben. (Alles keine Delphi Programmierer!)
Es gab ein paar Duzend *.dll Dateien die SQL-Dateien nach der obigen Methode eingebunden haben. (Jeweils ein Subset, aber auch redundante Statements)
Das ist der Grund warum ich das damals so gelöst habe.

[Flocke]

Zitat:

Zitat von MaBuSE

Die SQL Dateien können so sehr leicht in z.B: TOAD benutzt und erweitert werden.

Das ist ein Grund.

Zitat:

Zitat von MaBuSE

Und ca. 15 Leute die diese Dateien bearbeitet haben. (Alles keine Delphi Programmierer!)

Das ist auch ein Grund.

Zitat:

Zitat von MaBuSE

Es gab ein paar Duzend *.dll Dateien die SQL-Dateien nach der obigen Methode eingebunden haben. (Jeweils ein Subset, aber auch redundante Statements)

... und das ist natürlich auch ein guter Grund.

Allerdings hat man sehr selten so große Projekte!

[MaBuSE]

Zitat:

Zitat von Luckie

Warum über eine Ressourcendatei gehen? Gleiches erreicht man einfacher mit resourcenstrings.

Nachtrag:
Ach ja, die SQL-Dateien (*.res) wurden auch in anderen Programmiersprachen verwendet (C++)
Damals haben wir die *.rc Datei mit dem Resourcencompiler in eine *.res Datei umgewandelt, aber Delphi kann das ja auch in der IDE :-)

Ich habe neulich in der Firma in derich jetzt arbeite eine ähnliche Problematik gehabt, und das zum Anlass genommen dieses Tutorial zu schreiben.

[MaBuSE]

[OT]

Zitat:

Zitat von Flocke

Allerdings hat man sehr selten so große Projekte!

Ich habe bisher in mehreren "großen" Projekten gearbeitet. (Man glaubt ja gar nicht wie viele Firmen Delphi einsetzen)
Im Moment arbeite ich in einer Firma und mache den Support für ca. 40 Delphi Entwickler.[/OT]

[joachimd]

Zitat:

Zitat von shmia

Man darf auch Kommentare in den SQL-Dateien einbauen.
Diese Kommentare müssen aber vor dem Öffnen der Query gelöscht werden.

warum müssen die Kommentarzeilen entfernt werden? -- und // werden genauso wie /* */ im SQL unterstützt und können so an den Server geschickt werden.