private int GetParameterValueSize()
{
NativeDBType dbType = NativeDBType;
Type dataType = dbType.dataType;
object value = GetParameterValue();
if (typeof(string) == dataType)
{
if (value is String)
{
if (NativeDBType.STR == dbType.wType)
{
// CONSIDER: doing slow method to compute correct ansi length
// user work-around is to specify a size
return(((String)value).Length * 2); // MDAC 69865
}
return(((String)value).Length); // MDAC 69865
}
}
else if ((typeof(byte[]) == dataType) && (value is byte[]))
{
return(((Byte[])value).Length); // MDAC 69865
}
return(0);
}
private static object CoerceValue(object value, NativeDBType destinationType)
{
if (((value != null) && (DBNull.Value != value)) && (typeof(object) != destinationType.dataType))
{
Type type = value.GetType();
if (!(type != destinationType.dataType))
{
return(value);
}
try
{
if ((typeof(string) == destinationType.dataType) && (typeof(char[]) == type))
{
return(value);
}
if ((6 == destinationType.dbType) && (typeof(string) == type))
{
value = decimal.Parse((string)value, NumberStyles.Currency, null);
return(value);
}
value = Convert.ChangeType(value, destinationType.dataType, null);
}
catch (Exception exception)
{
if (!ADP.IsCatchableExceptionType(exception))
{
throw;
}
throw ADP.ParameterConversionFailed(value, destinationType.dataType, exception);
}
}
return(value);
}
private static object CoerceValue(object value, NativeDBType destinationType)
{
Debug.Assert(null != destinationType, "null destinationType");
if ((null != value) && (DBNull.Value != value) && (typeof(object) != destinationType.dataType))
{
Type currentType = value.GetType();
if (currentType != destinationType.dataType)
{
try {
if ((typeof(string) == destinationType.dataType) && (typeof(char[]) == currentType))
{
}
else if ((NativeDBType.CY == destinationType.dbType) && (typeof(string) == currentType))
{
value = Decimal.Parse((string)value, NumberStyles.Currency, (IFormatProvider)null); // WebData 99376
}
else
{
value = Convert.ChangeType(value, destinationType.dataType, (IFormatProvider)null);
}
}
catch (Exception e) {
//
if (!ADP.IsCatchableExceptionType(e))
{
throw;
}
throw ADP.ParameterConversionFailed(value, destinationType.dataType, e); // WebData 75433
}
}
}
return(value);
}
public void ResetOleDbType()
{
if (this._metaType != null)
{
this.PropertyTypeChanging();
this._metaType = null;
}
}
public void ResetOleDbType()
{
if (null != _metaType)
{
PropertyTypeChanging();
_metaType = null;
}
}
internal bool IsParameterComputed()
{
NativeDBType metaType = _metaType;
return((null == metaType) ||
(!ShouldSerializeSize() && metaType.IsVariableLength) ||
((NativeDBType.DECIMAL == metaType.dbType) || (NativeDBType.NUMERIC == metaType.dbType) &&
(!ShouldSerializeScale() || !ShouldSerializePrecision())
)
); // MDAC 69299
}
internal bool BindParameter(int i, DBBindings bindings, UnsafeNativeMethods.tagDBPARAMBINDINFO[] bindInfo)
{
ValidateParameter();
int wtype = NativeDBType.wType;
int maxLen = GetParameterByteCount();
NativeDBType dbType = NativeDBType;
if (dbType.islong || (IsParameterVarLength() && (ODB.LargeDataSize < maxLen)))
{
maxLen = IntPtr.Size;
wtype |= NativeDBType.BYREF;
}
byte precision = GetParameterPrecision();
byte scale = GetParameterScale();
bindInfo[i].pwszDataSourceType = NativeDBType.dbString;
bindInfo[i].pwszName = IntPtr.Zero;
bindInfo[i].ulParamSize = new IntPtr(GetParameterSize());
bindInfo[i].dwFlags = GetParameterFlags();
bindInfo[i].bPrecision = precision;
bindInfo[i].bScale = scale;
// tagDBBINDING info for CreateAccessor
bindings.CurrentIndex = i;
bindings.Ordinal = i + 1;
//bindings.ValueOffset = bindings.DataBufferSize; // set via MaxLen
//bindings.LengthOffset = i * sizeof_int64;
//bindings.StatusOffset = i * sizeof_int64 + sizeof_int32;
//bindings.TypeInfoPtr = 0;
//bindings.ObjectPtr = 0;
//bindings.BindExtPtr = 0;
bindings.Part = NativeDBType.dbPart;
//bindings.MemOwner = /*DBMEMOWNER_CLIENTOWNED*/0;
bindings.ParamIO = GetParameterDirection();
bindings.MaxLen = maxLen; // also increments databuffer size
//bindings.Flags = 0;
bindings.DbType = wtype;
bindings.Precision = precision;
bindings.Scale = scale;
#if DEBUG
if (AdapterSwitches.OleDbTrace.TraceVerbose)
{
ODB.Trace_Binding(i, bindings, ParameterName);
}
#endif
return(IsParameterComputed());
}
private NativeDBType GetBindType(object value)
{
NativeDBType type = this._metaType;
if (type != null)
{
return(type);
}
if (ADP.IsNull(value))
{
return(NativeDBType.Default);
}
return(NativeDBType.FromSystemType(value));
}
private NativeDBType GetBindType(object value)
{
NativeDBType dbtype = _metaType;
if (null == dbtype)
{
if (ADP.IsNull(value))
{
dbtype = OleDb.NativeDBType.Default;
}
else
{
dbtype = NativeDBType.FromSystemType(value);
}
}
return(dbtype);
}
private int GetParameterSize()
{
NativeDBType dbType = NativeDBType;
if (-1 != dbType.fixlen)
{
return(dbType.fixlen);
}
if (dbType.islong) // MDAC 80657
{
return(~0);
}
if (0 < Size)
{
return(Size);
}
if (ParameterDirection.Input == Direction) // MDAC 63571, 69475
{
object value = GetParameterValue();
if (typeof(string) == dbType.dataType)
{
if (value is String)
{
int len = ((String)value).Length;
if (NativeDBType.STR == dbType.dbType) // MDAC 63961
{
len *= 2;
}
return(len);
}
}
else if (typeof(Byte[]) == dbType.dataType)
{
if (value is Byte[])
{
return(((Byte[])value).Length);
}
}
}
return(0);
}
internal bool IsParameterComputed()
{
NativeDBType type = this._metaType;
if ((type != null) && (this.ShouldSerializeSize() || !type.IsVariableLength))
{
if (14 == type.dbType)
{
return(true);
}
if (0x83 != type.dbType)
{
return(false);
}
if (this.ShouldSerializeScale())
{
return(!this.ShouldSerializePrecision());
}
}
return(true);
}
private int GetParameterByteCount()
{
NativeDBType dbType = NativeDBType;
int tmp = dbType.fixlen; // fixed length
Debug.Assert(0 != tmp, "GetParameterByteCount: 0 length in lookup table");
if (0 >= tmp)
{
tmp = Size;
if ((0 == tmp) && (0 != (ParameterDirection.Input & Direction)))
{
tmp = GetParameterValueSize();
}
tmp = Math.Max(tmp, 0);
if (0 < tmp)
{
if (NativeDBType.STR == dbType.wType)
{
tmp = Math.Min(tmp, Int32.MaxValue - 1) + 1;
}
else if (NativeDBType.WSTR == dbType.wType)
{
tmp = Math.Min(tmp, 1073741822 /*Int32.MaxValue/2-1*/) * 2 + 2;
}
}
else if (NativeDBType.STR == dbType.wType) // allow space for null termination character
{
tmp = 1;
}
else if (NativeDBType.WSTR == dbType.wType) // allow space for null termination character
{
tmp = 2;
}
}
Debug.Assert(0 < tmp || NativeDBType.BYTES == dbType.wType, "GetParameterByteCount");
return(tmp);
}
private static object?CoerceValue(object?value, NativeDBType destinationType)
{
Debug.Assert(null != destinationType, "null destinationType");
if ((null != value) && (DBNull.Value != value) && (typeof(object) != destinationType.dataType))
{
Type currentType = value.GetType();
if (currentType != destinationType.dataType)
{
try
{
if ((typeof(string) == destinationType.dataType) && (typeof(char[]) == currentType))
{
}
else if ((NativeDBType.CY == destinationType.dbType) && (typeof(string) == currentType))
{
value = decimal.Parse((string)value, NumberStyles.Currency, null);
}
else
{
value = Convert.ChangeType(value, destinationType.dataType !, null);
}
}
catch (Exception e)
{
// UNDONE - should not be catching all exceptions!!!
if (!ADP.IsCatchableExceptionType(e))
{
throw;
}
throw ADP.ParameterConversionFailed(value, destinationType.dataType !, e);
}
}
}
return(value);
}
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);
}
public void ResetOleDbType()
{
if (this._metaType != null)
{
this.PropertyTypeChanging();
this._metaType = null;
}
}
private void PropertyTypeChanging()
{
this.PropertyChanging();
this._coerceMetaType = null;
this.CoercedValue = null;
}
private static object CoerceValue(object value, NativeDBType destinationType)
{
if (((value != null) && (DBNull.Value != value)) && (typeof(object) != destinationType.dataType))
{
Type type = value.GetType();
if (!(type != destinationType.dataType))
{
return value;
}
try
{
if ((typeof(string) == destinationType.dataType) && (typeof(char[]) == type))
{
return value;
}
if ((6 == destinationType.dbType) && (typeof(string) == type))
{
value = decimal.Parse((string) value, NumberStyles.Currency, null);
return value;
}
value = Convert.ChangeType(value, destinationType.dataType, null);
}
catch (Exception exception)
{
if (!ADP.IsCatchableExceptionType(exception))
{
throw;
}
throw ADP.ParameterConversionFailed(value, destinationType.dataType, exception);
}
}
return value;
}
internal bool BindParameter(int index, Bindings bindings)
{
int size;
int ptrSize;
byte precisionInternal;
byte scaleInternal;
object obj2 = this.Value;
NativeDBType bindType = this.GetBindType(obj2);
if (bindType.enumOleDbType == System.Data.OleDb.OleDbType.Empty)
{
throw ODB.UninitializedParameters(index, bindType.enumOleDbType);
}
this._coerceMetaType = bindType;
obj2 = CoerceValue(obj2, bindType);
this.CoercedValue = obj2;
ParameterDirection direction = this.Direction;
if (this.ShouldSerializePrecision())
{
precisionInternal = this.PrecisionInternal;
}
else
{
precisionInternal = this.ValuePrecision(obj2);
}
if (precisionInternal == 0)
{
precisionInternal = bindType.maxpre;
}
if (this.ShouldSerializeScale())
{
scaleInternal = this.ScaleInternal;
}
else
{
scaleInternal = this.ValueScale(obj2);
}
int wType = bindType.wType;
if (bindType.islong)
{
ptrSize = ADP.PtrSize;
if (this.ShouldSerializeSize())
{
size = this.Size;
}
else if (0x81 == bindType.dbType)
{
size = 0x7fffffff;
}
else if (130 == bindType.dbType)
{
size = 0x3fffffff;
}
else
{
size = 0x7fffffff;
}
wType |= 0x4000;
}
else if (bindType.IsVariableLength)
{
bool flag;
if (!this.ShouldSerializeSize() && ADP.IsDirection(this, ParameterDirection.Output))
{
throw ADP.UninitializedParameterSize(index, this._coerceMetaType.dataType);
}
if (this.ShouldSerializeSize())
{
size = this.Size;
flag = false;
}
else
{
size = this.ValueSize(obj2);
flag = true;
}
if (0 >= size)
{
if (size != 0)
{
if (-1 != size)
{
throw ADP.InvalidSizeValue(size);
}
ptrSize = ADP.PtrSize;
wType |= 0x4000;
}
else if (130 == wType)
{
ptrSize = 2;
}
else
{
ptrSize = 0;
}
}
else
{
if (130 == bindType.wType)
{
ptrSize = (Math.Min(size, 0x3ffffffe) * 2) + 2;
}
else
{
ptrSize = size;
}
if (flag && (0x81 == bindType.dbType))
{
size = Math.Min(size, 0x3ffffffe) * 2;
}
if (0x2000 < ptrSize)
{
ptrSize = ADP.PtrSize;
wType |= 0x4000;
}
}
}
else
{
ptrSize = bindType.fixlen;
size = ptrSize;
}
bindings.CurrentIndex = index;
bindings.DataSourceType = bindType.dbString.DangerousGetHandle();
bindings.Name = ADP.PtrZero;
bindings.ParamSize = new IntPtr(size);
bindings.Flags = GetBindFlags(direction);
bindings.Ordinal = (IntPtr) (index + 1);
bindings.Part = bindType.dbPart;
bindings.ParamIO = GetBindDirection(direction);
bindings.Precision = precisionInternal;
bindings.Scale = scaleInternal;
bindings.DbType = wType;
bindings.MaxLen = ptrSize;
if (Bid.AdvancedOn)
{
Bid.Trace("<oledb.struct.tagDBPARAMBINDINFO|INFO|ADV> index=%d, parameterName='%ls'\n", index, this.ParameterName);
Bid.Trace("<oledb.struct.tagDBBINDING|INFO|ADV>\n");
}
return this.IsParameterComputed();
}
private static object CoerceValue(object value, NativeDBType destinationType) {
Debug.Assert(null != destinationType, "null destinationType");
if ((null != value) && (DBNull.Value != value) && (typeof(object) != destinationType.dataType)) {
Type currentType = value.GetType();
if (currentType != destinationType.dataType) {
try {
if ((typeof(string) == destinationType.dataType) && (typeof(char[]) == currentType)) {
}
else if ((NativeDBType.CY == destinationType.dbType) && (typeof(string) == currentType)) {
value = Decimal.Parse((string)value, NumberStyles.Currency, (IFormatProvider)null); // WebData 99376
}
else {
value = Convert.ChangeType(value, destinationType.dataType, (IFormatProvider)null);
}
}
catch (Exception e) {
//
if (!ADP.IsCatchableExceptionType(e)) {
throw;
}
throw ADP.ParameterConversionFailed(value, destinationType.dataType, e); // WebData 75433
}
}
}
return value;
}
// goal: call virtual property getters only once per parameter
internal bool BindParameter(int index, Bindings bindings) {
int changeID = _changeID;
object value = Value;
NativeDBType dbtype = GetBindType(value);
if (OleDbType.Empty == dbtype.enumOleDbType) {
throw ODB.UninitializedParameters(index, dbtype.enumOleDbType);
}
_coerceMetaType = dbtype;
value = CoerceValue(value, dbtype);
CoercedValue = value;
ParameterDirection direction = Direction;
byte precision;
if (ShouldSerializePrecision()) {
precision = PrecisionInternal;
}
else {
precision = ValuePrecision(value);
}
if (0 == precision) {
precision = dbtype.maxpre;
}
byte scale;
if (ShouldSerializeScale()) {
scale = ScaleInternal;
}
else {
scale = ValueScale(value);
}
int wtype = dbtype.wType;
int bytecount, size;
if (dbtype.islong) { // long data (image, text, ntext)
bytecount = ADP.PtrSize;
if (ShouldSerializeSize()) {
size = Size;
}
else {
if (NativeDBType.STR == dbtype.dbType) {
size = Int32.MaxValue; // WebData 98940
}
else if (NativeDBType.WSTR == dbtype.dbType) {
size = Int32.MaxValue/2;
}
else {
size = Int32.MaxValue;
}
}
wtype |= NativeDBType.BYREF;
}
else if (dbtype.IsVariableLength) { // variable length data (varbinary, varchar, nvarchar)
if (!ShouldSerializeSize() && ADP.IsDirection(this, ParameterDirection.Output)) {
throw ADP.UninitializedParameterSize(index, _coerceMetaType.dataType);
}
bool computedSize;
if (ShouldSerializeSize()) {
size = Size;
computedSize = false;
}
else {
size = ValueSize(value);
computedSize = true;
}
if (0 < size) {
if (NativeDBType.WSTR == dbtype.wType) {
// maximum 0x3FFFFFFE characters, computed this way to avoid overflow exception
bytecount = Math.Min(size, 0x3FFFFFFE) * 2 + 2;
}
else {
Debug.Assert(NativeDBType.STR != dbtype.wType, "should have ANSI binding, describing is okay");
bytecount = size;
}
if (computedSize) {
if (NativeDBType.STR == dbtype.dbType) { // WebData 98140
// maximum 0x7ffffffe characters, computed this way to avoid overflow exception
size = Math.Min(size, 0x3FFFFFFE) * 2;
}
}
if (ODB.LargeDataSize < bytecount) {
bytecount = ADP.PtrSize;
wtype |= NativeDBType.BYREF;
}
}
else if (0 == size) {
if (NativeDBType.WSTR == wtype) { // allow space for null termination character
bytecount = 2;
// 0 == size, okay for (STR == dbType)
}
else {
Debug.Assert(NativeDBType.STR != dbtype.wType, "should have ANSI binding, describing is okay");
bytecount = 0;
}
}
else if (-1 == size) {
bytecount = ADP.PtrSize;
wtype |= NativeDBType.BYREF;
}
else {
throw ADP.InvalidSizeValue(size);
}
}
else { // fixed length data
bytecount = dbtype.fixlen;
size = bytecount;
}
bindings.CurrentIndex = index;
// tagDBPARAMBINDINFO info for SetParameterInfo
bindings.DataSourceType = dbtype.dbString.DangerousGetHandle(); // NOTE: This is a constant and isn't exposed publicly, so there really isn't a potential for Handle Recycling.
bindings.Name = ADP.PtrZero;
bindings.ParamSize = new IntPtr(size);
bindings.Flags = GetBindFlags(direction);
//bindings.Precision = precision;
//bindings.Scale = scale;
// tagDBBINDING info for CreateAccessor
bindings.Ordinal = (IntPtr)(index+1);
bindings.Part = dbtype.dbPart;
bindings.ParamIO = GetBindDirection(direction);
bindings.Precision = precision;
bindings.Scale = scale;
bindings.DbType = wtype;
bindings.MaxLen = bytecount; // also increments databuffer size (uses DbType)
//bindings.ValueOffset = bindings.DataBufferSize; // set via MaxLen
//bindings.LengthOffset = i * sizeof_int64;
//bindings.StatusOffset = i * sizeof_int64 + sizeof_int32;
//bindings.TypeInfoPtr = 0;
//bindings.ObjectPtr = 0;
//bindings.BindExtPtr = 0;
//bindings.MemOwner = /*DBMEMOWNER_CLIENTOWNED*/0;
//bindings.Flags = 0;
//bindings.ParameterChangeID = changeID; // bind until something changes
Debug.Assert(_changeID == changeID, "parameter has unexpectedly changed");
if (Bid.AdvancedOn) {
Bid.Trace("<oledb.struct.tagDBPARAMBINDINFO|INFO|ADV> index=%d, parameterName='%ls'\n", index, ParameterName);//, bindings.BindInfo[index]);
Bid.Trace("<oledb.struct.tagDBBINDING|INFO|ADV>\n");//, bindings.DBBinding[index]);
}
return IsParameterComputed();
}
private void PropertyTypeChanging() {
PropertyChanging();
_coerceMetaType = null;
CoercedValue = null;
}
private void PropertyTypeChanging()
{
this.PropertyChanging();
this._coerceMetaType = null;
this.CoercedValue = null;
}
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);
}
private void PropertyTypeChanging()
{
PropertyChanging();
_coerceMetaType = null;
CoercedValue = null;
}
// goal: call virtual property getters only once per parameter
internal bool BindParameter(int index, Bindings bindings)
{
int changeID = _changeID;
object value = Value;
NativeDBType dbtype = GetBindType(value);
if (OleDbType.Empty == dbtype.enumOleDbType)
{
throw ODB.UninitializedParameters(index, dbtype.enumOleDbType);
}
_coerceMetaType = dbtype;
value = CoerceValue(value, dbtype);
CoercedValue = value;
ParameterDirection direction = Direction;
byte precision;
if (ShouldSerializePrecision())
{
precision = PrecisionInternal;
}
else
{
precision = ValuePrecision(value);
}
if (0 == precision)
{
precision = dbtype.maxpre;
}
byte scale;
if (ShouldSerializeScale())
{
scale = ScaleInternal;
}
else
{
scale = ValueScale(value);
}
int wtype = dbtype.wType;
int bytecount, size;
if (dbtype.islong) // long data (image, text, ntext)
{
bytecount = ADP.PtrSize;
if (ShouldSerializeSize())
{
size = Size;
}
else
{
if (NativeDBType.STR == dbtype.dbType)
{
size = Int32.MaxValue; // WebData 98940
}
else if (NativeDBType.WSTR == dbtype.dbType)
{
size = Int32.MaxValue / 2;
}
else
{
size = Int32.MaxValue;
}
}
wtype |= NativeDBType.BYREF;
}
else if (dbtype.IsVariableLength) // variable length data (varbinary, varchar, nvarchar)
{
if (!ShouldSerializeSize() && ADP.IsDirection(this, ParameterDirection.Output))
{
throw ADP.UninitializedParameterSize(index, _coerceMetaType.dataType);
}
bool computedSize;
if (ShouldSerializeSize())
{
size = Size;
computedSize = false;
}
else
{
size = ValueSize(value);
computedSize = true;
}
if (0 < size)
{
if (NativeDBType.WSTR == dbtype.wType)
{
// maximum 0x3FFFFFFE characters, computed this way to avoid overflow exception
bytecount = Math.Min(size, 0x3FFFFFFE) * 2 + 2;
}
else
{
Debug.Assert(NativeDBType.STR != dbtype.wType, "should have ANSI binding, describing is okay");
bytecount = size;
}
if (computedSize)
{
if (NativeDBType.STR == dbtype.dbType) // WebData 98140
// maximum 0x7ffffffe characters, computed this way to avoid overflow exception
{
size = Math.Min(size, 0x3FFFFFFE) * 2;
}
}
if (ODB.LargeDataSize < bytecount)
{
bytecount = ADP.PtrSize;
wtype |= NativeDBType.BYREF;
}
}
else if (0 == size)
{
if (NativeDBType.WSTR == wtype) // allow space for null termination character
{
bytecount = 2;
// 0 == size, okay for (STR == dbType)
}
else
{
Debug.Assert(NativeDBType.STR != dbtype.wType, "should have ANSI binding, describing is okay");
bytecount = 0;
}
}
else if (-1 == size)
{
bytecount = ADP.PtrSize;
wtype |= NativeDBType.BYREF;
}
else
{
throw ADP.InvalidSizeValue(size);
}
}
else // fixed length data
{
bytecount = dbtype.fixlen;
size = bytecount;
}
bindings.CurrentIndex = index;
// tagDBPARAMBINDINFO info for SetParameterInfo
bindings.DataSourceType = dbtype.dbString.DangerousGetHandle(); // NOTE: This is a constant and isn't exposed publicly, so there really isn't a potential for Handle Recycling.
bindings.Name = ADP.PtrZero;
bindings.ParamSize = new IntPtr(size);
bindings.Flags = GetBindFlags(direction);
//bindings.Precision = precision;
//bindings.Scale = scale;
// tagDBBINDING info for CreateAccessor
bindings.Ordinal = (IntPtr)(index + 1);
bindings.Part = dbtype.dbPart;
bindings.ParamIO = GetBindDirection(direction);
bindings.Precision = precision;
bindings.Scale = scale;
bindings.DbType = wtype;
bindings.MaxLen = bytecount; // also increments databuffer size (uses DbType)
//bindings.ValueOffset = bindings.DataBufferSize; // set via MaxLen
//bindings.LengthOffset = i * sizeof_int64;
//bindings.StatusOffset = i * sizeof_int64 + sizeof_int32;
//bindings.TypeInfoPtr = 0;
//bindings.ObjectPtr = 0;
//bindings.BindExtPtr = 0;
//bindings.MemOwner = /*DBMEMOWNER_CLIENTOWNED*/0;
//bindings.Flags = 0;
//bindings.ParameterChangeID = changeID; // bind until something changes
Debug.Assert(_changeID == changeID, "parameter has unexpectedly changed");
if (Bid.AdvancedOn)
{
Bid.Trace("<oledb.struct.tagDBPARAMBINDINFO|INFO|ADV> index=%d, parameterName='%ls'\n", index, ParameterName); //, bindings.BindInfo[index]);
Bid.Trace("<oledb.struct.tagDBBINDING|INFO|ADV>\n"); //, bindings.DBBinding[index]);
}
return(IsParameterComputed());
}
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);
}
// 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);
}
public void ResetOleDbType() {
if (null != _metaType) {
PropertyTypeChanging();
_metaType = null;
}
}
// 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];
internal bool BindParameter(int index, Bindings bindings)
{
int size;
int ptrSize;
byte precisionInternal;
byte scaleInternal;
object obj2 = this.Value;
NativeDBType bindType = this.GetBindType(obj2);
if (bindType.enumOleDbType == System.Data.OleDb.OleDbType.Empty)
{
throw ODB.UninitializedParameters(index, bindType.enumOleDbType);
}
this._coerceMetaType = bindType;
obj2 = CoerceValue(obj2, bindType);
this.CoercedValue = obj2;
ParameterDirection direction = this.Direction;
if (this.ShouldSerializePrecision())
{
precisionInternal = this.PrecisionInternal;
}
else
{
precisionInternal = this.ValuePrecision(obj2);
}
if (precisionInternal == 0)
{
precisionInternal = bindType.maxpre;
}
if (this.ShouldSerializeScale())
{
scaleInternal = this.ScaleInternal;
}
else
{
scaleInternal = this.ValueScale(obj2);
}
int wType = bindType.wType;
if (bindType.islong)
{
ptrSize = ADP.PtrSize;
if (this.ShouldSerializeSize())
{
size = this.Size;
}
else if (0x81 == bindType.dbType)
{
size = 0x7fffffff;
}
else if (130 == bindType.dbType)
{
size = 0x3fffffff;
}
else
{
size = 0x7fffffff;
}
wType |= 0x4000;
}
else if (bindType.IsVariableLength)
{
bool flag;
if (!this.ShouldSerializeSize() && ADP.IsDirection(this, ParameterDirection.Output))
{
throw ADP.UninitializedParameterSize(index, this._coerceMetaType.dataType);
}
if (this.ShouldSerializeSize())
{
size = this.Size;
flag = false;
}
else
{
size = this.ValueSize(obj2);
flag = true;
}
if (0 >= size)
{
if (size != 0)
{
if (-1 != size)
{
throw ADP.InvalidSizeValue(size);
}
ptrSize = ADP.PtrSize;
wType |= 0x4000;
}
else if (130 == wType)
{
ptrSize = 2;
}
else
{
ptrSize = 0;
}
}
else
{
if (130 == bindType.wType)
{
ptrSize = (Math.Min(size, 0x3ffffffe) * 2) + 2;
}
else
{
ptrSize = size;
}
if (flag && (0x81 == bindType.dbType))
{
size = Math.Min(size, 0x3ffffffe) * 2;
}
if (0x2000 < ptrSize)
{
ptrSize = ADP.PtrSize;
wType |= 0x4000;
}
}
}
else
{
ptrSize = bindType.fixlen;
size = ptrSize;
}
bindings.CurrentIndex = index;
bindings.DataSourceType = bindType.dbString.DangerousGetHandle();
bindings.Name = ADP.PtrZero;
bindings.ParamSize = new IntPtr(size);
bindings.Flags = GetBindFlags(direction);
bindings.Ordinal = (IntPtr)(index + 1);
bindings.Part = bindType.dbPart;
bindings.ParamIO = GetBindDirection(direction);
bindings.Precision = precisionInternal;
bindings.Scale = scaleInternal;
bindings.DbType = wType;
bindings.MaxLen = ptrSize;
if (Bid.AdvancedOn)
{
Bid.Trace("<oledb.struct.tagDBPARAMBINDINFO|INFO|ADV> index=%d, parameterName='%ls'\n", index, this.ParameterName);
Bid.Trace("<oledb.struct.tagDBBINDING|INFO|ADV>\n");
}
return(this.IsParameterComputed());
}
