//---------------------------------------------------------------------------------------------
private void FiltrerTable()
{
if (m_tableExport == null ||
(!(m_tableExport is C2iTableExport)))
{
return;
}
ITableExport tableExport = (ITableExport)m_tableExport;
if (tableExport.ChampOrigine == null)
{
return;
}
CFiltreDynamique filtre = ((ITableExport)m_tableExport).FiltreAAppliquer;
if (filtre == null)
{
filtre = new CFiltreDynamique();
filtre.TypeElements = tableExport.ChampOrigine.TypeDonnee.TypeDotNetNatif;
}
filtre.ElementAVariablesExterne = m_elementAVariablesPourFiltre;
if (CFormEditFiltreDynamique.EditeFiltre(filtre, true, true, tableExport.ChampOrigine))
{
tableExport.FiltreAAppliquer = filtre;
InitChamps();
}
}
//----------------------------------------------------------------------------------
public CResultAErreur InsertDataInDataSet(
IEnumerable list,
DataSet ds,
ITableExport tableParente,
int nValeurCle,
IElementAVariablesDynamiquesAvecContexteDonnee elementAVariablePourFiltres,
CCacheValeursProprietes cacheValeurs,
ITableExport tableFilleANeParCharger,
bool bAvecOptimisation,
CConteneurIndicateurProgression indicateur)
{
return(InsertDataInDataSet(list, ds, tableParente, new int[] { nValeurCle }, null, elementAVariablePourFiltres, cacheValeurs, null, bAvecOptimisation, indicateur));
}
//---------------------------------
public override CResultAErreur InsertDataInDataSet(
IEnumerable list,
DataSet ds,
ITableExport tableParente,
int[] nValeursCle,
RelationAttribute relationToObjetParent,
IElementAVariablesDynamiquesAvecContexteDonnee elementAVariablePourFiltres,
CCacheValeursProprietes cacheValeurs,
ITableExport tableFilleANePasCharger,
bool bAvecOptimisation,
CConteneurIndicateurProgression indicateur)
{
if (tableParente != null)
{
return(base.InsertDataInDataSet(
list,
ds,
tableParente,
nValeursCle,
relationToObjetParent,
elementAVariablePourFiltres,
cacheValeurs,
tableFilleANePasCharger,
bAvecOptimisation,
indicateur));
}
else
{
CResultAErreur result = CResultAErreur.True;
foreach (ITableExport tableFille in TablesFilles)
{
result = tableFille.InsertDataInDataSet(
list,
ds,
tableParente,
nValeursCle,
relationToObjetParent,
elementAVariablePourFiltres,
cacheValeurs,
tableFilleANePasCharger,
bAvecOptimisation,
indicateur);
if (!result)
{
return(result);
}
}
return(result);
}
}
//----------------------------------------------------------------------------------
public CResultAErreur InitChamps(
ITableExport table,
ITableExport tableParente,
C2iStructureExport structure,
IElementAVariablesDynamiquesAvecContexteDonnee eltAVariablesDynamiques)
{
CResultAErreur result = CResultAErreur.True;
m_tableCalculee = table as C2iTableExportCalculee;
if (m_tableCalculee == null)
{
return(CResultAErreur.False);
}
m_structureExport = structure;
m_txtNomTable.Text = m_tableCalculee.NomTable;
if (m_tableCalculee.FormuleValeur != null)
{
m_txtFormuleValeur.Text = m_tableCalculee.FormuleValeur.GetString();
}
else
{
m_txtFormuleValeur.Text = "";
}
if (m_tableCalculee.FormuleNbRecords != null)
{
m_txtFormuleNbRecords.Text = m_tableCalculee.FormuleNbRecords.GetString();
}
else
{
m_txtFormuleNbRecords.Text = "0";
}
ElementAVariablesDynamiques = eltAVariablesDynamiques;
C2iTableExportCalculee.CTypeForFormule leType = new C2iTableExportCalculee.CTypeForFormule(m_elementAVariablesDynamiques);
m_wndAideFormule.ObjetInterroge = typeof(C2iTableExportCalculee.CTypeForFormule);
m_wndAideFormule.FournisseurProprietes = leType;
m_txtFormuleValeur.Init(m_wndAideFormule.FournisseurProprietes, m_wndAideFormule.ObjetInterroge);
m_txtFormuleNbRecords.Init(m_wndAideFormule.FournisseurProprietes, m_wndAideFormule.ObjetInterroge);
return(result);
}
/// /////////////////////////////////////////////////////////
public CResultAErreur InsertDataInDataSet(
IEnumerable list,
DataSet ds,
ITableExport tableParente,
int[] nValeursCle,
RelationAttribute relationToObjetParent,
IElementAVariablesDynamiquesAvecContexteDonnee elementAVariablePourFiltres,
CCacheValeursProprietes cacheValeurs,
ITableExport tableFilleANeParCharger,
bool bAvecOptimisation,
CConteneurIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
result.EmpileErreur(I.T("Not supported function calling : C2iTableExportCalculée.InsertDataInDataset|124"));
return(result);
}
//----------------------------------------------------------------------------------
private void GetDependancesDeTableSimple(ITableExport table, Hashtable tableOrigines, string strChemin)
{
foreach (ITableExport tableFille in table.TablesFilles)
{
CDefinitionProprieteDynamique def = tableFille.ChampOrigine;
if (def != null)
{
string strChamp = strChemin;
if (strChamp.Length > 0)
{
strChamp += ".";
}
strChamp += def.NomPropriete;
tableOrigines[strChamp] = true;
GetDependancesDeTableSimple(tableFille, tableOrigines, strChamp);
}
}
}
//------------------------------------------
public CResultAErreur InitChamps(
ITableExport table,
ITableExport tableParente,
C2iStructureExport structure,
IElementAVariablesDynamiquesAvecContexteDonnee eltAVariablesPourFiltre)
{
CResultAErreur result = CResultAErreur.True;
m_tableExport = table as C2iTableExport;
m_tableParente = tableParente;
m_structureExport = structure;
m_elementAVariablesPourFiltre = eltAVariablesPourFiltre;
if (m_tableExport == null)
{
result.EmpileErreur(I.T("Bad table format|20003"));
return(result);
}
InitChamps();
return(result);
}
//------------------------------------------
public CResultAErreur InitChamps(
ITableExport table,
ITableExport tableParente,
C2iStructureExport structure,
IElementAVariablesDynamiquesAvecContexteDonnee eltAVariablesPourFiltre)
{
CResultAErreur result = CResultAErreur.True;
m_tableVue = table as C2iTableExportVue;
m_tableParente = tableParente;
m_structureExport = structure;
m_elementAVariablesPourFiltre = eltAVariablesPourFiltre;
if (m_tableVue == null)
{
result.EmpileErreur(I.T("Bad table format|20003"));
return(result);
}
InitChamps();
//Crée une table bidon avec tous les champs de la table fille de cette table
DataTable tableBidon = new DataTable();
if (m_tableVue.TablesFilles.Length != 0)
{
foreach (IChampDeTable champ in m_tableVue.TablesFilles[0].Champs)
{
Type tp = champ.TypeDonnee;
if (tp.IsGenericType && tp.GetGenericTypeDefinition() == typeof(Nullable <>))
{
tp = tp.GetGenericArguments()[0];
}
DataColumn col = new DataColumn(champ.NomChamp, tp);
tableBidon.Columns.Add(col);
}
}
m_fournisseur = new CFournisseurPropDynForDataTable(tableBidon);
return(result);
}
//----------------------------------------------------------------------------------
public CResultAErreur InitChamps(
ITableExport table,
ITableExport tableParente,
C2iStructureExport structure,
IElementAVariablesDynamiquesAvecContexteDonnee eltAVariablesDynamiques)
{
CResultAErreur result = CResultAErreur.True;
m_tableUnion = table as C2iTableExportUnion;
if (m_tableUnion == null)
{
return(CResultAErreur.False);
}
m_txtNomTable.Text = m_tableUnion.NomTable;
if (m_tableUnion.ChampOrigine is CDefinitionProprieteDynamiqueThis)
{
m_lblType.Text = DynamicClassAttribute.GetNomConvivial(m_tableUnion.ChampOrigine.TypeDonnee.TypeDotNetNatif);
}
else if (m_tableUnion.ChampOrigine != null)
{
m_lblType.Text = m_tableUnion.ChampOrigine.Nom;
}
else
{
m_lblType.Text = "";
}
m_chkSupprimerTablesTravail.Checked = m_tableUnion.SupprimerTablesTravail;
m_tableUnion.RecalcStructure();
FillListeChamps();
return(result);
}
/// /////////////////////////////////////////////////////////
public void AddTableFille(ITableExport table)
{
m_listeTables.Add(table);
}
/// /////////////////////////////////////////////////////////
public CResultAErreur InsertDataInDataSet(
IEnumerable list,
DataSet ds,
ITableExport tableParente,
int[] nValeursCle,
RelationAttribute relationToObjetParent,
IElementAVariablesDynamiquesAvecContexteDonnee elementAVariablePourFiltres,
CCacheValeursProprietes cacheValeurs,
ITableExport tableFilleANeParCharger,
bool bAvecOptimisation,
CConteneurIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
if (NePasCalculer)
{
return(result);
}
int nValeurIndicateur = 0;
indicateur.SetBornesSegment(0, m_tableauCroise == null?2:3);
if (list == null)
{
return(result);
}
if (!(list is CListeObjetsDonnees))
{
result.EmpileErreur(I.T("Attempt of cumulated table on something other that a data list|125"));
return(result);
}
CListeObjetsDonnees listeDonnees = (CListeObjetsDonnees)list;
if (relationToObjetParent == null)
{
//Principe de la lecture en une fois :
//Si la liste des une liste objets contenus, c'est que chaque élément
//est un composant d'un parent. On stock donc tous les parents
//Pour lesquels on veut les données,
//et elles seront lues dans le EndInsertTable.
//Par contre si la liste contenu a un filtre, on ne peut plus
//stocker juste ça, il faudrait en plus stocker le filtre et ça
//devient compliqué.
if (listeDonnees is CListeObjetsDonneesContenus &&
(listeDonnees.Filtre == null ||
!listeDonnees.Filtre.HasFiltre))
{
CListeObjetsDonneesContenus listeContenu = (CListeObjetsDonneesContenus)listeDonnees;
if (listeContenu.ObjetConteneur != null &&
typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(listeContenu.ObjetConteneur.GetType()))
{
if (m_mapIdBaseParentToReadToIdTable == null)
{
m_mapIdBaseParentToReadToIdTable = new Hashtable();
}
m_mapIdBaseParentToReadToIdTable[((CObjetDonneeAIdNumerique)listeContenu.ObjetConteneur).Id] = nValeursCle[0];
m_strChampIdParent = listeContenu.ChampsFille[0];
m_tableParente = tableParente;
listeContenu.GetFiltreForRead();
m_nIdSession = listeContenu.ContexteDonnee.IdSession;
m_elementAVariablePourFiltres = elementAVariablePourFiltres;
return(result);
}
}
}
DataTable table = ds.Tables[NomTable];
if (table == null)
{
result.EmpileErreur(I.T("Table @1 doesn't exist|116", NomTable));
return(result);
}
DataColumn colFille = null;
if (tableParente != null)
{
foreach (Constraint constraint in table.Constraints)
{
if (constraint is ForeignKeyConstraint)
{
ForeignKeyConstraint fkConst = (ForeignKeyConstraint)constraint;
colFille = fkConst.Columns[0];
}
}
}
CFiltreData filtreDeBase = listeDonnees.GetFiltreForRead();
result = GetFiltreDataAAppliquer(elementAVariablePourFiltres);
if (!result)
{
result.EmpileErreur(I.T("Error in cumulated table @1 filter|126", NomTable));
return(result);
}
CFiltreData leFiltreComplet = CFiltreData.GetAndFiltre(
filtreDeBase, (CFiltreData)result.Data);
C2iRequeteAvancee requete = m_requete;
CTableauCroise tableauCroise = m_tableauCroise;
string strChampParent = "";
if (relationToObjetParent != null)
{
requete = (C2iRequeteAvancee)CCloner2iSerializable.Clone(m_requete);
strChampParent = relationToObjetParent.ChampsParent[0] + "_CLE_DB";
Type typeChampParent = typeof(string);
IChampDeTable champParent = tableParente.Champs.FirstOrDefault(c => c.NomChamp == strChampParent);
if (champParent != null)
{
typeChampParent = champParent.TypeDonnee;
}
C2iChampDeRequete champ = new C2iChampDeRequete(
strChampParent,
new CSourceDeChampDeRequete(relationToObjetParent.ChampsFils[0]),
typeof(int),
OperationsAgregation.None,
true);
requete.ListeChamps.Add(champ);
string strListe = "";
foreach (int nId in nValeursCle)
{
strListe += nId.ToString() + ";";
}
strListe = strListe.Substring(0, strListe.Length - 1);
leFiltreComplet = CFiltreData.GetAndFiltre(leFiltreComplet, new CFiltreDataAvance(
requete.TableInterrogee,
relationToObjetParent.ChampsFils[0] + " in {" + strListe + "}"));
if (tableauCroise != null)
{
tableauCroise = (CTableauCroise)CCloner2iSerializable.Clone(m_tableauCroise);
tableauCroise.AddChampCle(new CCleTableauCroise(strChampParent, typeChampParent));
}
}
requete.FiltreAAppliquer = leFiltreComplet;
indicateur.SetInfo(I.T("Table @1 (request)|127", NomTable));
if (ChampOrigine == null)
{
requete.TableInterrogee = CContexteDonnee.GetNomTableForType(listeDonnees.TypeObjets);
}
result = requete.ExecuteRequete(listeDonnees.ContexteDonnee.IdSession);
indicateur.SetValue(nValeurIndicateur++);
if (indicateur.CancelRequest)
{
result.EmpileErreur(I.T("Execution cancelled by the user|118"));
return(result);
}
if (!result)
{
return(result);
}
if (result.Data == null)
{
return(null);
}
DataTable tableDonnees = (DataTable)result.Data;
if (tableauCroise != null)
{
indicateur.SetInfo(I.T("Table @1 (cross table)|128", NomTable));
result = tableauCroise.CreateTableCroisee(tableDonnees);
indicateur.SetValue(nValeurIndicateur++);
if (!result)
{
result.EmpileErreur(I.T("Error in data crossing|130"));
return(result);
}
if (indicateur.CancelRequest)
{
result.EmpileErreur(I.T("Execution cancelled by the user|118"));
return(result);
}
tableDonnees = (DataTable)result.Data;
foreach (DataColumn col in tableDonnees.Columns)
{
DataColumn laColonne = table.Columns[col.ColumnName];
if (laColonne == null)
{
table.Columns.Add(col.ColumnName, col.DataType);
}
//Stef le 5/5/2005 : Si la colonne n'est pas du bon type,
//son type est ajusté !
else if (laColonne.DataType != col.DataType)
{
laColonne.DataType = col.DataType;
}
}
}
else
{
//Ajuste le type des colonnes
foreach (DataColumn col in tableDonnees.Columns)
{
DataColumn laColonne = table.Columns[col.ColumnName];
if (laColonne != null && laColonne.DataType != col.DataType)
{
laColonne.DataType = col.DataType;
}
}
}
indicateur.SetInfo(I.T("Storage|129"));
indicateur.PushSegment(nValeurIndicateur, nValeurIndicateur + 1);
indicateur.SetBornesSegment(0, tableDonnees.Rows.Count);
int nFrequence = Math.Min(tableDonnees.Rows.Count / 20, 500) + 1;
//Intègre les données dans la table
ArrayList lstNewRows = new ArrayList();
int nCompteur = 0;
foreach (DataRow row in tableDonnees.Rows)
{
nCompteur++;
if (nCompteur % nFrequence == 0)
{
indicateur.SetValue(nCompteur);
if (indicateur.CancelRequest)
{
result.EmpileErreur(I.T("Execution cancelled by the user|118"));
return(result);
}
}
DataRow newRow = table.NewRow();
foreach (DataColumn col in row.Table.Columns)
{
if (newRow.Table.Columns[col.ColumnName] != null)
{
newRow[col.ColumnName] = row[col];
}
}
if (colFille != null)
{
if (relationToObjetParent == null)
{
newRow[colFille] = nValeursCle[0];
}
else
{
newRow[colFille] = row[strChampParent];
}
}
table.Rows.Add(newRow);
}
indicateur.PopSegment();
return(result);
}
//----------------------------------------------------------------------------------
/// <summary>
/// Indique si une table fille peut être optimisée, et donc, chargée
/// en une seule passe, ou s'il est nécéssaire de créer chaque enregistrement
/// fils pour chaque enregistrement parent
/// </summary>
/// <param name="tableFille"></param>
/// <param name="tpDeMesElements">Type des éléments contenus dans this</param>
/// <returns></returns>
public virtual bool IsOptimisable(ITableExport tableFille, Type tpDeMesElements)
{
if (ChampOrigine == null || ChampOrigine.NomPropriete.IndexOf('.') < 0 ||
!ChampOrigine.TypeDonnee.IsArrayOfTypeNatif)
{
if (tableFille is C2iTableExportATableFille || tableFille is C2iTableExportCumulee)
{
if (tableFille.ChampOrigine is CDefinitionProprieteDynamiqueDonneeCumulee)
{
return(true);
}
else if (tableFille.ChampOrigine is CDefinitionProprieteDynamiqueRelationTypeId)
{
return(true);
}
else if (tableFille.ChampOrigine != null && !tableFille.ChampOrigine.TypeDonnee.IsArrayOfTypeNatif && tableFille.ChampOrigine.GetType() == typeof(CDefinitionProprieteDynamiqueDotNet)) //Table parente
{
//est-ce que cette table parente peut être lue comme une dépendance ?
return(true);
}
else if (tableFille.ChampOrigine is CDefinitionProprieteDynamiqueThis)
{
return(true);
}
else
{
string strPropOrigine = tableFille.ChampOrigine.NomProprieteSansCleTypeChamp;
if (strPropOrigine.IndexOf('.') < 0)
{
//Seules les propriétés directes sont optimisées (pour le moment et peut être que ça suffit)
PropertyInfo info = tpDeMesElements.GetProperty(strPropOrigine);
if (info != null)
{
object[] attribs = info.GetCustomAttributes(typeof(RelationFilleAttribute), true);
if (attribs.Length > 0)
{
RelationFilleAttribute attrFille = (RelationFilleAttribute)attribs[0];
tpDeMesElements = attrFille.TypeFille;
if (typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tpDeMesElements))
{
info = tpDeMesElements.GetProperty(attrFille.ProprieteFille);
if (info != null)
{
attribs = info.GetCustomAttributes(typeof(RelationAttribute), true);
if (attribs.Length > 0)
{
RelationAttribute attrParent = (RelationAttribute)attribs[0];
if (attrParent.ChampsFils.Length == 1)
{
return(true);
}
}
}
}
}
}
}
}
}
}
return(false);
}
/// //////////////////////////////////////////////////////////////
public void RemoveTableFille(ITableExport table)
{
}
//----------------------------------------------------------------------------------
public virtual CResultAErreur InsertDataInDataSet(
IEnumerable list,
DataSet ds,
ITableExport tableParente,
int[] nValeursCle,
RelationAttribute relationToObjetParent,
IElementAVariablesDynamiquesAvecContexteDonnee elementAVariablePourFiltres,
CCacheValeursProprietes cacheValeurs,
ITableExport tableFilleANePasCharger,
bool bAvecOptimisation,
CConteneurIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
if (NePasCalculer)
{
return(result);
}
if (tableParente != null && nValeursCle.Length == 0)
{
return(result);
}
DataTable table = ds.Tables[NomTable];
if (table == null)
{
result.EmpileErreur(I.T("Table @1 doesn't exist|116", NomTable));
return(result);
}
indicateur.SetInfo(I.T("Table @1|115", NomTable));
if (nValeursCle.Length > 1 &&
relationToObjetParent == null)
{
result.EmpileErreur(I.T("Error: Multiple child table loading without knowing the relation indicating how the parental link is established|117"));
return(result);
}
DataColumn colFilleDeContrainte = null;
DataTable tableFilleDeContrainte = null;
if (tableParente != null)
{
if (ChampOrigine.TypeDonnee.IsArrayOfTypeNatif || !bAvecOptimisation ||
ChampOrigine is CDefinitionProprieteDynamiqueThis)
{
//On est dans une relation fille
foreach (Constraint constraint in table.Constraints)
{
if (constraint is ForeignKeyConstraint)
{
ForeignKeyConstraint fkConst = (ForeignKeyConstraint)constraint;
if (fkConst.RelatedTable.TableName == tableParente.NomTable)
{
colFilleDeContrainte = fkConst.Columns[0];
break;
}
}
}
tableFilleDeContrainte = table;
}
else
{
//On est dans une relation parente
DataTable tblP = ds.Tables[tableParente.NomTable];
foreach (Constraint contraint in tblP.Constraints)
{
if (contraint is ForeignKeyConstraint)
{
ForeignKeyConstraint fk = (ForeignKeyConstraint)contraint;
if (fk.RelatedTable.TableName == table.TableName)
{
colFilleDeContrainte = fk.Columns[0];
tableFilleDeContrainte = tblP;
break;
}
}
}
}
}
if (list == null)
{
return(result);
}
//Désactive les ids auto sur les objetDonneeAIdNumerique.
//Car on utilise alors les valeurs de clé des éléments
bool bUtiliserIdObjets = false;
if (bAvecOptimisation && (ChampOrigine == null || ChampOrigine.NomPropriete.IndexOf('.') < 0 || !ChampOrigine.TypeDonnee.IsArrayOfTypeNatif))
{
if (list is CListeObjetsDonnees && (tableParente == null || colFilleDeContrainte == null))
{
if (typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(((CListeObjetsDonnees)list).TypeObjets))
{
table.PrimaryKey[0].AutoIncrement = false;
bUtiliserIdObjets = true;
}
}
if (list is ArrayList)
{
ArrayList arrL = (ArrayList)list;
if (arrL.Count > 0 &&
typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(arrL[0].GetType()))
{
table.PrimaryKey[0].AutoIncrement = false;
bUtiliserIdObjets = true;
}
}
}
if (FiltreAAppliquer != null)
{
CListeObjetsDonnees listeObjetsDonnee = list as CListeObjetsDonnees;
if (listeObjetsDonnee == null)//Tente de convertir en liste d'objets
{
//Récupère le contexte de données
CContexteDonnee ctx = null;
foreach (object obj in list)
{
IObjetAContexteDonnee objACtx = obj as IObjetAContexteDonnee;
if (objACtx != null)
{
ctx = objACtx.ContexteDonnee;
break;
}
}
listeObjetsDonnee = CListeObjetsDonnees.CreateListFrom(ctx, list);
}
if (listeObjetsDonnee != null)
{
list = listeObjetsDonnee;
result = GetFiltreDataAAppliquer(elementAVariablePourFiltres);
if (!result)
{
result.EmpileErreur(I.T("Error in the filter of the table @1|119", NomTable));
return(result);
}
try
{
if (result.Data != null)
{
listeObjetsDonnee.Filtre = CFiltreData.GetAndFiltre(listeObjetsDonnee.Filtre, (CFiltreData)result.Data);
}
}
catch (Exception e)
{
result.EmpileErreur(new CErreurException(e));
result.EmpileErreur(I.T("Error during combination of table @1 filter|120", NomTable));
return(result);
}
}
}
//Table fille->
//si relation : Attribut relation (parente) représentant le lien entre la relation fille et cette tablle
//Si donnée cumulée : true
Hashtable tableTablesFillesToDependanceDirecte = new Hashtable();
//Table parente->Champ fille contenant l'id
Hashtable tableParentsCharges = new Hashtable();
#region Optimisations des CListeObjetsDonnees
if (bAvecOptimisation && list is CListeObjetsDonnees)
{
CListeObjetsDonnees listeObjets = (CListeObjetsDonnees)list;
if (bUtiliserIdObjets)
{
#region Identifie les tables filles qui peuvent être remplies en une seule requête.
//Identifie les sous tables qui peuvent être chargées en une seule fois :
//Il s'agit des sous tables liée directement à une propriété par
//des relations (attribut RelationFille ou Relation).
foreach (ITableExport tableFille in TablesFilles)
{
Type tpAnalyse = listeObjets.TypeObjets;
if (tableFille != tableFilleANePasCharger && (tableFille is C2iTableExportATableFille || tableFille is C2iTableExportCumulee))
{
if (tableFille.ChampOrigine is CDefinitionProprieteDynamiqueDonneeCumulee)
{
tableTablesFillesToDependanceDirecte[tableFille] = true;
}
else if (tableFille.ChampOrigine is CDefinitionProprieteDynamiqueRelationTypeId)
{
tableTablesFillesToDependanceDirecte[tableFille] = true;
}
else if (tableFille.ChampOrigine is CDefinitionProprieteDynamiqueThis)
{
tableTablesFillesToDependanceDirecte[tableFille] = true;
}
else if (tableFille.ChampOrigine != null)
{
string strPropOrigine = tableFille.ChampOrigine.NomProprieteSansCleTypeChamp;
if (strPropOrigine.IndexOf('.') < 0)
{
//Seules les propriétés directes sont optimisées (pour le moment et peut être que ça suffit)
PropertyInfo info = tpAnalyse.GetProperty(strPropOrigine);
if (info != null)
{
object[] attribs = info.GetCustomAttributes(typeof(RelationFilleAttribute), true);
if (attribs.Length > 0)
{
RelationFilleAttribute attrFille = (RelationFilleAttribute)attribs[0];
tpAnalyse = attrFille.TypeFille;
if (typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(tpAnalyse))
{
info = tpAnalyse.GetProperty(attrFille.ProprieteFille);
if (info != null)
{
attribs = info.GetCustomAttributes(typeof(RelationAttribute), true);
if (attribs.Length > 0)
{
RelationAttribute attrParent = (RelationAttribute)attribs[0];
if (attrParent.ChampsFils.Length == 1)
{
tableTablesFillesToDependanceDirecte[tableFille] = attrParent;
}
}
}
}
}
}
}
}
}
}
#endregion
#region Charges les tables parentes qui peuvent être chargées
if (typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(listeObjets.TypeObjets))
{
string strNomTableFille = listeObjets.NomTable;
foreach (ITableExport tableParenteAOptimiser in TablesFilles)
{
if (tableParenteAOptimiser != tableFilleANePasCharger && tableParenteAOptimiser.ChampOrigine != null && !tableParenteAOptimiser.ChampOrigine.TypeDonnee.IsArrayOfTypeNatif)
{
if (IsOptimisable(tableParenteAOptimiser, TypeSource))
{
CListeObjetsDonnees listeMere = listeObjets.GetDependances(tableParenteAOptimiser.ChampOrigine.NomProprieteSansCleTypeChamp);
if (listeMere != null)
{
result = tableParenteAOptimiser.InsertDataInDataSet(
listeMere,
ds,
null,
0,
elementAVariablePourFiltres,
cacheValeurs,
this,
true,
indicateur);
if (!result)
{
return(result);
}
//Trouve le champ fille de lien
foreach (Constraint contrainte in table.Constraints)
{
if (contrainte is ForeignKeyConstraint)
{
ForeignKeyConstraint fk = (ForeignKeyConstraint)contrainte;
if (fk.RelatedTable.TableName == tableParenteAOptimiser.NomTable)
{
tableParentsCharges[tableParenteAOptimiser] = fk.Columns[0].ColumnName;
break;
}
}
}
}
}
}
}
}
#endregion
}
#region Identification des dépendances
if (m_strDependancesToOptim == null)
{
Hashtable tableDependances = new Hashtable();
AddProprietesOrigineDesChampsToTable(tableDependances, "", listeObjets.ContexteDonnee);
foreach (ITableExport tableFille in TablesFilles)
{
if (tableFille != tableFilleANePasCharger &&
!tableTablesFillesToDependanceDirecte.Contains(tableFille) &&
!tableParentsCharges.Contains(tableFille))
{
string strChemin = "";
if (ChampOrigine != null)
{
strChemin = ChampOrigine.NomPropriete;
}
if (tableFille.FiltreAAppliquer == null)
{
tableFille.AddProprietesOrigineDesChampsToTable(tableDependances, strChemin, listeObjets.ContexteDonnee);
}
}
}
m_strDependancesToOptim = new string[tableDependances.Count];
int nDep = 0;
foreach (string strOrigine in tableDependances.Keys)
{
m_strDependancesToOptim[nDep++] = strOrigine;
}
}
#endregion
}
#endregion
indicateur.SetInfo(I.T("Table @1|115", NomTable));
CFiltreData filtreDeBase = null;
if (list is CListeObjetsDonnees)
{
filtreDeBase = ((CListeObjetsDonnees)list).Filtre;
}
ArrayList listeIds = new ArrayList();
string strColonneCle = table.PrimaryKey[0].ColumnName;
indicateur.SetBornesSegment(0, nValeursCle.Length);
indicateur.SetValue(0);
//Lecture par paquets de 1000 clés
for (int n = 0; n < nValeursCle.Length; n += c_nNbLectureParLotFils)
{
if (bAvecOptimisation && (list is CListeObjetsDonnees) && relationToObjetParent != null)
{
CListeObjetsDonnees listeObjets = (CListeObjetsDonnees)list;
StringBuilder blCles = new StringBuilder();
char cSepIn = ',';
if (filtreDeBase is CFiltreDataAvance)
{
cSepIn = ';';
}
for (int nCle = n; nCle < Math.Min(n + c_nNbLectureParLotFils, nValeursCle.Length); nCle++)
{
blCles.Append(nValeursCle[nCle]);
blCles.Append(cSepIn);
}
if (blCles.Length > 0)
{
blCles.Remove(blCles.Length - 1, 1);
string strCles = blCles.ToString();
if (filtreDeBase is CFiltreDataAvance)
{
listeObjets.Filtre = CFiltreData.GetAndFiltre(
filtreDeBase, new CFiltreDataAvance(
listeObjets.NomTable,
relationToObjetParent.ChampsFils[0] + " in {" + strCles + "}"));
}
else
{
listeObjets.Filtre = CFiltreData.GetAndFiltre(
filtreDeBase,
new CFiltreData(
relationToObjetParent.ChampsFils[0] + " in (" + strCles.Replace(';', ',') + ")"));
}
}
}
if (indicateur.CancelRequest)
{
result.EmpileErreur(I.T("Execution cancelled by the user|118"));
return(result);
}
if (list is CListeObjetsDonnees && m_strDependancesToOptim != null && m_strDependancesToOptim.Length > 0)
{
((CListeObjetsDonnees)list).ReadDependances(m_strDependancesToOptim);
}
int nCountTotal = 1;
if (list is IList)
{
nCountTotal = ((IList)list).Count;
}
else if (list is Array)
{
nCountTotal = ((Array)list).Length;
}
indicateur.PushSegment(n, Math.Min(n + c_nNbLectureParLotFils, nValeursCle.Length));
int nNbElements = 0;
indicateur.SetBornesSegment(0, nCountTotal);
int nFrequence = Math.Min(nCountTotal / 20, 500) + 1;
CSessionClient session = CSessionClient.GetSessionUnique();
IInfoUtilisateur infoUser = session != null?session.GetInfoUtilisateur() : null;
///AJOUT DES LIGNES DANS LA TABLE
foreach (object obj in list)
{
CRestrictionUtilisateurSurType restriction = null;
if (infoUser != null && obj != null)
{
restriction = infoUser.GetRestrictionsSur(obj.GetType(), obj is IObjetAContexteDonnee?((IObjetAContexteDonnee)obj).ContexteDonnee.IdVersionDeTravail:null);
}
nNbElements++;
if (nNbElements % nFrequence == 0)
{
indicateur.SetValue(nNbElements);
if (indicateur.CancelRequest)
{
result.EmpileErreur(I.T("Execution cancelled by the user|118"));
return(result);
}
}
bool bShouldImporte = true;
DataRow row = null;
if (bUtiliserIdObjets)
{
row = table.Rows.Find(((CObjetDonneeAIdNumerique)obj).Id);
bShouldImporte = row == null;
}
if (bShouldImporte)
{
row = table.NewRow();
if (bUtiliserIdObjets)
{
int nId = ((CObjetDonneeAIdNumerique)obj).Id;
row[strColonneCle] = nId;
listeIds.Add(nId);
}
//Ajoute les valeurs de champs propres à cette table
result = InsereValeursChamps(obj, row, cacheValeurs, restriction);
if (!result)
{
return(result);
}
if (colFilleDeContrainte != null && nValeursCle.Length > 0)
{
DataRow rowFille = row;
if (tableFilleDeContrainte == table)
{
if (relationToObjetParent == null)
{
rowFille[colFilleDeContrainte] = nValeursCle[0];
}
else
{
rowFille[colFilleDeContrainte] = ((CObjetDonnee)obj).Row[relationToObjetParent.ChampsFils[0]];
}
}
}
table.Rows.Add(row);
}
//Dans tous les cas, met à jour la table dépendante si besoin est !
if (colFilleDeContrainte != null && nValeursCle.Length > 0)
{
DataRow rowFille = row;
if (tableFilleDeContrainte != table)
{
rowFille = tableFilleDeContrainte.Rows.Find(nValeursCle[0]);
rowFille[colFilleDeContrainte] = row[strColonneCle];
}
}
if (bShouldImporte)
{
//AJout des données des sous tables non optimisées
foreach (ITableExport tbl in TablesFilles)
{
if (tbl.ChampOrigine != null && !tableTablesFillesToDependanceDirecte.Contains(tbl) && tbl != tableFilleANePasCharger)
{
bool bChildIsOptimisable = IsOptimisable(tbl, TypeSource);
//Impossible de lire en direct
object objet = null;
if (tbl.ChampOrigine is CDefinitionProprieteDynamiqueThis)
{
objet = obj;
}
else
{
objet = CInterpreteurProprieteDynamique.GetValue(obj, tbl.ChampOrigine, cacheValeurs).Data;
}
string strNomCol = (string)tableParentsCharges[tbl];
if (strNomCol != null)
{
if (objet != null)
{
row[strNomCol] = ((CObjetDonneeAIdNumerique)objet).Id;
}
else
{
row[strNomCol] = DBNull.Value;
}
}
else
{
indicateur.PushSegment(nNbElements, nNbElements + 1);
if (objet != null)
{
IEnumerable tempList;
if (objet is IEnumerable)
{
tempList = (IEnumerable)objet;
}
else
{
ArrayList listeObjetUnique = new ArrayList();
listeObjetUnique.Add(objet);
tempList = listeObjetUnique;
}
if (tempList != null)
{
result = tbl.InsertDataInDataSet(
tempList,
ds,
this,
(int)row[table.PrimaryKey[0]],
elementAVariablePourFiltres,
cacheValeurs,
this,
bChildIsOptimisable,
indicateur);
if (!result)
{
return(result);
}
}
}
indicateur.PopSegment();
}
}
}
//vide le cache après chaque objet de la table principale
if (tableParente == null)
{
cacheValeurs.ResetCache();
}
}
}
indicateur.PopSegment();
}
indicateur.SetValue(nValeursCle.Length);
///Chargement des relations optimisées
int nTable = 0;
foreach (DictionaryEntry entry in tableTablesFillesToDependanceDirecte)
{
nTable++;
ITableExport tableFille = (ITableExport)entry.Key;
if (tableFille.ChampOrigine is CDefinitionProprieteDynamiqueDonneeCumulee)
{
CDefinitionProprieteDynamiqueDonneeCumulee defCum = (CDefinitionProprieteDynamiqueDonneeCumulee)tableFille.ChampOrigine;
//Trouve les données cumulées correspondants aux éléments
CListeObjetsDonnees listeInit = (CListeObjetsDonnees)list;
CTypeDonneeCumulee typeCumule = new CTypeDonneeCumulee(listeInit.ContexteDonnee);
if (!typeCumule.ReadIfExists(
defCum.DbKeyTypeDonnee))
{
result.EmpileErreur(I.T("The cumulated data type @1 doesn't exist|122", defCum.DbKeyTypeDonnee.ToString()));
return(result);
}
RelationAttribute attr = typeCumule.GetRelationAttributeToType(listeInit.TypeObjets);
string strChampIdOuDbKey = "";
if (defCum.DbKeyTypeDonnee.IsNumericalId())
{
strChampIdOuDbKey = CTypeDonneeCumulee.c_champId;
}
else
{
strChampIdOuDbKey = CObjetDonnee.c_champIdUniversel;
}
CListeObjetsDonnees listeFils = new CListeObjetsDonnees(
listeInit.ContexteDonnee,
typeof(CDonneeCumulee),
new CFiltreData(strChampIdOuDbKey + " = @1 ", defCum.DbKeyTypeDonnee.GetValeurInDb()));
listeFils.ModeSansTri = true; //Optimisation pour ne pas utiliser de dataview
result = tableFille.InsertDataInDataSet(
listeFils,
ds,
this,
(int[])listeIds.ToArray(typeof(int)),
attr,
elementAVariablePourFiltres,
cacheValeurs,
this,
true,
indicateur);
if (!result)
{
return(result);
}
}
else if (tableFille.ChampOrigine is CDefinitionProprieteDynamiqueRelationTypeId)
{
CDefinitionProprieteDynamiqueRelationTypeId defTypeId = (CDefinitionProprieteDynamiqueRelationTypeId)tableFille.ChampOrigine;
RelationTypeIdAttribute relTpIdAttr = defTypeId.Relation;
//Trouve les données cumulées correspondants aux éléments
CListeObjetsDonnees listeInit = (CListeObjetsDonnees)list;
if (listeInit.Count != 0)
{
CListeObjetsDonnees listeFils = new CListeObjetsDonnees(
listeInit.ContexteDonnee,
CContexteDonnee.GetTypeForTable(relTpIdAttr.TableFille),
new CFiltreData(relTpIdAttr.ChampType + "=@1", listeInit.TypeObjets.ToString()));
listeFils.ModeSansTri = true; //Optimisation pour ne pas utiliser de dataview
RelationAttribute attrTmp = new RelationAttribute(
listeInit.NomTable,
((CObjetDonneeAIdNumerique)listeInit[0]).GetChampId(),
relTpIdAttr.ChampId, false, false);
result = tableFille.InsertDataInDataSet(
listeFils,
ds,
this,
(int[])listeIds.ToArray(typeof(int)),
attrTmp,
elementAVariablePourFiltres,
cacheValeurs,
this,
true,
indicateur);
if (!result)
{
return(result);
}
}
}
else if (tableFille.ChampOrigine is CDefinitionProprieteDynamiqueThis)
{
CListeObjetsDonnees listeInit = new CListeObjetsDonnees(
((CListeObjetsDonnees)list).ContexteDonnee,
tableFille.ChampOrigine.TypeDonnee.TypeDotNetNatif, true);
listeInit.ModeSansTri = true; //Optimisation pour ne pas utiliser de dataview
string strChampId = listeInit.ContexteDonnee.GetTableSafe(CContexteDonnee.GetNomTableForType(listeInit.TypeObjets)).PrimaryKey[0].ColumnName;
RelationAttribute attrTmp = new RelationAttribute(
listeInit.NomTable,
strChampId,
strChampId,
false, false);
//Copie les clés dans la clé et dans la valeur de champ externe
result = tableFille.InsertDataInDataSet(
listeInit,
ds,
this,
(int[])listeIds.ToArray(typeof(int)),
attrTmp,
elementAVariablePourFiltres,
cacheValeurs,
this,
true,
indicateur);
if (!result)
{
return(result);
}
}
else if (tableFille.ChampOrigine != null)
{
RelationAttribute attr = (RelationAttribute)entry.Value;
CListeObjetsDonnees listeFils = new CListeObjetsDonnees(
((CListeObjetsDonnees)list).ContexteDonnee,
tableFille.ChampOrigine.TypeDonnee.TypeDotNetNatif, true);
listeFils.ModeSansTri = true; //Optimisation pour ne pas utiliser de dataview
result = tableFille.InsertDataInDataSet(
listeFils,
ds,
this,
(int[])listeIds.ToArray(typeof(int)),
attr,
elementAVariablePourFiltres,
cacheValeurs,
this,
true,
indicateur);
if (!result)
{
return(result);
}
}
else
{
result = tableFille.InsertDataInDataSet(
null,
ds,
this,
(int[])listeIds.ToArray(typeof(int)),
null,
elementAVariablePourFiltres,
cacheValeurs,
this,
true,
indicateur);
if (!result)
{
return(result);
}
}
}
return(result);
}
//-------------------------------------------------------------
public bool IsOptimisable(ITableExport table, Type typeDeMesElements)
{
return(false);
}
/// //////////////////////////////////////////////////////////////
public void AddTableFille(ITableExport table)
{
}
public static CResultAErreur GetTableSource(IElementAVariablesDynamiquesAvecContexteDonnee elt, IDefinitionJeuDonnees defDonnees, IIndicateurProgression indicateur)
{
CResultAErreur result = CResultAErreur.True;
if (!(defDonnees is CStructureExportAvecFiltre))
{
/*
* if (defDonnees is C2iRequete)
* return defDonnees.GetDonnees(elt, null, indicateur);
* if (defDonnees is CDefinitionJeuDonneesEasyQuery)
* {
* defDonnees.GetDonnees(elt, null, indicateur);
*
* }*/
result = defDonnees.GetDonnees(elt, null, indicateur);
if (result)
{
DataSet ds = result.Data as DataSet;
if (ds != null && ds.Tables.Count > 0)
{
DataTable tableOrg = ds.Tables[0];
DataTable tableRetour = tableOrg.Clone();
tableRetour.BeginLoadData();
foreach (DataRow row in tableOrg.Rows)
{
tableRetour.ImportRow(row);
}
tableRetour.EndLoadData();
result.Data = tableRetour;
}
return(result);
}
}
if (defDonnees is CStructureExportAvecFiltre)
{
C2iStructureExport structure = ((CStructureExportAvecFiltre)defDonnees).Structure;
ITableExport table = structure.Table;
List <C2iChampDeRequete> lstGroupBy = new List <C2iChampDeRequete>();
if (table is C2iTableExport)
{
bool bFirst = true;
if (table is C2iTableExport)
{
//Vérifie que toutes les tables filles sont similaires
foreach (ITableExport tableFilleTmp in table.TablesFilles)
{
if (!(tableFilleTmp is C2iTableExportCumulee))
{
result.EmpileErreur(I.T("Child tables must all be Cumulated tables|186"));
return(result);
}
C2iRequeteAvancee requete = ((C2iTableExportCumulee)tableFilleTmp).Requete;
if (bFirst)
{
foreach (C2iChampDeRequete champ in requete.Champs)
{
if (champ.GroupBy)
{
lstGroupBy.Add(champ);
}
}
}
else
{
List <C2iChampDeRequete> lst = new List <C2iChampDeRequete>();
foreach (C2iChampDeRequete champ in requete.Champs)
{
if (champ.GroupBy)
{
lst.Add(champ);
}
}
bool bErreur = false;
if (lst.Count == lstGroupBy.Count)
{
foreach (C2iChampDeRequete champ in lst)
{
if (!lstGroupBy.Contains(champ))
{
bErreur = true;
break;
}
}
}
else
{
bErreur = true;
}
if (bErreur)
{
result.EmpileErreur(I.T("All child tables must have the same 'group by' clause|286"));
return(result);
}
}
bFirst = false;
}
}
}
result = defDonnees.GetDonnees(elt, null, indicateur);
if (!result)
{
return(result);
}
DataSet ds = (DataSet)result.Data;
if (table is C2iTableExport && table.TablesFilles.Length != 0)
{
//Met à plat la table
ds.EnforceConstraints = false;
DataTable tableParent = ds.Tables[structure.Table.NomTable];
DataTable tableFille = ds.Tables[structure.Table.TablesFilles[0].NomTable];
DataRelation relation = null;
//Cherche la relation entre la table Fille et la table parente
if (tableFille != null && tableParent != null)
{
foreach (DataRelation rel in tableParent.ChildRelations)
{
if (rel.ChildTable.TableName == tableFille.TableName)
{
relation = rel;
break;
}
}
}
if (tableParent == null || tableFille == null || relation == null)
{
result.EmpileErreur(I.T("Inexpected error on exported data|187"));
return(result);
}
//Ajoute les colonnes de la table parente
List <string> strCols = new List <String>();
foreach (DataColumn col in tableParent.Columns)
{
string strNewCol = tableParent.TableName + "_" + col.ColumnName;
DataColumn newCol = tableFille.Columns.Add(strNewCol, col.DataType);
newCol.AllowDBNull = col.AllowDBNull;
strCols.Add(strNewCol);
}
//Rempli les données dans la table filles
foreach (DataRow row in tableParent.Rows)
{
object[] datas = row.ItemArray;
foreach (DataRow rowFille in row.GetChildRows(relation))
{
for (int i = 0; i < datas.Length; i++)
{
rowFille[strCols[i]] = datas[i];
}
}
}
if (table.TablesFilles.Length > 1)
{
//Plus d'1 table, ajoute les colonnes des autres tables
//Repère les lignes par group by
Hashtable tableGrpByToRow = new Hashtable();
List <string> lstNomsGroupBy = new List <string>();
foreach (DataColumn col in relation.ChildColumns)
{
lstNomsGroupBy.Add(col.ColumnName);
}
foreach (C2iChampDeRequete champ in lstGroupBy)
{
lstNomsGroupBy.Add(champ.NomChamp);
}
foreach (DataRow row in tableFille.Rows)
{
tableGrpByToRow[GetCleLigne(row, lstNomsGroupBy)] = row;
}
//Ajoute les données des tables filles
for (int nTableFille = 1; nTableFille < table.TablesFilles.Length; nTableFille++)
{
//Crée la liste des champs groupBy
DataTable tableTmp = ds.Tables[structure.Table.TablesFilles[nTableFille].NomTable];
lstNomsGroupBy.Clear();
foreach (DataColumn col in tableTmp.ParentRelations[0].ChildColumns)
{
lstNomsGroupBy.Add(col.ColumnName);
}
foreach (C2iChampDeRequete champ in lstGroupBy)
{
lstNomsGroupBy.Add(champ.NomChamp);
}
//AJoute les colonnes
foreach (DataColumn col in tableTmp.Columns)
{
if (!col.AutoIncrement && !tableFille.Columns.Contains(col.ColumnName))
{
tableFille.Columns.Add(col.ColumnName, col.DataType);
}
}
foreach (DataRow row in tableTmp.Rows)
{
DataRow rowDest = (DataRow)tableGrpByToRow[GetCleLigne(row, lstNomsGroupBy)];
if (rowDest == null)
{
rowDest = tableFille.NewRow();
//copie les valeurs parentes sur la nouvelle row
DataRow rowParente = row.GetParentRow(tableTmp.ParentRelations[0]);
foreach (DataColumn col in rowParente.Table.Columns)
{
string strCol = tableParent.TableName + "_" + col.ColumnName;
if (tableFille.Columns[strCol] != null)
{
rowDest[strCol] = rowParente[col.ColumnName];
}
}
tableGrpByToRow[GetCleLigne(row, lstNomsGroupBy)] = rowDest;
}
foreach (DataColumn col in tableTmp.Columns)
{
if (tableFille.Columns.Contains(col.ColumnName))
{
rowDest[col.ColumnName] = row[col];
}
}
if (rowDest.RowState == DataRowState.Detached)
{
tableFille.Rows.Add(rowDest);
}
}
}
}
result.Data = tableFille;
}
else
{
result.Data = ds.Tables[table.NomTable];
}
return(result);
}
return(result);
}
//----------------------------------------------------------------------------------
public CResultAErreur Serialize(C2iSerializer serializer)
{
int nVersion = GetNumVersion();
CResultAErreur result = serializer.TraiteVersion(ref nVersion);
if (!result)
{
return(result);
}
serializer.TraiteType(ref m_typeSource);
if (serializer.Mode == ModeSerialisation.Ecriture && !m_bIsStructureComplexe)
{
RenommeNomTablesSimples();
}
I2iSerializable obj = m_table;
result = serializer.TraiteObject(ref obj);
if (!result)
{
return(result);
}
m_table = (ITableExport)obj;
if (m_table != null)
{
m_table.TypeSource = TypeSource;
}
if (nVersion > 0)
{
serializer.TraiteBool(ref m_bIsStructureComplexe);
}
else
{
m_bIsStructureComplexe = true;
}
if (nVersion > 1)
{
serializer.TraiteBool(ref m_bTraitementSurServeur);
}
else
{
m_bTraitementSurServeur = true;
}
if (nVersion > 2)
{
result = serializer.TraiteArrayListOf2iSerializable(m_listeTablesAutonomes);
}
if (nVersion < 4 && serializer.Mode == ModeSerialisation.Lecture)
{
RenommeNomTablesSimples();
}
return(result);
}
//----------------------------------------------------------------------------------
public C2iStructureExport()
{
m_table = new C2iTableExport();
}
/// /////////////////////////////////////////////////////////
public void RemoveTableFille(ITableExport table)
{
m_listeTables.Remove(table);
}
//----------------------------------------------------------------------------------
public CResultAErreur CreateTableComplexeInDataset(bool bAvecOptim, Type typeSource, ITableExport tableExport, DataSet ds, DataColumn colParente)
{
CResultAErreur result = CResultAErreur.True;
if (ds.Tables.Contains(tableExport.NomTable))
{
return(result);
}
DataTable table = new DataTable(tableExport.NomTable);
DataColumn colKey = CreateChampInTableAIdAuto(table, 1);
tableExport.InsertColonnesInTable(table);
ds.Tables.Add(table);
foreach (ITableExport tbl in tableExport.TablesFilles)
{
bool bAvecOptimForTable = bAvecOptim && tableExport.IsOptimisable(tbl, typeSource);
if (tbl.ChampOrigine != null)
{
result = CreateTableComplexeInDataset(bAvecOptimForTable, tbl.ChampOrigine.TypeDonnee.TypeDotNetNatif, tbl, ds, colKey);
}
else
{
result = CreateTableComplexeInDataset(bAvecOptimForTable, null, tbl, ds, colKey);
}
if (!result)
{
return(result);
}
//Gestion des relations filles et relations parentes
if (tbl.ChampOrigine != null && (tbl.ChampOrigine.TypeDonnee.IsArrayOfTypeNatif || !bAvecOptimForTable ||
tbl.ChampOrigine is CDefinitionProprieteDynamiqueThis))
{
CreateForeignKeyInTable(table.PrimaryKey[0], ds.Tables[tbl.NomTable], 1);
}
else
{
CreateForeignKeyInTable(ds.Tables[tbl.NomTable].PrimaryKey[0], table, 1);
}
}
return(result);
}
