[.NET] DataTable ou DataAdapter et update/insert -goto en C# oo-

DataTable ou DataAdapter et update/insert -goto en C# oo- [.NET] - C#/.NET managed - Programmation

Marsh Posté le 10-07-2006 à 19:36:26    

Bonjour,
 
A la façon d'un RecordSet avec ADODB, je voudrais pouvoir modifier/ajouter des données dans un DataTable retourné par un "select ...".
 
Voici mon code pour le moment (ça ne fait que le select) :
 

Code :
  1. cmd.CommandText = sql;
  2.             cmd.CommandType = CommandType.Text;
  3.             cmd.Prepare();
  5.             DataTable dt = new DataTable();
  6.             SqlDataAdapter da = new SqlDataAdapter(cmd);
  7.             da.Fill(dt);
  9.             foreach (DataRow row in dt.Rows)
  10.             {
  11.                 XmlNode rLine = outputNode.OwnerDocument.CreateElement("line" );
  13.                 foreach (DataColumn col in dt.Columns)
  14.                 {
  15.                     // ICI, je veux pouvoir modifier les données de la cellule en cours de lecture
  17.                     XmlElement rNode = rLine.OwnerDocument.CreateElement(col.ColumnName);
  18.                     rNode.InnerXml = row[col].ToString();
  19.                     rLine.AppendChild(rNode);
  20.                 }
  22.                 outputNode.AppendChild(rLine);
  24.                 // For each row, we can have embeded views
  25.                 if (view.SelectNodes("views/view" ) != null)
  26.                 {
  27.                     RenderViews(outputNode, view.SelectNodes("views/view" ), row);
  28.                 }
  29.             }
  31.             // ICI, je veux pouvoir ajouter une ligne
  33.             dt.Dispose();
  34.             da.Dispose();
  36.             cmd.Dispose();


 
Je ne connais pas la structure de la table lue. Cependant, j'utilise SQL Server, qui permet tout à fait de modifier des données retournées dans un select (via des mises à jours sur curseur).
Je dois modifier à la fois les données de mon DataTable, ainsi que celle de la table lue.


Message édité par Arjuna le 12-07-2006 à 22:29:48
Reply

Marsh Posté le 10-07-2006 à 19:36:26   

Reply

Marsh Posté le 10-07-2006 à 21:05:50    

Youpi tralala !
 
Ca marche :)
 

Code :
  1. cmd.CommandText = sql;
  2.             cmd.CommandType = CommandType.Text;
  3.             cmd.Prepare();
  5.             DataTable dt = new DataTable();
  6.             SqlDataAdapter da = new SqlDataAdapter(cmd);
  7.             da.Fill(dt);
  8.            
  9.             bool addRow = false;
  10.             DataRow newRow = null;
  12.             foreach (string param in Request.Params.Keys)
  13.             {
  14.                 if (param.StartsWith(string.Format("add:{0}-", viewName)))
  15.                 {
  16.                     addRow = true;
  17.                     break;
  18.                 }
  19.             }
  21.             if (addRow)
  22.             {
  23.                 bool notNullRow = false;
  24.                 newRow = dt.NewRow();
  25.                 foreach (DataColumn col in dt.Columns)
  26.                 {
  27.                     foreach (string param in Request.Params.Keys)
  28.                     {
  29.                         if (param == string.Format("add:{0}-{1}", viewName, col.ColumnName))
  30.                         {
  31.                             switch (col.DataType.Name)
  32.                             {
  33.                                 case "String":
  34.                                     if (Request.Params[string.Format("add:{0}-{1}", viewName, col.ColumnName)].ToString() != string.Empty)
  35.                                     {
  36.                                         notNullRow = true;
  37.                                         newRow[col] = Request.Params[string.Format("add:{0}-{1}", viewName, col.ColumnName)].ToString();
  38.                                     }
  39.                                     break;
  40.                             }
  41.                             break;
  42.                         }
  43.                     }
  44.                 }
  45.                 if (notNullRow)
  46.                 {
  47.                     dt.Rows.Add(newRow);
  48.                 }
  49.                 else
  50.                 {
  51.                     newRow = null;
  52.                 }
  53.             }
  55.             bool delRow = false;
  57.             foreach (string param in Request.Params.Keys)
  58.             {
  59.                 if (param == string.Format("del:{0}", viewName))
  60.                 {
  61.                     delRow = true;
  62.                     break;
  63.                 }
  64.             }
  66.             if (delRow)
  67.             {
  68.                 string[] param = Request.Params[string.Format("del:{0}", viewName)].Split(',');
  70.                 foreach(string id in param)
  71.                 {
  72.                     dt.Rows[int.Parse(id) - 1].Delete();
  73.                 }
  74.             }
  76.             int cptLine = 0;
  78.             foreach (DataRow row in dt.Rows)
  79.             {
  80.                 cptLine++;
  82.                 if (row.RowState != DataRowState.Deleted)
  83.                 {
  84.                     XmlNode rLine = outputNode.OwnerDocument.CreateElement("line" );
  86.                     foreach (DataColumn col in dt.Columns)
  87.                     {
  88.                         foreach (string param in Request.Params.Keys)
  89.                         {
  90.                             if (param == string.Format("upd:{0}-{1}-{2}", viewName, col.ColumnName, cptLine.ToString()))
  91.                             {
  92.                                 switch (col.DataType.Name)
  93.                                 {
  94.                                     case "String":
  95.                                         if (row[col] != Request.Params[string.Format("upd:{0}-{1}-{2}", viewName, col.ColumnName, cptLine.ToString())].ToString())
  96.                                         {
  97.                                             row[col] = Request.Params[string.Format("upd:{0}-{1}-{2}", viewName, col.ColumnName, cptLine.ToString())].ToString();
  98.                                         }
  99.                                         break;
  100.                                 }
  101.                                 break;
  102.                             }
  103.                         }
  105.                         XmlElement rNode = rLine.OwnerDocument.CreateElement(col.ColumnName);
  106.                         rNode.InnerXml = row[col].ToString();
  107.                         XmlAttribute rAtt = rLine.OwnerDocument.CreateAttribute("type" );
  108.                         rAtt.Value = col.DataType.Name;
  109.                         rNode.Attributes.Append(rAtt);
  110.                         rLine.AppendChild(rNode);
  111.                     }
  113.                     outputNode.AppendChild(rLine);
  115.                     // For each row, we can have embeded views
  116.                     if (view.SelectNodes("views/view" ) != null)
  117.                     {
  118.                         RenderViews(outputNode, view.SelectNodes("views/view" ), row);
  119.                     }
  120.                 }
  121.             }
  123.             DataTable updDataTabe = dt.GetChanges();
  124.             if (updDataTabe != null)
  125.             {
  126.                 SqlCommandBuilder cmdBuilder = new SqlCommandBuilder(da);
  127.                 if (newRow != null)
  128.                 {
  129.                     da.InsertCommand = cmdBuilder.GetInsertCommand();
  130.                 }
  131.                 if (delRow)
  132.                 {
  133.                     da.DeleteCommand = cmdBuilder.GetDeleteCommand();
  134.                 }
  135.                 da.UpdateCommand = cmdBuilder.GetUpdateCommand();
  136.                 da.Update(updDataTabe);
  137.                 cmdBuilder.Dispose();
  138.                 cmdBuilder = null;
  139.             }
  141.             dt.Dispose();
  142.             da.Dispose();
  144.             cmd.Dispose();


 
Merci bien à ce lien :
http://samples.gotdotnet.com/quick [...] romDB.aspx
 
--edit--
1/ Mise à jour du code : maintenant, seules les lignes non vides sont ajoutées. Deplus, seules les lignes réellement modifiées sont mises à jour.
2/ Nouvelle mise à jour : maintenant on peut aussi supprimer des lignes


Message édité par Arjuna le 10-07-2006 à 22:22:42
Reply

Marsh Posté le 12-07-2006 à 14:48:22    

Bon, je me permet de remonter ce topic en réouvrant la question, puisque ma solution actuelle n'est pas satisfaisante.
 
En effet, retrouver les lignes dans mon datatable via leur "position" n'est pas satisfaisant, dans la mesure où, pendant que je modifie la ligne 2 par exemple, une personne peut ajouter une nouvelle ligne, qui, à cause de ma clause de tri, va se trouver en position numéro deux.
Ainsi, quand je vais soumettre la requête "modifier la ligne 2", je vais modifier la mauvaise ligne.
 
J'ai vu une propriété "primaryKey" dans datatable. Vu qu'on est obligé d'avoir une PK dans une datatable, à priori c'est une source plus fiable.
 
Cependant, j'ai toujours le souci de généricité. Ainsi, la clé peut être composées ou autre, ce qui ne facilite en rien mon truc...
 
Si vous voyez une meilleur solution (ou avez une idée précise de comment implémenter cette dernière, je suis preneur)

Reply

Marsh Posté le 12-07-2006 à 15:32:18    

En fait, tu veux recoder l'Enterprise Manager de SQL Server ?
 
Déjà, le fait que tu utilises des string ça t'empêche de considérer toutes les clefs primaires possibles, donc niveau généricité, ça marchera que dans 99% des cas. (mais c déjà pas mal :)
 
Les clefs primaires c bien : ca t'identifie une ligne de façon unique.
Si tu as plusieurs clefs primaires, bah il faut faire un système pour les passer toutes en paramètres pour identifier tes lignes.
Pour éviter de faire une using à gaz, je collerai la gestion de la clef primaire dans un object spécialisé (DataIdentifier ?) qui gère les clefs simples et composées de façon transparent au niveau de ton code 'fonctionnel'.
Cet objet à pour but de lire les clefs primaires d'un DataRow et les coller dans une chaine à la demande, et vice-versa. Avec une redéfinition de Equals tu peux aussi vérifier l'égalité de deux lignes, quel que soit le nombre de clefs qui le compose.
 
Chui clair ou pas ?

Reply

Marsh Posté le 12-07-2006 à 15:46:36    

Dans mon flux XML, je récupère le type et les infos du type. Donc y'a pas de souci, je sais dans tous les cas recomposer ma clé.
 
Par contre, je viens de me rendre compte d'un truc très con : "primaryKey" de mon datatable est vide. Il est nécessaire d'avoir une PK dans la requête qui l'allimente, mais il n'est pas foutu de le retrouver dans l'objet :/ comment faire :sweat:

Reply

Marsh Posté le 12-07-2006 à 15:47:47    

sinon, une clé primaire, par définition, y'en a qu'une par table, après ce sont des clés alternatives ;) si je fais le choix d'utiliser la pk je n'ai pas à me soucier de savoir combien il y a de clé ;)

Reply

Marsh Posté le 12-07-2006 à 21:37:14    

Ca y est !
 
J'ai donc trouvé comme mettre à jour selon la PK.
Ce fût quelque peut difficile, mais finalement c'est plutôt simple :)
 
Pour récupérer la PK dans l'objet DataTable, il suffit de faire un "FillSchema()" à partir du DataAdapter.
 
Pour le reste, je vous laisse contempler le bordel :D
 
Edit :
Correction des bugs, et surtout, rechargement des données en cas de modification. Désolé pour le goto :D --
 
Edit :
Correction d'un nouveau bug : Si la requête ne retourne pas de PK identifiable, alors le .FillSchema() vide la DataTable. Il faut donc ensuite la recharger sans schema
Cette correction est largement améliorable (ici, on doit obligatoirement faire deux fois la requête, avec toutes les requêtes imbriquées !). Mais ça demande la duplication d'une grande partie du code...

Code :
  1. cmd.CommandText = sql;
  2.             cmd.CommandType = CommandType.Text;
  3.             cmd.Prepare();
  5.             DataTable dt = new DataTable();
  6.             SqlDataAdapter da = new SqlDataAdapter(cmd);
  7.             da.Fill(dt);
  8.             int nbRows = dt.Rows.Count;
  9.             da.FillSchema(dt, SchemaType.Mapped);
  10.             int nbRowsSchema = dt.Rows.Count;
  12.             bool addRow = false;
  13.             bool delRow = false;
  15.             if (nbRows == nbRowsSchema)
  16.             {
  17.                 // Insert
  18.                 DataRow newRow = null;
  19.                 foreach (string param in Request.Params.Keys)
  20.                 {
  21.                     if (param != null && param.StartsWith(string.Format("add:{0}-", viewName)) && Request.Params[param] != string.Empty)
  22.                     {
  23.                         addRow = true;
  24.                         break;
  25.                     }
  26.                 }
  28.                 if (addRow)
  29.                 {
  30.                     bool notNullRow = false;
  31.                     newRow = dt.NewRow();
  32.                     foreach (DataColumn col in dt.Columns)
  33.                     {
  34.                         foreach (string param in Request.Params.Keys)
  35.                         {
  36.                             if (param != null && param == string.Format("add:{0}-{1}", viewName, col.ColumnName))
  37.                             {
  38.                                 switch (col.DataType.Name)
  39.                                 {
  40.                                     case "String":
  41.                                         if (Request.Params[string.Format("add:{0}-{1}", viewName, col.ColumnName)].ToString() != string.Empty)
  42.                                         {
  43.                                             notNullRow = true;
  44.                                             newRow[col] = Request.Params[string.Format("add:{0}-{1}", viewName, col.ColumnName)].ToString();
  45.                                         }
  46.                                         break;
  47.                                 }
  48.                                 break;
  49.                             }
  50.                         }
  51.                     }
  52.                     if (notNullRow)
  53.                     {
  54.                         dt.Rows.Add(newRow);
  55.                     }
  56.                     else
  57.                     {
  58.                         newRow = null;
  59.                     }
  60.                 }
  62.                 // Delete
  63.                 foreach (string param in Request.Params.Keys)
  64.                 {
  65.                     if (param != null && param == string.Format("del:{0}", viewName))
  66.                     {
  67.                         delRow = true;
  68.                         break;
  69.                     }
  70.                 }
  72.                 if (delRow)
  73.                 {
  74.                     // Primary keys retrieve
  75.                     foreach (string lineId in Request.Params[string.Format("del:{0}", viewName)].Split(','))
  76.                     {
  77.                         bool deleted = false;
  78.                         string[] keys = Request.Params[string.Format("pk:{0}-{1}", viewName, lineId)].Split(',');
  79.                         foreach (DataRow row in dt.Rows)
  80.                         {
  81.                             if (row.RowState != DataRowState.Deleted)
  82.                             {
  83.                                 bool wouldDelete = true;
  84.                                 for (int i = 0; i < keys.Length; i++)
  85.                                 {
  86.                                     if (row[dt.PrimaryKey[i]].ToString() != keys[i].Substring(1, keys[i].Length - 2))
  87.                                     {
  88.                                         wouldDelete = false;
  89.                                         break;
  90.                                     }
  91.                                 }
  92.                                 if (wouldDelete)
  93.                                 {
  94.                                     row.Delete();
  95.                                     deleted = true;
  96.                                 }
  97.                                 if (deleted)
  98.                                 {
  99.                                     break;
  100.                                 }
  101.                             }
  102.                         }
  103.                     }
  104.                 }
  105.             }
  107.         BuildLineNode:
  108.             if (nbRows == nbRowsSchema)
  109.             {
  110.                 if (!addRow && !delRow)
  111.                 {
  112.                     foreach (DataRow row in dt.Rows)
  113.                     {
  114.                         XmlNode rLine = outputNode.OwnerDocument.CreateElement("line" );
  116.                         // Create Primary Key definition
  117.                         XmlAttribute pk = rLine.OwnerDocument.CreateAttribute("primaryKey" );
  118.                         string pkVal = string.Empty;
  119.                         foreach (DataColumn dc in dt.PrimaryKey)
  120.                         {
  121.                             pkVal += string.Format("<{0}>,", row[dc].ToString());
  122.                         }
  123.                         if (pkVal != string.Empty)
  124.                         {
  125.                             pk.Value = pkVal.Substring(0, pkVal.Length - 1);
  126.                         }
  127.                         rLine.Attributes.Append(pk);
  129.                         foreach (DataColumn col in dt.Columns)
  130.                         {
  131.                             // Primary keys retrieve
  132.                             foreach (string param in Request.Params.Keys)
  133.                             {
  134.                                 bool updated = false;
  135.                                 if (param != null && param.StartsWith(string.Format("upd:{0}-{1}-", viewName, col.ColumnName)))
  136.                                 {
  137.                                     bool wouldUpdate = true;
  138.                                     string lineId = param.Substring(param.LastIndexOf('-') + 1);
  139.                                     string[] keys = Request.Params[string.Format("pk:{0}-{1}", viewName, lineId)].Split(',');
  140.                                     for (int i = 0; i < keys.Length; i++)
  141.                                     {
  142.                                         if (row[dt.PrimaryKey[i]].ToString() != keys[i].Substring(1, keys[i].Length - 2))
  143.                                         {
  144.                                             wouldUpdate = false;
  145.                                             break;
  146.                                         }
  147.                                     }
  148.                                     if (wouldUpdate)
  149.                                     {
  150.                                         switch (col.DataType.Name)
  151.                                         {
  152.                                             case "String":
  153.                                                 if (row[col].ToString() != Request.Params[param].ToString())
  154.                                                 {
  155.                                                     row[col] = Request.Params[param].ToString();
  156.                                                 }
  157.                                                 break;
  158.                                         }
  159.                                         updated = true;
  160.                                     }
  161.                                     if (updated)
  162.                                     {
  163.                                         break;
  164.                                     }
  165.                                 }
  166.                             }
  168.                             XmlElement rNode = rLine.OwnerDocument.CreateElement(col.ColumnName);
  169.                             rNode.InnerXml = row[col].ToString();
  170.                             XmlAttribute rAtt = rLine.OwnerDocument.CreateAttribute("type" );
  171.                             rAtt.Value = col.DataType.Name;
  172.                             rNode.Attributes.Append(rAtt);
  173.                             rLine.AppendChild(rNode);
  174.                         }
  176.                         outputNode.AppendChild(rLine);
  178.                         // For each row, we can have embeded views
  179.                         if (view.SelectNodes("views/view" ) != null)
  180.                         {
  181.                             RenderViews(outputNode, view.SelectNodes("views/view" ), row);
  182.                         }
  183.                     }
  184.                 }
  185.             }
  187.             DataTable updDataTabe = dt.GetChanges();
  188.             if (updDataTabe != null)
  189.             {
  190.                 SqlCommandBuilder cmdBuilder = new SqlCommandBuilder(da);
  191.                 if (addRow || delRow)
  192.                 {
  193.                     if (addRow)
  194.                     {
  195.                         da.InsertCommand = cmdBuilder.GetInsertCommand();
  196.                     }
  197.                     if (delRow)
  198.                     {
  199.                         da.DeleteCommand = cmdBuilder.GetDeleteCommand();
  200.                     }
  201.                 }
  202.                 else
  203.                 {
  204.                     da.UpdateCommand = cmdBuilder.GetUpdateCommand();
  205.                 }
  206.                 da.Update(updDataTabe);
  207.                 cmdBuilder.Dispose();
  208.                 cmdBuilder = null;
  209.             }
  210.             if (updDataTabe != null || nbRows != nbRowsSchema)
  211.             {
  212.                 dt.Clear();
  213.                 dt.Dispose();
  214.                 da.Dispose();
  215.                 da = new SqlDataAdapter(cmd);
  216.                 da.Fill(dt);
  217.                 outputNode.RemoveAll();
  218.                 delRow = false;
  219.                 addRow = false;
  220.                 nbRows = dt.Rows.Count;
  221.                 nbRowsSchema = nbRows;
  222.                 goto BuildLineNode;
  223.             }
  225.             dt.Dispose();
  226.             da.Dispose();
  228.             cmd.Dispose();


Message édité par Arjuna le 12-07-2006 à 23:07:07
Reply

Marsh Posté le 12-07-2006 à 22:14:43    

je suis certain que j'arriverais à faire la même chose en faisant 5x moins de ligne. Il y a une technique bien particulière pour cela. Traiter déjà des event sur le dataset. Après, ça fait tout à fait la même chose que tu fais la, en plus facile et en plus cours :D

Reply

Marsh Posté le 12-07-2006 à 22:31:29    

yep, sauf que moi je ne bosse pas en mode connecté et j'ai pas de databind,  j'ai pas de viewstate ni rien, donc pour les event...

Message cité 1 fois
Reply

Marsh Posté le 12-07-2006 à 22:33:11    

ceci dit, il y a pas mal d'optimisations à faire. si tu te sens le courrage, je suis preneur d'optimisations :) (le premier, ce serait de faire un Request.Params["toto%"] afin d'éviter de tous me les palucher un peu partout... Là les boucles imbriquées qui servent à rien, y'en a une trippoté :D

Reply

Marsh Posté le 12-07-2006 à 22:33:11   

Reply

Marsh Posté le 12-07-2006 à 23:14:51    

Groumpf...
 
Je viens de m'appercevoir que pour les cas tordus, genre je met à jours les données d'une table liée, pour chaque ligne de la table principale, je vais avoir un truc très con : pas capable de retrouver la PK correspondant à chaque champ :sweat:
 
Bon, là je suis mal, y'a plus qu'à réécrire une grande partie du code... Dans le principe, ça reste pareil, sauf qu'il faut que j'inclue la PK dans le nom du champ si je veux pouvoir le retrouver :sweat:
 
Edit :
Ceci dit, je me rend compte aussi que pour les INSERT, je suis encore plus dans la merde dans le cas d'une table liée... Obligé dans tous les cas de passer par un JS pour pas avoir d'embrouille... Et là je ne vois pas de solution simple pour faire une correction qui colle...
 
Du coup, une solution JS est possible pour le coup du INSERT et une autre, côté XSL, pour le UPDATE et DELETE... du coup ben... Ouais, en fait c'est bien comme ça :D


Message édité par Arjuna le 12-07-2006 à 23:19:10
Reply

Marsh Posté le 13-07-2006 à 00:12:18    

FillSchema, c'est trop trop trop con comme fonction :fou:
 
Non seulement ça vite le DT s'il est vide, mais en plus, si je filtre par la PK lors de la requête, il doit décider que l'information de PK est inutile, donc il la vire :fou:

Reply

Marsh Posté le 13-07-2006 à 01:05:33    

c'est même pire que tout...
 
si je met id = 1 en dur, j'ai bien une pk
si je met id = @idval alors ça marche plus, y'a plus de pk
 
en fait, il me vire le schema si un paramètre porte sur une composante de la pk :sweat:

Reply

Marsh Posté le 13-07-2006 à 01:06:33    

à moins que ce ne soit carrément dès que j'ai un paramètre...
 
ouais, en fait ça c'est. dès que j'utilise un paramètre à ma requêtes, j'ai plus d'info de pk...

Reply

Marsh Posté le 13-07-2006 à 09:27:19    

Arjuna a écrit :

yep, sauf que moi je ne bosse pas en mode connecté et j'ai pas de databind,  j'ai pas de viewstate ni rien, donc pour les event...


 
ma technique consisterait également à travailler en mode déconnecté. Bien entendu, j'aurais besoin du viewstate pour conserver les data d'un passage à l'autre.  
Cependant, je ne l'ai jms implémenté en Web, donc finalement, ça deviendrait peut etre marteau burin aussi...  

Reply

Marsh Posté le 13-07-2006 à 10:25:40    

ouais, chais pas trop.
 
d'un autre côté, mon truc est récursif, on peut donc avoir n requêtes imbriquées et m requêtes à la queue leu-leue. Du coup, pour retrouver quelque chose dans le viewstate... j'ai préféré écarter cette option dès le départ, jugeant les problèmes d'accès mémoire trop compliqués par rapport à réxécuter les requêtes.
 
de plus, à la sortie, je crée un flux XML que je transforme en XSL, je n'ai donc pas la possibilité de lier un contrôle à chaque datatable comme on ferait avec des datarepeater.
 
dans tous les cas, ça ne résoud pas mon problème de fillschema qui ne marche pas quand j'ai un paramètre dans ma requête... :/


Message édité par Arjuna le 13-07-2006 à 10:27:14
Reply

Marsh Posté le 13-07-2006 à 13:23:09    

Et le goto , tu l'as enlevé ?
 
Pourquoi tu découpes pas ton code en fonctions ? Ca te simplifiera la vie méchamment !
Les méthodes 'usines à gaz' de 200 lignes de long c'est super chiant à maintenir, tu passes des lustres à essayer de re-comprendre ce que tu as fait quand tu les reprends un mois plus tard, tu factorises aucun traitement et du coup tu multiplies les copier-coller là ou tu pourrais l'éviter, etc...
 
Vive les méthodes privée !  :)

Reply

Marsh Posté le 13-07-2006 à 14:26:35    

=> dans le dernier code que j'ai posté en date, non, il est toujours présent le gogo.
=> pour les fonction, je suis d'accord que ça deviens un peu usine à gaz. ceci dit, c'est carrément du oneshot à chaque fois : même si parfois je fais deux fois un traîtement similaire, il y a suffisament de différences pour ne pas le rendre factorisable. du coup j'ai tout laissé en pense de vache, mais je ne vois pas comment faire mieux, du moins si je veux conserver le peu d'optimisations qu'il y a dans le code...
 
sinon, voici ma bidouille pour contourner le problème du fillschema... d'un côté, j'ai fortement optimisé le code, et surtout, il n'y a plus de goto... mais d'un autre côté, là je lance systématiquement la requête une première fois sans filtre ! du coup je vous raconte pas les perfs si y'a beaucoup de ligne :/
 
j'espère qu'une bonne âme voudra bien me donner une explication de ce "bug" de fillschema, afin de retrouver un semblant de performances dans mon truc...
 
du coup, j'en suis à me demander si ce ne serait pas plus simple de tout charger, et de faire les filtres dans le DataTable au lieu de les faire en SQL. A priori, ça serait pas moins performant :/
 
Voilà le code complet qui marche.
Y'a plus de bugs. Et je peux mettre à jour n'importe quelle requête du moment qu'il n'y a pas d'agrégations dedans (ni de jointures complexes, ça va de soit)
 

Code :
  1. SqlCommand cmd = cnx.CreateCommand();
  2.             string sql = string.Format("select * from ({0}) res", xmlDefinition.SelectSingleNode("view/sql" ).InnerText);
  4.             cmd.CommandText = sql;
  5.             cmd.CommandType = CommandType.Text;
  6.             cmd.Prepare();
  8.             DataTable dts = new DataTable();
  9.             SqlDataAdapter das = new SqlDataAdapter(cmd);
  10.             das.Fill(dts);
  11.             das.FillSchema(dts, SchemaType.Source);
  13.             bool addRow = false;
  14.             bool delRow = false;
  16.             // Insert
  17.             DataRow newRow = null;
  18.             foreach (string param in Request.Params.Keys)
  19.             {
  20.                 if (param != null && param.StartsWith(string.Format("add:{0}-", viewName)) && Request.Params[param] != string.Empty)
  21.                 {
  22.                     addRow = true;
  23.                     break;
  24.                 }
  25.             }
  27.             if (addRow)
  28.             {
  29.                 bool notNullRow = false;
  30.                 newRow = dts.NewRow();
  31.                 foreach (DataColumn col in dts.Columns)
  32.                 {
  33.                     foreach (string param in Request.Params.Keys)
  34.                     {
  35.                         if (param != null && param == string.Format("add:{0}-{1}", viewName, col.ColumnName))
  36.                         {
  37.                             switch (col.DataType.Name)
  38.                             {
  39.                                 case "String":
  40.                                     if (Request.Params[string.Format("add:{0}-{1}", viewName, col.ColumnName)].ToString() != string.Empty)
  41.                                     {
  42.                                         notNullRow = true;
  43.                                         newRow[col] = Request.Params[string.Format("add:{0}-{1}", viewName, col.ColumnName)].ToString();
  44.                                     }
  45.                                     break;
  46.                             }
  47.                             break;
  48.                         }
  49.                     }
  50.                 }
  51.                 if (notNullRow)
  52.                 {
  53.                     dts.Rows.Add(newRow);
  54.                 }
  55.                 else
  56.                 {
  57.                     newRow = null;
  58.                 }
  59.             }
  61.             // Delete
  62.             foreach (string param in Request.Params.Keys)
  63.             {
  64.                 if (param != null && param == string.Format("del:{0}", viewName))
  65.                 {
  66.                     delRow = true;
  67.                     break;
  68.                 }
  69.             }
  71.             if (delRow)
  72.             {
  73.                 // Primary keys retrieve
  74.                 foreach (string lineId in Request.Params[string.Format("del:{0}", viewName)].Split(','))
  75.                 {
  76.                     bool deleted = false;
  77.                     string[] keys = Request.Params[string.Format("pk:{0}-{1}", viewName, lineId)].Split(',');
  78.                     foreach (DataRow row in dts.Rows)
  79.                     {
  80.                         if (row.RowState != DataRowState.Deleted)
  81.                         {
  82.                             bool wouldDelete = true;
  83.                             for (int i = 0; i < keys.Length; i++)
  84.                             {
  85.                                 if (row[dts.PrimaryKey[i]].ToString() != keys[i].Substring(1, keys[i].Length - 2))
  86.                                 {
  87.                                     wouldDelete = false;
  88.                                     break;
  89.                                 }
  90.                             }
  91.                             if (wouldDelete)
  92.                             {
  93.                                 row.Delete();
  94.                                 deleted = true;
  95.                             }
  96.                             if (deleted)
  97.                             {
  98.                                 break;
  99.                             }
  100.                         }
  101.                     }
  102.                 }
  103.             }
  105.             // Update
  106.             foreach (DataRow row in dts.Rows)
  107.             {
  108.                 if (row.RowState != DataRowState.Deleted)
  109.                 {
  110.                     foreach (DataColumn col in dts.Columns)
  111.                     {
  112.                         // Primary keys retrieve
  113.                         foreach (string param in Request.Params.Keys)
  114.                         {
  115.                             bool updated = false;
  116.                             if (param != null && param.StartsWith(string.Format("upd:{0}-{1}-", viewName, col.ColumnName)))
  117.                             {
  118.                                 bool wouldUpdate = true;
  119.                                 string lineId = param.Substring(param.LastIndexOf('-') + 1);
  120.                                 string[] keys = Request.Params[string.Format("pk:{0}-{1}", viewName, lineId)].Split(',');
  121.                                 for (int i = 0; i < keys.Length; i++)
  122.                                 {
  123.                                     if (row[dts.PrimaryKey[i]].ToString() != keys[i].Substring(1, keys[i].Length - 2))
  124.                                     {
  125.                                         wouldUpdate = false;
  126.                                         break;
  127.                                     }
  128.                                 }
  129.                                 if (wouldUpdate)
  130.                                 {
  131.                                     switch (col.DataType.Name)
  132.                                     {
  133.                                         case "String":
  134.                                             if (row[col].ToString() != Request.Params[param].ToString())
  135.                                             {
  136.                                                 row[col] = Request.Params[param].ToString();
  137.                                             }
  138.                                             break;
  139.                                     }
  140.                                     updated = true;
  141.                                 }
  142.                                 if (updated)
  143.                                 {
  144.                                     break;
  145.                                 }
  146.                             }
  147.                         }
  148.                     }
  149.                 }
  150.             }
  152.             DataTable updDataTable = dts.GetChanges();
  153.             if (updDataTable != null)
  154.             {
  155.                 SqlCommandBuilder cmdBuilder = new SqlCommandBuilder(das);
  156.                 das.InsertCommand = cmdBuilder.GetInsertCommand();
  157.                 das.DeleteCommand = cmdBuilder.GetDeleteCommand();
  158.                 das.UpdateCommand = cmdBuilder.GetUpdateCommand();
  159.                 das.Update(updDataTable);
  160.                 cmdBuilder.Dispose();
  161.                 cmdBuilder = null;
  162.             }
  164.             SqlParameterCollection sqlParams = cmd.Parameters;
  166.             foreach (XmlNode filterNode in xmlDefinition.SelectNodes("view/filters/filter" ))
  167.             {
  168.                 if (filterNode.Attributes["name"].Value == filterName)
  169.                 {
  170.                     if (filterNode.Attributes["sql"] != null)
  171.                     {
  172.                         sql += " where " + filterNode.Attributes["sql"].Value;
  173.                         foreach (XmlNode parameterNode in filterNode.SelectNodes("parameter" ))
  174.                         {
  175.                             SqlParameter param = new SqlParameter();
  176.                             param.ParameterName = parameterNode.Attributes["name"].Value;
  177.                             param.Size = int.Parse(parameterNode.Attributes["length"].Value);
  178.                             param.Scale = byte.Parse(parameterNode.Attributes["scale"].Value);
  179.                             param.Precision = byte.Parse(parameterNode.Attributes["precision"].Value);
  180.                             switch (parameterNode.Attributes["sqltype"].Value)
  181.                             {
  182.                                 case "nvarchar":
  183.                                     param.SqlDbType = SqlDbType.NVarChar;
  184.                                     param.Value = parameters[parameterNode.Attributes["name"].Value];
  185.                                     sqlParams.Add(param);
  186.                                     break;
  187.                                 case "numeric":
  188.                                     param.SqlDbType = SqlDbType.Decimal;
  189.                                     param.Value = Int64.Parse(parameters[parameterNode.Attributes["name"].Value]);
  190.                                     sqlParams.Add(param);
  191.                                     break;
  192.                             }
  193.                         }
  194.                     }
  195.                     break;
  196.                 }
  197.             }
  199.             if (sortName != string.Empty)
  200.             {
  201.                 foreach (XmlNode sortNode in xmlDefinition.SelectNodes("view/sorts/sort" ))
  202.                 {
  203.                     if (sortNode.Attributes["name"].Value == sortName)
  204.                     {
  205.                         sql += string.Format(" order by {0}", sortNode.Attributes["sql"].Value);
  206.                         break;
  207.                     }
  208.                 }
  209.             }
  211.             cmd.CommandText = sql;
  212.             cmd.CommandType = CommandType.Text;
  213.             cmd.Prepare();
  215.             DataTable dt = new DataTable();
  216.             SqlDataAdapter da = new SqlDataAdapter(cmd);
  217.             da.Fill(dt);
  219.             foreach (DataRow row in dt.Rows)
  220.             {
  221.                 XmlNode rLine = outputNode.OwnerDocument.CreateElement("line" );
  223.                 // Create Primary Key definition
  224.                 XmlAttribute pk = rLine.OwnerDocument.CreateAttribute("primaryKey" );
  225.                 string pkVal = string.Empty;
  226.                 foreach (DataColumn dc in dts.PrimaryKey)
  227.                 {
  228.                     pkVal += string.Format("<{0}>,", row[dc.ColumnName].ToString());
  229.                 }
  230.                 if (pkVal != string.Empty)
  231.                 {
  232.                     pk.Value = pkVal.Substring(0, pkVal.Length - 1);
  233.                 }
  234.                 rLine.Attributes.Append(pk);
  236.                 foreach (DataColumn col in dt.Columns)
  237.                 {
  238.                     XmlElement rNode = rLine.OwnerDocument.CreateElement(col.ColumnName);
  239.                     rNode.InnerXml = row[col].ToString();
  240.                     XmlAttribute rAtt = rLine.OwnerDocument.CreateAttribute("type" );
  241.                     rAtt.Value = col.DataType.Name;
  242.                     rNode.Attributes.Append(rAtt);
  243.                     rLine.AppendChild(rNode);
  244.                 }
  246.                 outputNode.AppendChild(rLine);
  248.                 // For each row, we can have embeded views
  249.                 if (view.SelectNodes("views/view" ) != null)
  250.                 {
  251.                     RenderViews(outputNode, view.SelectNodes("views/view" ), row);
  252.                 }
  253.             }
  255.             dts.Dispose();
  256.             das.Dispose();
  257.             dt.Dispose();
  258.             da.Dispose();
  260.             cmd.Dispose();
  262.             // Add data to output view node
  263.             output.AppendChild(outputNode);
  265.             // Free memory resources and files handles
  266.             dts = null;
  267.             das = null;
  268.             dt = null;
  269.             da = null;
  270.             cmd = null;
  271.             outputNode = null;
  272.             xmlDefinition = null;


Message édité par Arjuna le 13-07-2006 à 14:27:23
Reply

Marsh Posté le 13-07-2006 à 16:27:46    

Suite à la correction de ce problème :
http://forum.hardware.fr/forum2.ph [...] 0#t1406039
 
Maintenant :
- ça marche
- c'est rapide
- c'est super optimisé (autant faire se peut)
 
:bounce:

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed