private static OdbcParameter[] DeriveParametersFromStoredProcedure(OdbcConnection connection, OdbcCommand command)
{
List <OdbcParameter> list = new List <OdbcParameter>();
CMDWrapper statementHandle = command.GetStatementHandle();
OdbcStatementHandle hrHandle = statementHandle.StatementHandle;
string leftQuote = connection.QuoteChar("DeriveParameters");
string[] strArray = MultipartIdentifier.ParseMultipartIdentifier(command.CommandText, leftQuote, leftQuote, '.', 4, true, "ODBC_ODBCCommandText", false);
if (strArray[3] == null)
{
strArray[3] = command.CommandText;
}
ODBC32.RetCode retcode = hrHandle.ProcedureColumns(strArray[1], strArray[2], strArray[3], null);
if (retcode != ODBC32.RetCode.SUCCESS)
{
connection.HandleError(hrHandle, retcode);
}
using (OdbcDataReader reader = new OdbcDataReader(command, statementHandle, CommandBehavior.Default))
{
reader.FirstResult();
int fieldCount = reader.FieldCount;
while (reader.Read())
{
OdbcParameter item = new OdbcParameter {
ParameterName = reader.GetString(3)
};
switch (reader.GetInt16(4))
{
case 1:
item.Direction = ParameterDirection.Input;
break;
case 2:
item.Direction = ParameterDirection.InputOutput;
break;
case 4:
item.Direction = ParameterDirection.Output;
break;
case 5:
item.Direction = ParameterDirection.ReturnValue;
break;
}
item.OdbcType = TypeMap.FromSqlType((ODBC32.SQL_TYPE)reader.GetInt16(5))._odbcType;
item.Size = reader.GetInt32(7);
switch (item.OdbcType)
{
case OdbcType.Decimal:
case OdbcType.Numeric:
item.ScaleInternal = (byte)reader.GetInt16(9);
item.PrecisionInternal = (byte)reader.GetInt16(10);
break;
}
list.Add(item);
}
}
retcode = hrHandle.CloseCursor();
return(list.ToArray());
}
private static void ThrowParse(string name, int expectedLength, bool removeQuotes = true, string leftQuotes = "[\"", string rightQuotes = "]\"", char separator = '.')
{
Exception originalException = Assert.Throws <ArgumentException>(
() =>
{
MultipartIdentifier.ParseMultipartIdentifier(name, leftQuotes, rightQuotes, separator, expectedLength, removeQuotes, "test", true);
}
);
Assert.NotNull(originalException);
}
private void ParseMultipartName()
{
if (null != _multipartName)
{
string[] parts = MultipartIdentifier.ParseMultipartIdentifier(_multipartName, "[\"", "]\"", SR.SQL_TDSParserTableName, false);
_serverName = parts[0];
_catalogName = parts[1];
_schemaName = parts[2];
_tableName = parts[3];
_multipartName = null;
}
}
private void ParseMultipartName()
{
if (this._multipartName != null)
{
string[] strArray = MultipartIdentifier.ParseMultipartIdentifier(this._multipartName, "[\"", "]\"", "SQL_TDSParserTableName", false);
this._serverName = strArray[0];
this._catalogName = strArray[1];
this._schemaName = strArray[2];
this._tableName = strArray[3];
this._multipartName = null;
}
}
private static List <string> ParsePath(string path)
{
List <string> multipartIdentifier = MultipartIdentifier.ParseMultipartIdentifier(path, "[", "]", '.');
for (int index = multipartIdentifier.Count - 1; index >= 0; --index)
{
if (multipartIdentifier[index] == null)
{
multipartIdentifier.RemoveAt(index);
}
else if (multipartIdentifier[index].Length == 0)
{
throw new ArgumentException(Strings.ObjectQuery_Span_SpanPathSyntaxError);
}
}
return(multipartIdentifier);
}
private static List <string> ParsePath(string path)
{
var navigations = MultipartIdentifier.ParseMultipartIdentifier(path, "[", "]", '.');
for (var i = navigations.Count - 1; i >= 0; i--)
{
if (navigations[i] == null)
{
navigations.RemoveAt(i);
}
else if (navigations[i].Length == 0)
{
throw new ArgumentException(Strings.ObjectQuery_Span_SpanPathSyntaxError);
}
}
Debug.Assert(navigations.Count > 0, "Empty path found");
return(navigations);
}
private static void ThrowParse <TException>(string name, string[] expected, bool removeQuotes = true, string leftQuotes = "[\"", string rightQuotes = "]\"", char separator = '.')
where TException : Exception
{
int maxCount = 0;
for (int index = 0; index < expected.Length; index++)
{
if (expected[index] != null)
{
maxCount += 1;
}
}
Exception originalException = Assert.Throws <TException>(() =>
MultipartIdentifier.ParseMultipartIdentifier(name, leftQuotes, rightQuotes, separator, maxCount, removeQuotes, "", true)
);
Assert.NotNull(originalException);
}
private static List <string> ParsePath(string path)
{
List <string> navigations = MultipartIdentifier.ParseMultipartIdentifier(path, "[", "]", '.');
for (int i = navigations.Count - 1; i >= 0; i--)
{
if (navigations[i] == null)
{
navigations.RemoveAt(i);
}
else if (navigations[i].Length == 0)
{
throw EntityUtil.SpanPathSyntaxError();
}
}
Debug.Assert(navigations.Count > 0, "Empty path found");
return(navigations);
}
private static void RunParse(string name, string[] expected, bool removeQuotes = true, int maxCount = 0)
{
if (maxCount == 0)
{
for (int index = 0; index < expected.Length; index++)
{
if (expected[index] != null)
{
maxCount += 1;
}
}
}
string[] originalParts = MultipartIdentifier.ParseMultipartIdentifier(name, "[\"", "]\"", '.', maxCount, removeQuotes, "", true);
for (int index = 0; index < expected.Length; index++)
{
string expectedPart = expected[index];
string originalPart = originalParts[index];
Assert.Equal(expectedPart, originalPart);
}
}
// 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];
// DeriveParametersFromStoredProcedure (
// OdbcConnection connection,
// OdbcCommand command);
//
// Uses SQLProcedureColumns to create an array of OdbcParameters
//
static private OdbcParameter[] DeriveParametersFromStoredProcedure(OdbcConnection connection, OdbcCommand command)
{
List <OdbcParameter> rParams = new List <OdbcParameter>();
// following call ensures that the command has a statement handle allocated
CMDWrapper cmdWrapper = command.GetStatementHandle();
OdbcStatementHandle hstmt = cmdWrapper.StatementHandle;
int cColsAffected;
// maps an enforced 4-part qualified string as follows
// parts[0] = null - ignored but removal would be a run-time breaking change from V1.0
// parts[1] = CatalogName (optional, may be null)
// parts[2] = SchemaName (optional, may be null)
// parts[3] = ProcedureName
//
string quote = connection.QuoteChar(ADP.DeriveParameters);
string[] parts = MultipartIdentifier.ParseMultipartIdentifier(command.CommandText, quote, quote, '.', 4, true, Res.ODBC_ODBCCommandText, false);
if (null == parts[3])
{ // match Everett behavior, if the commandtext is nothing but whitespace set the command text to the whitespace
parts[3] = command.CommandText;
}
// note: native odbc appears to ignore all but the procedure name
ODBC32.RetCode retcode = hstmt.ProcedureColumns(parts[1], parts[2], parts[3], null);
// Note: the driver does not return an error if the given stored procedure does not exist
// therefore we cannot handle that case and just return not parameters.
if (ODBC32.RetCode.SUCCESS != retcode)
{
connection.HandleError(hstmt, retcode);
}
using (OdbcDataReader reader = new OdbcDataReader(command, cmdWrapper, CommandBehavior.Default))
{
reader.FirstResult();
cColsAffected = reader.FieldCount;
// go through the returned rows and filter out relevant parameter data
//
while (reader.Read())
{
// devnote: column types are specified in the ODBC Programmer's Reference
// COLUMN_TYPE Smallint 16bit
// COLUMN_SIZE Integer 32bit
// DECIMAL_DIGITS Smallint 16bit
// NUM_PREC_RADIX Smallint 16bit
OdbcParameter parameter = new OdbcParameter();
parameter.ParameterName = reader.GetString(ODBC32.COLUMN_NAME - 1);
switch ((ODBC32.SQL_PARAM)reader.GetInt16(ODBC32.COLUMN_TYPE - 1))
{
case ODBC32.SQL_PARAM.INPUT:
parameter.Direction = ParameterDirection.Input;
break;
case ODBC32.SQL_PARAM.OUTPUT:
parameter.Direction = ParameterDirection.Output;
break;
case ODBC32.SQL_PARAM.INPUT_OUTPUT:
parameter.Direction = ParameterDirection.InputOutput;
break;
case ODBC32.SQL_PARAM.RETURN_VALUE:
parameter.Direction = ParameterDirection.ReturnValue;
break;
default:
Debug.Assert(false, "Unexpected Parametertype while DeriveParamters");
break;
}
parameter.OdbcType = TypeMap.FromSqlType((ODBC32.SQL_TYPE)reader.GetInt16(ODBC32.DATA_TYPE - 1))._odbcType;
parameter.Size = (int)reader.GetInt32(ODBC32.COLUMN_SIZE - 1);
switch (parameter.OdbcType)
{
case OdbcType.Decimal:
case OdbcType.Numeric:
parameter.ScaleInternal = (Byte)reader.GetInt16(ODBC32.DECIMAL_DIGITS - 1);
parameter.PrecisionInternal = (Byte)reader.GetInt16(ODBC32.NUM_PREC_RADIX - 1);
break;
}
rParams.Add(parameter);
}
}
retcode = hstmt.CloseCursor();
return(rParams.ToArray());;
}
// 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 BulkCopySimpleResultSet CreateAndExecuteInitialQuery()
{
string[] strArray;
try
{
strArray = MultipartIdentifier.ParseMultipartIdentifier(this.DestinationTableName, "[\"", "]\"", "SQL_BulkCopyDestinationTableName", true);
}
catch (Exception exception)
{
throw SQL.BulkLoadInvalidDestinationTable(this.DestinationTableName, exception);
}
if (ADP.IsEmpty(strArray[3]))
{
throw SQL.BulkLoadInvalidDestinationTable(this.DestinationTableName, null);
}
BulkCopySimpleResultSet bulkCopyHandler = new BulkCopySimpleResultSet();
string str3 = "select @@trancount; SET FMTONLY ON select * from " + this.DestinationTableName + " SET FMTONLY OFF ";
if (this._connection.IsShiloh)
{
string str5;
if (this._connection.IsKatmaiOrNewer)
{
str5 = "sp_tablecollations_100";
}
else if (this._connection.IsYukonOrNewer)
{
str5 = "sp_tablecollations_90";
}
else
{
str5 = "sp_tablecollations";
}
string str = strArray[3];
bool flag = (str.Length > 0) && ('#' == str[0]);
if (!ADP.IsEmpty(str))
{
str = SqlServerEscapeHelper.EscapeIdentifier(SqlServerEscapeHelper.EscapeStringAsLiteral(str));
}
string str2 = strArray[2];
if (!ADP.IsEmpty(str2))
{
str2 = SqlServerEscapeHelper.EscapeIdentifier(SqlServerEscapeHelper.EscapeStringAsLiteral(str2));
}
string str4 = strArray[1];
if (flag && ADP.IsEmpty(str4))
{
str3 = str3 + string.Format(null, "exec tempdb..{0} N'{1}.{2}'", new object[] { str5, str2, str });
}
else
{
if (!ADP.IsEmpty(str4))
{
str4 = SqlServerEscapeHelper.EscapeIdentifier(str4);
}
str3 = str3 + string.Format(null, "exec {0}..{1} N'{2}.{3}'", new object[] { str4, str5, str2, str });
}
}
Bid.Trace("<sc.SqlBulkCopy.CreateAndExecuteInitialQuery|INFO> Initial Query: '%ls' \n", str3);
this._parser.TdsExecuteSQLBatch(str3, this.BulkCopyTimeout, null, this._stateObj);
this._parser.Run(RunBehavior.UntilDone, null, null, bulkCopyHandler, this._stateObj);
return(bulkCopyHandler);
}
