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.