Discussion :

[masterdash]

Salut à tous et merci aux membres du forum pour toute l'aide qu'ils nous apportent dans nos problèmes.
Voilà. J'ai le résultat d'une requête et l'autre d'une table : ils sont identiques sur les champs, sauf les deux champs du montant. Le but de cela c'est de trouver la différence dans un champ nommé Écart.

Comment faire pour rassembler les 2 (résultat de la requête 'Oracle' et le résultat de la table 'Access') dans un seule DBGrid ?

[SergioMaster]

Bonjour

Salut à tous et merci aux membres du forum pour toutes l'aide qui nous apporte dans nos problèmes.

c'est gentil mais encore faudrait-il que le problème soit expliqué correctement

comment faire pour rassembles les deux (résultat de la requête 'Oracle' et le résultat de la table 'Access') dans un seule DBGrid

Quel composants de connexion ? car, pour donner un exemple Firedac permet un LocalSQL donc des requêtes entre deux bases de données
Quel version de Delphi tant qu'à donner des explications autant le faire complètement même si "DBGrid" fait obligatoirement référence à du VCL

Il est très difficile de répondre de manière hypothétique genre Ecart:=table1.FieldByName('montant').asCurrency-table2.FieldByName('montant').asCurrency;
avez-vous pensé au OnCalcField ?

[masterdash]

Salut, personne n'a d'ide pour mon problème.

[SergioMaster]

Tant que vous ne donnez pas plus de précisions ! Je vous ai déjà donné les indications nécessaire à savoir utiliser l'événement OnCalcfield sur une des deux sources de données.

[ShaiLeTroll]

TClientDataSet, tu repliques la structure (nommage distinct) des deux DataSet Oracle et ACCESS puis tu recopies les données
tu connectes un Datasource, et le DbGrid affichera tes données, en espérant que tu es une clé commune entre les deux pour faire la conciliation (normalement le cas puisque tu évoques une structure identique)

Autre approche, ajoute deux champs calculés sur un dataset qui iront lire leur donnée depuis le second dataset dans OnCalcField, un simple Locate pour la synchronisation
Un troisième champ, toujours calculé, tu affiche ton écart

Il y a tellement d'approche possible et tellement trivial quand on connait un peu le fonctionnement du TDataSet

Mais on peut faire aussi cela en dehors de Delphi avec les Bridges ODBC, depuis ORACLE tu peux accéder à ACCESS : CREATE DATABASE LINK avec Oracle Heterogeneous Services

[masterdash]

Merci Sergio,
j'utilise Delphi XE3
Les composants ODAC pour Oracle ORAQUERY et AdoQuery pour la base Acces.

le but afficher les 2 tables dans un seul DBGrid pour une comparatif.

[ShaiLeTroll]

As-tu étudié les propositions ci-dessus
soit TClientDataSet avec copie des deux DataSet (30 lignes de codes)
soit directement dans le TOraQuery champs persistants et champs calculés (un peu d'IDE et 10 lignes de codes)

[ShaiLeTroll]

Ah encore mieux, considérer l'une des tables comme un thésaurus et faire un lookup, je te laisse ajouter le champ calculé pour la delta entre le champ d'origine et le champ connecté

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
 
//------------------------------------------------------------------------------
procedure TDataSetSliteHelper.ConnectDataSet(ADataSet: TDataSet; const AKeyFields: string; const AFieldsNames: array of string);
var
  I: Integer;
  Field: TField;
  ConnectedField: TField;
begin
  if Self.Active then
    raise EDatabaseError.Create('The extended DataSet must be close');
 
  // Avant de forcer la création d'un champ lié, il faut créer les champs persistants définis.
  if Self.Fields.Count = 0 then
    raise EDatabaseError.CreateRes(@SErrorMustCreateFieldBeforeAddCalculated);
 
  if not ADataSet.Active then
    raise EDatabaseError.Create('The connected DataSet must be open');
 
  for I := Low(AFieldsNames) to High(AFieldsNames) do
  begin
    Field := ADataSet.FieldByName(AFieldsNames[I]);
    ConnectedField := TFieldClass(Field.ClassType()).Create(Self);
    ConnectedField.FieldName := 'ConnectTo' + AFieldsNames[I];
    ConnectedField.FieldKind := fkLookup;
    ConnectedField.Size := Field.Size;
    ConnectedField.LookupDataSet := ADataSet;
    ConnectedField.LookupKeyFields := AKeyFields;
    ConnectedField.LookupResultField := AFieldsNames[I];
    ConnectedField.KeyFields := AKeyFields;
    ConnectedField.Lookup := True;
    ConnectedField.DataSet := Self;
  end;
end;

[ShaiLeTroll]

Pour créer un champ calculé à la volée sans passer par l'IDE

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
 
//------------------------------------------------------------------------------
function TDataSetSliteHelper.AddCalculatedField(const Name: string; DataType: TFieldType; Size: Integer = 0; Required: Boolean = False): TField;
begin
  // Avant de forcer la création d'un champ calculé, il faut créer les champs persistants définis.
  if Self.Fields.Count = 0 then
    raise EDatabaseError.CreateRes(@SErrorMustCreateFieldBeforeAddCalculated);
 
  Result := Self.FindField(Name);
  if not Assigned(Result) then
  begin
    Result := DefaultFieldClasses[DataType].Create(Self);
    Result.FieldName := Name;
    Result.Name := Name;
    if Self is TClientDataSet then
      Result.FieldKind := fkInternalCalc
    else
      Result.FieldKind := fkCalculated;
 
    Result.DataSet := Self;
  end;
end;

Il faut définir les champs persistants dans l'IDE ou par Code de ton OraQuery1
Tu peux définir les champs calculés par l'IDE ou par l'appel de OraQuery1.AddCalculatedField('Delta', ftFloat);.

Ensuite il faut remplir OnCalcFields pour calculer 'Delta' en considérant que tu as déjà connecté le champ 'Value' de ton AdoQuery en utilisant ConnectDataSet

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
procedure TZooVCLControlExperimentForm.ClientDataSetCtrlGridCalcFields(DataSet: TDataSet);
begin
  DataSet.FieldByName('Delta').AsFloat := DataSet.FieldByName('Value').AsFloat - DataSet.FieldByName('ConnectToValue').AsFloat;
end;

Comme je le disais, c'est trivial, codé, testé, publié en 40 minutes.

[masterdash]

Merci ShaiLeTroll, mais j'avoue je ne comprend pas ce que vous me proposer, juste que il s'agit de 2 Requêtes la 1er avec OraQuery et la 2eme AdoTable sur une base d'Access.

Je dois extraire le résultat des deux pour le mettre dans un seul dbgrid pour une comparaison, pour ce qui y du calcule je me débrouillerais merci.

[ShaiLeTroll]

J'ai isolé le code de test car j'ai foutu ça à l'arrache dans une application à bordel en repartant d'un code pour gérer la couleur dans un TDBCtrlGrid, vous semblez déjà bien perdu

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
unit Unit2;
 
interface
 
uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Data.DB, Vcl.Grids, Vcl.DBGrids,
  Vcl.StdCtrls, Vcl.Buttons, Datasnap.DBClient;
 
type
  TForm2 = class(TForm)
    ClientDataSetCtrlGrid: TClientDataSet;
    ClientDataSetCtrlGridVALUE: TIntegerField;
    DataSourceCtrlGrid: TDataSource;
    btnFillDBCtrlGrid: TBitBtn;
    DBGridFusion: TDBGrid;
    btnFillDBGridFusion: TBitBtn;
    ClientDataSetFusion: TClientDataSet;
    ClientDataSetFusionVALUE: TIntegerField;
    ClientDataSetFusionVALUEX: TStringField;
    procedure btnFillDBCtrlGridClick(Sender: TObject);
    procedure btnFillDBGridFusionClick(Sender: TObject);
    procedure ClientDataSetCtrlGridCalcFields(DataSet: TDataSet);
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;
 
var
  Form2: TForm2;
 
implementation
 
{$R *.dfm}
 
 
procedure TForm2.btnFillDBCtrlGridClick(Sender: TObject);
var
  I: Integer;
begin
  if not ClientDataSetCtrlGrid.Active then
    ClientDataSetCtrlGrid.CreateDataSet();
  for I := 0 to 9 do
  begin
    ClientDataSetCtrlGrid.Append();
    ClientDataSetCtrlGridVALUE.AsInteger := ClientDataSetCtrlGrid.RecordCount + 1;
    ClientDataSetCtrlGrid.Post();
  end;
end;
 
//------------------------------------------------------------------------------
function AddCalculatedField(ADataSet: TDataSet; const Name: string; DataType: TFieldType; Size: Integer = 0; Required: Boolean = False): TField;
begin
  // Avant de forcer la création d'un champ calculé, il faut créer les champs persistants définis.
  if ADataSet.Fields.Count = 0 then
    raise EDatabaseError.Create('Must create fields before add calculated field');
 
  Result := ADataSet.FindField(Name);
  if not Assigned(Result) then
  begin
    Result := DefaultFieldClasses[DataType].Create(ADataSet);
    Result.FieldName := Name;
    Result.Name := Name;
    if ADataSet is TClientDataSet then
      Result.FieldKind := fkInternalCalc
    else
      Result.FieldKind := fkCalculated;
 
    Result.DataSet := ADataSet;
  end;
end;
 
//------------------------------------------------------------------------------
procedure ConnectDataSet(ADataSetExtended: TDataSet; ADataSetConnected: TDataSet; const AKeyFields: string; const AFieldsNames: array of string);
var
  I: Integer;
  Field: TField;
  ConnectedField: TField;
begin
  if ADataSetExtended.Active then
    raise EDatabaseError.Create('The extended DataSet must be close');
 
  // Avant de forcer la création d'un champ lié, il faut créer les champs persistants définis.
  if ADataSetExtended.Fields.Count = 0 then
    raise EDatabaseError.Create('Must create fields before add calculated field');
 
  if not ADataSetConnected.Active then
    raise EDatabaseError.Create('The connected DataSet must be open');
 
  for I := Low(AFieldsNames) to High(AFieldsNames) do
  begin
    Field := ADataSetConnected.FieldByName(AFieldsNames[I]);
    ConnectedField := TFieldClass(Field.ClassType()).Create(ADataSetExtended);
    ConnectedField.FieldName := 'ConnectTo' + AFieldsNames[I];
    ConnectedField.FieldKind := fkLookup;
    ConnectedField.Size := Field.Size;
    ConnectedField.LookupDataSet := ADataSetConnected;
    ConnectedField.LookupKeyFields := AKeyFields;
    ConnectedField.LookupResultField := AFieldsNames[I];
    ConnectedField.KeyFields := AKeyFields;
    ConnectedField.Lookup := True;
    ConnectedField.DataSet := ADataSetExtended;
  end;
end;
 
 
procedure TForm2.btnFillDBGridFusionClick(Sender: TObject);
var
  I: Integer;
begin
  if not ClientDataSetFusion.Active then
    ClientDataSetFusion.CreateDataSet();
  for I := 0 to 9 do
  begin
    ClientDataSetFusion.Append();
    ClientDataSetFusionVALUE.AsInteger := ClientDataSetFusion.RecordCount + 1;
    ClientDataSetFusionVALUEX.AsString := IntToHex(ClientDataSetFusionVALUE.AsInteger, 8);
    ClientDataSetFusion.Post();
  end;
 
  ConnectDataSet(ClientDataSetCtrlGrid, ClientDataSetFusion, 'VALUE', ['VALUE', 'VALUEX']);
  AddCalculatedField(ClientDataSetCtrlGrid, 'CALC', ftInteger);
end;
 
procedure TForm2.ClientDataSetCtrlGridCalcFields(DataSet: TDataSet);
begin
  DataSet.FieldByName('CALC').AsFloat := DataSet.FieldByName('Value').AsFloat * DataSet.FieldByName('ConnectToValue').AsFloat;
end;
 
end.

Code dfm :

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
 
object Form2: TForm2
  Left = 659
  Top = 307
  Caption = 'Form2'
  ClientHeight = 444
  ClientWidth = 956
  Color = clBtnFace
  Font.Charset = DEFAULT_CHARSET
  Font.Color = clWindowText
  Font.Height = -11
  Font.Name = 'Tahoma'
  Font.Style = []
  OldCreateOrder = False
  PixelsPerInch = 96
  TextHeight = 13
  object btnFillDBCtrlGrid: TBitBtn
    Left = 89
    Top = 8
    Width = 75
    Height = 25
    Caption = 'Fill 2'
    TabOrder = 0
    OnClick = btnFillDBCtrlGridClick
  end
  object DBGridFusion: TDBGrid
    Left = 8
    Top = 39
    Width = 613
    Height = 518
    DataSource = DataSourceCtrlGrid
    TabOrder = 1
    TitleFont.Charset = DEFAULT_CHARSET
    TitleFont.Color = clWindowText
    TitleFont.Height = -11
    TitleFont.Name = 'Tahoma'
    TitleFont.Style = []
  end
  object btnFillDBGridFusion: TBitBtn
    Left = 8
    Top = 8
    Width = 75
    Height = 25
    Caption = 'Fill 1'
    TabOrder = 2
    OnClick = btnFillDBGridFusionClick
  end
  object ClientDataSetCtrlGrid: TClientDataSet
    Aggregates = <>
    Params = <>
    OnCalcFields = ClientDataSetCtrlGridCalcFields
    Left = 140
    Top = 80
    object ClientDataSetCtrlGridVALUE: TIntegerField
      FieldName = 'VALUE'
    end
  end
  object DataSourceCtrlGrid: TDataSource
    DataSet = ClientDataSetCtrlGrid
    Left = 200
    Top = 120
  end
  object ClientDataSetFusion: TClientDataSet
    Aggregates = <>
    Params = <>
    Left = 276
    Top = 80
    object ClientDataSetFusionVALUE: TIntegerField
      FieldName = 'VALUE'
    end
    object ClientDataSetFusionVALUEX: TStringField
      FieldName = 'VALUEX'
    end
  end
end

[masterdash]

ShaiLeTroll, voir m'en message avant votre réponse Merci.

[ShaiLeTroll]

J'ai vu votre message et il n'apporte rien de plus !
Je ne comprends pas où vous bloquez, rassurez-nous, vous avez au moins réussi à afficher chaque Query dans un DBGrid différent,
vous avez votre OraSession/OraQuery/DataSource1/DBgrid1 d'un côté et ADOConnection/ADOQuery/DataSource2/DBGrid2 de l'autre ?

A Partir de là, vous crée un champ lookup sur le OraQuery sur un champ du ADOQuery entre les deux et ajouter un champ calculé sur le OraQuery
C'est on ne peut plus simple et basique.

Avec l'exemple que j'ai fourni, vous devriez pouvoir y arriver.
Essayer de le décortiquer, de le comprendre

[masterdash]

Salut à tous, je remercie ShaiLeTroll pour tous ses ides et conseils précieux, aussi je remercie par l’occasion SergioMaster pour ses explications instructifs, merci au forum.