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