|
static private GetMetaTypeFromSqlDbType ( SqlDbType target, bool isMultiValued ) : |
||
| target | SqlDbType | |
| isMultiValued | bool | |
| return | ||
internal void SetCharsLength(long length)
{
Debug.Assert(
SmiXetterAccessMap.IsSetterAccessValid(_metaData, SmiXetterTypeCode.XetChars));
CheckSettingOffset(length);
if (0 == length)
{
if (_isPlp)
{
Debug.Assert(!_plpUnknownSent, "A plpUnknown has already been sent before setting length to zero.");
_stateObj.Parser.WriteLong(0, _stateObj);
_plpUnknownSent = true;
}
else
{
Debug.Assert(!MetaType.GetMetaTypeFromSqlDbType(_metaData.SqlDbType, _metaData.IsMultiValued).IsLong,
"We're assuming long length types are sent as PLP. SqlDbType = " + _metaData.SqlDbType);
_stateObj.Parser.WriteShort(0, _stateObj);
}
}
if (_plpUnknownSent)
{
_stateObj.Parser.WriteInt(TdsEnums.SQL_PLP_CHUNK_TERMINATOR, _stateObj);
_plpUnknownSent = false;
}
_encoder = null;
#if DEBUG
_currentOffset = 0;
#endif
}
// Semantics for SetChars are to modify existing value, not overwrite
// Use in combination with SetLength to ensure overwriting when necessary
// valid for character types: Char, VarChar, Text, NChar, NVarChar, NText
// (NVarChar and global clr collation assumed for variants)
internal int SetChars(long fieldOffset, char[] buffer, int bufferOffset, int length)
{
Debug.Assert(
SmiXetterAccessMap.IsSetterAccessValid(_metaData, SmiXetterTypeCode.XetChars));
// ANSI types must convert to byte[] because that's the tool we have.
if (MetaDataUtilsSmi.IsAnsiType(_metaData.SqlDbType))
{
if (null == _encoder)
{
_encoder = _stateObj.Parser._defaultEncoding.GetEncoder();
}
byte[] bytes = new byte[_encoder.GetByteCount(buffer, bufferOffset, length, false)];
_encoder.GetBytes(buffer, bufferOffset, length, bytes, 0, false);
SetBytesNoOffsetHandling(fieldOffset, bytes, 0, bytes.Length);
}
else
{
CheckSettingOffset(fieldOffset);
// Send via PLP format if we can.
if (_isPlp)
{
// Handle initial PLP markers
if (!_plpUnknownSent)
{
_stateObj.Parser.WriteUnsignedLong(TdsEnums.SQL_PLP_UNKNOWNLEN, _stateObj);
_plpUnknownSent = true;
}
// Write chunk length
_stateObj.Parser.WriteInt(length * ADP.CharSize, _stateObj);
_stateObj.Parser.WriteCharArray(buffer, length, bufferOffset, _stateObj);
}
else
{
// Non-plp data must be sent in one chunk for now.
#if DEBUG
Debug.Assert(0 == _currentOffset, "SetChars doesn't yet support chunking for non-plp data: " + _currentOffset);
#endif
if (SqlDbType.Variant == _metaData.SqlDbType)
{
_stateObj.Parser.WriteSqlVariantValue(new string(buffer, bufferOffset, length), length, 0, _stateObj);
}
else
{
Debug.Assert(!MetaType.GetMetaTypeFromSqlDbType(_metaData.SqlDbType, _metaData.IsMultiValued).IsLong,
"We're assuming long length types are sent as PLP. SqlDbType = " + _metaData.SqlDbType);
_stateObj.Parser.WriteShort(length * ADP.CharSize, _stateObj);
_stateObj.Parser.WriteCharArray(buffer, length, bufferOffset, _stateObj);
}
}
}
#if DEBUG
_currentOffset += length;
#endif
return(length);
}
private void SetBytesNoOffsetHandling(long fieldOffset, byte[] buffer, int bufferOffset, int length)
{
if (_isPlp)
{
if (!_plpUnknownSent)
{
_stateObj.Parser.WriteUnsignedLong(TdsEnums.SQL_PLP_UNKNOWNLEN, _stateObj);
_plpUnknownSent = true;
}
// Write chunk length & chunk
_stateObj.Parser.WriteInt(length, _stateObj);
_stateObj.WriteByteArray(buffer, length, bufferOffset);
}
else
{
// Non-plp data must be sent in one chunk for now.
#if DEBUG
Debug.Assert(0 == _currentOffset, "SetBytes doesn't yet support chunking for non-plp data: " + _currentOffset);
#endif
Debug.Assert(!MetaType.GetMetaTypeFromSqlDbType(_metaData.SqlDbType, _metaData.IsMultiValued).IsLong,
"We're assuming long length types are sent as PLP. SqlDbType = " + _metaData.SqlDbType);
if (SqlDbType.Variant == _metaData.SqlDbType)
{
_stateObj.Parser.WriteSqlVariantHeader(4 + length, TdsEnums.SQLBIGVARBINARY, 2, _stateObj);
}
_stateObj.Parser.WriteShort(length, _stateObj);
_stateObj.WriteByteArray(buffer, length, bufferOffset);
}
}
public override Type GetProviderSpecificFieldType(int ordinal)
{
this.EnsureCanGetMetaData("GetProviderSpecificFieldType");
if (SqlDbType.Udt == this._currentMetaData[ordinal].SqlDbType)
{
return(this._currentMetaData[ordinal].Type);
}
return(MetaType.GetMetaTypeFromSqlDbType(this._currentMetaData[ordinal].SqlDbType, this._currentMetaData[ordinal].IsMultiValued).SqlType);
}
public override DataTable GetSchemaTable()
{
this.ThrowIfClosed("GetSchemaTable");
if ((this._schemaTable == null) && this.FInResults())
{
DataTable table = new DataTable("SchemaTable")
{
Locale = CultureInfo.InvariantCulture,
MinimumCapacity = this.InternalFieldCount
};
DataColumn column31 = new DataColumn(SchemaTableColumn.ColumnName, typeof(string));
DataColumn column9 = new DataColumn(SchemaTableColumn.ColumnOrdinal, typeof(int));
DataColumn column30 = new DataColumn(SchemaTableColumn.ColumnSize, typeof(int));
DataColumn column29 = new DataColumn(SchemaTableColumn.NumericPrecision, typeof(short));
DataColumn column8 = new DataColumn(SchemaTableColumn.NumericScale, typeof(short));
DataColumn column7 = new DataColumn(SchemaTableColumn.DataType, typeof(Type));
DataColumn column6 = new DataColumn(SchemaTableOptionalColumn.ProviderSpecificDataType, typeof(Type));
DataColumn column28 = new DataColumn(SchemaTableColumn.ProviderType, typeof(int));
DataColumn column27 = new DataColumn(SchemaTableColumn.NonVersionedProviderType, typeof(int));
DataColumn column5 = new DataColumn(SchemaTableColumn.IsLong, typeof(bool));
DataColumn column26 = new DataColumn(SchemaTableColumn.AllowDBNull, typeof(bool));
DataColumn column25 = new DataColumn(SchemaTableOptionalColumn.IsReadOnly, typeof(bool));
DataColumn column4 = new DataColumn(SchemaTableOptionalColumn.IsRowVersion, typeof(bool));
DataColumn column3 = new DataColumn(SchemaTableColumn.IsUnique, typeof(bool));
DataColumn column24 = new DataColumn(SchemaTableColumn.IsKey, typeof(bool));
DataColumn column23 = new DataColumn(SchemaTableOptionalColumn.IsAutoIncrement, typeof(bool));
DataColumn column22 = new DataColumn(SchemaTableOptionalColumn.IsHidden, typeof(bool));
DataColumn column21 = new DataColumn(SchemaTableOptionalColumn.BaseCatalogName, typeof(string));
DataColumn column20 = new DataColumn(SchemaTableColumn.BaseSchemaName, typeof(string));
DataColumn column19 = new DataColumn(SchemaTableColumn.BaseTableName, typeof(string));
DataColumn column2 = new DataColumn(SchemaTableColumn.BaseColumnName, typeof(string));
DataColumn column18 = new DataColumn(SchemaTableOptionalColumn.BaseServerName, typeof(string));
DataColumn column17 = new DataColumn(SchemaTableColumn.IsAliased, typeof(bool));
DataColumn column16 = new DataColumn(SchemaTableColumn.IsExpression, typeof(bool));
DataColumn column15 = new DataColumn("IsIdentity", typeof(bool));
DataColumn column = new DataColumn("DataTypeName", typeof(string));
DataColumn column14 = new DataColumn("UdtAssemblyQualifiedName", typeof(string));
DataColumn column13 = new DataColumn("XmlSchemaCollectionDatabase", typeof(string));
DataColumn column12 = new DataColumn("XmlSchemaCollectionOwningSchema", typeof(string));
DataColumn column11 = new DataColumn("XmlSchemaCollectionName", typeof(string));
DataColumn column10 = new DataColumn("IsColumnSet", typeof(bool));
column9.DefaultValue = 0;
column5.DefaultValue = false;
DataColumnCollection columns = table.Columns;
columns.Add(column31);
columns.Add(column9);
columns.Add(column30);
columns.Add(column29);
columns.Add(column8);
columns.Add(column3);
columns.Add(column24);
columns.Add(column18);
columns.Add(column21);
columns.Add(column2);
columns.Add(column20);
columns.Add(column19);
columns.Add(column7);
columns.Add(column26);
columns.Add(column28);
columns.Add(column17);
columns.Add(column16);
columns.Add(column15);
columns.Add(column23);
columns.Add(column4);
columns.Add(column22);
columns.Add(column5);
columns.Add(column25);
columns.Add(column6);
columns.Add(column);
columns.Add(column13);
columns.Add(column12);
columns.Add(column11);
columns.Add(column14);
columns.Add(column27);
columns.Add(column10);
for (int i = 0; i < this.InternalFieldCount; i++)
{
SmiQueryMetaData data = this._currentMetaData[i];
long maxLength = data.MaxLength;
MetaType metaTypeFromSqlDbType = MetaType.GetMetaTypeFromSqlDbType(data.SqlDbType, data.IsMultiValued);
if (-1L == maxLength)
{
metaTypeFromSqlDbType = MetaType.GetMaxMetaTypeFromMetaType(metaTypeFromSqlDbType);
maxLength = (metaTypeFromSqlDbType.IsSizeInCharacters && !metaTypeFromSqlDbType.IsPlp) ? ((long)0x3fffffff) : ((long)0x7fffffff);
}
DataRow row = table.NewRow();
if (SqlDbType.Decimal == data.SqlDbType)
{
maxLength = 0x11L;
}
else if (SqlDbType.Variant == data.SqlDbType)
{
maxLength = 0x1f49L;
}
row[column31] = data.Name;
row[column9] = i;
row[column30] = maxLength;
row[column28] = (int)data.SqlDbType;
row[column27] = (int)data.SqlDbType;
if (data.SqlDbType != SqlDbType.Udt)
{
row[column7] = metaTypeFromSqlDbType.ClassType;
row[column6] = metaTypeFromSqlDbType.SqlType;
}
else
{
row[column14] = data.Type.AssemblyQualifiedName;
row[column7] = data.Type;
row[column6] = data.Type;
}
byte precision = 0xff;
switch (data.SqlDbType)
{
case SqlDbType.BigInt:
case SqlDbType.DateTime:
case SqlDbType.Decimal:
case SqlDbType.Int:
case SqlDbType.Money:
case SqlDbType.SmallDateTime:
case SqlDbType.SmallInt:
case SqlDbType.SmallMoney:
case SqlDbType.TinyInt:
precision = data.Precision;
break;
case SqlDbType.Float:
precision = 15;
break;
case SqlDbType.Real:
precision = 7;
break;
default:
precision = 0xff;
break;
}
row[column29] = precision;
if (((SqlDbType.Decimal == data.SqlDbType) || (SqlDbType.Time == data.SqlDbType)) || ((SqlDbType.DateTime2 == data.SqlDbType) || (SqlDbType.DateTimeOffset == data.SqlDbType)))
{
row[column8] = data.Scale;
}
else
{
row[column8] = MetaType.GetMetaTypeFromSqlDbType(data.SqlDbType, data.IsMultiValued).Scale;
}
row[column26] = data.AllowsDBNull;
if (!data.IsAliased.IsNull)
{
row[column17] = data.IsAliased.Value;
}
if (!data.IsKey.IsNull)
{
row[column24] = data.IsKey.Value;
}
if (!data.IsHidden.IsNull)
{
row[column22] = data.IsHidden.Value;
}
if (!data.IsExpression.IsNull)
{
row[column16] = data.IsExpression.Value;
}
row[column25] = data.IsReadOnly;
row[column15] = data.IsIdentity;
row[column10] = data.IsColumnSet;
row[column23] = data.IsIdentity;
row[column5] = metaTypeFromSqlDbType.IsLong;
if (SqlDbType.Timestamp == data.SqlDbType)
{
row[column3] = true;
row[column4] = true;
}
else
{
row[column3] = false;
row[column4] = false;
}
if (!ADP.IsEmpty(data.ColumnName))
{
row[column2] = data.ColumnName;
}
else if (!ADP.IsEmpty(data.Name))
{
row[column2] = data.Name;
}
if (!ADP.IsEmpty(data.TableName))
{
row[column19] = data.TableName;
}
if (!ADP.IsEmpty(data.SchemaName))
{
row[column20] = data.SchemaName;
}
if (!ADP.IsEmpty(data.CatalogName))
{
row[column21] = data.CatalogName;
}
if (!ADP.IsEmpty(data.ServerName))
{
row[column18] = data.ServerName;
}
if (SqlDbType.Udt == data.SqlDbType)
{
row[column] = data.TypeSpecificNamePart1 + "." + data.TypeSpecificNamePart2 + "." + data.TypeSpecificNamePart3;
}
else
{
row[column] = metaTypeFromSqlDbType.TypeName;
}
if (SqlDbType.Xml == data.SqlDbType)
{
row[column13] = data.TypeSpecificNamePart1;
row[column12] = data.TypeSpecificNamePart2;
row[column11] = data.TypeSpecificNamePart3;
}
table.Rows.Add(row);
row.AcceptChanges();
}
foreach (DataColumn column32 in columns)
{
column32.ReadOnly = true;
}
this._schemaTable = table;
}
return(this._schemaTable);
}
private object ConvertValue(object value, _SqlMetaData metadata)
{
object obj2;
if (ADP.IsNull(value))
{
if (!metadata.isNullable)
{
throw SQL.BulkLoadBulkLoadNotAllowDBNull(metadata.column);
}
return(value);
}
MetaType metaType = metadata.metaType;
try
{
MetaType metaTypeFromSqlDbType;
SqlDecimal num2;
switch (metaType.NullableType)
{
case 0x22:
case 0x23:
case 0x24:
case 0x26:
case 40:
case 0x29:
case 0x2a:
case 0x2b:
case 50:
case 0x3a:
case 0x3b:
case 0x3d:
case 0x3e:
case 0x68:
case 0x6d:
case 110:
case 0x6f:
case 0xa5:
case 0xa7:
case 0xad:
case 0xaf:
metaTypeFromSqlDbType = MetaType.GetMetaTypeFromSqlDbType(metaType.SqlDbType, false);
value = SqlParameter.CoerceValue(value, metaTypeFromSqlDbType);
goto Label_0290;
case 0x62:
value = this.ValidateBulkCopyVariant(value);
goto Label_0290;
case 0x63:
case 0xef:
case 0xe7:
{
metaTypeFromSqlDbType = MetaType.GetMetaTypeFromSqlDbType(metaType.SqlDbType, false);
value = SqlParameter.CoerceValue(value, metaTypeFromSqlDbType);
int num3 = (value is string) ? ((string)value).Length : ((SqlString)value).Value.Length;
if (num3 > (metadata.length / 2))
{
throw SQL.BulkLoadStringTooLong();
}
goto Label_0290;
}
case 0x6a:
case 0x6c:
metaTypeFromSqlDbType = MetaType.GetMetaTypeFromSqlDbType(metaType.SqlDbType, false);
value = SqlParameter.CoerceValue(value, metaTypeFromSqlDbType);
if (!(value is SqlDecimal))
{
break;
}
num2 = (SqlDecimal)value;
goto Label_017D;
case 240:
if (value.GetType() != typeof(byte[]))
{
value = this._connection.GetBytes(value);
}
goto Label_0290;
case 0xf1:
if (value is XmlReader)
{
value = MetaType.GetStringFromXml((XmlReader)value);
}
goto Label_0290;
default:
throw SQL.BulkLoadCannotConvertValue(value.GetType(), metadata.metaType, null);
}
num2 = new SqlDecimal((decimal)value);
Label_017D:
if (num2.Scale != metadata.scale)
{
num2 = TdsParser.AdjustSqlDecimalScale(num2, metadata.scale);
value = num2;
}
if (num2.Precision > metadata.precision)
{
throw SQL.BulkLoadCannotConvertValue(value.GetType(), metaTypeFromSqlDbType, ADP.ParameterValueOutOfRange(num2));
}
Label_0290:
obj2 = value;
}
catch (Exception exception)
{
if (!ADP.IsCatchableExceptionType(exception))
{
throw;
}
throw SQL.BulkLoadCannotConvertValue(value.GetType(), metadata.metaType, exception);
}
return(obj2);
}
