System.Data.SqlClient.MetaType.GetMaxMetaTypeFromMetaType C# (CSharp) Method

GetMaxMetaTypeFromMetaType() static private method

static private GetMaxMetaTypeFromMetaType ( MetaType mt ) : MetaType
mt MetaType
return MetaType
        internal static MetaType GetMaxMetaTypeFromMetaType(MetaType mt)
        {
            // if we can't map it, we need to throw
            switch (mt.SqlDbType)
            {
                case SqlDbType.VarBinary:
                case SqlDbType.Binary:
                    return MetaMaxVarBinary;
                case SqlDbType.VarChar:
                case SqlDbType.Char:
                    return MetaMaxVarChar;
                case SqlDbType.NVarChar:
                case SqlDbType.NChar:
                    return MetaMaxNVarChar;
                case SqlDbType.Udt:
                    return s_metaMaxUdt;
                default:
                    return mt;
            }
        }

Usage Example

        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);
        }