Discussion :

[tomlev]

Ah ok...

Pour récupérer les colonnes communes à toutes les tables, je te propose la solution suivante, en utilisant Linq :

Code C# :

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

1
2
3
4
5
6
7
8
9
10
var columnNames = tmpResult.Tables[0].Columns
                                     .Cast<DataColumn>()
                                     .Select(c => c.ColumnName);
for(int i = 1; i < ds.Tables.Count; i++)
{
	columnNames = columnNames.Intersect(
                                      tmpResult.Tables[i].Columns
                                               .Cast<DataColumn>()
                                               .Select(c => c.ColumnName));
}

A la fin columnNames contient les noms des colonnes communes.

Pour créer la table qui contient toutes les données des colonnes communes, je ferais quelque chose comme ça :

Code C# :

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
DataTable newTable = new DataTable("NewTable");
foreach (var columnName in columnNames)
{
    Type type = tmpResult.Tables[0].Columns[columnName].DataType;
    table.Columns.Add(columnName, type);
}
 
foreach (DataTable table in tmpResult.Tables)
{
    foreach(DataRow row in table.Rows)
    {
        DataRow newRow = newTable.NewRow();
        foreach (var columnName in columnNames)
        {
            newRow[columnName] = row[columnName];
        }
        newTable.Rows.Add(newRow);
    }
}
 
tmpResult.Tables.Add(newTable);

(pas sûr que ce soit le plus efficace... on pourrait sans doute utiliser DataTable.Merge pour améliorer un peu)

[Leelith]

J'ai procédé un peu différemment, mais je ne sais pas si c'est identique à ce que tu as fais:

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
 
private DataTable findCommonFields()
        {
            //initalise the result set
            tmpResult = new DataSet();
 
            for (int currentTable = 0; currentTable < tableToAnalyze.Tables.Count; currentTable++)
            {
                for (int tableSearchingIn = 0; tableSearchingIn < tableToAnalyze.Tables.Count; tableSearchingIn++)
                {
                    //check if we are not comparing same table
                    if (!tableToAnalyze.Tables[currentTable].TableName.ToString().Equals(tableToAnalyze.Tables[tableSearchingIn].TableName.ToString()))
                    {
                        tmpResult.Tables.Add(findFields(tableToAnalyze.Tables[currentTable], tableToAnalyze.Tables[tableSearchingIn]));
                    }
                }
            }
 
            convertToDataTable();
 
            return result;
        }
 
        private DataTable findFields(DataTable firstTable, DataTable tableToCheckIn)
        {
            DataTable tmp = new DataTable();
            tmp.Columns.Add("Field");
 
            for (int fieldFirstTable = 0; fieldFirstTable < firstTable.Rows.Count; fieldFirstTable++)
            {
                for (int fieldOfTableToCheck = 0; fieldOfTableToCheck < tableToCheckIn.Rows.Count; fieldOfTableToCheck++)
                {
                    if (firstTable.Rows[fieldFirstTable]["Field"].ToString().Equals(tableToCheckIn.Rows[fieldOfTableToCheck]["Field"].ToString()))
                    {
                        tmp.TableName = firstTable.TableName;
                        //MessageBox.Show(firstTable.Rows[fieldFirstTable]["Field"].ToString());
                        tmp.Rows.Add(firstTable.Rows[fieldFirstTable]["Field"]);
                    }
                }
            }
            return tmp;
        }
 
        public void convertToDataTable()
        {
            result = new DataTable(); 
 
            for (int table = 0; table < tmpResult.Tables.Count - 1; table++)
            {
                //string name = tmpResult.Tables[table].TableName;
                result.Columns.Add(tmpResult.Tables[table].TableName);
                for (int field = 0; field < tmpResult.Tables[table].Rows.Count - 1; field++)
                {
                    result.Rows.Add(tmpResult.Tables[table].Copy().Rows[field]);
                }
            }
        }

la méthode convertToDataTable() n'est pas fonctionnelle encore

J'ai pas compris tout ton code, donc je sais pas si ca fait la même chose?

[tomlev]

J'ai pas compris tout ton code, donc je sais pas si ca fait la même chose?

Euh, je sais pas, moi c'est ton code où j'ai pas tout compris
Plus exactement j'ai pas le temps de vraiment l'analyser pour l'instant, mais ça me semble beaucoup plus compliqué...

Qu'est-ce que tu ne comprends pas dans mon code ? L'intersection ? Les expressions lambda ?

[Leelith]

exactement, ainsi que les foreach imbriqués

[tomlev]

- La première instruction récupère les noms de toutes les colonnes de la première table. Le Select signifie "pour chaque colonne c, récupère la propriété ColumnName". Ca renvoie un IEnumerable<string>. Le Cast est un détail, c'est juste parce que Columns n'implémente pas IEnumerable<DataColumn> mais juste IEnumerable.

- Ensuite, je boucle sur les autres tables, et je fais l'Intersection des colonnes que j'ai déjà avec celle de la table courante : donc à chaque étape, je ne garde que les colonnes qui sont dans toutes les tables déjà vérifiées.

- Ensuite, je crée une nouvelle table avec les colonnes communes à toutes les tables

- Enfin, je copie les données de chaque colonne de chaque ligne de chaque table (d'où les 3 foreach imbriqués) dans la nouvelle table

[Leelith]

Je suis pas sûr à 100 pour 100 que les deux approches sont identiques, je préfère valider que c'est bien les mêmes résultats obtenus en décrivant un peu mon code.

Sur ce morceau de code, ce que je fais est relativement simple. Je parcours toutes les tables, et je compare chaque champs des tables avec toutes les autres tables. Je rajoute les champs commun dans mon dataset tmpResult trouvé grâce à la méthode findFields (décrit dans la deuxième procédure à la suite de ce code):

Code c# :

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
 
        private DataTable findCommonFields()
        {
            //initalise the result set
            tmpResult = new DataSet();
            for (int currentTable = 0; currentTable < tableToAnalyze.Tables.Count; currentTable++)
            {
                for (int tableSearchingIn = 0; tableSearchingIn < tableToAnalyze.Tables.Count; tableSearchingIn++)
                {
                    //check if we are not comparing same table
                    if (!tableToAnalyze.Tables[currentTable].TableName.ToString().Equals(tableToAnalyze.Tables[tableSearchingIn].TableName.ToString()))
                    {
                        tmpResult.Tables.Add(findFields(tableToAnalyze.Tables[currentTable], tableToAnalyze.Tables[tableSearchingIn]));
                    }
                }
            }
            convertToDataTable();
            return result;
        }

Avec findFields, je retourne une datatable qui contient les champs se trouvant dans les autres tables. Pour chaque table comparée, findFields est appelé:

Code c# :

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
 
        private DataTable findFields(DataTable firstTable, DataTable tableToCheckIn)
        {
            DataTable tmp = new DataTable();
            tmp.Columns.Add("Field");
 
            // check every field in the table
            for (int fieldFirstTable = 0; fieldFirstTable < firstTable.Rows.Count; fieldFirstTable++)
            {
                // we go through each field of the table to check to see if any field are the same
                for (int fieldOfTableToCheck = 0; fieldOfTableToCheck < tableToCheckIn.Rows.Count; fieldOfTableToCheck++)
                {
                    // if matched, then we add it to the result
                    if (firstTable.Rows[fieldFirstTable]["Field"].ToString().Equals(tableToCheckIn.Rows[fieldOfTableToCheck]["Field"].ToString()))
                    {
                        tmp.TableName = firstTable.TableName;
                        //MessageBox.Show(firstTable.Rows[fieldFirstTable]["Field"].ToString());
                        tmp.Rows.Add(firstTable.Rows[fieldFirstTable]["Field"]);
                    }
                }
            }
            return tmp;
        }

Je ne pense pas aussi que ça soit la meilleure manière de faire ça...

Voilà voilà : )

[Leelith]

- La première instruction récupère les noms de toutes les colonnes de la première table. Le Select signifie "pour chaque colonne c, récupère la propriété ColumnName". Ca renvoie un IEnumerable<string>. Le Cast est un détail, c'est juste parce que Columns n'implémente pas IEnumerable<DataColumn> mais juste IEnumerable.

- Ensuite, je boucle sur les autres tables, et je fais l'Intersection des colonnes que j'ai déjà avec celle de la table courante : donc à chaque étape, je ne garde que les colonnes qui sont dans toutes les tables déjà vérifiées.

- Ensuite, je crée une nouvelle table avec les colonnes communes à toutes les tables

- Enfin, je copie les données de chaque colonne de chaque ligne de chaque table (d'où les 3 foreach imbriqués) dans la nouvelle table

J'ai repris ton code pour essayer d'avancer, mais je suis toujours bloqué

En faite, je crois que j'ai mal expliqué ce que j'essaye de faire:

1. Dans un premier temps, je mets dans une datatable les champs que je trouve en commun de ma table en question (on va appeler table1 pour l'exemple) en la comparant à une autre table (pour l'exemple appelons-là table2). La table prend le nom de la table table1 (dont si on dit qu'elle s'appel table1, son nom sera table1). Ensuite je lui rajoute une colonne "Fields" dans laquel je vais mettre tout mes champs que je vais trouver dans ma table table2.
2. Je rajoute les résultats trouvé dans table1 dans une dataset qui a tout les resultats (donc il aura plusieurs datatable avec pour chaque table, les résultats des champs qui se retrouve dans les autres tables à comparer)
3. Ce que je souhaites faire, c'est maintenant convertir mon dataset en datatable pour afficher mes résultats dans mon datagrid.

Mon idée était de prendre en faite chaque table et la transformer en datacolumn. L'idée est d'avoir dans le nom de la colonne le nom de la table que je souhaite transformer, ça me permettrais après d'avoir dans chaque entête de colonne le nom de la table, et dans les lignes les champs qui sont commun aux autres tables.

Pour ça, j'ai donc utilisé ton code de la manière suivante:

Je parcours toutes les tables, et je compare chaque champs des tables avec toutes les autres tables. Je rajoute les champs commun dans mon dataset tmpResult trouvé grâce à la méthode findFields (décrit dans la deuxième procédure à la suite de ce code):

Code C# :

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
 
        private DataTable findCommonFields()
        {
            //initalise the result set
            tmpResult = new DataSet();
            for (int currentTable = 0; currentTable < tableToAnalyze.Tables.Count; currentTable++)
            {
                for (int tableSearchingIn = 0; tableSearchingIn < tableToAnalyze.Tables.Count; tableSearchingIn++)
                {
                    //check if we are not comparing same table
                    if (!tableToAnalyze.Tables[currentTable].TableName.ToString().Equals(tableToAnalyze.Tables[tableSearchingIn].TableName.ToString()))
                    {
                        tmpResult.Tables.Add(findFields(tableToAnalyze.Tables[currentTable], tableToAnalyze.Tables[tableSearchingIn]));
                    }
                }
            }
            convertToDataTable();
            return result;
        }

Avec findFields, je retourne une datatable qui contient les champs se trouvant dans les autres tables. Pour chaque table comparée, findFields est appelé:

Code C# :

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
 
        private DataTable findFields(DataTable firstTable, DataTable tableToCheckIn)
        {
            DataTable tmp = new DataTable();
            tmp.Columns.Add("Field");
 
            // check every field in the table
            for (int fieldFirstTable = 0; fieldFirstTable < firstTable.Rows.Count; fieldFirstTable++)
            {
                // we go through each field of the table to check to see if any field are the same
                for (int fieldOfTableToCheck = 0; fieldOfTableToCheck < tableToCheckIn.Rows.Count; fieldOfTableToCheck++)
                {
                    // if matched, then we add it to the result
                    if (firstTable.Rows[fieldFirstTable]["Field"].ToString().Equals(tableToCheckIn.Rows[fieldOfTableToCheck]["Field"].ToString()))
                    {
                        tmp.TableName = firstTable.TableName;
                        //MessageBox.Show(firstTable.Rows[fieldFirstTable]["Field"].ToString());
                        tmp.Rows.Add(firstTable.Rows[fieldFirstTable]["Field"]);
                    }
                }
            }
            return tmp;
        }

Et j'effectue ma conversion du dataset en datatable (je me suis basé sur le code que tu as fais, mais il coince dans la partie du foreach lié à la datarow):

Code C# :

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
 
        public void convertToDataTable()
        {
            result = new DataTable();
 
            foreach (DataTable table in tmpResult.Tables)
            {
                result.Columns.Add(table.TableName);
            }
 
            foreach (DataTable table in tmpResult.Tables)
            {
                foreach (DataRow row in table.Rows)
                {
                    DataRow newRow = result.NewRow();
 
                    foreach (DataColumn columnName in table.Columns)
                    {
                        newRow[columnName.ColumnName] = row[columnName.ColumnName];
                    }
                    result.Rows.Add(newRow);
                }
            }
 
        }

Je patine vraiment dans la neige (et c'est le cas de le dire en ce moment), je suis sûr que c'est une erreur vraiment idiote, mais je ne maîtrise pas vraiment super bien ce concepte de datarow je crois :s

Merci bien pour toi aide et bonne année

Leelith,

[tomlev]

oula... c'est bien compliqué ton histoire

Je vais essayer de résumer pour voir si j'ai bien compris :

Tu as plein de tables, avec des champs communs à toutes les tables ET des champs spécifiques à chaque table. Tu voudrais tout mettre dans une seule table qui contient TOUS les champs de TOUTES les tables. Donc par exemple si le champs Toto existe dans la table A mais pas dans la table B, dans la table finale les lignes qui viennent de B n'auront pas de valeur dans la colonne Toto.

C'est bien ça ?

En supposant que ce soit ça, voilà une petite modification de mon code précédent qui devrait donner le résultat voulu...

Récupération des noms des colonnes :

Code :

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

1
2
3
4
5
6
7
8
9
10
var columnNames = tmpResult.Tables[0].Columns
                                     .Cast<DataColumn>()
                                     .Select(c => c.ColumnName);
for(int i = 1; i < ds.Tables.Count; i++)
{
	columnNames = columnNames.Union(
                                      tmpResult.Tables[i].Columns
                                               .Cast<DataColumn>()
                                               .Select(c => c.ColumnName));
}

Copie des données de chaque table dans une table unique, pour les champs qui existent dans la table source :

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
// Création de la table finale
DataTable newTable = new DataTable("NewTable");
foreach (var columnName in columnNames)
{
    Type type = tmpResult.Tables[0].Columns[columnName].DataType;
    table.Columns.Add(columnName, type);
}
 
// Copie des données
foreach (DataTable table in tmpResult.Tables)
{
    foreach(DataRow row in table.Rows)
    {
        DataRow newRow = newTable.NewRow();
        foreach (var column in table.Columns)
        {
            newRow[column.ColumnName] = row[column];
        }
        newTable.Rows.Add(newRow);
    }
}
 
tmpResult.Tables.Add(newTable);

Donc au final pas beaucoup de différences... je fais une Union à la place d'une Intersection, et je ne copie que les colonnes qui existent dans la table source (vu que les colonnes de columnNames n'existent pas dans toutes les tables)

Mais bon, j'ai peut-être toujours pas bien compris ce que tu cherchais à faire, auquel cas j'ai écrit tout ça pour rien

[Leelith]

oula... c'est bien compliqué ton histoire

Je vais essayer de résumer pour voir si j'ai bien compris :

Tu as plein de tables, avec des champs communs à toutes les tables ET des champs spécifiques à chaque table. Tu voudrais tout mettre dans une seule table qui contient TOUS les champs de TOUTES les tables. Donc par exemple si le champs Toto existe dans la table A mais pas dans la table B, dans la table finale les lignes qui viennent de B n'auront pas de valeur dans la colonne Toto.

C'est bien ça ?

Euh

En faite, je vais illustrer ça par un exemple, ça sera plus simple:

Mon application va lire les données se trouvant dans des fichiers excels. Les données sont organisée de la façon décrites ci-dessous. Pour l'exemple, prenons deux fichier histoire de pas rendre plus compliquer la chose qu'elle ne l'est déjà

Mon premier fichier nommé table1.xls contient les données suivantes (c'est organisé sous forme de colonne):

| Type | Field |
----------------
| pk | id1 |
----------------
| | name1|
| | data1 |
| | data2 |
| | data3 |


Mon deuxième fichier nommé table2.xls contient les données suivantes :

| Type | Field |
----------------
| pk | id2 |
----------------
| | name2 |
| | data11 |
| | data2 |
| | data3 |

Mon code de récupération des données excels exclue la première ligne qui contient les headers (type, field), et les valeurs importantes sont celles de la colonne "Field".

Donc moi, ce que je veux faire c'est un datatable qui sera sous la forme:

| table1 | table1 |
-------------------
| data2 | data2 |
| data3 | data3 |

La première ligne étant les colonnes Donc cette exemple, c'est pas très parlant mais quand ensuite on sait qu'il y a plusieurs fichier et que chaque fichier contient 1xx champs, c'est vite plus utile

Donc si j'ai bien compris, ce n'est pas exactement ça que tu as fais...

Mon code fonctionne jusqu'à la partie ou je trouve les champs commun et que je les mets vers mon dataset , mais je bloque justement vers la conversion de mon databale vers un dataset.
Par contre, ton code est beaucoup plus clean que le mien ça c'est vrai

Par contre, vu que j'ai déjà les resultats dans mon dataset, on peut partir du principe que ça c'est bon, et qu'il suffit de prendre toute les données de mon dataset, et les mettres dans un datatable de la façon comme j'ai indiqué non? Ou ce n'est pas possible avec Linq?

[tomlev]

toujours pas très clair, même avec l'exemple

y a rien dans ta colonnes PK ? ou tu t'en fous ?

pour le tableau final, je suppose que la deuxième colonne s'appelle en fait table2 ?

Donne plutôt un exemple avec des vraies données, ce sera plus parlant... là ça reste encore assez abstrait

[Leelith]

toujours pas très clair, même avec l'exemple

y a rien dans ta colonnes PK ? ou tu t'en fous ?

pour le tableau final, je suppose que la deuxième colonne s'appelle en fait table2 ?

C'est exact! Copier-coller trop rapide

Donne plutôt un exemple avec des vraies données, ce sera plus parlant... là ça reste encore assez abstrait

C'est mes données de tests justement ^^

En faite, si ça peut t'aider c'est principalement pour trouver les colonnes d'une table commune à d'autres tables qui sont soumise à mon programme. Pourquoi? Parce que la base de donnée du système sur lequel je veux faire des jointures est sacrément mal faite et que certaines tables ont des relations avec d'autres tables par des champs qui ne sont ni des pk ni des fk. Du coup, au lieu de m'embêter à chercher les champs commun des tables sur lesquels je veux faire ma jointure, je me suis dis que c'était plus intélligent de faire un petit programme qui va faire ça pour moi

C'est pour cette raison que sur 5 tables par exemple, je vais prendre la première table, et pour chaque champ de cette table regarder s'il se trouve dans les 4 autres tables. Si oui, je créer une table avec le nom de ma table courante et j'ajoute le champ qui est commun à une des autres tables (pas obligatoire que ça soit commun à toutes les tables). Et ainsi de suite pour chaque champ, de chaque table ^^

[tomlev]

OK, donc il y a une relation 1-1 entre chacune de tes tables ?

Ce serait pas plus simple de définir des clés primaire et étrangères et de faire des jointures en SQL ?

[Leelith]

Il y a en effet une relation de 1-1 en tout cas oui (enfin je pense, je suis pas un expert de SAP).

Pour la définition de clés primaire et étrangères, en faite je récupère les tables sous forme Excel. L'ERP sur lequel je veux faire ça est SAP, et il ne gère pas forcément les clés primaires et etrangères. J'ai reçu une extraction des tables ainsi que de leurs champs sous forme Excel. Du coup suis obliger de procéder comme ça (à moins de le faire manuellement, ce qui impliquerais plus de travail encore que le temps que je passe a essayer de faire marcher ce petit programme^^)

[tomlev]

OK... ben moi je ferais quelque chose comme ça :

- création d'une DataTable pour chaque table reçue
- définition de clés primaires sur chaque DataTable
- définition de relations entre les DataTable (selon la clé primaire)
- définition de colonnes calculées (propriété Expression) qui utilisent les relations

Par exemple, si la table "parent" est A et la table "enfant" est B, par défaut la relation s'appelle A_B. Pour récupérer dans A la colonne X de B, tu crées dans A une colonne X et tu lui mets comme Expression "Max(Child(A_B).X)"

(le Max est nécessaire parce qu'il peut théoriquement y avoir plusieurs lignes "enfant" pour une ligne "parent", même si dans ton cas il n'y en aura qu'une)

[Leelith]

Je ne peux justement pas définir les clés primaires et leurs relations car le schéma de la base de donnée de SAP n'est pas publique :/

Je suis donc obligé de faire ma bricole