protected virtual string GetRequeteCreateCleEtrangere(CInfoRelation rel) { string strTableFilleInDb = CContexteDonnee.GetNomTableInDbForNomTable(rel.TableFille); string strTableParenteInDb = CContexteDonnee.GetNomTableInDbForNomTable(rel.TableParente); string strRequeteRelation = ""; strRequeteRelation += "ALTER TABLE " + strTableFilleInDb + " "; strRequeteRelation += "ADD CONSTRAINT " + GetNewNomClefEtrangere(rel); strRequeteRelation += " FOREIGN KEY ("; foreach (string strChamp in rel.ChampsFille) { strRequeteRelation += strChamp + ","; } strRequeteRelation = strRequeteRelation.Substring(0, strRequeteRelation.Length - 1); strRequeteRelation += ") "; strRequeteRelation += "REFERENCES " + strTableParenteInDb + "("; foreach (string strChamp in rel.ChampsParent) { strRequeteRelation += strChamp + ","; } strRequeteRelation = strRequeteRelation.Substring(0, strRequeteRelation.Length - 1); strRequeteRelation += ")"; return(strRequeteRelation); }
//------------------------------------------------------------------------------------------------ protected static string GetRequeteRelation(CInfoRelation rel) { string strNomTableFille = CContexteDonnee.GetNomTableInDbForNomTable(rel.TableFille); string strNomTableParente = CContexteDonnee.GetNomTableInDbForNomTable(rel.TableParente); string strRequeteRelation = ""; strRequeteRelation += "ALTER TABLE " + strNomTableFille + " "; strRequeteRelation += "ADD CONSTRAINT " + rel.RelationKey; strRequeteRelation += " FOREIGN KEY ("; foreach (string strChamp in rel.ChampsFille) { strRequeteRelation += strChamp + ","; } strRequeteRelation = strRequeteRelation.Substring(0, strRequeteRelation.Length - 1); strRequeteRelation += ") "; strRequeteRelation += "REFERENCES " + strNomTableParente + "("; foreach (string strChamp in rel.ChampsParent) { strRequeteRelation += strChamp + ","; } strRequeteRelation = strRequeteRelation.Substring(0, strRequeteRelation.Length - 1); strRequeteRelation += ")"; return(strRequeteRelation); }
/// ///////////////////////////////////////////////////////////////// private DataTable TyperLesColonnes(DataTable dt) { DataTable dtcol = new DataTable(); string strNomTableInDb = CContexteDonnee.GetNomTableInDbForNomTable(dt.TableName); if (strNomTableInDb == null) { strNomTableInDb = dt.TableName; } string strRequeteInfoCols = "SELECT CNAME, COLTYPE, WIDTH, SCALE, \"PRECISION\" FROM SYS.COL WHERE "; strRequeteInfoCols += "TNAME = '" + strNomTableInDb + "'"; dtcol = ExecuterRequeteEnParallele(strRequeteInfoCols); foreach (DataColumn col in dt.Columns) { //On récupère le type et la longueur de la colonne DataRow[] infocol = dtcol.Select("CNAME = '" + col.ColumnName + "'"); if (infocol.Length > 0) { string strTypeCol = infocol[0]["COLTYPE"].ToString(); string strLngCol = infocol[0]["WIDTH"].ToString(); string strPrecisionCol = infocol[0]["PRECISION"].ToString(); string strEchelleCol = infocol[0]["SCALE"].ToString(); col.DataType = (new CMySqlTypeMapper()).GetTypeCSharpFromDBType(strTypeCol, strLngCol, strPrecisionCol, strEchelleCol); } } return(dt); }
/// ///////////////////////////////////////////////////////////////// public void RenseignerPourSynchro(DataRow row, StatementType typeOperation) { if (!m_bEnableLogSyncrhonisation) { return; } string strNomTableInDb = CContexteDonnee.GetNomTableInDbForNomTable(row.Table.TableName); if (strNomTableInDb == null) { strNomTableInDb = row.Table.TableName; } //Si la synchro est active et que la table est synchronisable... if (row.Table.Columns[CSc2iDataConst.c_champIdSynchro] != null && (typeOperation == StatementType.Insert || typeOperation == StatementType.Delete)) { //Recupération de l'ID de l'élément string strID; DataColumn[] colsID = row.Table.PrimaryKey; if (colsID.Length == 1 && colsID[0].AutoIncrement) { if (typeOperation == StatementType.Delete) { strID = row[colsID[0], DataRowVersion.Original].ToString(); } else { strID = row[colsID[0]].ToString(); } } else { return; } //Creation de la requete int nIdSync = IdSyncSession; string rqtMAJTableSynchro = "Insert into " + CEntreeLogSynchronisation.c_nomTable + " (" + CEntreeLogSynchronisation.c_champTable + "," + CEntreeLogSynchronisation.c_champIdElement + "," + CEntreeLogSynchronisation.c_champType + "," + CSc2iDataConst.c_champIdSynchro + ") values (" + "'" + strNomTableInDb + "'," + strID + ","; if (typeOperation == StatementType.Insert) { rqtMAJTableSynchro += ((int)CEntreeLogSynchronisation.TypeModifLogSynchro.tAdd).ToString(); } else { rqtMAJTableSynchro += ((int)CEntreeLogSynchronisation.TypeModifLogSynchro.tDelete).ToString(); } rqtMAJTableSynchro += "," + nIdSync.ToString() + ")"; RunStatement(rqtMAJTableSynchro); } }
protected virtual CResultAErreur CreateTable_ClesEtrangeres(CStructureTable structure) { CResultAErreur result = CResultAErreur.True; foreach (CInfoRelation rel in structure.RelationsParentes) { if (rel.IsInDb) { string strRequeteRelation = GetRequeteCreateCleEtrangere(rel); string strNomTableFilleInDb = CContexteDonnee.GetNomTableInDbForNomTable(rel.TableFille); result = Connection.RunStatement(strRequeteRelation); if (result) { AfterChangeContraintes(strNomTableFilleInDb); } if (!result) { result.EmpileErreur(I.T("Error while creating foreign key of @1 (@2)|127", structure.NomTableInDb, strRequeteRelation)); } else if (rel.Indexed && !IndexExists(strNomTableFilleInDb, rel.ChampsFille)) { result = Connection.RunStatement(GetRequeteCreateIndex(strNomTableFilleInDb, rel.IsClustered, rel.ChampsFille)); if (!result) { result.EmpileErreur(I.T("Error while creating index in table @1|128", structure.NomTableInDb)); } if (result) { AfterChangeIndexs(strNomTableFilleInDb); } } } } return(result); }
protected virtual string GetRequeteDeleteClefEtrangere(CInfoRelation relationToDelete) { string nomcleetr = GetNomClefEtrangere(relationToDelete); string strNomTableFilleInDb = CContexteDonnee.GetNomTableInDbForNomTable(relationToDelete.TableFille); if (nomcleetr == "") { return(""); } return("ALTER TABLE " + strNomTableFilleInDb + " DROP CONSTRAINT " + nomcleetr); }
/// //////////////////////////////////////////////////// private void OnRowAIdAutoInsertedGeneric(object sender, DataRow row) { string strNomTableInDb = CContexteDonnee.GetNomTableInDbForNomTable(row.Table.TableName); string strChampId = row.Table.PrimaryKey[0].ColumnName; CResultAErreur result = m_connexion.ExecuteScalar("select @@IDENTITY"); /*"select max([" + strChampId + "]) from " + * "[" + strNomTableInDb + "]");*/ if (!result) { result.EmpileErreur(I.T("Access97 Recovery IdAuto Error|101")); throw new CExceptionErreur(result.Erreur); } row[strChampId] = (int)result.Data; }
private string GetRequetePourRecupererLesDonnéesApresModification(DataRow row) { if (m_strChampIdCache == null) { DataColumn[] colKeys = row.Table.PrimaryKey; if (colKeys.Length != 1 || colKeys[0].DataType != typeof(int)) { throw new Exception("Oracle adapter error, Can not use 'Modified by trigger' on table with no Numeric ID"); } m_strChampIdCache = colKeys[0].ColumnName; } string strNomTable = CContexteDonnee.GetNomTableInDbForNomTable(row.Table.TableName); return("select * from " + strNomTable + " where " + m_strChampIdCache + "=" + row[m_strChampIdCache].ToString()); }
/// ///////////////////////////////////////////////////////////////// private DataTable TyperLesColonnes(DataTable dt) { DataTable dtcol = new DataTable(); string strNomTable = dt.TableName; foreach (DataTableMapping map in TableMappings) { if (map.SourceTable.ToUpper() == dt.TableName.ToUpper()) { strNomTable = map.DataSetTable; } } string strNomTableInDb = CContexteDonnee.GetNomTableInDbForNomTable(strNomTable); if (strNomTableInDb == null) { strNomTableInDb = dt.TableName; } string strRequeteInfoCols = "SELECT CNAME, COLTYPE, WIDTH, SCALE, \"PRECISION\" FROM SYS.COL WHERE "; strRequeteInfoCols += "TNAME = '" + strNomTableInDb + "'"; if (!m_dicTableToStructureOracle.TryGetValue(strNomTable, out dtcol)) { dtcol = ExecuterRequeteEnParallele(strRequeteInfoCols); m_dicTableToStructureOracle[strNomTable] = dtcol; } foreach (DataColumn col in dt.Columns) { //On récupère le type et la longueur de la colonne DataRow[] infocol = dtcol.Select("CNAME = '" + col.ColumnName + "'"); if (infocol.Length > 0) { string strTypeCol = infocol[0]["COLTYPE"].ToString(); string strLngCol = infocol[0]["WIDTH"].ToString(); string strPrecisionCol = infocol[0]["PRECISION"].ToString(); string strEchelleCol = infocol[0]["SCALE"].ToString(); col.DataType = (new COracleTypeMapper()).GetTypeCSharpFromDBType(strTypeCol, strLngCol, strPrecisionCol, strEchelleCol); } } return(dt); }
//------------------------------------------------------------------------------------------------ public static CResultAErreur CreationOuUpdateTableFromType(Type tp, IDatabaseConnexion connexion, ArrayList strChampsAutorisesANull) { CResultAErreur result = CResultAErreur.True; CStructureTable structure = CStructureTable.GetStructure(tp); if (!result) { return(result); } //S'assure que toutes les tables parentes existent foreach (CInfoRelation relation in structure.RelationsParentes) { if (relation.TableParente != structure.NomTable) { string strNomTableParenteInDb = CContexteDonnee.GetNomTableInDbForNomTable(relation.TableParente); if (!CAccessTableCreatorOld.TableExists(strNomTableParenteInDb, connexion)) { result = CreationOuUpdateTableFromType(CContexteDonnee.GetTypeForTable(relation.TableParente), connexion); if (!result) { return(result); } } } } if (CAccessTableCreatorOld.TableExists(structure.NomTableInDb, connexion)) { result = CAccessTableCreatorOld.UpdateTable(structure, connexion, strChampsAutorisesANull); } else { result = CAccessTableCreatorOld.CreateTable(structure, connexion); } return(result); }
public CArbreTableParente(string strNomTable) { m_strNomTable = strNomTable; Alias = CContexteDonnee.GetNomTableInDbForNomTable(strNomTable); }
//////////////////////////////////////////////////////// public string GetStringExpression(IExpression expression, CFiltreData filtre) { string strRetour = ""; if (expression is CComposantFiltre) { expression = ((CComposantFiltre)expression).GetComposantFiltreFinal(filtre); } if (expression is CComposantFiltreChamp) { CComposantFiltreChamp champ = (CComposantFiltreChamp)expression; if (champ.Alias != "") { strRetour += champ.Alias + "."; } strRetour += champ.NomChamp; } else if (expression is CComposantFiltreVariable) { strRetour = ((CComposantFiltreVariable)expression).GetString(); } else if (expression is CComposantFiltreConstante) { CComposantFiltreConstante constante = (CComposantFiltreConstante)expression; strRetour = CConvertisseurObjetToSqlServeur.ConvertToSql(constante.Valeur); } else if (expression is CComposantFiltreHasNo) { strRetour += GetStringExpression((IExpression)expression.Parametres[0], filtre); strRetour += " is null"; } else if (expression is CComposantFiltreHas) { strRetour += GetStringExpression((IExpression)expression.Parametres[0], filtre); strRetour += " is not null"; } else if (expression is CComposantFiltreListe) { CComposantFiltreListe liste = (CComposantFiltreListe)expression; strRetour = ""; foreach (IExpression expInListe in liste.Liste) { strRetour += GetStringExpression(expInListe, filtre) + ","; } if (strRetour.Length > 0) { strRetour = strRetour.Substring(0, strRetour.Length - 1); } strRetour = "(" + strRetour + ")"; } else if (expression is CComposantFiltreSousFiltre && m_connexion != null) { CComposantFiltreSousFiltre compo = (CComposantFiltreSousFiltre)expression; CResultAErreur result = compo.InterpreteParametres(); if (result) { string strWhere = ""; string strJoin = ""; string strPrefixFrom = ""; bool bDistinct = false; compo.Filtre.Parametres.Clear(); compo.Filtre.AddChampAAjouterAArbreTable(compo.ChampSousFiltre); foreach (object parametre in filtre.Parametres) { compo.Filtre.Parametres.Add(parametre); } CComposantFiltreOperateur compoEt = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEt); compoEt.Parametres.Add(compo.Filtre.ComposantPrincipal); CComposantFiltreHas compoNotNull = new CComposantFiltreHas(); compoNotNull.Parametres.Add(compo.ChampSousFiltre); compoEt.Parametres.Add(compoNotNull); compo.Filtre.ComposantPrincipal = compoEt; IEnumerable <C2iDbDatabaseConnexion.CParametreRequeteDatabase> parametres = null; result = m_connexion.PrepareRequeteFromFiltre( compo.Filtre, ref strWhere, ref strJoin, ref bDistinct, ref strPrefixFrom, ref parametres); if (result) { strRetour += " "; if (compo.ChampTeste.Alias != "") { strRetour += compo.ChampTeste.Alias + "."; } strRetour += compo.ChampTeste.NomChamp; if (compo is CComposantFiltreInSousFiltre) { strRetour += " in ("; } else { strRetour += " not in ("; } string strSelect = "select "; if (compo.ChampSousFiltre.Alias != "") { strSelect += compo.ChampSousFiltre.Alias + "."; } strSelect += compo.ChampSousFiltre.NomChamp; strSelect += " from " + CContexteDonnee.GetNomTableInDbForNomTable(compo.TableSousFiltre); strRetour += m_connexion.GetSql(strSelect, strPrefixFrom, strJoin, strWhere); strRetour += ")"; } } } else if (expression is CComposantFiltreOperateur) { COperateurAnalysable operateur = ((CComposantFiltreOperateur)expression).Operateur; string strTexteOperateur = operateur.Texte; if (operateur.Texte.Length > 3 && operateur.Texte.Substring(0, 3).ToUpper() == "NOT") { strTexteOperateur = operateur.Texte.Substring(0, 3) + " " + operateur.Texte.Substring(3); } if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurContains) { strTexteOperateur = "like"; } if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurWithout) { strTexteOperateur = "not like"; } if (operateur.Niveau > 0 && operateur.Niveau != 4) { string str1, str2, str3; str1 = GetStringExpression((IExpression)expression.Parametres[0], filtre); str2 = strTexteOperateur; str3 = GetStringExpression((IExpression)expression.Parametres[1], filtre); string[] valeurs = new string[] { str3 }; if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurContains || operateur.Id == CComposantFiltreOperateur.c_IdOperateurWithout) { str3 = "'%'+" + str3 + "+'%'"; } if (operateur.Niveau >= 4) { str1 = "(" + str1 + ")"; str3 = "(" + str3 + ")"; } bool bChercheVide = false; if (strTexteOperateur.ToUpper() == "LIKE") { bChercheVide = str3 == "%%"; if (!bChercheVide && str3.Contains("@")) { try { int nParam = Int32.Parse(str3.Substring("@PARAM".Length)); if (filtre.Parametres[nParam - 1].ToString() == "%%") { bChercheVide = true; } } catch { } } } if (bChercheVide) { strRetour += str3 + "=" + str3; } else { strRetour = str1 + " " + str2 + " " + str3; if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurLike || operateur.Id == CComposantFiltreOperateur.c_IdOperateurNotLike) { strRetour += " ESCAPE '\\'"; } } } else { strRetour = strTexteOperateur + "("; foreach (IExpression exp in expression.Parametres) { strRetour += GetStringExpression(exp, filtre) + ","; } if (expression.Parametres.Count > 0) { strRetour = strRetour.Substring(0, strRetour.Length - 1); } strRetour += ")"; } } return(strRetour); }
//-------------------------------------------------------------------------------------------------------------------- public override CResultAErreur ExecuterOperation(IDatabaseConnexion connection, IIndicateurProgression indicateur) { CResultAErreur result = CResultAErreur.True; IDataBaseCreator createur = connection.GetDataBaseCreator(); string strNomTableInContexte = CContexteDonnee.GetNomTableForType(m_type); string strNomTableInDb = CContexteDonnee.GetNomTableInDbForNomTable(strNomTableInContexte); createur.CreationOuUpdateTableFromType(m_type); string strChampIdObjet = m_strChampIdObjet; if (m_strChampIdObjet.StartsWith("#SQL#")) { strChampIdObjet = m_strChampIdObjet.Substring("#SQL#".Length); } CObjetServeur.ClearCacheSchemas(); if (createur.ChampExists(strNomTableInDb, strChampIdObjet) && createur.ChampExists(strNomTableInDb, m_strChampDbKey)) { using (CContexteDonnee ctx = new CContexteDonnee(connection.IdSession, true, false)) { C2iRequeteAvancee requete = new C2iRequeteAvancee(); requete.TableInterrogee = strNomTableInDb; CStructureTable structure = CStructureTable.GetStructure(m_type); /* * requete.ListeChamps.Add ( new C2iChampDeRequete ( * "ID", * new CSourceDeChampDeRequete(structure.ChampsId[0].NomChamp), * typeof(int), * OperationsAgregation.None, * true ));*/ requete.ListeChamps.Add(new C2iChampDeRequete( "IDOBJET", new CSourceDeChampDeRequete(m_strChampIdObjet), typeof(int), OperationsAgregation.None, true)); if (m_typeObjetFixe == null) { requete.ListeChamps.Add(new C2iChampDeRequete( "TYPEOBJET", new CSourceDeChampDeRequete(m_strChampTypeObjet), typeof(string), OperationsAgregation.None, true)); } result = requete.ExecuteRequete(connection.IdSession); if (!result) { return(result); } DataTable table = result.Data as DataTable; Dictionary <int, int?> dicIdToIdObjet = new Dictionary <int, int?>(); string strFieldIdObjetInTable = m_strChampIdObjet.Replace("#SQL#", ""); foreach (DataRow row in table.Rows) { object val = row["IDOBJET"]; int? nValId = val == DBNull.Value?null:(int?)val; if (nValId != null && nValId >= 0) { CDbKey key = null; Type tp = m_typeObjetFixe; if (tp == null)//Type non fixe { string strType = (string)row["TYPEOBJET"]; tp = CActivatorSurChaine.GetType(strType); } if (tp != null) { CObjetDonneeAIdNumerique objPointe = (CObjetDonneeAIdNumerique)Activator.CreateInstance(tp, ctx); if (objPointe.ReadIfExists(nValId.Value)) { key = objPointe.DbKey; } } if (key != null) { string strRequete = "Update " + strNomTableInDb + " set " + m_strChampDbKey + "=" + connection.GetStringForRequete(key.StringValue) + " where " + strFieldIdObjetInTable + "=" + nValId.Value; if (m_typeObjetFixe == null) { strRequete += " and " + m_strChampTypeObjet + "='" + row["TYPEOBJET"].ToString() + "'"; } connection.RunStatement(strRequete); } } } } //Supprime le champ createur.DeleteChamp(strNomTableInDb, strChampIdObjet); } return(result); }
//-------------------------------------------------------------------------------------------------------------------- public override CResultAErreur ExecuterOperation(IDatabaseConnexion connection, IIndicateurProgression indicateur) { CResultAErreur result = CResultAErreur.True; if (!typeof(IObjetDonneeAIdNumerique).IsAssignableFrom(m_type) || !CObjetDonnee.TypeManageIdUniversel(m_type)) { result.EmpileErreur(m_type.ToString() + " can not have Universal Id"); } string strNomTable = CContexteDonnee.GetNomTableForType(m_type); CStructureTable structure = CStructureTable.GetStructure(m_type); string strChampId = structure.ChampsId[0].NomChamp; C2iRequeteAvancee requete = new C2iRequeteAvancee(); requete.FiltreAAppliquer = new CFiltreData(CObjetDonnee.c_champIdUniversel + "=@1", ""); requete.TableInterrogee = CContexteDonnee.GetNomTableForType(m_type); requete.ListeChamps.Add(new C2iChampDeRequete(strChampId, new CSourceDeChampDeRequete(strChampId), typeof(int), OperationsAgregation.None, true)); Console.WriteLine("Update Universal id on " + strNomTable); result = requete.ExecuteRequete(connection.IdSession); if (!result) { return(result); } string strNomTableInDb = CContexteDonnee.GetNomTableInDbForNomTable(strNomTable); DataTable table = result.Data as DataTable; int nNb = 0; bool bWasInTrans = connection.IsInTrans(); if (bWasInTrans) { connection.CommitTrans(); } DateTime dt = DateTime.Now; if (table.Rows.Count > 0) { if (table.Rows.Count > 10000 && connection is COracleDatabaseConnexion) { string strQuery = "Update " + strNomTableInDb + " set " + CObjetDonnee.c_champIdUniversel + "=CONCAT('" + strNomTableInDb + "'," + strChampId + ")"; result = connection.RunStatement(strQuery); } else { foreach (DataRow row in table.Rows) { string strQuery = "Update " + strNomTableInDb + " set " + CObjetDonnee.c_champIdUniversel + "='" + CUniqueIdentifier.GetNew() + "' where " + strChampId + "=" + row[0].ToString(); result = connection.ExecuteScalar(strQuery); if (!result) { break; } nNb++; if (nNb % 100 == 0) { TimeSpan sp = DateTime.Now - dt; double fVal = (double)sp.TotalSeconds / (double)nNb * (double)(table.Rows.Count - nNb); Console.WriteLine(strNomTableInDb + " " + nNb + "/" + table.Rows.Count + " reste " + fVal.ToString("0s")); } } } } if (bWasInTrans) { connection.BeginTrans(); } return(result); /* * * //Trouve tous les éléments du type qui n'ont pas d'id universel * using (CContexteDonnee ctx = new CContexteDonnee(connection.IdSession, true, false)) * { * CListeObjetsDonnees lst = new CListeObjetsDonnees(ctx, m_type, false); * lst.Filtre = new CFiltreData(CObjetDonnee.c_champIdUniversel + "=@1", ""); * lst.Filtre.IgnorerVersionDeContexte = true; * lst.AppliquerFiltreAffichage = false; * * foreach (IObjetDonnee objet in lst.ToArrayList()) * { * objet.Row[CObjetDonnee.c_champIdUniversel] = CUniqueIdentifier.GetNew(); * } * string strNomTable = CContexteDonnee.GetNomTableForType(m_type); * CObjetServeur objetServeur = CContexteDonnee.GetTableLoader(strNomTable, null, connection.IdSession) as CObjetServeur; * int nCount = ctx.Tables[strNomTable].Rows.Count; * DataTable tableSource = ctx.Tables[strNomTable]; * * List<string> lstChampsExclus = new List<string>(); * HashSet<string> lstIDs = new HashSet<string>(); * CStructureTable structure = CStructureTable.GetStructure(m_type); * foreach (CInfoChampTable info in structure.ChampsId) * lstIDs.Add(info.NomChamp); * * foreach (CInfoChampTable champ in structure.Champs) * if (champ.NomChamp != CObjetDonnee.c_champIdUniversel && !lstIDs.Contains(champ.NomChamp)) * lstChampsExclus.Add(champ.NomChamp); * * IDataAdapter adapter = objetServeur.GetDataAdapter(DataRowState.Modified, lstChampsExclus.ToArray()); * * for (int nRow = 0; nRow < nCount; nRow += 5000) * { * * using (DataSet dsCopie = new DataSet()) * { * dsCopie.EnforceConstraints = false; * DataTable tableCopie = ctx.Tables[strNomTable].Clone(); * tableCopie.BeginLoadData(); * dsCopie.Tables.Add(tableCopie); * int nMax = Math.Min(nRow + 5000, nCount); * DateTime dt = DateTime.Now; * for (int n = nRow; n < nMax; n++) * { * tableCopie.ImportRow(tableSource.Rows[n]); * } * TimeSpan sp = DateTime.Now - dt; * Console.WriteLine("Write 1" + strNomTable + " " + nRow + "/" + nCount+" "+sp.TotalSeconds.ToString()); * adapter.Update(dsCopie); * sp = DateTime.Now - dt; * Console.WriteLine("Write 2" + strNomTable + " " + nRow + "/" + nCount + " " + sp.TotalSeconds.ToString()); * } * } * } * return result;*/ }
/// ////////////////////////////////////////// ///<summary> ///Charge les données de la table qui vont devoir être mise à jour ///à partir des données modifiées dans la table source ///</summary> public CResultAErreur ChargeDonneesAMettreAJour(DataSet donneesSources) { CResultAErreur result = CResultAErreur.True; ArrayList lstTables = CContexteDonnee.GetTablesOrderInsert(donneesSources); foreach (DataTable table in lstTables) { DataTable tableDest = null; //S'assure que la table est bien chargée try { tableDest = GetTableSafe(table.TableName); } catch { //La table n'existe pas } if (tableDest != null && m_mappeurTablesToClass.IsSynchronisable(table.TableName) && table.Rows.Count != 0) { IObjetServeur serveur = CContexteDonnee.GetTableLoader(tableDest.TableName, null, IdSession); string strNomTableInDb = CContexteDonnee.GetNomTableInDbForNomTable(tableDest.TableName); if (serveur.CountRecords(strNomTableInDb, new CFiltreData("1=1")) != 0) //Première maj : copie complète { string strColPrim = table.PrimaryKey[0].ColumnName; string strFiltre = ""; foreach (DataRow row in table.Rows) { strFiltre += row[strColPrim].ToString() + ","; } if (strFiltre.Length != 0) { //Supprime la dernière virgule; strFiltre = strFiltre.Substring(0, strFiltre.Length - 1); strFiltre = strColPrim += " in (" + strFiltre + ")"; IObjetServeur loader = GetTableLoader(table.TableName); DataTable tableNew = loader.Read(new CFiltreData(strFiltre)); if (table == null) { result.EmpileErreur(I.T("Error while reading table @1|128", table.TableName)); return(result); } IntegreTable(tableNew, false); } } } } //Charge les éléments à supprimer CContexteDonnee contexteForListe = new CContexteDonnee(IdSession, true, false); DataTable tableSync = donneesSources.Tables[CEntreeLogSynchronisation.c_nomTable]; DataTable tableCopie = CUtilDataSet.AddTableCopie(donneesSources.Tables[CEntreeLogSynchronisation.c_nomTable], contexteForListe); foreach (DataRow row in tableSync.Rows) { tableCopie.ImportRow(row); } CListeObjetsDonnees liste = new CListeObjetsDonnees(contexteForListe, typeof(CEntreeLogSynchronisation)); liste.InterditLectureInDB = true; liste.Filtre = new CFiltreData(CEntreeLogSynchronisation.c_champType + "=@1", (int)CEntreeLogSynchronisation.TypeModifLogSynchro.tDelete); foreach (CEntreeLogSynchronisation entree in liste) { DataTable table = GetTableSafe(entree.TableConcernee); CObjetDonneeAIdNumerique objet = (CObjetDonneeAIdNumerique)GetNewObjetForTable(table); objet.ReadIfExists(entree.IdElement); } return(result); }
///////////////////////////////////////////////////////////////////////////////////// public override void CreateJoinPourLiens( CFiltreData filtre, CArbreTable arbreTables, CComposantFiltre composantFiltre, ref bool bDistinct, ref string strJoin, ref string strWhere, ref string strPrefixeFrom) { strJoin = ""; arbreTables.SortTablesLiees(); foreach (CArbreTableFille arbreFils in arbreTables.TablesLiees) { strPrefixeFrom += "("; if (arbreFils.IsLeftOuter) { strJoin += " LEFT OUTER JOIN "; } else { strJoin += " INNER JOIN "; } if (arbreFils.Relation.IsRelationFille) { bDistinct = true; } string strTable; strTable = CContexteDonnee.GetNomTableInDbForNomTable(arbreFils.NomTable) + GetSqlForAliasDecl(arbreFils.Alias); string strSuiteFrom = ""; string strSuiteWhere = ""; string strPrefixe = ""; CreateJoinPourLiens(filtre, arbreFils, composantFiltre, ref bDistinct, ref strSuiteFrom, ref strSuiteWhere, ref strPrefixe); strJoin += strPrefixe; if (strSuiteFrom.Trim() != "") { strTable = "(" + strTable; } strTable += strSuiteFrom; if (strSuiteFrom.Trim() != "") { strTable += ")"; } strJoin += strTable; strJoin += " ON ("; CInfoRelationComposantFiltre relation = arbreFils.Relation; string strAliasParent, strAliasFille; string strTableDependante = ""; if (relation.IsRelationFille) { strAliasParent = arbreTables.Alias; strAliasFille = arbreFils.Alias; strTableDependante = arbreFils.NomTable; } else { strAliasParent = arbreFils.Alias; strAliasFille = arbreTables.Alias; strTableDependante = arbreTables.NomTable; } string strJointure = relation.GetJoinClause(strAliasParent, "", strAliasFille, ""); string strComplementVersion = ""; if (EstCeQueLaTableGereLesVersions(strTableDependante) && !filtre.IntegrerLesElementsSupprimes) { strComplementVersion = "(" + strAliasFille + "." + CSc2iDataConst.c_champIsDeleted + "=0 or " + strAliasFille + "." + CSc2iDataConst.c_champIsDeleted + " is null)"; } string strIdsVersionsALire = filtre.GetStringListeIdsVersionsALire(','); if (EstCeQueLaTableGereLesVersions(strTableDependante)) { if (strComplementVersion != "") { strComplementVersion += " and "; } if (strIdsVersionsALire == null) { strComplementVersion += strAliasFille + "." + CSc2iDataConst.c_champIdVersion + " is null"; } else { strComplementVersion += "(" + strAliasFille + "." + CSc2iDataConst.c_champIdVersion + " in (" + strIdsVersionsALire + ") or " + strAliasFille + "." + CSc2iDataConst.c_champIdVersion + " is null)"; } } if (strComplementVersion != "") { if (strWhere != "") { strWhere += " and (" + strComplementVersion + ") and ("; } else { strWhere += "("; } strWhere += strComplementVersion + ")"; } strJoin += strJointure + "))"; if (composantFiltre != null) { composantFiltre.DefinitAlias(arbreFils.CheminRelations, arbreFils.Alias); } if (filtre is CFiltreDataAvance) { foreach (CComposantFiltreChamp champ in ((CFiltreDataAvance)filtre).ChampsAAjouterAArbreTable) { champ.DefinitAlias(arbreFils.CheminRelations, arbreFils.Alias); } } } }
protected override string GetNewNomClefEtrangere(CInfoRelation rel) { string strNomTable = CContexteDonnee.GetNomTableInDbForNomTable(rel.TableFille); return(GetNewNom(EntiteTable.ClefEtrangere, strNomTable)); }
//------------------------------------------------------------------------------------------------ public static CResultAErreur CreateTable(CStructureTable structure, IDatabaseConnexion connexion) { CResultAErreur result = CResultAErreur.True; //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #region Creation de la table string strRequeteCreation = ""; strRequeteCreation += "CREATE TABLE " + structure.NomTableInDb + " ("; if (structure.HasChampIdAuto) { strRequeteCreation += structure.ChampsId[0].NomChamp + " "; strRequeteCreation += (new CSQLServeurTypeMappeur()).GetStringDBTypeFromType(structure.ChampsId[0].TypeDonnee) + " "; strRequeteCreation += "NOT NULL IDENTITY (1, 1)"; strRequeteCreation += ","; } ArrayList lstIndex = new ArrayList(); foreach (CInfoChampTable info in structure.Champs) { if (!info.IsId || !structure.HasChampIdAuto) { strRequeteCreation += info.NomChamp + " "; string strType = (new CSQLServeurTypeMappeur()).GetStringDBTypeFromType(info.TypeDonnee); if (info.TypeDonnee == typeof(string)) { if (info.IsLongString) { strType = "NText"; } else { strType += "(" + ((info.Longueur > 0) ? info.Longueur.ToString() : "1024") + ")"; } } strRequeteCreation += strType; strRequeteCreation += " "; if (!info.NullAuthorized) { strRequeteCreation += "NOT NULL"; } strRequeteCreation += ","; if (info.IsIndex) { lstIndex.Add(info.NomChamp); } } } strRequeteCreation = strRequeteCreation.Substring(0, strRequeteCreation.Length - 1); strRequeteCreation += ")"; result = connexion.RunStatement(strRequeteCreation); if (!result) { result.EmpileErreur(I.T("Error while creating table @1|125", structure.NomTableInDb)); return(result); } #endregion #region création des indexs foreach (string strChamp in lstIndex) { string strRequeteIndex = GetRequeteIndex(structure.NomTableInDb, strChamp); result = connexion.RunStatement(strRequeteIndex); } #endregion //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #region Creation de la contrainte de clé primaire string strRequetePrimaryKey = ""; strRequetePrimaryKey += "ALTER TABLE " + structure.NomTableInDb + " "; strRequetePrimaryKey += "ADD CONSTRAINT PK_" + structure.NomTableInDb + " "; strRequetePrimaryKey += "PRIMARY KEY ("; foreach (CInfoChampTable info in structure.ChampsId) { strRequetePrimaryKey += info.NomChamp + ","; } strRequetePrimaryKey = strRequetePrimaryKey.Substring(0, strRequetePrimaryKey.Length - 1); strRequetePrimaryKey += ")"; result = connexion.RunStatement(strRequetePrimaryKey); if (!result) { result.EmpileErreur(I.T("Error while creating primary key of table @1|126", structure.NomTableInDb)); return(result); } #endregion //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #region Creation des contrainte de clés étrangères foreach (CInfoRelation rel in structure.RelationsParentes) { string strRequeteRelation = GetRequeteRelation(rel); result = connexion.RunStatement(strRequeteRelation); if (!result) { result.EmpileErreur(I.T("Error while creating foreign key of @1 (@2)|127", structure.NomTableInDb, strRequeteRelation)); return(result); } if (result && rel.Indexed) { string strNomTableFilleInDb = CContexteDonnee.GetNomTableInDbForNomTable(rel.TableFille); string strRequeteIndex = GetRequeteIndex(strNomTableFilleInDb, rel.ChampsFille); result = connexion.RunStatement(strRequeteIndex); if (!result) { result.EmpileErreur(I.T("Error while creating index in table @1|128", structure.NomTableInDb)); return(result); } } } #endregion //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ return(result); }
//------------------------------------------------------------------------------------------------ public static CResultAErreur UpdateTable(CStructureTable structure, IDatabaseConnexion connexion, ArrayList strChampsAutorisesANull) { ArrayList champsCrees = new ArrayList(); CResultAErreur result = CResultAErreur.True; IDataAdapter adapter = connexion.GetSimpleReadAdapter("SELECT * FROM " + structure.NomTableInDb); DataSet ds = new DataSet(); adapter.FillSchema(ds, SchemaType.Mapped); DataTable dt = ds.Tables["TABLE"]; //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #region M.A.J des champs de la table foreach (CInfoChampTable info in structure.Champs) { bool bExists = true; bool bModifiedType = false; bool bModifiedNotNull = false; bool bModifiedLength = false; foreach (DataColumn colonne in dt.Columns) { if (info.NomChamp == colonne.ColumnName) { if (info.IsLongString) { if (colonne.MaxLength < 10000) { bModifiedLength = true; } } else if (colonne.MaxLength != info.Longueur && info.TypeDonnee == typeof(string)) { bModifiedLength = true; } if (colonne.DataType != info.TypeDonnee) { if (info.TypeDonnee != typeof(CDonneeBinaireInRow) && colonne.DataType != typeof(byte[])) { bModifiedType = true; } } if (colonne.AllowDBNull != info.NullAuthorized) { bModifiedNotNull = true; } bExists = true; break; } bExists = false; } if (!bExists) { string strRequeteUpdate = "ALTER TABLE " + structure.NomTableInDb + " ADD " + info.NomChamp + " "; string strType = (new CSQLServeurTypeMappeur()).GetStringDBTypeFromType(info.TypeDonnee); if (info.TypeDonnee == typeof(string)) { if (!info.IsLongString) { strType += "(" + info.Longueur.ToString() + ") "; } else { strType = "NText"; } } strRequeteUpdate += strType; if (!info.NullAuthorized && !strChampsAutorisesANull.Contains(info.NomChamp)) { strRequeteUpdate += " NOT NULL DEFAULT ''"; } result = connexion.RunStatement(strRequeteUpdate); if (!result) { result.EmpileErreur(I.T("Error while fields updating of table @1|131", structure.NomTableInDb)); return(result); } champsCrees.Add(info.NomChamp); } else if (bModifiedType || bModifiedNotNull || bModifiedLength) { if (info.IsIndex) { SupprimeIndex(structure.NomTableInDb, connexion, info.NomChamp); } string strRequeteUpdate = "ALTER TABLE " + structure.NomTableInDb + " ALTER COLUMN " + info.NomChamp + " "; string strType = (new CSQLServeurTypeMappeur()).GetStringDBTypeFromType(info.TypeDonnee); if (info.TypeDonnee == typeof(string)) { if (!info.IsLongString) { strType += "(" + info.Longueur.ToString() + ") "; } else { strType = "NText"; } } strRequeteUpdate += strType; if (!info.NullAuthorized && !strChampsAutorisesANull.Contains(info.NomChamp)) { strRequeteUpdate += " NOT NULL "; } result = connexion.RunStatement(strRequeteUpdate); if (!result) { result.EmpileErreur(I.T("Error while fields updating of table @1|131", structure.NomTableInDb)); return(result); } } if (info.IsIndex) { result = CreateOrUpdateIndex(structure.NomTableInDb, connexion, info.NomChamp); } else { result = SupprimeIndex(structure.NomTableInDb, connexion, info.NomChamp); } } // Suppression d'une colonne de la table foreach (DataColumn colonne in dt.Columns) { bool bExists = false; foreach (CInfoChampTable info in structure.Champs) { if (info.NomChamp == colonne.ColumnName) { bExists = true; break; } } if (!bExists) { CResultAErreur tempResult = CAccessTableCreatorOld.SupprimeDependances(structure.NomTableInDb, colonne.ColumnName, connexion); if (!tempResult) { result.Erreur.EmpileErreurs(tempResult.Erreur); result.SetFalse(); return(result); } tempResult = CAccessTableCreatorOld.SupprimeForeignKeys(structure.NomTableInDb, colonne.ColumnName, connexion); if (!tempResult) { result.Erreur.EmpileErreurs(tempResult.Erreur); result.SetFalse(); return(result); } string strReq = "ALTER TABLE " + structure.NomTableInDb + " DROP COLUMN " + colonne.ColumnName; result = connexion.RunStatement(strReq); if (!result) { result.EmpileErreur(I.T("Error while deleting column @1 of table @2|132", colonne.ColumnName, structure.NomTableInDb)); return(result); } } } #endregion //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #region M.A.J des contraintes de la table foreach (CInfoRelation rel in structure.RelationsParentes) { foreach (string strChampCree in champsCrees) { foreach (string strChamp in rel.ChampsFille) { if (strChampCree == strChamp) { string strRequeteRelation = GetRequeteRelation(rel); result = connexion.RunStatement(strRequeteRelation); if (!result) { result.EmpileErreur(I.T("Error while creating foreign key of @1 (@2)|127", structure.NomTableInDb, strRequeteRelation)); return(result); } break; } } } if (result) { string strNomTableFilleInDb = CContexteDonnee.GetNomTableInDbForNomTable(rel.TableFille); if (rel.Indexed) { result = CreateOrUpdateIndex(strNomTableFilleInDb, connexion, rel.ChampsFille); } else { result = SupprimeIndex(strNomTableFilleInDb, connexion, rel.ChampsFille); } } if (!result) { return(result); } } #endregion //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ return(result); }
private List <CInfoRelation> GetRelationsInnexistantes(List <CInfoRelation> relationsDeBase, List <CInfoRelation> relations) { List <CInfoRelation> relationsInnexistantes = new List <CInfoRelation>(); foreach (CInfoRelation relVoulu in relations) { bool bRelExistante = false; foreach (CInfoRelation relActuelle in relationsDeBase) { string strNomTable1 = relActuelle.TableParente; string strNomTable2 = relVoulu.TableParente; if (strNomTable1 == null)//La table n'existe plus { continue; } if (strNomTable2 == null)//La table n'existe plus { continue; } //La relation voulu et la relation actuelle concernent les mêmes tables if (strNomTable1 != strNomTable2) { strNomTable1 = CContexteDonnee.GetNomTableInDbForNomTable(strNomTable1); strNomTable2 = CContexteDonnee.GetNomTableInDbForNomTable(strNomTable2); } if (strNomTable1 == strNomTable2) { #region Verification que les champs fils sont identiques bool bChampsFilsIdentiques = false; foreach (string champFilsVoulu in relVoulu.ChampsFille) { foreach (string champFilsActuel in relActuelle.ChampsFille) { if (champFilsActuel == champFilsVoulu) { bChampsFilsIdentiques = true; break; } } if (!bChampsFilsIdentiques) { break; } } if (!bChampsFilsIdentiques) { continue; } #endregion #region Verification que les champs peres sont identiques bool bChampsParentsIdentiques = false; foreach (string champPereVoulu in relVoulu.ChampsParent) { foreach (string champPereActuel in relActuelle.ChampsParent) { if (champPereActuel == champPereVoulu) { bChampsParentsIdentiques = true; break; } } if (!bChampsParentsIdentiques) { break; } } bRelExistante = bChampsParentsIdentiques; #endregion } if (bRelExistante) { break; } } if (!bRelExistante) { relationsInnexistantes.Add(relVoulu); } } return(relationsInnexistantes); }
protected virtual CResultAErreur UpdateTable(CStructureTable structure, ArrayList strChampsAutorisesANull) { CResultAErreur result = CResultAErreur.True; ArrayList champsCrees = new ArrayList(); DataTable dt = GetDataTableForUpdateTable(structure); //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #region M.A.J des champs de la table string strNomTable = structure.NomTableInDb; foreach (CInfoChampTable champ in structure.Champs) { bool bExists = false; bool bModifiedType = false; bool bModifiedNotNull = false; bool bModifiedLength = false; bool bModifiedIndex = false; if (strChampsAutorisesANull.Contains(champ.NomChamp)) { champ.NullAuthorized = true; } // 1 - Verification d'existance de la colonne et des modifs à faire si elle existe foreach (DataColumn colonne in dt.Columns) { if (champ.NomChamp == colonne.ColumnName) { bModifiedType = Champ_ModifiedType(champ, colonne); bModifiedLength = Champ_ModifiedLength(champ, colonne); bModifiedNotNull = Champ_ModifiedNotNull(champ, colonne, strChampsAutorisesANull); bModifiedIndex = Champ_ModifiedIndex(strNomTable, champ); bExists = true; break; } } // 2 - Creation d'une colonne inexistante if (!bExists) { result = CreateChamp(structure.NomTableInDb, champ); if (result) { champsCrees.Add(champ.NomChamp); } } // 3 - Modification d'une colonne else if (bModifiedType || bModifiedNotNull || bModifiedLength) { result = UpdateChamp(strNomTable, champ, bModifiedNotNull, bModifiedLength, bModifiedType); } if (!result) { return(result); } if (bModifiedIndex) { if (champ.IsIndex) { result = CreateIndex(strNomTable, false, champ.NomChamp); } else { result = DeleteIndex(strNomTable, champ.NomChamp); } if (!result) { return(result); } } } // Suppression d'une colonne de la table foreach (DataColumn colonne in dt.Columns) { bool bExists = false; foreach (CInfoChampTable info in structure.Champs) { if (info.NomChamp == colonne.ColumnName) { bExists = true; break; } } if (!bExists) { //SC le 17082009 : Plus de suppression automatique de colonne //Par UpdateTable. Pour supprimer une colonne, il faut utiliser une opération //de suppression de colonne C2iEventLog.WriteInfo("Field " + colonne.ColumnName + " in table " + structure.NomTableInDb + " should be deleted"); //result = DeleteChamp(structure.NomTableInDb, colonne.ColumnName); if (!result) { return(result); } } } #endregion //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #region M.A.J des contraintes de la table List <CInfoRelation> relationsActuelles = new List <CInfoRelation>(); result = GetRelationsExistantes(strNomTable, ref relationsActuelles); if (!result) { return(result); } List <CInfoRelation> relationsVoulues = new List <CInfoRelation>(); foreach (CInfoRelation r in structure.RelationsParentes) { if (r.IsInDb) { relationsVoulues.Add(r); } } List <CInfoRelation> nouvellesRelations = GetRelationsInnexistantes(relationsActuelles, relationsVoulues); List <CInfoRelation> relationsObseletes = GetRelationsInnexistantes(relationsVoulues, relationsActuelles); foreach (CInfoRelation rel in nouvellesRelations) { foreach (string strChampFils in rel.ChampsFille) { if (strChampsAutorisesANull.Contains(strChampFils)) { rel.Obligatoire = false; } } string strRequeteRelation = GetRequeteCreateCleEtrangere(rel); result = Connection.RunStatement(strRequeteRelation); if (result) { AfterChangeContraintes(CContexteDonnee.GetNomTableInDbForNomTable(rel.TableFille)); } string strNomTableFilleInDb = CContexteDonnee.GetNomTableInDbForNomTable(rel.TableFille); if (result && rel.Indexed) { result = CreateIndex(strNomTableFilleInDb, rel.IsClustered, rel.ChampsFille); if (result) { AfterChangeIndexs(CContexteDonnee.GetNomTableInDbForNomTable(rel.TableFille)); } } if (!result) { result.EmpileErreur(I.T("Error while creating foreign key of @1 table (@2)|127", structure.NomTableInDb, strRequeteRelation)); return(result); } } foreach (CInfoRelation rel in relationsObseletes) { string strNomTableFilleInDb = CContexteDonnee.GetNomTableInDbForNomTable(rel.TableFille); result = DeleteIndex(strNomTableFilleInDb, rel.ChampsFille); string strRequeteRelation = GetRequeteDeleteClefEtrangere(rel); result = Connection.RunStatement(strRequeteRelation); if (result) { AfterChangeContraintes(strNomTableFilleInDb); } if (!result) { result.EmpileErreur(I.T("Error while deleting foreign key of @1 table (@2)|212", structure.NomTableInDb, strRequeteRelation)); return(result); } } //Vérification des indexs des relations foreach (CInfoRelation rel in relationsVoulues) { if (!nouvellesRelations.Contains(rel)) { string strNomTableFilleInDb = CContexteDonnee.GetNomTableInDbForNomTable(rel.TableFille); if (rel.Indexed) { result = CreateIndex(strNomTableFilleInDb, rel.IsClustered, rel.ChampsFille); } else if (ShouldDeleteIndexRelation(strNomTableFilleInDb, rel)) { result = DeleteIndex(strNomTableFilleInDb, rel.ChampsFille); } if (!result) { return(result); } } } //Gestion des attributs Index sur la classe foreach (CInfoIndexTable info in structure.IndexSupplementaires) { result = CreateIndex(strNomTable, info.IsCluster, info.Champs); if (!result) { return(result); } } #endregion //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ return(result); }
virtual public CResultAErreur CreationOuUpdateTableFromType(Type tp, ArrayList strChampsAutorisesANull) { CResultAErreur result = CResultAErreur.True; CStructureTable structure = CStructureTable.GetStructure(tp); object objServeur = null; try { objServeur = CContexteDonnee.GetTableLoader(structure.NomTable, null, Connection.IdSession); } catch { } if (objServeur == null) { return(result); } //Vérifie que le type est bien lié à cette connexion IDatabaseConnexion connexion = CSc2iDataServer.GetInstance().GetDatabaseConnexion( Connection.IdSession, objServeur.GetType()); if (connexion == null || connexion.ConnexionString != Connection.ConnexionString) { return(result); } if (!result) { return(result); } //S'assure que toutes les tables parentes existent foreach (CInfoRelation relation in structure.RelationsParentes) { if (relation.TableParente != structure.NomTable && relation.IsInDb) { string strNomTableParenteInDb = CContexteDonnee.GetNomTableInDbForNomTable(relation.TableParente); if (!TableExists(strNomTableParenteInDb)) { result = CreationOuUpdateTableFromType(CContexteDonnee.GetTypeForTable(relation.TableParente)); if (!result) { return(result); } } } } if (TableExists(structure.NomTableInDb)) { result = UpdateTable(structure, strChampsAutorisesANull); } else { result = CreateTable(structure); } return(result); }
//------------------------------------------------------------ public CResultAErreur PurgeEntites( Type typeObjets, int[] nIdsElementsTotal, CDonneeNotificationModificationContexteDonnee dataModifs) { CResultAErreur result = TestTypePurgeable(typeObjets); if (!result) { return(result); } //travaille par paquets de 100; for (int nPaquet = 0; nPaquet < nIdsElementsTotal.Length; nPaquet += 100) { List <int> lstTmp = new List <int>(); int nMin = Math.Min(nPaquet + 100, nIdsElementsTotal.Length); for (int n = nPaquet; n < nMin; n++) { lstTmp.Add(nIdsElementsTotal[n]); } int[] nIdsElements = lstTmp.ToArray(); if (nIdsElements.Count() == 0) { return(result); } string strNomTable = CContexteDonnee.GetNomTableForType(typeObjets); if (strNomTable == null) { result.EmpileErreur(I.T("Can not find table for type '@1'|20011"), DynamicClassAttribute.GetNomConvivial(typeObjets)); return(result); } CStructureTable structure = CStructureTable.GetStructure(typeObjets); StringBuilder blIds = new StringBuilder(); foreach (int nId in nIdsElements) { blIds.Append(nId); blIds.Append(','); } if (blIds.Length == 0) { return(result); } blIds.Remove(blIds.Length - 1, 1); //Si autoref, va tout chercher d'un coup if (typeof(IObjetDonneeAutoReference).IsAssignableFrom(typeObjets)) { HashSet <int> setIds = new HashSet <int>(); foreach (int nId in nIdsElements) { setIds.Add(nId); } //Va cherche toutes les dépendances int nNbLast = setIds.Count(); while (true) { foreach (CInfoRelation rel in CContexteDonnee.GetListeRelationsTable(strNomTable)) { if (rel.TableFille == rel.TableParente) { int[] idsFilles = null; CFiltreData filtre = new CFiltreData(rel.ChampsFille[0] + " in (" + blIds.ToString() + ")"); result = GetIdsFilles( typeObjets, filtre, out idsFilles); if (!result) { return(result); } foreach (int nId in idsFilles) { setIds.Add(nId); } } } nIdsElements = setIds.ToArray(); if (nNbLast == setIds.Count) { break; } blIds = new StringBuilder(); foreach (int nId in setIds) { blIds.Append(nId); blIds.Append(','); } blIds.Remove(blIds.Length - 1, 1); nNbLast = setIds.Count; } } //Suppression des relations filles foreach (CInfoRelation info in CContexteDonnee.GetListeRelationsTable(strNomTable)) { if (info.TableParente == strNomTable && info.TableFille != strNomTable) { Type typeFils = CContexteDonnee.GetTypeForTable(info.TableFille); int[] lstIdsFils = null; CFiltreData filtre = new CFiltreData( info.ChampsFille[0] + " in (" + blIds.ToString() + ")"); result = GetIdsFilles(typeFils, filtre, out lstIdsFils); if (!result) { return(result); } if (lstIdsFils.Count() > 0) { result = PurgeEntites(typeFils, lstIdsFils, dataModifs); } if (!result) { return(result); } } } //Suppression des relations TypeId if (typeObjets.GetCustomAttributes(typeof(NoRelationTypeIdAttribute), true).Length == 0) { foreach (RelationTypeIdAttribute rel in CContexteDonnee.RelationsTypeIds) { if (rel.IsAppliqueToType(typeObjets)) { Type typeFils = CContexteDonnee.GetTypeForTable(rel.TableFille); result = TestTypePurgeable(typeFils); if (!result) { return(result); } CFiltreData filtre = new CFiltreData( rel.ChampId + " in (" + blIds + ") and " + rel.ChampType + "=@1", typeObjets.ToString()); int[] lstIdsFils = null; result = GetIdsFilles( typeFils, filtre, out lstIdsFils); if (!result) { return(result); } if (lstIdsFils.Count() > 0) { result = PurgeEntites(typeFils, lstIdsFils, dataModifs); } if (!result) { return(result); } } } } //Suppression des valeurs de champs if (m_listeTypesValeursChamps == null) { m_listeTypesValeursChamps = new List <Type>(); foreach (Type tp in CContexteDonnee.GetAllTypes()) { if (typeof(CRelationElementAChamp_ChampCustom).IsAssignableFrom(tp)) { m_listeTypesValeursChamps.Add(tp); } } } foreach (Type tp in m_listeTypesValeursChamps) { CFiltreData filtre = new CFiltreData( CRelationElementAChamp_ChampCustom.c_champValeurInt + " in (" + blIds.ToString() + ") and " + CRelationElementAChamp_ChampCustom.c_champValeurString + "=@1", typeObjets.ToString()); int[] idsFils = null; result = GetIdsFilles(tp, filtre, out idsFils); if (!result) { return(result); } if (idsFils.Length > 0) { result = PurgeEntites(tp, idsFils, dataModifs); } if (!result) { return(result); } } //Prépare les notifications foreach (int nId in nIdsElements) { dataModifs.AddModifiedRecord(strNomTable, true, new object[] { nId }); } //supprime les éléments //Et c'est parti pour la requete de suppression IDatabaseConnexion con; con = CSc2iDataServer.GetInstance().GetDatabaseConnexion(IdSession, typeObjets); string strWhere = structure.ChampsId[0].NomChamp + " in (" + blIds + ")"; strWhere = COracleDatabaseConnexion.PasseLaLimiteDesMilleIn(strWhere); string strNomTableInDb = CContexteDonnee.GetNomTableInDbForNomTable(strNomTable); result = con.ExecuteScalar("delete from " + strNomTableInDb + " where " + strWhere); if (!result) { return(result); } } return(result); }
//////////////////////////////////////////////////////// protected string GetStringExpression( IExpression expression, CFiltreData filtre, Dictionary <string, object> valeursParametres) { string strRetour = ""; if (expression is CComposantFiltreChamp) { CComposantFiltreChamp champ = (CComposantFiltreChamp)expression; if (champ.Alias != "") { strRetour += champ.Alias + "."; } strRetour += champ.NomChamp; /*if ( champ.Relations.Length > 0 ) * { * if (champ.Relations[champ.Relations.Length-1].IsRelationFille) * strRetour = champ.Relations[champ.Relations.Length-1].TableFille+"."; * else * strRetour = champ.Relations[champ.Relations.Length-1].TableParente+"."; * } * strRetour += champ.NomChamp;*/ } else if (expression is CComposantFiltreVariable) { strRetour = ((CComposantFiltreVariable)expression).GetString(); } else if (expression is CComposantFiltreConstante) { CComposantFiltreConstante constante = (CComposantFiltreConstante)expression; strRetour = CConvertisseurObjetToSqlServeur.ConvertToSql(constante.Valeur); } else if (expression is CComposantFiltreHasNo) { strRetour += GetStringExpression((IExpression)expression.Parametres[0], filtre, valeursParametres); strRetour += " is null"; } else if (expression is CComposantFiltreHas) { strRetour += GetStringExpression((IExpression)expression.Parametres[0], filtre, valeursParametres); strRetour += " is not null"; } else if (expression is CComposantFiltreListe) { CComposantFiltreListe liste = (CComposantFiltreListe)expression; strRetour = ""; foreach (IExpression expInListe in liste.Liste) { strRetour += GetStringExpression(expInListe, filtre, valeursParametres) + ","; } if (strRetour.Length > 0) { strRetour = strRetour.Substring(0, strRetour.Length - 1); } strRetour = "(" + strRetour + ")"; } else if (expression is CComposantFiltreSousFiltre && m_connexion != null) { CComposantFiltreSousFiltre compo = (CComposantFiltreSousFiltre)expression; CResultAErreur result = compo.InterpreteParametres(); if (result) { string strWhere = ""; string strJoin = ""; string strPrefixFrom = ""; bool bDistinct = false; compo.Filtre.Parametres.Clear(); compo.Filtre.AddChampAAjouterAArbreTable(compo.ChampSousFiltre); foreach (object parametre in filtre.Parametres) { compo.Filtre.Parametres.Add(parametre); } CComposantFiltreOperateur compoEt = new CComposantFiltreOperateur(CComposantFiltreOperateur.c_IdOperateurEt); compoEt.Parametres.Add(compo.Filtre.ComposantPrincipal); CComposantFiltreHas compoNotNull = new CComposantFiltreHas(); compoNotNull.Parametres.Add(compo.ChampSousFiltre); compoEt.Parametres.Add(compoNotNull); compo.Filtre.ComposantPrincipal = compoEt; IEnumerable <C2iDbDatabaseConnexion.CParametreRequeteDatabase> parametres = null; result = m_connexion.PrepareRequeteFromFiltre( compo.Filtre, ref strWhere, ref strJoin, ref bDistinct, ref strPrefixFrom, ref parametres); if (result) { strRetour += " "; if (compo.ChampTeste.Alias != "") { strRetour += compo.ChampTeste.Alias + "."; } strRetour += compo.ChampTeste.NomChamp; if (compo is CComposantFiltreInSousFiltre) { strRetour += " in ("; } else { strRetour += " not in ("; } string strSelect = "select "; if (compo.ChampSousFiltre.Alias != "") { strSelect += compo.ChampSousFiltre.Alias + "."; } strSelect += compo.ChampSousFiltre.NomChamp; strSelect += " from " + CContexteDonnee.GetNomTableInDbForNomTable(compo.TableSousFiltre); strRetour += m_connexion.GetSql(strSelect, strPrefixFrom, strJoin, strWhere); strRetour += ")"; } } } else if (expression is CComposantFiltreOperateur) { COperateurAnalysable operateur = ((CComposantFiltreOperateur)expression).Operateur; string strTexteOperateur = operateur.Texte; //Remplacement du not par not espace operateur bool bToUpper = false; if (operateur.Texte.Length > 3 && operateur.Texte.Substring(0, 3).ToUpper() == "NOT") { strTexteOperateur = operateur.Texte.Substring(0, 3) + " " + operateur.Texte.Substring(3); } if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurContains) { strTexteOperateur = "like"; } if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurWithout) { strTexteOperateur = "not like"; } if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurLike || operateur.Id == CComposantFiltreOperateur.c_IdOperateurNotLike || operateur.Id == CComposantFiltreOperateur.c_IdOperateurContains || operateur.Id == CComposantFiltreOperateur.c_IdOperateurWithout) { bToUpper = true; } if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurEtBinaire) { string str1, str2; str1 = GetStringExpression((IExpression)expression.Parametres[0], filtre, valeursParametres); str2 = GetStringExpression((IExpression)expression.Parametres[1], filtre, valeursParametres); strRetour = "BitAnd(" + str1 + "," + str2 + ")"; } else if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurOuBinaire) { string str1, str2; str1 = GetStringExpression((IExpression)expression.Parametres[0], filtre, valeursParametres); str2 = GetStringExpression((IExpression)expression.Parametres[1], filtre, valeursParametres); strRetour = "BitOr(" + str1 + "," + str2 + ")"; } else if (operateur.Niveau > 0 && operateur.Niveau != 4) { string str1, str2, str3; str1 = GetStringExpression((IExpression)expression.Parametres[0], filtre, valeursParametres); if (bToUpper) { str1 = "Upper(" + str1 + ")"; } str2 = strTexteOperateur; str3 = GetStringExpression((IExpression)expression.Parametres[1], filtre, valeursParametres); object val = null; if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurEgal && valeursParametres != null && valeursParametres.TryGetValue(str3, out val) && val == c_null) { //Obligé d'ajouter une référence au nom de la variable, sinon, oracle fait la gueule //d'où or str3 is null qui ne sert à rien strRetour = "(" + str1 + " is null or " + str3 + " is null)"; } else if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurDifferent && valeursParametres != null && valeursParametres.TryGetValue(str3, out val) && val == c_null) { //Obligé d'ajouter une référence au nom de la variable, sinon, oracle fait la gueule //d'où or str3 is null qui ne sert à rien strRetour = "(" + str1 + " is not null or " + str3 + " is null)"; } else { if (operateur.Id == CComposantFiltreOperateur.c_IdOperateurContains || operateur.Id == CComposantFiltreOperateur.c_IdOperateurWithout) { str3 = "Concat('%',concat(" + str3 + ",'%'))"; } if (bToUpper) { str3 = "Upper(" + str3 + ")"; } if (operateur.Niveau >= 4) { str1 = "(" + str1 + ")"; str3 = "(" + str3 + ")"; } strRetour = str1 + " " + str2 + " " + str3; } } else { strRetour = strTexteOperateur + "("; foreach (IExpression exp in expression.Parametres) { strRetour += GetStringExpression(exp, filtre, valeursParametres) + ","; } if (expression.Parametres.Count > 0) { strRetour = strRetour.Substring(0, strRetour.Length - 1); } strRetour += ")"; } } return(strRetour); }
/// ///////////////////////////////////////////////////// public override void CreateJoinPourLiens( CFiltreData filtre, CArbreTable arbreTables, CComposantFiltre composantFiltre, ref bool bDistinct, ref string strFrom, ref string strWhere) { strFrom = ""; strWhere = ""; foreach (CArbreTableFille arbreFils in arbreTables.TablesLiees) { if (arbreFils.Relation.IsRelationFille) { bDistinct = true; } string strNomTableFils = CContexteDonnee.GetNomTableInDbForNomTable(arbreFils.NomTable); strNomTableFils = GetPrefixeForTable(arbreFils.NomTable) + strNomTableFils; strFrom += "," + strNomTableFils + GetSqlForAliasDecl(arbreFils.Alias); string strSuiteFrom = ""; string strSuiteWhere = ""; CreateJoinPourLiens(filtre, arbreFils, composantFiltre, ref bDistinct, ref strSuiteFrom, ref strSuiteWhere); if (strSuiteFrom != "") { strFrom += strSuiteFrom; } if (strWhere.Trim() != "" && strSuiteWhere.Trim() != "") { strWhere += " and (" + strSuiteWhere + ")"; } if (strWhere.Trim() == "" && strSuiteWhere.Trim() != "") { strWhere = strSuiteWhere; } //Equivalence WHERE ( MACOL = MACOL (+)) CInfoRelationComposantFiltre relation = arbreFils.Relation; string strAliasParent, strAliasFille; string strSuffixeParent = ""; string strSuffixeFils = ""; string strTableDependante = ""; if (relation.IsRelationFille) { strAliasParent = arbreTables.Alias; strAliasFille = arbreFils.Alias; strTableDependante = arbreFils.NomTable; if (arbreFils.IsLeftOuter) { strSuffixeFils = "(+)"; } } else { strAliasParent = arbreFils.Alias; strAliasFille = arbreTables.Alias; strTableDependante = arbreTables.Alias; if (arbreFils.IsLeftOuter) { strSuffixeParent = "(+)"; } } string strTmp = relation.GetJoinClause(strAliasParent, strSuffixeParent, strAliasFille, strSuffixeFils); string strComplementVersion = ""; if (EstCeQueLaTableGereLesVersions(strTableDependante) && !filtre.IntegrerLesElementsSupprimes) { strComplementVersion = "(" + strAliasFille + "." + CSc2iDataConst.c_champIsDeleted + "=0 or " + strAliasFille + "." + CSc2iDataConst.c_champIsDeleted + " is null)"; } string strIdsVersionsALire = filtre.GetStringListeIdsVersionsALire(','); if (EstCeQueLaTableGereLesVersions(strTableDependante)) { if (strComplementVersion != "") { strComplementVersion += " and "; } if (strIdsVersionsALire == null) { strComplementVersion += strAliasFille + "." + CSc2iDataConst.c_champIdVersion + " is null"; } else { strComplementVersion += "(" + strAliasFille + "." + CSc2iDataConst.c_champIdVersion + " in (" + strIdsVersionsALire + ") or " + strAliasFille + "." + CSc2iDataConst.c_champIdVersion + " is null)"; } } if (strComplementVersion != "") { if (strTmp != "") { strTmp = "((" + strTmp + ") and "; } else { strAliasFille += "("; } strTmp += strComplementVersion + ")"; } if (strWhere.Trim() != "") { strWhere = "(" + strTmp + ") and (" + strWhere + ")"; } else { strWhere = strTmp; } if (composantFiltre != null) { composantFiltre.DefinitAlias(arbreFils.CheminRelations, arbreFils.Alias); } } }