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);
}
}
}