bonjour,

voila , je suis en train de faire mon premier thread, grâce aux codes trouvé ici

c'est une petite application pour les bases SQL, j'ai une listview avec la liste des bases et je peux restaurer, sauvegarder, lire la version,etc

j'ai simplifié mon code pour pas en mettre 50 pages.
quand je click sur le bouton "Restaure" , je lance la procédure "restaure_base_thread" , le démarrage du thread passe ma base en "occupé" (j'affiche une petite led rouge devant la base) et quand le thread ce termine, la base passe en libre, ce qui empêche d'effectuer par exemple un backup sur une base que je suis en train de restaurer.

PROBLEME:
Quand je fais la procédure "lire_toute_version_thread", ce thread cherche la version de tourtes les bases, quand il interroge la premiere base, il la passe en occupé, puis qd il termine, il la passe en libre, il boucle ainsi de suite sur toutes les tables.
c'est le "synchronique" qui permet de mettre a jour mon interface est de bloquer la base en cours, mais comment je fais pour savoir qu'une base n'est pas occupé par un autre thread (qui fait un restaure par exemple) ? , en fait, je vois comment "descendre" l'info vers "unit1" avec le synchronise, mais comme je fais pour récupérer une info de "l'unit1" ? (j'ai pas trop envie de mettre un use "unit1" dans mon "unit_thread_requete" pour avoir acces a mes bases.occupé)....
je sais pas si je suis clair....

merci

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
procedure TForm1.ButtonRestaureClick(Sender: TObject);
begin
  restaure_base_thread(instance, login, pwd, nom_base, chemin_backup, chemin_base, thread_start, thread_msg, thread_finish); 
end;
{------------------------------------------------------------------------------}
procedure TForm1.ButtonDeleteClick(Sender: TObject);
begin
  efface_base_thread(instance, login, pwd, nom_base,thread_start,thread_msg,thread_finish);
end;
{------------------------------------------------------------------------------}
procedure TForm1.ButtonVersionClick(Sender: TObject);
begin
  lire_toute_version_thread(instance, login, pwd , liste_base, thread_start, thread_msg, thread_finish);
end;
{------------------------------------------------------------------------------}
procedure TForm1.thread_start(Sender: TObject;nom_base, Msg : string);
begin
  nom_base.bloque := True;
  Memo_log.Lines.Add(msg);
end;
{------------------------------------------------------------------------------}
procedure TForm1.thread_msg(Sender: TObject;nom_base, Msg : string);
begin
  Memo_log.Lines.Add(msg);
end;
(*---------------------------------------------------------------------------------*)
procedure TForm1.thread_finish(Sender: TObject;nom_base,action:string; date_restaure:Tdatetime);
begin
  nom_base.bloque := False;
  if sametext(Action,'restaure')  then    listview1.maj_date_restaure(nom_base,date_restaure);
  if sametext(Action,'delete') then    listview1.supprime(nom_base);
  if sametext(Action,'Lire toutes les versions') then    listview1.maj_version(nom_base,version);
end;
Unité thread

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
 
unit unit_thread_requete;
interface
 
type
  TCallbackFinished = procedure (Sender: TObject;nom_base,msg,action:string; date_restaure:Tdatetime) of object;
  TCallbackStart = procedure (Sender: TObject;nom_base,msg:string) of object;
  TCallbackMsg = procedure (Sender: TObject;nom_base, Msg:string) of object;
 
procedure restaure_base_thread(instance,login,password,nom_base,chemin_backup,chemin_base : string;CallbackStart: TCallbackStart;CallbackMsg:TCallbackMsg; CallbackFinished: TCallbackFinished);
procedure efface_base_thread(instance,login,password,nom_base:string;CallbackStart: TCallbackStart;CallbackMsg:TCallbackMsg;CallbackFinished:TCallbackFinished);
procedure lire_toute_version_thread(instance,login,password:string;liste_nom_base:Tstringlist;CallbackStart: TCallbackStart;CallbackMsg:TCallbackMsg;CallbackFinished:TCallbackFinished);
 
implementation
 
uses DB,fonctions_ado;
 
type
  TADO_sql_thread = class(TThread)
  private
    finstance : string;
    fnom_base : string;
    flist_base : Tstringlist;
    fmsg : string;
    faction : string; // pour savoir une fois terminé le thread quelle action je dois faire dans unit1, par ex refresh ligne du listview
    fversion : string;
    flogin : string;
    fpassword : string;
    fchemin_backup : string;
    fchemin_base : string;
    fdate_restaure : Tdatetime;
    fCallbackMsg: TCallbackMsg;
    fCallbackStart: TCallbackStart;
    fCallbackFinished : TCallbackFinished;
    fStatusMsg: string;
    procedure delete_base;
    procedure Restorebase;
    procedure LireToutesVersion;
    procedure FinishedSync;
    procedure StartSync;
    procedure MsgSync;
 
  protected
    procedure Execute; override;
  public
    constructor Create(ainstance,alogin,apassword,anom_base,achemin_backup,aaction : string;aCallbackStart:TCallbackStart;aCallbackMsg:TCallbackMsg;aCallbackFinished:TCallbackFinished);overload;
    constructor Create(ainstance,alogin,apassword,anom_base,achemin_backup,achemin_base,aaction : string;aCallbackStart:TCallbackStart;aCallbackMsg:TCallbackMsg;aCallbackFinished:TCallbackFinished);overload;
    constructor Create(ainstance,alogin,apassword:string;aliste_base:Tstringlist;aaction: string;aCallbackStart:TCallbackStart;aCallbackMsg:TCallbackMsg;aCallbackFinished:TCallbackFinished);overload;
 
  procedure debug;
  published
    property connexion_string : string read get_connexion_string;
end;
(*---------------------------------------------------------------------------------*)
constructor TADO_sql_thread.Create(ainstance,alogin,apassword,anom_base,achemin_backup,aaction: string;aCallbackStart: TCallbackStart;aCallbackMsg:TCallbackMsg;  aCallbackFinished: TCallbackFinished);
begin
  inherited Create(False);
  FreeOnTerminate := True;
  fnom_base := anom_base;
  finstance := ainstance;
  flogin := alogin;
  fpassword := apassword;
  fchemin_backup := achemin_backup;
  faction   := aaction;
  fCallbackFinished := aCallbackFinished;
  fCallbackStart := aCallbackStart;
  fCallbackMsg := aCallbackMsg;
end;
(*---------------------------------------------------------------------------------*)
constructor TADO_sql_thread.Create(ainstance,alogin,apassword,anom_base,achemin_backup,achemin_base,aaction : string;aCallbackStart: TCallbackStart;aCallbackMsg:TCallbackMsg; aCallbackFinished: TCallbackFinished);
begin
  inherited Create(False);
  FreeOnTerminate := True;
  fSql := '';
  fnom_base := anom_base;
  finstance := ainstance;
  faction   := aaction;
  flogin := alogin;
  fpassword := apassword;
  fchemin_backup := achemin_backup;
  fchemin_base := IncludeTrailingPathDelimiter(achemin_base);
  fCallbackFinished := aCallbackFinished;
  fCallbackStart := aCallbackStart;
  fCallbackMsg := aCallbackMsg;
end;
(*---------------------------------------------------------------------------------*)
constructor TADO_sql_thread.Create(ainstance,alogin,apassword:string;aliste_base:Tstringlist;aaction: string;aCallbackStart: TCallbackStart;aCallbackMsg:TCallbackMsg;  aCallbackFinished: TCallbackFinished);
begin
  inherited Create(False);
  FreeOnTerminate := True;
  flist_base := Tstringlist.create;
  fSql := '';
  fnom_base := '';
  flist_base.AddStrings(aliste_base);
  finstance := ainstance;
  flogin := alogin;
  fpassword := apassword;
  faction   := aaction;
  fCallbackFinished := aCallbackFinished;
  fCallbackStart := aCallbackStart;
  fCallbackMsg := aCallbackMsg;
end;
 (*---------------------------------------------------------------------------------*)
procedure TADO_sql_thread.debug;
begin
  showmessage(fmsg);
end;
{------------------------------------------------------------------------------}
procedure TADO_sql_thread.delete_base;
begin
  With TADOQuery.Create(nil) do
  begin
  try
    ConnectionString := connexion_string;
    CursorLocation := clUseServer;
    SQL.add('use master ');
    SQL.add('if exists (SELECT * FROM master..sysdatabases WHERE name ='+quotedstr(fnom_base)+') drop database ['+fnom_base+']');
    ExecSQL;
  finally
    Free;
  end;
  end;
end;
(*---------------------------------------------------------------------------------*)
function TADO_sql_thread.retourne_version:string;
begin
try
  With  TADOQuery.Create(nil) do
    try
      ConnectionString := connexion_string;
      CursorLocation := clUseServer;
      SQL.add('IF EXISTS (SELECT * FROM ['+fnom_base+']..sysobjects WHERE name=''fn_version'' AND xtype=N''FN'') select ['+fnom_base+'].dbo.fn_version() else select ''?'' ');
      open;
      result := Fields[0].Asstring;
    finally
      Free;
    end;
except
  result := '?';
end;
end;
(*---------------------------------------------------------------------------------*)
procedure TADO_sql_thread.Restorebase;
begin
   // restaure la base
end;
 (*---------------------------------------------------------------------------------*)
procedure TADO_sql_thread.Deletebase;
begin
  //delete_base;
end;
 (*---------------------------------------------------------------------------------*)
procedure TADO_sql_thread.LireToutesVersion;
var f:integer;
begin
  for f := 0 to flist_base.Count - 1 do
  begin
    fnom_base := flist_base[f];
    fmsg := fnom_base+' Start Lire Version';
    Synchronize(StartSync);
    fversion := retourne_version;
    fmsg := fnom_base+' Finish Lire Version';
    Synchronize(FinishedSync);
end;
end;
 (*---------------------------------------------------------------------------------*)
procedure TADO_sql_thread.Execute;
begin
  try
    CoInitialize(nil);
    fmsg := fnom_base+' Start '+faction;
    Synchronize(StartSync);
    if sametext(faction,'Restaure') then Restorebase
    else
      if sametext(faction,'Delete') then Deletebase
      else
        if sametext(faction,'Lire toutes les versions') then LireToutesVersion;
    fmsg := fnom_base+' Finish '+faction;
    Synchronize(FinishedSync);
    CoUninitialize();
  except
    fmsg := 'erreur '+faction;
    Synchronize(debug);
  end;
end;
(*---------------------------------------------------------------------------------*)
procedure TADO_sql_thread.FinishedSync;
begin
  if Assigned(fCallbackFinished) then   fCallbackFinished(Self, fnom_base,fmsg,faction,fversion,ftaille_data,ftaille_log,fdate_restaure,fsecu);
end;
(*---------------------------------------------------------------------------------*)
procedure TADO_sql_thread.StartSync;
begin
  if Assigned(fCallbackStart) then   fCallbackStart(Self, fnom_base,fmsg);
end;
(*---------------------------------------------------------------------------------*)
procedure TADO_sql_thread.MsgSync;
begin
  if Assigned(fCallbackMsg) then   fCallbackMsg(Self,fnom_base,fmsg);
end;
 (*---------------------------------------------------------------------------------*)
procedure restaure_base_thread(instance,login,password,nom_base,chemin_backup,chemin_base : string;CallbackStart: TCallbackStart;CallbackMsg:TCallbackMsg;CallbackFinished: TCallbackFinished);
begin
  TADO_sql_thread.Create(instance,login,password,nom_base,chemin_backup,chemin_base,'Restaure',CallbackStart,CallbackMsg,CallbackFinished);
end;
(*---------------------------------------------------------------------------------*)
procedure efface_base_thread(instance,login,password,nom_base:string;CallbackStart: TCallbackStart;CallbackMsg:TCallbackMsg;CallbackFinished:TCallbackFinished);
begin
  TADO_sql_thread.Create(instance,login,password,nom_base,'','Delete',CallbackStart,CallbackMsg,CallbackFinished);
end;
(*---------------------------------------------------------------------------------*)
procedure lire_toute_version_thread(instance,login,password:string;liste_nom_base:Tstringlist;CallbackStart: TCallbackStart;CallbackMsg:TCallbackMsg;CallbackFinished:TCallbackFinished);
begin
  TADO_sql_thread.Create(instance,login,password,liste_nom_base,'Lire toutes les versions',CallbackStart,CallbackMsg,CallbackFinished);
end;
 (*---------------------------------------------------------------------------------*)
 
end.