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);
}
}
public ResultsetFormatter ReadDiscoverResponse(XmlReader reader, InlineErrorHandlingType inlineErrorHandling, DataTable inTable, bool schemaOnly, Dictionary <string, bool> columnsToConvertTimeFor)
{
ResultsetFormatter result;
try
{
ResultsetFormatter resultsetFormatter = SoapFormatter.ReadDiscoverResponsePrivate(reader, inlineErrorHandling, inTable, schemaOnly, columnsToConvertTimeFor);
result = resultsetFormatter;
}
catch (XmlException innerException)
{
throw new AdomdUnknownResponseException(XmlaSR.UnknownServerResponseFormat, innerException);
}
catch (IOException innerException2)
{
if (this.client != null)
{
this.client.Disconnect(false);
}
throw new AdomdConnectionException(XmlaSR.ConnectionBroken, innerException2);
}
catch (AdomdUnknownResponseException)
{
throw;
}
catch (XmlaException)
{
throw;
}
catch
{
if (this.client != null)
{
this.client.Disconnect(false);
}
throw;
}
finally
{
this.EndReceival(reader);
}
return(result);
}
public ResultsetFormatter ReadDiscoverResponse(XmlReader reader, InlineErrorHandlingType inlineErrorHandling, DataTable inTable, Dictionary <string, bool> columnsToConvertTimeFor)
{
return(this.ReadDiscoverResponse(reader, inlineErrorHandling, inTable, false, columnsToConvertTimeFor));
}
public ResultsetFormatter ReadResponse(XmlReader reader, InlineErrorHandlingType inlineErrorHandling)
{
ResultsetFormatter result;
try
{
ResultsetFormatter resultsetFormatter = null;
if (XmlaClient.IsExecuteResponseS(reader))
{
resultsetFormatter = SoapFormatter.ReadExecuteResponsePrivate(reader, inlineErrorHandling);
}
else if (XmlaClient.IsDiscoverResponseS(reader))
{
resultsetFormatter = SoapFormatter.ReadDiscoverResponsePrivate(reader, inlineErrorHandling, null, false, null);
}
else
{
if (!XmlaClient.IsEmptyResultS(reader))
{
throw new AdomdUnknownResponseException(XmlaSR.UnknownServerResponseFormat, string.Format(CultureInfo.InvariantCulture, "Expected execute or discover response, or empty result, got {0}", new object[]
{
reader.Name
}));
}
XmlaClient.ReadEmptyRootS(reader);
}
result = resultsetFormatter;
}
catch (XmlException innerException)
{
throw new AdomdUnknownResponseException(XmlaSR.UnknownServerResponseFormat, innerException);
}
catch (IOException innerException2)
{
if (this.client != null)
{
this.client.Disconnect(false);
}
throw new AdomdConnectionException(XmlaSR.ConnectionBroken, innerException2);
}
catch (AdomdUnknownResponseException)
{
throw;
}
catch (XmlaException)
{
throw;
}
catch
{
if (this.client != null)
{
this.client.Disconnect(false);
}
throw;
}
finally
{
this.EndReceival(reader);
}
return(result);
}
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);
}
private static ResultsetFormatter ReadDiscoverResponsePrivate(XmlReader reader, InlineErrorHandlingType inlineErrorHandling, DataTable inTable, bool schemaOnly, Dictionary <string, bool> columnsToConvertTimeFor)
{
XmlaClient.StartDiscoverResponseS(reader);
if (XmlaClient.IsRowsetResponseS(reader))
{
return(SoapFormatter.ReadRowsetResponsePrivate(reader, inlineErrorHandling, inTable, schemaOnly, columnsToConvertTimeFor));
}
if (!XmlaClient.IsEmptyResultS(reader))
{
throw new AdomdUnknownResponseException(XmlaSR.UnknownServerResponseFormat, string.Format("Expected rowset or empty result, got {0}", reader.Name));
}
XmlaClient.ReadEmptyRootS(reader);
XmlaClient.EndDiscoverResponseS(reader);
return(null);
}
private static ResultsetFormatter ReadExecuteResponsePrivate(XmlReader reader, InlineErrorHandlingType inlineErrorHandling)
{
XmlaClient.StartExecuteResponseS(reader);
if (XmlaClient.IsDatasetResponseS(reader))
{
return(SoapFormatter.ReadDataSetResponsePrivate(reader));
}
if (XmlaClient.IsRowsetResponseS(reader))
{
return(SoapFormatter.ReadRowsetResponsePrivate(reader, inlineErrorHandling, null, false, null));
}
if (!XmlaClient.IsEmptyResultS(reader))
{
throw new AdomdUnknownResponseException(XmlaSR.UnknownServerResponseFormat, string.Format("Expected dataset, rowset, or empty result, got {0}", reader.Name));
}
XmlaClient.ReadEmptyRootS(reader);
XmlaClient.EndExecuteResponseS(reader);
return(null);
}
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 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);
}
private static void PopulateDataset(XmlReader reader, InlineErrorHandlingType inlineErrorHandling, DataTable inTable)
{
RowsetFormatter.PopulateMultiRow(reader, FormattersHelpers.RowElement, FormattersHelpers.RowElementNamespace, inTable, inlineErrorHandling, -1);
}
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();
}
