AGB  ·  Datenschutz  ·  Impressum  







Anmelden
Nützliche Links
Registrieren
Zurück Delphi-PRAXiS Tutorials Delphi SQL Dateien als Resource einbinden.

SQL Dateien als Resource einbinden.

Ein Tutorial von MaBuSE · begonnen am 12. Jul 2005 · letzter Beitrag vom 23. Sep 2016
Antwort Antwort
Seite 1 von 2  1 2   
Benutzerbild von MaBuSE
MaBuSE
Registriert seit: 23. Sep 2002
Tutorial
SQL-Dateien als Resource einbinden



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



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.
    {%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:
    {$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. "arName") definiert werden, die dann im TParams Initialisiert und mit folgenden Delphi Quelltext zugewiesen werden können:
    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
(°¿°) MaBuSE - proud to be a DP member
(°¿°) MaBuSE - proud to be a "Rüsselmops" ;-)
 
shmia

 
Delphi 5 Professional
 
#2
  Alt 12. Jul 2005, 13:01
Ich gebe mal meine Anmerkungen dazu:

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;
Andreas
  Mit Zitat antworten Zitat
Benutzerbild von MaBuSE
MaBuSE

 
Delphi 10 Seattle Enterprise
 
#3
  Alt 12. Jul 2005, 13:18
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)
...
  Mit Zitat antworten Zitat
Benutzerbild von Luckie
Luckie
Online

 
Delphi 2006 Professional
 
#4
  Alt 12. Jul 2005, 13:20
Warum über eine Ressourcendatei gehen? Gleiches erreicht man einfacher mit Delphi-Referenz durchsuchenresourcenstrings.
Michael
  Mit Zitat antworten Zitat
Benutzerbild von Flocke
Flocke

 
Delphi 10 Seattle Professional
 
#5
  Alt 12. Jul 2005, 13:23
... 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.
Volker
  Mit Zitat antworten Zitat
Benutzerbild von MaBuSE
MaBuSE

 
Delphi 10 Seattle Enterprise
 
#6
  Alt 12. Jul 2005, 13:27
Zitat von Luckie:
Warum über eine Ressourcendatei gehen? Gleiches erreicht man einfacher mit Delphi-Referenz durchsuchenresourcenstrings.
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.
  Mit Zitat antworten Zitat
Benutzerbild von Flocke
Flocke

 
Delphi 10 Seattle Professional
 
#7
  Alt 12. Jul 2005, 13:33
Zitat von MaBuSE:
Die SQL Dateien können so sehr leicht in z.B: TOAD benutzt und erweitert werden.
Das ist ein Grund.
Zitat von MaBuSE:
Und ca. 15 Leute die diese Dateien bearbeitet haben. (Alles keine Delphi Programmierer!)
Das ist auch ein Grund.
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!
Volker
  Mit Zitat antworten Zitat
Benutzerbild von MaBuSE
MaBuSE

 
Delphi 10 Seattle Enterprise
 
#8
  Alt 12. Jul 2005, 13:33
Zitat von Luckie:
Warum über eine Ressourcendatei gehen? Gleiches erreicht man einfacher mit Delphi-Referenz durchsuchenresourcenstrings.
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.
  Mit Zitat antworten Zitat
Benutzerbild von MaBuSE
MaBuSE

 
Delphi 10 Seattle Enterprise
 
#9
  Alt 12. Jul 2005, 13:36
[OT]
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]
  Mit Zitat antworten Zitat
Benutzerbild von joachimd
joachimd

 
Delphi 10.1 Berlin Enterprise
 
#10
  Alt 12. Jul 2005, 15:11
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.
Joachim Dürr
  Mit Zitat antworten Zitat
Themen-Optionen Tutorial durchsuchen
Tutorial durchsuchen:

Erweiterte Suche
Ansicht

Forumregeln

Es ist dir nicht erlaubt, neue Themen zu verfassen.
Es ist dir nicht erlaubt, auf Beiträge zu antworten.
Es ist dir nicht erlaubt, Anhänge hochzuladen.
Es ist dir nicht erlaubt, deine Beiträge zu bearbeiten.

BB-Code ist an.
Smileys sind an.
[IMG] Code ist an.
HTML-Code ist aus.
Trackbacks are an
Pingbacks are an
Refbacks are aus

Gehe zu:

Impressum · AGB · Datenschutz · Nach oben
Alle Zeitangaben in WEZ +1. Es ist jetzt 09:50 Uhr.
Powered by vBulletin® Copyright ©2000 - 2018, Jelsoft Enterprises Ltd.
LinkBacks Enabled by vBSEO © 2011, Crawlability, Inc.
Delphi-PRAXiS (c) 2002 - 2018 by Daniel R. Wolf