private static void PopulateMultiRow(XmlReader reader, string elementName, string elementNamespace, DataTable datatable, InlineErrorHandlingType inlineErrorHandling, int parentRowIndex)
{
DataColumn parentColumn = null;
if (parentRowIndex >= 0 && datatable.Columns.Contains(datatable.TableName))
{
parentColumn = datatable.Columns[datatable.TableName];
}
while (reader.IsStartElement(elementName, elementNamespace))
{
if (reader.IsEmptyElement)
{
reader.ReadStartElement();
DataRow row = RowsetFormatter.CreateNewRow(datatable, parentColumn, parentRowIndex);
datatable.Rows.Add(row);
}
else
{
reader.ReadStartElement();
RowsetFormatter.PopulateRow(reader, datatable, inlineErrorHandling, parentRowIndex, parentColumn);
reader.ReadEndElement();
}
}
FormattersHelpers.CheckException(reader);
}
internal void PopulateIgnorableNamespaces(XmlReader reader)
{
if (!reader.IsStartElement("NamespaceCompatibility", "http://schemas.microsoft.com/analysisservices/2003/engine"))
{
this.namespacesToIgnore = null;
return;
}
this.namespacesToIgnore = new Hashtable();
DataSet dataSet = NamespacesMgr.compatibilityDataSet.Clone();
reader.ReadStartElement("NamespaceCompatibility", "http://schemas.microsoft.com/analysisservices/2003/engine");
if (!reader.IsStartElement("root", "urn:schemas-microsoft-com:xml-analysis:rowset"))
{
throw new AdomdUnknownResponseException(XmlaSR.UnknownServerResponseFormat, string.Format(CultureInfo.InvariantCulture, "Expected {0}:{1} element, got {2}", new object[]
{
"urn:schemas-microsoft-com:xml-analysis:rowset",
"root",
reader.Name
}));
}
if (reader.IsEmptyElement)
{
reader.ReadStartElement();
}
else
{
reader.ReadStartElement("root", "urn:schemas-microsoft-com:xml-analysis:rowset");
RowsetFormatter.PopulateDataset(reader, "row", "urn:schemas-microsoft-com:xml-analysis:rowset", InlineErrorHandlingType.StoreInCell, dataSet.Tables["rowsetTable"]);
DataTable dataTable = dataSet.Tables["rowsetTable"];
foreach (DataRow dataRow in dataTable.Rows)
{
string text = dataRow["Namespace"] as string;
if (text != null)
{
DataRow[] childRows = dataRow.GetChildRows("rowsetTableCompatibility");
if (childRows.Length > 0)
{
DataRow[] array = childRows;
for (int i = 0; i < array.Length; i++)
{
DataRow dataRow2 = array[i];
string a = dataRow2["ProductBranch"] as string;
object obj = dataRow2["VersionTimeStamp"];
DateTime t = (obj == null || obj is DBNull) ? DateTime.MinValue : ((DateTime)obj);
if ((a == "MicrosoftAnalysisServices" || a == "xmla") && t <= NamespacesMgr.AdomdVersionTimeStamp && !this.IsKnown(text))
{
this.namespacesToIgnore[text] = 1;
}
}
}
else if (!this.IsKnown(text))
{
this.namespacesToIgnore[text] = 1;
}
}
}
reader.ReadEndElement();
}
reader.ReadEndElement();
}
internal static void PopulateDataset(XmlReader reader, string rowElementName, string rowNamespace, InlineErrorHandlingType inlineErrorHandling, DataTable inTable)
{
DataSet dataSet = inTable.DataSet;
if (dataSet != null)
{
IEnumerator enumerator = dataSet.Tables.GetEnumerator();
{
while (enumerator.MoveNext())
{
DataTable dataTable = (DataTable)enumerator.Current;
dataTable.BeginLoadData();
}
goto IL_50;
}
}
inTable.BeginLoadData();
IL_50:
RowsetFormatter.PopulateMultiRow(reader, rowElementName, rowNamespace, inTable, inlineErrorHandling, -1);
if (dataSet != null)
{
IEnumerator enumerator2 = dataSet.Tables.GetEnumerator();
{
while (enumerator2.MoveNext())
{
DataTable dataTable2 = (DataTable)enumerator2.Current;
dataTable2.EndLoadData();
}
return;
}
}
inTable.EndLoadData();
}
public void ReadRowset(XmlReader reader, InlineErrorHandlingType inlineErrorHandling, DataTable inTable, bool doCreate, bool schemaOnly, Dictionary <string, bool> columnsToConvertTimeFor)
{
if (doCreate)
{
this.CreateDataset(reader, inlineErrorHandling == InlineErrorHandlingType.Throw || inlineErrorHandling == InlineErrorHandlingType.StoreInErrorsCollection, inTable, columnsToConvertTimeFor);
}
if (!schemaOnly)
{
RowsetFormatter.PopulateDataset(reader, inlineErrorHandling, (inTable == null) ? this.rowsetDataset.Tables["rowsetTable"] : inTable);
}
}
private static ResultsetFormatter ReadRowsetResponsePrivate(XmlReader reader, InlineErrorHandlingType inlineErrorHandling, DataTable inTable, bool schemaOnly, Dictionary <string, bool> columnsToConvertTimeFor)
{
RowsetFormatter rowsetFormatter = new RowsetFormatter();
if (reader.IsEmptyElement)
{
reader.Skip();
}
else
{
XmlaClient.StartRowsetResponseS(reader);
rowsetFormatter.ReadRowset(reader, inlineErrorHandling, inTable, inTable == null || inTable.Columns.Count <= 1, schemaOnly, columnsToConvertTimeFor);
XmlaClient.EndRowsetResponseS(reader);
}
return(rowsetFormatter);
}
public object ConstructDataSetColumnDelegate(int ordinal, string name, string theNamespace, string caption, Type type, bool isNested, object parent, string strColumnXsdType)
{
object result = parent;
DataTable dataTable;
if (parent == null)
{
dataTable = this.dataset.Tables["rowsetTable"];
}
else
{
dataTable = (parent as DataTable);
}
if (isNested)
{
DataColumn dataColumn = new DataColumn(name, typeof(int));
dataColumn.Caption = name;
dataColumn.AutoIncrement = true;
FormattersHelpers.SetColumnNamespace(dataColumn, theNamespace);
dataTable.Columns.Add(dataColumn);
string text = dataTable.TableName + name;
DataTable dataTable2;
if (!this.dataset.Tables.Contains(text))
{
dataTable2 = new DataTable(text);
dataTable2.Locale = CultureInfo.InvariantCulture;
this.dataset.Tables.Add(dataTable2);
}
else
{
dataTable2 = this.dataset.Tables[text];
}
DataColumn dataColumn2 = new DataColumn(text, typeof(int));
dataColumn2.Caption = text;
dataTable2.Columns.Add(dataColumn2);
this.dataset.Relations.Add(text, dataColumn, dataColumn2, false);
result = dataTable2;
}
else
{
RowsetFormatter.AddColumn(dataTable, name, theNamespace, caption, type, this.setColumnTypes, strColumnXsdType, this.columnsToConvertTimeFor);
}
return(result);
}
public object ConstructDataTableColumnDelegate(int ordinal, string name, string theNamespace, string caption, Type type, bool isNested, object parent, string strColumnXsdType)
{
object result = parent;
if (parent == null)
{
if (isNested)
{
DataColumn dataColumn = new DataColumn(name, typeof(int));
dataColumn.Caption = name;
dataColumn.AutoIncrement = true;
FormattersHelpers.SetColumnNamespace(dataColumn, theNamespace);
this.datatable.Columns.Add(dataColumn);
result = this.datatable;
}
else
{
RowsetFormatter.AddColumn(this.datatable, name, theNamespace, caption, type, this.setColumnTypes, strColumnXsdType, this.columnsToConvertTimeFor);
}
}
return(result);
}
internal static DataRowCollection GetRows(AdomdConnection connection, string requestType, ListDictionary restrictions)
{
RowsetFormatter rowsetFormatter = connection.IDiscoverProvider.Discover(requestType, restrictions);
return(rowsetFormatter.MainRowsetTable.Rows);
}
internal static void DiscoverNested(AdomdConnection connection, string requestType, ListDictionary restrictions, out DataSet destinationDS)
{
RowsetFormatter rowsetFormatter = connection.IDiscoverProvider.Discover(requestType, restrictions);
destinationDS = rowsetFormatter.RowsetDataset;
}
private static void PopulateRow(XmlReader reader, DataTable datatable, InlineErrorHandlingType inlineErrorHandling, int parentRowIndex, DataColumn parentColumn)
{
DataRow dataRow = RowsetFormatter.CreateNewRow(datatable, parentColumn, parentRowIndex);
while (reader.IsStartElement())
{
FormattersHelpers.CheckException(reader);
if (!FormattersHelpers.IsNullContentElement(reader))
{
string localName = reader.LocalName;
DataColumn dataColumn = datatable.Columns[localName];
if (dataColumn == null)
{
throw new AdomdUnknownResponseException(XmlaSR.UnknownServerResponseFormat, string.Format(CultureInfo.InvariantCulture, "Unknown column {0}", new object[]
{
localName
}));
}
string columnNamespace = FormattersHelpers.GetColumnNamespace(dataColumn);
if (reader.NamespaceURI == columnNamespace)
{
if (RowsetFormatter.IsNestedColumn(dataColumn))
{
DataTable dataTable = RowsetFormatter.FindNestedTable(dataColumn);
if (dataTable != null)
{
RowsetFormatter.PopulateMultiRow(reader, localName, columnNamespace, dataTable, inlineErrorHandling, (int)dataRow[dataColumn]);
}
else
{
reader.Skip();
}
}
else
{
Type elementType = FormattersHelpers.GetElementType(reader, "http://www.w3.org/2001/XMLSchema-instance", dataColumn);
bool throwOnInlineError = inlineErrorHandling == InlineErrorHandlingType.Throw;
object obj = FormattersHelpers.ReadRowsetProperty(reader, localName, columnNamespace, elementType, throwOnInlineError, elementType.IsArray && FormattersHelpers.GetColumnXsdTypeName(dataColumn) != "base64Binary", FormattersHelpers.GetConvertToLocalTime(dataColumn));
if (inlineErrorHandling == InlineErrorHandlingType.StoreInErrorsCollection)
{
XmlaError xmlaError = obj as XmlaError;
if (xmlaError == null)
{
dataRow[localName] = obj;
}
else
{
dataRow.SetColumnError(localName, xmlaError.Description);
}
}
else
{
dataRow[localName] = obj;
}
}
}
else
{
reader.Skip();
}
}
else
{
reader.Skip();
}
}
datatable.Rows.Add(dataRow);
}
private static void PopulateDataset(XmlReader reader, InlineErrorHandlingType inlineErrorHandling, DataTable inTable)
{
RowsetFormatter.PopulateMultiRow(reader, FormattersHelpers.RowElement, FormattersHelpers.RowElementNamespace, inTable, inlineErrorHandling, -1);
}
