////////////////////////////////////////////////////////////////////////
public IDatabaseConnexion GetConnexion(string strIdConnexion)
{
if (strIdConnexion == "")
{
strIdConnexion = m_strIdConnexionParDefaut;
}
IDatabaseConnexion connexion = (IDatabaseConnexion)m_connexions[strIdConnexion];
if (connexion == null)
{
if (!CGestionnaireSessions.IsSessionOpenStatic(IdSession))
{
throw new Exception(I.T("The session has been closed|198"));
}
CDefinitionConnexionDataSource def = (CDefinitionConnexionDataSource)m_tableDefinitionsConnexions[strIdConnexion];
connexion = (IDatabaseConnexion)Activator.CreateInstance(def.TypeConnexion, new object[] { m_nIdSession });
m_connexions[strIdConnexion] = connexion;
connexion.ConnexionString = def.ConnexionString;
connexion.PrefixeTables = def.PrefixeTables;
//Se met en phase avec les transactions des autres connexions
for (int nTrans = 0; nTrans < m_nNbTransactionsOuvertes; nTrans++)
{
connexion.BeginTrans(m_lastIsolationLevel);
}
}
return(connexion);
}
public override sc2i.common.CResultAErreur ExecuterOperation(IDatabaseConnexion connection, sc2i.common.IIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
CAccess97DatabaseConnexion cnx = connection as CAccess97DatabaseConnexion;
if (cnx == null)
{
return(result);
}
CAccessDataBaseCreator creator = cnx.GetDataBaseCreator() as CAccessDataBaseCreator;
if (creator == null)
{
return(result);
}
foreach (Type tp in CContexteDonnee.GetAllTypes())
{
CStructureTable structure = CStructureTable.GetStructure(tp);
if (structure != null && creator.TableExists(structure.NomTable))
{
foreach (CInfoChampTable info in structure.Champs)
{
if (!info.NullAuthorized && !structure.ChampsId.Contains(info))
{
result = creator.SetValeursParDefautAuxDonneesNulles(structure.NomTable, info);
if (!result)
{
return(result);
}
}
}
}
}
return(result);
}
/// ///////////////////////////////////////////////////////
public override string GetRequeteSelectForRead(IDatabaseConnexion connexion, params string[] strChampsARetourner)
{
CStructureTable structure = CStructureTable.GetStructure(GetTypeObjets());
string strReq = "";
ArrayList lstBlobs = new ArrayList();
string strNomTable = structure.NomTableInDb;
foreach (CInfoChampTable info in structure.Champs)
{
if (info.TypeDonnee != typeof(CDonneeBinaireInRow))
{
strReq += strNomTable + "." + info.NomChamp + ",";
}
else
{
lstBlobs.Add(info.NomChamp);
}
}
lock (m_listeChampsBlobs)
{
m_listeChampsBlobs = lstBlobs;
}
if (strReq.Length > 0)
{
strReq = strReq.Substring(0, strReq.Length - 1);
}
strReq = "select " + strReq + " from " + GetNomTableInDb();
return(strReq);
}
public override CResultAErreur ExecuterOperation(IDatabaseConnexion connection, IIndicateurProgression indicateur)
{
if (connection.GetDataBaseCreator().ChampExists(m_strNomTable, m_strNomChamp))
{
return(connection.GetDataBaseCreator().DeleteChamp(m_strNomTable, m_strNomChamp));
}
return(CResultAErreur.True);
}
public static CUpdaterDataBase GetInstance(IDatabaseConnexion connexion, IStructureDataBase structureDB)
{
if (m_instance == null)
{
m_instance = new CUpdaterDataBase(connexion, structureDB);
}
return(m_instance);
}
private static bool ExistIndex(string strNomTable, IDatabaseConnexion connexion, params string[] strChamps)
{
//Vérifie l'existance de l'index
OleDbConnection oldDbCon = (OleDbConnection)((C2iDbDatabaseConnexion)connexion).GetConnexion();
string strNomIndex = GetNomIndex(strNomTable, strChamps);
DataTable table = oldDbCon.GetOleDbSchemaTable(OleDbSchemaGuid.Indexes,
new object[] { null, null, strNomIndex, null, strNomTable });
return(table.Rows.Count != 0);
}
//------------------------------------------------------------------------------------------------
public static CResultAErreur SuppressionTable(string strNomTable, IDatabaseConnexion connexion)
{
CResultAErreur result = CResultAErreur.True;
if (CAccessTableCreatorOld.TableExists(strNomTable, connexion))
{
result = CAccessTableCreatorOld.DeleteTable(strNomTable, connexion);
}
return(result);
}
public override CResultAErreur ExecuterOperation(IDatabaseConnexion connection, IIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
IDataBaseCreator createur = connection.GetDataBaseCreator();
if (createur.TableExists(m_strNomTable))
{
result = createur.DeleteTable(m_strNomTable);
}
return(result);
}
//------------------------------------------------------------------------------------------------
public static CResultAErreur DeleteTable(string strNomTable, IDatabaseConnexion connexion)
{
string strRequeteSuppressionTable = "DROP TABLE " + strNomTable;
CResultAErreur result = connexion.RunStatement(strRequeteSuppressionTable);
if (!result)
{
result.EmpileErreur(I.T("Error while deleting of table @1|129", strNomTable));
}
return(result);
}
//--------------------------------------------------------------------------------------
public static bool TableExists(string strTableName, IDatabaseConnexion connexion)
{
string[] tableauNomsTable = connexion.TablesNames;
foreach (string obj in tableauNomsTable)
{
if (obj == strTableName)
{
return(true);
}
}
return(false);
}
//--------------------------------------------------------------------------------------
public static CResultAErreur SupprimeChamp(string strTable, string strChamp, IDatabaseConnexion connexion)
{
string strReq = "ALTER TABLE " + strTable + " DROP COLUMN " + strChamp;
CResultAErreur result = connexion.RunStatement(strReq);
if (!result)
{
result.EmpileErreur(I.T("Error while deleting column @1 of table @2|132", strChamp, strTable));
}
return(result);
}
/// //////////////////////////////////////////////////
public C2iDataAdapterForType(IDatabaseConnexion connexion, Type typeObjets, CFiltreData filtre, params string[] strExclusions)
{
m_connexion = connexion;
m_typeObjets = typeObjets;
m_structure = CStructureTable.GetStructure(m_typeObjets);
m_tableMapping.Add(new DataTableMapping(m_structure.NomTableInDb, m_structure.NomTable));
m_filtre = filtre;
foreach (string strChamp in strExclusions)
{
m_tableExclusions[strChamp] = true;
}
}
//------------------------------------------------------------------------------------------------
public static CResultAErreur CreateDatabase(IDatabaseConnexion connexion)
{
CResultAErreur result = CResultAErreur.True;
if (!connexion.IsConnexionValide())
{
if (connexion is COleDbDatabaseConnexion)
{
string strConnexionString = connexion.ConnexionString;
//Trouve le nom de la base
Regex findName = new Regex("Data Source[ ]*=[ ]*(.*);?", RegexOptions.IgnoreCase);
Match match = findName.Match(strConnexionString);
string strBase = "";
if (match != null)
{
strBase = match.Value;
string[] strVals = strBase.Split('=');
if (strVals.Length > 1)
{
strBase = strVals[1].Split(';') [0];
}
}
if (!File.Exists(strBase))
{
System.Reflection.Assembly thisExe;
thisExe = System.Reflection.Assembly.GetExecutingAssembly();
Stream source =
thisExe.GetManifestResourceStream("sc2i.data.serveur.BASEVIDE.MDB");
if (strBase == "")
{
result.EmpileErreur(I.T("Impossible to determine the database name|123"));
return(result);
}
Stream dest = new FileStream(strBase, FileMode.CreateNew);
result = CStreamCopieur.CopyStream(source, dest, 2048);
dest.Close();
if (!result)
{
return(result);
}
}
}
else
{
result.EmpileErreur(I.T("'CreateDatabase' function not possible for connection @1|124", connexion.GetType().Name));
}
}
return(result);
}
////////////////////////////////////////////////////////////////////////
public void ResetConnexion(string strIdConnexion)
{
IDatabaseConnexion connexion = (IDatabaseConnexion)m_tableDefinitionsConnexions[strIdConnexion];
if (connexion != null)
{
try
{
connexion.Dispose();
}
catch
{
}
}
m_tableDefinitionsConnexions[strIdConnexion] = null;
}
//------------------------------------------------------------------------------------------------
private static CResultAErreur CreateOrUpdateIndex(string strNomTable, IDatabaseConnexion connexion, params string[] strChamps)
{
CResultAErreur result = CResultAErreur.True;
if (ExistIndex(strNomTable, connexion, strChamps))
{
return(result);
}
string strNomIndex = GetNomIndex(strNomTable, strChamps);
string strRequeteIndex = GetRequeteIndex(strNomTable, strChamps);
result = connexion.RunStatement(strRequeteIndex);
if (!result)
{
result.EmpileErreur(I.T("Error while creating index in the table @1|128", strNomTable));
return(result);
}
return(result);
}
//------------------------------------------------------------------------------------------------
private static CResultAErreur SupprimeIndex(string strNomTable, IDatabaseConnexion connexion, params string[] strChamps)
{
CResultAErreur result = CResultAErreur.True;
if (!ExistIndex(strNomTable, connexion, strChamps))
{
return(result);
}
string strNomIndex = GetNomIndex(strNomTable, strChamps);
string strRequeteIndex = "DROP INDEX " + strNomTable + "." + strNomIndex;
result = connexion.RunStatement(strRequeteIndex);
if (!result)
{
result.EmpileErreur(I.T("Error while deleting index @1 of the table @2|130", strNomIndex, strNomTable));
return(result);
}
return(result);
}
//------------------------------------------------------------------------------------------------
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 override CResultAErreur ExecuterOperation(IDatabaseConnexion connection, IIndicateurProgression indicateur)
{
IDataBaseCreator creator = connection.GetDataBaseCreator();
string strNomTable = DynamicClassAttribute.GetNomConvivial(m_type);
if (!m_bSuppression)
{
#if PDA
return(COracleTableCreator.CreationOuUpdateTableFromType(tp, m_nIdSession));
#else
return(creator.CreationOuUpdateTableFromType(m_type, new ArrayList(m_strChampsAutorisesANull)));
#endif
}
else
{
#if PDA
return(CSQLCeTableCreator.SuppressionTable(strNomTable, m_nIdSession));
#else
return(creator.DeleteTable(CStructureTable.GetStructure(m_type).NomTableInDb));
#endif
}
}
//------------------------------------------------------------------------
private static bool IsTransactionTerminee(int nIdSession)
{
//S'assure que la transaction est terminée pour cette session
CSessionClient session = CSessionClient.GetSessionForIdSession(nIdSession);
IDatabaseConnexion cnx = null;
if (session != null && session.IsConnected)
{
try
{
cnx = CSc2iDataServer.GetInstance().GetDatabaseConnexion(nIdSession, typeof(CEtapeWorkflow));
}
catch //En cas d'erreur, c'est probablement que la session a été fermée, du coup, on peut y aller !
{
cnx = null;
}
}
else
{
cnx = null;
}
return(cnx == null || !cnx.IsInTrans());
}
/// //////////////////////////////////////////////////////
private CResultAErreur OnCommitTrans()
{
CResultAErreur result = CResultAErreur.True;
try
{
ArrayList lstToDelete = null;
ArrayList lstToValidate = null;
ArrayList lstNotToDelete = null;
GetListesPourValidation(ref lstToDelete, ref lstToValidate, ref lstNotToDelete);
foreach (CReferenceDocument refDoc in lstToDelete)
{
DeleteDocument(refDoc);
}
foreach (CReferenceDocument refDoc in lstToValidate)
{
ValideDocument(refDoc);
}
lstToDelete.Clear();
lstToValidate.Clear();
lstNotToDelete.Clear();
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error while deleting/validating of EDM Documents|30001"));
}
finally
{
IDatabaseConnexion con = CSc2iDataServer.GetInstance().GetDatabaseConnexion(IdSession, GetType());
if (con != null)
{
con.OnCommitTrans -= m_commitEventHandlerNote;
}
}
return(result);
}
//--------------------------------------------------------------------
static void CTimosServeur_OnMajStructureBaseEvent(object sender, EventArgs e)
{
// Mise à jour de la base
C2iDataBaseUpdateOperationTable opTableCamusatData =
new C2iDataBaseUpdateOperationTable(typeof(CCamusatQowisioData));
C2iDataBaseUpdateOperationTable opTableCamusatAlarm =
new C2iDataBaseUpdateOperationTable(typeof(CCamusatQowisioAlarm));
IDatabaseConnexion connexion = CSc2iDataServer.GetInstance().GetDatabaseConnexion(0, "");
if (connexion != null)
{
CResultAErreur result = CResultAErreur.True;
try
{
connexion.BeginTrans();
result = opTableCamusatData.ExecuterOperation(connexion, null);
if (result)
{
result = opTableCamusatAlarm.ExecuterOperation(connexion, null);
}
if (!result)
{
connexion.RollbackTrans();
}
else
{
connexion.CommitTrans();
}
}
catch (Exception ex)
{
result.EmpileErreur(ex.Message);
}
}
m_bTraitementEnCours = false;
}
public CResultAErreur ExecuteScalar(string strStatement)
{
IDatabaseConnexion connexion = CSc2iDataServer.GetInstance().GetDatabaseConnexion(IdSession, typeof(CSpvSiteServeur));
return(connexion.ExecuteScalar(strStatement));
}
////////////////////////////////////////////////////////////////////////
public void SetConnexion(string strIdConnexion, IDatabaseConnexion connexion)
{
m_connexions[strIdConnexion] = connexion;
}
//--------------------------------------------------------------------------------------------------------------------
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);
}
/// //////////////////////////////////////////////////
///Démarre une étape.
///Attention, un étape ne peut démarrer que si elle n'est pas déjà démarrée
public void RunEtape(int nIdSessionMain, int nIdEtape)
{
CResultAErreur result = CResultAErreur.True;
CDbKey keyUser = null;
//Attend la fin des transactions en cours pour la session principale
IDatabaseConnexion cnx = null;
do
{
CSessionClient session = CSessionClient.GetSessionForIdSession(IdSession);
if (session != null && session.IsConnected)
{
IInfoUtilisateur info = session.GetInfoUtilisateur();
//TESTDBKEYTODO
if (info != null)
{
keyUser = info.KeyUtilisateur;
}
try
{
cnx = CSc2iDataServer.GetInstance().GetDatabaseConnexion(IdSession, typeof(CEtapeWorkflow));
}
catch //En cas d'erreur, c'est probablement que la session a été fermée, du coup, on peut y aller !
{
cnx = null;
}
System.Threading.Thread.Sleep(50);
}
else
{
cnx = null;
}
}while (cnx != null && cnx.IsInTrans());
lock (typeof(CLockerStartEtape))//S'assure que deux étapes ne démarrent pas en même temps !
{
List <CDonneeNotificationWorkflow> lstNotifications = new List <CDonneeNotificationWorkflow>();
CAuthentificationSessionProcess auth = new CAuthentificationSessionProcess();
using (CSessionClient sousSession = CSessionClient.CreateInstance())
{
try
{
Console.WriteLine("Thread : " + System.Diagnostics.Process.GetCurrentProcess().Threads.Count);
sousSession.OpenSession(auth, "Workflow step " + nIdEtape, ETypeApplicationCliente.Process);
//TESTDBKEYTODO
if (keyUser != null)
{
sousSession.ChangeUtilisateur(keyUser);
}
using (CContexteDonnee ctx = new CContexteDonnee(sousSession.IdSession, true, true))
{
CEtapeWorkflow etape = new CEtapeWorkflow(ctx);
int nWaiter = 10;
while (!etape.ReadIfExists(nIdEtape) && nWaiter > 0)
{
//On ne trouve pas l'étape, c'est peut être que l'écriture en base n'est pas completement terminée
//On va retenter toutes les 2 secondes pendant 20 secondes, si elle n'existe jamais,
//c'est qu'il y a eu suppression (ou au moins non commit).
nWaiter--;
Thread.Sleep(2000);
}
if (etape.ReadIfExists(nIdEtape))
{
result = etape.InternalSetInfosDemarrageInCurrentContext();
etape.EtatCode = (int)EEtatEtapeWorkflow.Démarrée;
result = ctx.SaveAll(true);
if (result)
{
result = etape.InternalRunAndSaveifOk();
}
if (result && etape.CodeAffectations.Length > 0 && etape.DateFin == null)
{
CDonneeNotificationWorkflow donneeWorkflow = new CDonneeNotificationWorkflow(
nIdSessionMain,
etape.Id,
etape.Libelle,
etape.CodeAffectations,
etape.TypeEtape.ExecutionAutomatique);
lstNotifications.Add(donneeWorkflow);
// Déclenche l'evenement spécifique au démarrage de l'étape
result = etape.EnregistreEvenement(CEtapeWorkflow.c_codeEvenementOnRunStep, true);
}
if (!result)
{
NoteErreurSurEtape(etape, result.Erreur.ToString());
return;
}
}
}
}
catch (Exception e)
{
}
finally
{
sousSession.CloseSession();
}
}
if (lstNotifications != null)
{
CEnvoyeurNotification.EnvoieNotifications(lstNotifications.ToArray());
}
}
}
public abstract CResultAErreur ExecuterOperation(IDatabaseConnexion connection, IIndicateurProgression indicateur);
//--------------------------------------------------------------------------------------------------------------------
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;*/
}
///////////////////////////////////////////
public void SetDatabaseConnexion(int nIdSession, string strIdConnexion, IDatabaseConnexion connexion)
{
nIdSession = GetIdSessionForDb(nIdSession);
GetConnexions(nIdSession).SetConnexion(strIdConnexion, connexion);
}
public override CResultAErreur ExecuterOperation(IDatabaseConnexion connection, IIndicateurProgression indicateur)
{
return(CResultAErreur.True);
}
public override CResultAErreur ExecuterOperation(IDatabaseConnexion connection, IIndicateurProgression indicateur)
{
return(Delegue(connection.GetDataBaseCreator()));
}
