// known difference: when getting the parameters for a sproc, the
// return value gets marked as a return value but for a sql stmt
// the return value gets marked as an output parameter.
private static OleDbParameter[] DeriveParametersFromStoredProcedure(OleDbConnection connection, OleDbCommand command)
{
OleDbParameter[] plist = Array.Empty <OleDbParameter>();
if (connection.SupportSchemaRowset(OleDbSchemaGuid.Procedure_Parameters))
{
string quotePrefix, quoteSuffix;
connection.GetLiteralQuotes(ADP.DeriveParameters, out quotePrefix, out quoteSuffix);
object?[] parsed = MultipartIdentifier.ParseMultipartIdentifier(command.CommandText, quotePrefix, quoteSuffix, '.', 4, true, SR.OLEDB_OLEDBCommandText, false);
if (null == parsed[3])
{
throw ADP.NoStoredProcedureExists(command.CommandText);
}
object?[] restrictions = new object[4];
object value;
// Parse returns an enforced 4 part array
// 0) Server - ignored but removal would be a run-time breaking change from V1.0
// 1) Catalog
// 2) Schema
// 3) ProcedureName
// Restrictions array which is passed to OleDb API expects:
// 0) Catalog
// 1) Schema
// 2) ProcedureName
// 3) ParameterName (leave null)
// Copy from Parse format to OleDb API format
Array.Copy(parsed, 1, restrictions, 0, 3);
//if (cmdConnection.IsServer_msdaora) {
// restrictions[1] = Convert.ToString(cmdConnection.UserId).ToUpper();
//}
DataTable?table = connection.GetSchemaRowset(OleDbSchemaGuid.Procedure_Parameters, restrictions);
if (null != table)
{
DataColumnCollection columns = table.Columns;
DataColumn?parameterName = null;
DataColumn?parameterDirection = null;
DataColumn?dataType = null;
DataColumn?maxLen = null;
DataColumn?numericPrecision = null;
DataColumn?numericScale = null;
DataColumn?backendtype = null;
int index = columns.IndexOf(ODB.PARAMETER_NAME);
if (-1 != index)
{
parameterName = columns[index];
}
index = columns.IndexOf(ODB.PARAMETER_TYPE);
if (-1 != index)
{
parameterDirection = columns[index];
}
index = columns.IndexOf(ODB.DATA_TYPE);
if (-1 != index)
{
dataType = columns[index];
}
index = columns.IndexOf(ODB.CHARACTER_MAXIMUM_LENGTH);
if (-1 != index)
{
maxLen = columns[index];
}
index = columns.IndexOf(ODB.NUMERIC_PRECISION);
if (-1 != index)
{
numericPrecision = columns[index];
}
index = columns.IndexOf(ODB.NUMERIC_SCALE);
if (-1 != index)
{
numericScale = columns[index];
}
index = columns.IndexOf(ODB.TYPE_NAME);
if (-1 != index)
{
backendtype = columns[index];
}
DataRow[] dataRows = table.Select(null, ODB.ORDINAL_POSITION_ASC, DataViewRowState.CurrentRows);
plist = new OleDbParameter[dataRows.Length];
for (index = 0; index < dataRows.Length; ++index)
{
DataRow dataRow = dataRows[index];
OleDbParameter parameter = new OleDbParameter();
if ((null != parameterName) && !dataRow.IsNull(parameterName, DataRowVersion.Default))
{
// $CONSIDER - not trimming the @ from the beginning but to left the designer do that
parameter.ParameterName = Convert.ToString(dataRow[parameterName, DataRowVersion.Default], CultureInfo.InvariantCulture) !.TrimStart(new char[] { '@', ' ', ':' });
}
if ((null != parameterDirection) && !dataRow.IsNull(parameterDirection, DataRowVersion.Default))
{
short direction = Convert.ToInt16(dataRow[parameterDirection, DataRowVersion.Default], CultureInfo.InvariantCulture);
parameter.Direction = ConvertToParameterDirection(direction);
}
if ((null != dataType) && !dataRow.IsNull(dataType, DataRowVersion.Default))
{
// need to ping FromDBType, otherwise WChar->WChar when the user really wants VarWChar
short wType = Convert.ToInt16(dataRow[dataType, DataRowVersion.Default], CultureInfo.InvariantCulture);
parameter.OleDbType = NativeDBType.FromDBType(wType, false, false).enumOleDbType;
}
if ((null != maxLen) && !dataRow.IsNull(maxLen, DataRowVersion.Default))
{
parameter.Size = Convert.ToInt32(dataRow[maxLen, DataRowVersion.Default], CultureInfo.InvariantCulture);
}
switch (parameter.OleDbType)
{
case OleDbType.Decimal:
case OleDbType.Numeric:
case OleDbType.VarNumeric:
if ((null != numericPrecision) && !dataRow.IsNull(numericPrecision, DataRowVersion.Default))
{
// @devnote: unguarded cast from Int16 to Byte
parameter.PrecisionInternal = (byte)Convert.ToInt16(dataRow[numericPrecision], CultureInfo.InvariantCulture);
}
if ((null != numericScale) && !dataRow.IsNull(numericScale, DataRowVersion.Default))
{
// @devnote: unguarded cast from Int16 to Byte
parameter.ScaleInternal = (byte)Convert.ToInt16(dataRow[numericScale], CultureInfo.InvariantCulture);
}
break;
case OleDbType.VarBinary:
case OleDbType.VarChar:
case OleDbType.VarWChar:
value = dataRow[backendtype !, DataRowVersion.Default];
// known difference: when getting the parameters for a sproc, the
// return value gets marked as a return value but for a sql stmt
// the return value gets marked as an output parameter.
static private OleDbParameter[] DeriveParametersFromStoredProcedure(OleDbConnection connection, OleDbCommand command)
{
OleDbParameter[] plist = new OleDbParameter[0];
if (connection.SupportSchemaRowset(OleDbSchemaGuid.Procedure_Parameters))
{
string quotePrefix, quoteSuffix;
connection.GetLiteralQuotes(ADP.DeriveParameters, out quotePrefix, out quoteSuffix);
Object[] parsed = MultipartIdentifier.ParseMultipartIdentifier(command.CommandText, quotePrefix, quoteSuffix, '.', 4, true, SR.OLEDB_OLEDBCommandText, false);
if (null == parsed[3])
{
throw ADP.NoStoredProcedureExists(command.CommandText);
}
Object[] restrictions = new object[4];
object value;
// Parse returns an enforced 4 part array
// 0) Server - ignored but removal would be a run-time breaking change from V1.0
// 1) Catalog
// 2) Schema
// 3) ProcedureName
// Restrictions array which is passed to OleDb API expects:
// 0) Catalog
// 1) Schema
// 2) ProcedureName
// 3) ParameterName (leave null)
// Copy from Parse format to OleDb API format
Array.Copy(parsed, 1, restrictions, 0, 3);
//if (cmdConnection.IsServer_msdaora) {
// restrictions[1] = Convert.ToString(cmdConnection.UserId).ToUpper();
//}
DataTable table = connection.GetSchemaRowset(OleDbSchemaGuid.Procedure_Parameters, restrictions);
if (null != table)
{
DataColumnCollection columns = table.Columns;
DataColumn parameterName = null;
DataColumn parameterDirection = null;
DataColumn dataType = null;
DataColumn maxLen = null;
DataColumn numericPrecision = null;
DataColumn numericScale = null;
DataColumn backendtype = null;
int index = columns.IndexOf(ODB.PARAMETER_NAME);
if (-1 != index)
{
parameterName = columns[index];
}
index = columns.IndexOf(ODB.PARAMETER_TYPE);
if (-1 != index)
{
parameterDirection = columns[index];
}
index = columns.IndexOf(ODB.DATA_TYPE);
if (-1 != index)
{
dataType = columns[index];
}
index = columns.IndexOf(ODB.CHARACTER_MAXIMUM_LENGTH);
if (-1 != index)
{
maxLen = columns[index];
}
index = columns.IndexOf(ODB.NUMERIC_PRECISION);
if (-1 != index)
{
numericPrecision = columns[index];
}
index = columns.IndexOf(ODB.NUMERIC_SCALE);
if (-1 != index)
{
numericScale = columns[index];
}
index = columns.IndexOf(ODB.TYPE_NAME);
if (-1 != index)
{
backendtype = columns[index];
}
DataRow[] dataRows = table.Select(null, ODB.ORDINAL_POSITION_ASC, DataViewRowState.CurrentRows);
plist = new OleDbParameter[dataRows.Length];
for (index = 0; index < dataRows.Length; ++index)
{
DataRow dataRow = dataRows[index];
OleDbParameter parameter = new OleDbParameter();
if ((null != parameterName) && !dataRow.IsNull(parameterName, DataRowVersion.Default))
{
// $CONSIDER - not trimming the @ from the beginning but to left the designer do that
parameter.ParameterName = Convert.ToString(dataRow[parameterName, DataRowVersion.Default], CultureInfo.InvariantCulture).TrimStart(new char[] { '@', ' ', ':' });
}
if ((null != parameterDirection) && !dataRow.IsNull(parameterDirection, DataRowVersion.Default))
{
short direction = Convert.ToInt16(dataRow[parameterDirection, DataRowVersion.Default], CultureInfo.InvariantCulture);
parameter.Direction = ConvertToParameterDirection(direction);
}
if ((null != dataType) && !dataRow.IsNull(dataType, DataRowVersion.Default))
{
// need to ping FromDBType, otherwise WChar->WChar when the user really wants VarWChar
short wType = Convert.ToInt16(dataRow[dataType, DataRowVersion.Default], CultureInfo.InvariantCulture);
parameter.OleDbType = NativeDBType.FromDBType(wType, false, false).enumOleDbType;
}
if ((null != maxLen) && !dataRow.IsNull(maxLen, DataRowVersion.Default))
{
parameter.Size = Convert.ToInt32(dataRow[maxLen, DataRowVersion.Default], CultureInfo.InvariantCulture);
}
switch (parameter.OleDbType)
{
case OleDbType.Decimal:
case OleDbType.Numeric:
case OleDbType.VarNumeric:
if ((null != numericPrecision) && !dataRow.IsNull(numericPrecision, DataRowVersion.Default))
{
// @devnote: unguarded cast from Int16 to Byte
parameter.PrecisionInternal = (Byte)Convert.ToInt16(dataRow[numericPrecision], CultureInfo.InvariantCulture);
}
if ((null != numericScale) && !dataRow.IsNull(numericScale, DataRowVersion.Default))
{
// @devnote: unguarded cast from Int16 to Byte
parameter.ScaleInternal = (Byte)Convert.ToInt16(dataRow[numericScale], CultureInfo.InvariantCulture);
}
break;
case OleDbType.VarBinary:
case OleDbType.VarChar:
case OleDbType.VarWChar:
value = dataRow[backendtype, DataRowVersion.Default];
if (value is string)
{
string backendtypename = ((string)value).ToLower(CultureInfo.InvariantCulture);
switch (backendtypename)
{
case "binary":
parameter.OleDbType = OleDbType.Binary;
break;
//case "varbinary":
// parameter.OleDbType = OleDbType.VarBinary;
// break;
case "image":
parameter.OleDbType = OleDbType.LongVarBinary;
break;
case "char":
parameter.OleDbType = OleDbType.Char;
break;
//case "varchar":
//case "varchar2":
// parameter.OleDbType = OleDbType.VarChar;
// break;
case "text":
parameter.OleDbType = OleDbType.LongVarChar;
break;
case "nchar":
parameter.OleDbType = OleDbType.WChar;
break;
//case "nvarchar":
// parameter.OleDbType = OleDbType.VarWChar;
case "ntext":
parameter.OleDbType = OleDbType.LongVarWChar;
break;
}
}
break;
}
//if (AdapterSwitches.OleDbSql.TraceVerbose) {
// ADP.Trace_Parameter("StoredProcedure", parameter);
//}
plist[index] = parameter;
}
}
if ((0 == plist.Length) && connection.SupportSchemaRowset(OleDbSchemaGuid.Procedures))
{
restrictions = new Object[4] {
null, null, command.CommandText, null
};
table = connection.GetSchemaRowset(OleDbSchemaGuid.Procedures, restrictions);
if (0 == table.Rows.Count)
{
throw ADP.NoStoredProcedureExists(command.CommandText);
}
}
}
else if (connection.SupportSchemaRowset(OleDbSchemaGuid.Procedures))
{
Object[] restrictions = new Object[4] {
null, null, command.CommandText, null
};
DataTable table = connection.GetSchemaRowset(OleDbSchemaGuid.Procedures, restrictions);
if (0 == table.Rows.Count)
{
throw ADP.NoStoredProcedureExists(command.CommandText);
}
// we don't ever expect a procedure with 0 parameters, they should have at least a return value
throw ODB.NoProviderSupportForSProcResetParameters(connection.Provider);
}
else
{
throw ODB.NoProviderSupportForSProcResetParameters(connection.Provider);
}
return(plist);
}
private static OleDbParameter[] DeriveParametersFromStoredProcedure(OleDbConnection connection, OleDbCommand command)
{
OleDbParameter[] parameterArray = new OleDbParameter[0];
if (connection.SupportSchemaRowset(OleDbSchemaGuid.Procedure_Parameters))
{
string str3;
string str4;
connection.GetLiteralQuotes("DeriveParameters", out str4, out str3);
object[] sourceArray = MultipartIdentifier.ParseMultipartIdentifier(command.CommandText, str4, str3, '.', 4, true, "OLEDB_OLEDBCommandText", false);
if (sourceArray[3] == null)
{
throw ADP.NoStoredProcedureExists(command.CommandText);
}
object[] destinationArray = new object[4];
Array.Copy(sourceArray, 1, destinationArray, 0, 3);
DataTable schemaRowset = connection.GetSchemaRowset(OleDbSchemaGuid.Procedure_Parameters, destinationArray);
if (schemaRowset != null)
{
DataColumnCollection columns = schemaRowset.Columns;
DataColumn column6 = null;
DataColumn column5 = null;
DataColumn column4 = null;
DataColumn column3 = null;
DataColumn column2 = null;
DataColumn column = null;
DataColumn column7 = null;
int index = columns.IndexOf("PARAMETER_NAME");
if (-1 != index)
{
column6 = columns[index];
}
index = columns.IndexOf("PARAMETER_TYPE");
if (-1 != index)
{
column5 = columns[index];
}
index = columns.IndexOf("DATA_TYPE");
if (-1 != index)
{
column4 = columns[index];
}
index = columns.IndexOf("CHARACTER_MAXIMUM_LENGTH");
if (-1 != index)
{
column3 = columns[index];
}
index = columns.IndexOf("NUMERIC_PRECISION");
if (-1 != index)
{
column2 = columns[index];
}
index = columns.IndexOf("NUMERIC_SCALE");
if (-1 != index)
{
column = columns[index];
}
index = columns.IndexOf("TYPE_NAME");
if (-1 != index)
{
column7 = columns[index];
}
DataRow[] rowArray = schemaRowset.Select(null, "ORDINAL_POSITION ASC", DataViewRowState.CurrentRows);
parameterArray = new OleDbParameter[rowArray.Length];
for (index = 0; index < rowArray.Length; index++)
{
DataRow row = rowArray[index];
OleDbParameter parameter = new OleDbParameter();
if ((column6 != null) && !row.IsNull(column6, DataRowVersion.Default))
{
parameter.ParameterName = Convert.ToString(row[column6, DataRowVersion.Default], CultureInfo.InvariantCulture).TrimStart(new char[] { '@', ' ', ':' });
}
if ((column5 != null) && !row.IsNull(column5, DataRowVersion.Default))
{
short num3 = Convert.ToInt16(row[column5, DataRowVersion.Default], CultureInfo.InvariantCulture);
parameter.Direction = ConvertToParameterDirection(num3);
}
if ((column4 != null) && !row.IsNull(column4, DataRowVersion.Default))
{
short dbType = Convert.ToInt16(row[column4, DataRowVersion.Default], CultureInfo.InvariantCulture);
parameter.OleDbType = NativeDBType.FromDBType(dbType, false, false).enumOleDbType;
}
if ((column3 != null) && !row.IsNull(column3, DataRowVersion.Default))
{
parameter.Size = Convert.ToInt32(row[column3, DataRowVersion.Default], CultureInfo.InvariantCulture);
}
switch (parameter.OleDbType)
{
case OleDbType.VarChar:
case OleDbType.VarWChar:
case OleDbType.VarBinary:
{
string str;
object obj2 = row[column7, DataRowVersion.Default];
if ((obj2 is string) && ((str = ((string)obj2).ToLower(CultureInfo.InvariantCulture)) != null))
{
if (str == "binary")
{
break;
}
if (str == "image")
{
goto Label_03B9;
}
if (str == "char")
{
goto Label_03C6;
}
if (str == "text")
{
goto Label_03D3;
}
if (str == "nchar")
{
goto Label_03E0;
}
if (str == "ntext")
{
goto Label_03ED;
}
}
goto Label_03F8;
}
case OleDbType.VarNumeric:
case OleDbType.Decimal:
case OleDbType.Numeric:
if ((column2 != null) && !row.IsNull(column2, DataRowVersion.Default))
{
parameter.PrecisionInternal = (byte)Convert.ToInt16(row[column2], CultureInfo.InvariantCulture);
}
if ((column != null) && !row.IsNull(column, DataRowVersion.Default))
{
parameter.ScaleInternal = (byte)Convert.ToInt16(row[column], CultureInfo.InvariantCulture);
}
goto Label_03F8;
default:
goto Label_03F8;
}
parameter.OleDbType = OleDbType.Binary;
goto Label_03F8;
Label_03B9:
parameter.OleDbType = OleDbType.LongVarBinary;
goto Label_03F8;
Label_03C6:
parameter.OleDbType = OleDbType.Char;
goto Label_03F8;
Label_03D3:
parameter.OleDbType = OleDbType.LongVarChar;
goto Label_03F8;
Label_03E0:
parameter.OleDbType = OleDbType.WChar;
goto Label_03F8;
Label_03ED:
parameter.OleDbType = OleDbType.LongVarWChar;
Label_03F8:
parameterArray[index] = parameter;
}
}
if ((parameterArray.Length == 0) && connection.SupportSchemaRowset(OleDbSchemaGuid.Procedures))
{
object[] objArray3 = new object[4];
objArray3[2] = command.CommandText;
destinationArray = objArray3;
if (connection.GetSchemaRowset(OleDbSchemaGuid.Procedures, destinationArray).Rows.Count == 0)
{
throw ADP.NoStoredProcedureExists(command.CommandText);
}
}
return(parameterArray);
}
if (!connection.SupportSchemaRowset(OleDbSchemaGuid.Procedures))
{
throw ODB.NoProviderSupportForSProcResetParameters(connection.Provider);
}
object[] objArray2 = new object[4];
objArray2[2] = command.CommandText;
object[] restrictions = objArray2;
if (connection.GetSchemaRowset(OleDbSchemaGuid.Procedures, restrictions).Rows.Count == 0)
{
throw ADP.NoStoredProcedureExists(command.CommandText);
}
throw ODB.NoProviderSupportForSProcResetParameters(connection.Provider);
}
private DataTable GetDataTypesTable(OleDbConnection connection)
{
// verify the existance of the table in the data set
DataTable dataTypesTable = CollectionDataSet.Tables[DbMetaDataCollectionNames.DataTypes];
if (dataTypesTable == null)
{
throw ADP.UnableToBuildCollection(DbMetaDataCollectionNames.DataTypes);
}
// copy the table filtering out any rows that don't apply to tho current version of the prrovider
dataTypesTable = CloneAndFilterCollection(DbMetaDataCollectionNames.DataTypes, null);
DataTable providerTypesTable = connection.GetOleDbSchemaTable(OleDbSchemaGuid.Provider_Types, null);
DataColumn[] targetColumns = new DataColumn[] {
dataTypesTable.Columns[DbMetaDataColumnNames.TypeName],
dataTypesTable.Columns[DbMetaDataColumnNames.ColumnSize],
dataTypesTable.Columns[DbMetaDataColumnNames.CreateParameters],
dataTypesTable.Columns[DbMetaDataColumnNames.IsAutoIncrementable],
dataTypesTable.Columns[DbMetaDataColumnNames.IsCaseSensitive],
dataTypesTable.Columns[DbMetaDataColumnNames.IsFixedLength],
dataTypesTable.Columns[DbMetaDataColumnNames.IsFixedPrecisionScale],
dataTypesTable.Columns[DbMetaDataColumnNames.IsLong],
dataTypesTable.Columns[DbMetaDataColumnNames.IsNullable],
dataTypesTable.Columns[DbMetaDataColumnNames.IsUnsigned],
dataTypesTable.Columns[DbMetaDataColumnNames.MaximumScale],
dataTypesTable.Columns[DbMetaDataColumnNames.MinimumScale],
dataTypesTable.Columns[DbMetaDataColumnNames.LiteralPrefix],
dataTypesTable.Columns[DbMetaDataColumnNames.LiteralSuffix],
dataTypesTable.Columns[OleDbMetaDataColumnNames.NativeDataType]
};
DataColumn[] sourceColumns = new DataColumn[] {
providerTypesTable.Columns["TYPE_NAME"],
providerTypesTable.Columns["COLUMN_SIZE"],
providerTypesTable.Columns["CREATE_PARAMS"],
providerTypesTable.Columns["AUTO_UNIQUE_VALUE"],
providerTypesTable.Columns["CASE_SENSITIVE"],
providerTypesTable.Columns["IS_FIXEDLENGTH"],
providerTypesTable.Columns["FIXED_PREC_SCALE"],
providerTypesTable.Columns["IS_LONG"],
providerTypesTable.Columns["IS_NULLABLE"],
providerTypesTable.Columns["UNSIGNED_ATTRIBUTE"],
providerTypesTable.Columns["MAXIMUM_SCALE"],
providerTypesTable.Columns["MINIMUM_SCALE"],
providerTypesTable.Columns["LITERAL_PREFIX"],
providerTypesTable.Columns["LITERAL_SUFFIX"],
providerTypesTable.Columns["DATA_TYPE"]
};
Debug.Assert(sourceColumns.Length == targetColumns.Length);
DataColumn isSearchable = dataTypesTable.Columns[DbMetaDataColumnNames.IsSearchable];
DataColumn isSearchableWithLike = dataTypesTable.Columns[DbMetaDataColumnNames.IsSearchableWithLike];
DataColumn providerDbType = dataTypesTable.Columns[DbMetaDataColumnNames.ProviderDbType];
DataColumn clrType = dataTypesTable.Columns[DbMetaDataColumnNames.DataType];
DataColumn isLong = dataTypesTable.Columns[DbMetaDataColumnNames.IsLong];
DataColumn isFixed = dataTypesTable.Columns[DbMetaDataColumnNames.IsFixedLength];
DataColumn sourceOleDbType = providerTypesTable.Columns["DATA_TYPE"];
DataColumn searchable = providerTypesTable.Columns["SEARCHABLE"];
foreach (DataRow sourceRow in providerTypesTable.Rows)
{
DataRow newRow = dataTypesTable.NewRow();
for (int i = 0; i < sourceColumns.Length; i++)
{
if ((sourceColumns[i] != null) && (targetColumns[i] != null))
{
newRow[targetColumns[i]] = sourceRow[sourceColumns[i]];
}
}
short nativeDataType = (short)Convert.ChangeType(sourceRow[sourceOleDbType], typeof(short), CultureInfo.InvariantCulture);
NativeDBType nativeType = NativeDBType.FromDBType(nativeDataType, (bool)newRow[isLong], (bool)newRow[isFixed]);
newRow[clrType] = nativeType.dataType.FullName;
newRow[providerDbType] = nativeType.enumOleDbType;
// searchable has to be special cased becasue it is not an eaxct mapping
if ((isSearchable != null) && (isSearchableWithLike != null) && (searchable != null))
{
newRow[isSearchable] = DBNull.Value;
newRow[isSearchableWithLike] = DBNull.Value;
if (DBNull.Value != sourceRow[searchable])
{
long searchableValue = (long)(sourceRow[searchable]);
switch (searchableValue)
{
case ODB.DB_UNSEARCHABLE:
newRow[isSearchable] = false;
newRow[isSearchableWithLike] = false;
break;
case ODB.DB_LIKE_ONLY:
newRow[isSearchable] = false;
newRow[isSearchableWithLike] = true;
break;
case ODB.DB_ALL_EXCEPT_LIKE:
newRow[isSearchable] = true;
newRow[isSearchableWithLike] = false;
break;
case ODB.DB_SEARCHABLE:
newRow[isSearchable] = true;
newRow[isSearchableWithLike] = true;
break;
}
}
}
dataTypesTable.Rows.Add(newRow);
}
dataTypesTable.AcceptChanges();
return(dataTypesTable);
}
private DataTable GetDataTypesTable(OleDbConnection connection)
{
if (base.CollectionDataSet.Tables[DbMetaDataCollectionNames.DataTypes] == null)
{
throw ADP.UnableToBuildCollection(DbMetaDataCollectionNames.DataTypes);
}
DataTable table = base.CloneAndFilterCollection(DbMetaDataCollectionNames.DataTypes, null);
DataTable oleDbSchemaTable = connection.GetOleDbSchemaTable(OleDbSchemaGuid.Provider_Types, null);
DataColumn[] columnArray4 = new DataColumn[] { table.Columns[DbMetaDataColumnNames.TypeName], table.Columns[DbMetaDataColumnNames.ColumnSize], table.Columns[DbMetaDataColumnNames.CreateParameters], table.Columns[DbMetaDataColumnNames.IsAutoIncrementable], table.Columns[DbMetaDataColumnNames.IsCaseSensitive], table.Columns[DbMetaDataColumnNames.IsFixedLength], table.Columns[DbMetaDataColumnNames.IsFixedPrecisionScale], table.Columns[DbMetaDataColumnNames.IsLong], table.Columns[DbMetaDataColumnNames.IsNullable], table.Columns[DbMetaDataColumnNames.IsUnsigned], table.Columns[DbMetaDataColumnNames.MaximumScale], table.Columns[DbMetaDataColumnNames.MinimumScale], table.Columns[DbMetaDataColumnNames.LiteralPrefix], table.Columns[DbMetaDataColumnNames.LiteralSuffix], table.Columns[OleDbMetaDataColumnNames.NativeDataType] };
DataColumn[] columnArray3 = new DataColumn[] { oleDbSchemaTable.Columns["TYPE_NAME"], oleDbSchemaTable.Columns["COLUMN_SIZE"], oleDbSchemaTable.Columns["CREATE_PARAMS"], oleDbSchemaTable.Columns["AUTO_UNIQUE_VALUE"], oleDbSchemaTable.Columns["CASE_SENSITIVE"], oleDbSchemaTable.Columns["IS_FIXEDLENGTH"], oleDbSchemaTable.Columns["FIXED_PREC_SCALE"], oleDbSchemaTable.Columns["IS_LONG"], oleDbSchemaTable.Columns["IS_NULLABLE"], oleDbSchemaTable.Columns["UNSIGNED_ATTRIBUTE"], oleDbSchemaTable.Columns["MAXIMUM_SCALE"], oleDbSchemaTable.Columns["MINIMUM_SCALE"], oleDbSchemaTable.Columns["LITERAL_PREFIX"], oleDbSchemaTable.Columns["LITERAL_SUFFIX"], oleDbSchemaTable.Columns["DATA_TYPE"] };
DataColumn column2 = table.Columns[DbMetaDataColumnNames.IsSearchable];
DataColumn column = table.Columns[DbMetaDataColumnNames.IsSearchableWithLike];
DataColumn column8 = table.Columns[DbMetaDataColumnNames.ProviderDbType];
DataColumn column7 = table.Columns[DbMetaDataColumnNames.DataType];
DataColumn column6 = table.Columns[DbMetaDataColumnNames.IsLong];
DataColumn column5 = table.Columns[DbMetaDataColumnNames.IsFixedLength];
DataColumn column4 = oleDbSchemaTable.Columns["DATA_TYPE"];
DataColumn column3 = oleDbSchemaTable.Columns["SEARCHABLE"];
foreach (DataRow row2 in oleDbSchemaTable.Rows)
{
DataRow row = table.NewRow();
for (int i = 0; i < columnArray3.Length; i++)
{
if ((columnArray3[i] != null) && (columnArray4[i] != null))
{
row[columnArray4[i]] = row2[columnArray3[i]];
}
}
short dbType = (short)Convert.ChangeType(row2[column4], typeof(short), CultureInfo.InvariantCulture);
NativeDBType type = NativeDBType.FromDBType(dbType, (bool)row[column6], (bool)row[column5]);
row[column7] = type.dataType.FullName;
row[column8] = type.enumOleDbType;
if (((column2 != null) && (column != null)) && (column3 != null))
{
row[column2] = DBNull.Value;
row[column] = DBNull.Value;
if (DBNull.Value != row2[column3])
{
long num2 = (long)row2[column3];
if ((num2 <= 4L) && (num2 >= 1L))
{
switch (((int)(num2 - 1L)))
{
case 0:
row[column2] = false;
row[column] = false;
break;
case 1:
row[column2] = false;
row[column] = true;
break;
case 2:
row[column2] = true;
row[column] = false;
break;
case 3:
row[column2] = true;
row[column] = true;
break;
}
}
}
}
table.Rows.Add(row);
}
table.AcceptChanges();
return(table);
}