Hallo!

ich arbeite seit einiger Zeit mit den Zeos Komponenten. Für ein etwas größeres Projekt gefällt mir das "hängen" der Anwendung nicht.

habe mich bereits versucht - allerdings funktioniert das nicht ganz (und ehrlich gesagt habe ich auch noch nicht viel mit Threads gearbeitet)

wäre super wenn mir jmd. helfen könnte das ganze zu realisieren. Muss dohc möglich sein.

zusammenfalten · markieren

Delphi-Quellcode:

unit mysqldb;

interface

uses Windows, Forms, Messages, SysUtils, Variants, Classes, Graphics, Controls,
     DB, ZQuery, ZMySqlQuery, ZTransact, ZMySqlTr, ZConnect, ZMySqlCon;

type TMySQL = class(TThread)
    Database: TZMySqlDatabase;
    Transact: TZMySqlTransact;
       Query: TZMySqlQuery;
    public
     constructor Create(CreateSuspendend : BOOLEAN);
     destructor Destroy;
    protected
     procedure Execute; override;
end;

implementation

constructor TMySQL.Create;
begin
Database := TZMySqlDatabase.Create(nil);
Transact := TZMySqlTransact.Create(nil);
Query := TZMySqlQuery.Create(nil);
Transact.Database := Database;
Query.Database := DAtabase;
inherited Create(FALSE);
end;

procedure TMySQL.Execute;
begin
//
end;

destructor TMySQL.Destroy;
begin
Database.Free;
Transact.Free;
Query.Free;
inherited Destroy;
end;
end.

Danke,

Daniel

Was für ein hängen?

naja ein "hängen" insofern dass die Anwendung während einer Query nicht reagiert...

Achso. Ich arbeite auch mit Zeos. Ist mir noch nicht aufgefallen
Welche DB nimmst du?

Du willst also denn Query asynchron laufen lassen?
D.h. der Query soll laufen und irgendwann fertig werden können
ohne Einfluss auf das Programm. Das Programm selbst soll ohne
auf ein Ergebnis des Query warten zu müssen, weiter arbeiten.
So richtig?

Zitat:

Achso. Ich arbeite auch mit Zeos. Ist mir noch nicht aufgefallen
Welche DB nimmst du?

Du willst also denn Query asynchron laufen lassen?
D.h. der Query soll laufen und irgendwann fertig werden können
ohne Einfluss auf das Programm. Das Programm selbst soll ohne
auf ein Ergebnis des Query warten zu müssen, weiter arbeiten.
So richtig?

Also ich arbeite mit einer !Externen! MYSQL DB

Ja Queries sollen die Anwendung nicht stören - aber wenn sie fertig sind einen Refresh ausführen.

Um dein Codevorgabe weiterzuführen:

markieren

Code:

unit mysqldb;

interface

uses Windows, Forms, Messages, SysUtils, Variants, Classes, Graphics, Controls,
     DB, ZQuery, ZMySqlQuery, ZTransact, ZMySqlTr, ZConnect, ZMySqlCon;

type TMySQL = class(TThread)
    Database: TZMySqlDatabase;
    Transact: TZMySqlTransact;
       Query: TZMySqlQuery;
    public
     
     constructor Create(CreateSuspendend : BOOLEAN);
     destructor Destroy;
    protected
     procedure Execute; override;
end;

implementation

constructor TMySQL.Create;
begin
Database := TZMySqlDatabase.Create(nil);
Transact := TZMySqlTransact.Create(nil);
Query   := TZMySqlQuery.Create(nil);
Transact.Database := Database;
Query.Database := DAtabase;
inherited Create(FALSE);
end;

procedure TMySQL.Execute;
const
 WM_REFRESHAFTERQUERY= WM_USER+1001
begin
QueryFW.Sql.Add('SELECT * FROM X WHERE a=b;');
Query.ExecSQL;
PostMessage (Handle, WM_REFRESHAFTERQUERY, 0, 0);
end;

destructor TMySQL.Destroy;
begin
Database.Free;
Transact.Free;
Query.Free;
inherited Destroy;
end;
end.

Dann halt noch ne Behandlungsroutine für den Abfang der Nachricht
WM_REFRESHAFTERQUERY.
Probier das mal. Ich weiss jedoch nicht ob das genau funktioniert.
Eigentlich hab ich nur Synchronisationen mit Threads gemacht.
Das ist aber nicht genau das was du brauchst, soweit ich dich richtig
verstanden hab.

Wie der Aufruf des Threads funktioniert weisst du, oder?

schon - soweit hab ich auch probiert.

das einzige was mich schlaucht ist:

- das funktioniert super bei INSERT, UPDATE oder DELETe

aber bei select - würd ich ja gerne Daten zurückerhalten. Wie kann ich das machen?

mfg
Daniel

Puh ... warte hab ne Idee:

markieren

Code:

unit mysqldb;

interface

uses Windows, Forms, Messages, SysUtils, Variants, Classes, Graphics, Controls,
     DB, ZQuery, ZMySqlQuery, ZTransact, ZMySqlTr, ZConnect, ZMySqlCon;

type TMySQL = class(TThread)
    Database: TZMySqlDatabase;
    Transact: TZMySqlTransact;
       Query: TZMySqlQuery;
    public
     
     constructor Create(CreateSuspendend : BOOLEAN);
     destructor Destroy;
     procedure DoQueryResultGlobal;
    protected
     procedure Execute; override;
end;

implementation

constructor TMySQL.Create;
begin
Database := TZMySqlDatabase.Create(nil);
Transact := TZMySqlTransact.Create(nil);
Query   := TZMySqlQuery.Create(nil);
Transact.Database := Database;
Query.Database := DAtabase;
inherited Create(FALSE);
end;

procedure TMySQL.DoQueryResultGlobal;
begin
 Form1.QueryGlobal:=Query;
end;

procedure TMySQL.Execute;
const
 WM_REFRESHAFTERQUERY= WM_USER+1001 
begin
Query.Sql.Add('SELECT * FROM X WHERE a=b;');
Query.ExecSQL;
Synchronize(DoQueryResultGlobal);
PostMessage (Handle, WM_REFRESHAFTERQUERY, 0, 0);
end;

destructor TMySQL.Destroy;
begin
Database.Free;
Transact.Free;
Query.Free;
inherited Destroy;
end;
end.

QueryGlobal ist dann ein Query (TZMySQLQuery) in dem Formular
oder Unit, von der aus der Thread gestartet wird. Ist die unsaubere Variante.

klingt blöd - gefällt mir nich die Variante.

wäre es nicht besser eine art "Result" zurückzugeben?

Hab es hinbekommen. Zumindest funktionierts bei mir;

markieren

Code:

unit MySQL;

interface

uses Windows, Forms, Messages, SysUtils, Variants, Classes, Graphics, Controls,
     DB, ZQuery, ZMySqlQuery, ZTransact, ZMySqlTr, ZConnect, ZMySqlCon;

type TMySQL = class(TThread)
    Database: TZMySqlDatabase;
    Transact: TZMySqlTransact;
       Query: TZMySqlQuery;
    public

     constructor Create(CreateSuspendend : BOOLEAN);
     destructor Destroy;
     procedure DoQueryResultGlobal;
    protected
     procedure Execute; override;
end;

implementation

uses Unit1;

constructor TMySQL.Create;
begin
Database := TZMySqlDatabase.Create(nil);
Transact := TZMySqlTransact.Create(nil);
Query   := TZMySqlQuery.Create(nil);
Transact.Database := Database;
Query.Database := DAtabase;
Database.Login:='Benutzername';
Database.Password:='Passwort';
Database.Database:='Deine Gewollte DB';
inherited Create(FALSE);
end;

procedure TMySQL.DoQueryResultGlobal;
begin
   Form1.DataSource.DataSet:=Query;
   Query.Active:=true;
end;

procedure TMySQL.Execute;
const
 WM_REFRESHAFTERQUERY= WM_USER+1001;
begin
 Query.Sql.Add('SELECT * FROM Tabelle;');
 Synchronize(DoQueryResultGlobal);
 PostMessage (Handle, WM_REFRESHAFTERQUERY, 0, 0);
 Application.ProcessMessages;
end;

destructor TMySQL.Destroy;
begin
Database.Free;
Transact.Free;
Query.Free;
inherited Destroy;
end;

In Form1 liegt bei mir nur ein DBGrid & eine DataSource, welche miteinander verbunden sind;
Vergiss aber nicht an irgendeiner Stelle den Thread wieder zubeenden.

Wenn du nun das Form1.xxx Zugriff zu unsauber ist, übergib einfach bei der Erzeugung des Threads das DataSource-Objekt.