mono/mcs/class/referencesource/System.Data/Microsoft/SqlServer/Server/SmiMetaData.cs

//------------------------------------------------------------------------------
// <copyright file="SmiMetaData.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
// <owner current="true" primary="true">Microsoft</owner>
// <owner current="true" primary="false">Microsoft</owner>
//------------------------------------------------------------------------------

namespace Microsoft.SqlServer.Server {

    using System;
    using System.Collections.Generic;
    using System.Diagnostics;
    using System.Data;
    using System.Data.Sql;
    using System.Data.SqlTypes;
    using System.Globalization;


    // DESIGN NOTES
    //
    //  The following classes are a tight inheritance heirarchy, and are not designed for
    //  being inherited outside of this file.  Instances are guaranteed to be immutable, and
    //  outside classes rely on this fact.
    //
    //  The various levels may not all be used outside of this file, but for clarity of purpose
    //  they are all usefull distinctions to make.
    //
    //  In general, moving lower in the type heirarchy exposes less portable values.  Thus,
    //  the root metadata can be readily shared across different (MSSQL) servers and clients,
    //  while QueryMetaData has attributes tied to a specific query, running against specific
    //  data storage on a specific server.
    //
    //  The SmiMetaData heirarchy does not do data validation on retail builds!  It will assert
    //  that the values passed to it have been validated externally, however.
    //


    // SmiMetaData
    //
    //  Root of the heirarchy.
    //  Represents the minimal amount of metadata required to represent any Sql Server datum
    //  without any references to any particular server or schema (thus, no server-specific multi-part names).
    //  It could be used to communicate solely between two disconnected clients, for instance.
    //
    //  NOTE: It currently does not contain sufficient information to describe typed XML, since we
    //      don't have a good server-independent mechanism for such.
    //
    //  This class is also used as implementation for the public SqlMetaData class.
    internal class SmiMetaData {

        private SqlDbType           _databaseType;          // Main enum that determines what is valid for other attributes.
        private long                _maxLength;             // Varies for variable-length types, others are fixed value per type
        private byte                _precision;             // Varies for SqlDbType.Decimal, others are fixed value per type
        private byte                _scale;                 // Varies for SqlDbType.Decimal, others are fixed value per type
        private long                _localeId;              // Valid only for character types, others are 0
        private SqlCompareOptions   _compareOptions;        // Valid only for character types, others are SqlCompareOptions.Default
        private Type                _clrType;               // Varies for SqlDbType.Udt, others are fixed value per type.
        private string _udtAssemblyQualifiedName;           // Valid only for UDT types when _clrType is not available
        private bool                _isMultiValued;         // Multiple instances per value? (I.e. tables, arrays)
        private IList<SmiExtendedMetaData>  _fieldMetaData;         // Metadata of fields for structured types
        private SmiMetaDataPropertyCollection _extendedProperties;  // Extended properties, Key columns, sort order, etc.

        // DevNote: For now, since the list of extended property types is small, we can handle them in a simple list.
        //  In the future, we may need to create a more performant storage & lookup mechanism, such as a hash table
        //  of lists indexed by type of property or an array of lists with a well-known index for each type.



        // Limits for attributes (SmiMetaData will assert that these limits as applicable in constructor)
        internal const long UnlimitedMaxLengthIndicator = -1;  // unlimited (except by implementation) max-length.
        internal const long MaxUnicodeCharacters = 4000;        // Maximum for limited type
        internal const long MaxANSICharacters = 8000;           // Maximum for limited type
        internal const long MaxBinaryLength = 8000;             // Maximum for limited type
        internal const int  MinPrecision = 1;       // SqlDecimal defines max precision
        internal const int  MinScale = 0;            // SqlDecimal defines max scale
        internal const int  MaxTimeScale = 7;        // Max scale for time, datetime2, and datetimeoffset
        internal static readonly DateTime MaxSmallDateTime = new DateTime(2079, 06, 06, 23, 59, 29, 998);
        internal static readonly DateTime MinSmallDateTime = new DateTime(1899, 12, 31, 23, 59, 29, 999);
        internal static readonly SqlMoney MaxSmallMoney = new SqlMoney( ( (Decimal)Int32.MaxValue ) / 10000 );
        internal static readonly SqlMoney MinSmallMoney = new SqlMoney( ( (Decimal)Int32.MinValue ) / 10000 );
        internal const SqlCompareOptions DefaultStringCompareOptions = SqlCompareOptions.IgnoreCase 
                                        | SqlCompareOptions.IgnoreKanaType | SqlCompareOptions.IgnoreWidth;
        
        internal const long MaxNameLength = 128;        // maximum length in the server is 128.
        private static readonly IList<SmiExtendedMetaData> __emptyFieldList = new List<SmiExtendedMetaData>().AsReadOnly();


        // Precision to max length lookup table
        private static byte[] __maxLenFromPrecision = new byte[] {5,5,5,5,5,5,5,5,5,9,9,9,9,9,
            9,9,9,9,9,13,13,13,13,13,13,13,13,13,17,17,17,17,17,17,17,17,17,17};

        // Scale offset to max length lookup table
        private static byte[] __maxVarTimeLenOffsetFromScale = new byte[] { 2, 2, 2, 1, 1, 0, 0, 0 };

        // Defaults
                                                                         //    SmiMetaData(SqlDbType,                  MaxLen,                     Prec, Scale,  CompareOptions)
        internal static readonly SmiMetaData DefaultBigInt               = new SmiMetaData(SqlDbType.BigInt,           8,                          19,   0,      SqlCompareOptions.None);     // SqlDbType.BigInt
        internal static readonly SmiMetaData DefaultBinary               = new SmiMetaData(SqlDbType.Binary,           1,                          0,    0,      SqlCompareOptions.None);     // SqlDbType.Binary
        internal static readonly SmiMetaData DefaultBit                  = new SmiMetaData(SqlDbType.Bit,              1,                          1,    0,      SqlCompareOptions.None);     // SqlDbType.Bit
        internal static readonly SmiMetaData DefaultChar_NoCollation     = new SmiMetaData(SqlDbType.Char,             1,                          0,    0,      DefaultStringCompareOptions);// SqlDbType.Char
        internal static readonly SmiMetaData DefaultDateTime             = new SmiMetaData(SqlDbType.DateTime,         8,                          23,   3,      SqlCompareOptions.None);     // SqlDbType.DateTime
        internal static readonly SmiMetaData DefaultDecimal              = new SmiMetaData(SqlDbType.Decimal,          9,                          18,   0,      SqlCompareOptions.None);     // SqlDbType.Decimal
        internal static readonly SmiMetaData DefaultFloat                = new SmiMetaData(SqlDbType.Float,            8,                          53,   0,      SqlCompareOptions.None);     // SqlDbType.Float
        internal static readonly SmiMetaData DefaultImage                = new SmiMetaData(SqlDbType.Image,            UnlimitedMaxLengthIndicator,0,    0,      SqlCompareOptions.None);     // SqlDbType.Image
        internal static readonly SmiMetaData DefaultInt                  = new SmiMetaData(SqlDbType.Int,              4,                          10,   0,      SqlCompareOptions.None);     // SqlDbType.Int
        internal static readonly SmiMetaData DefaultMoney                = new SmiMetaData(SqlDbType.Money,            8,                          19,   4,      SqlCompareOptions.None);     // SqlDbType.Money
        internal static readonly SmiMetaData DefaultNChar_NoCollation    = new SmiMetaData(SqlDbType.NChar,            1,                          0,    0,      DefaultStringCompareOptions);// SqlDbType.NChar
        internal static readonly SmiMetaData DefaultNText_NoCollation    = new SmiMetaData(SqlDbType.NText,            UnlimitedMaxLengthIndicator,0,    0,      DefaultStringCompareOptions);// SqlDbType.NText
        internal static readonly SmiMetaData DefaultNVarChar_NoCollation = new SmiMetaData(SqlDbType.NVarChar,         MaxUnicodeCharacters,       0,    0,      DefaultStringCompareOptions);// SqlDbType.NVarChar
        internal static readonly SmiMetaData DefaultReal                 = new SmiMetaData(SqlDbType.Real,             4,                          24,   0,      SqlCompareOptions.None);     // SqlDbType.Real
        internal static readonly SmiMetaData DefaultUniqueIdentifier     = new SmiMetaData(SqlDbType.UniqueIdentifier, 16,                         0,    0,      SqlCompareOptions.None);     // SqlDbType.UniqueIdentifier
        internal static readonly SmiMetaData DefaultSmallDateTime        = new SmiMetaData(SqlDbType.SmallDateTime,    4,                          16,   0,      SqlCompareOptions.None);     // SqlDbType.SmallDateTime
        internal static readonly SmiMetaData DefaultSmallInt             = new SmiMetaData(SqlDbType.SmallInt,         2,                          5,    0,      SqlCompareOptions.None);     // SqlDbType.SmallInt
        internal static readonly SmiMetaData DefaultSmallMoney           = new SmiMetaData(SqlDbType.SmallMoney,       4,                          10,   4,      SqlCompareOptions.None);     // SqlDbType.SmallMoney
        internal static readonly SmiMetaData DefaultText_NoCollation     = new SmiMetaData(SqlDbType.Text,             UnlimitedMaxLengthIndicator,0,    0,      DefaultStringCompareOptions);// SqlDbType.Text
        internal static readonly SmiMetaData DefaultTimestamp            = new SmiMetaData(SqlDbType.Timestamp,        8,                          0,    0,      SqlCompareOptions.None);     // SqlDbType.Timestamp
        internal static readonly SmiMetaData DefaultTinyInt              = new SmiMetaData(SqlDbType.TinyInt,          1,                          3,    0,      SqlCompareOptions.None);     // SqlDbType.TinyInt
        internal static readonly SmiMetaData DefaultVarBinary            = new SmiMetaData(SqlDbType.VarBinary,        MaxBinaryLength,            0,    0,      SqlCompareOptions.None);     // SqlDbType.VarBinary
        internal static readonly SmiMetaData DefaultVarChar_NoCollation  = new SmiMetaData(SqlDbType.VarChar,          MaxANSICharacters,          0,    0,      DefaultStringCompareOptions);// SqlDbType.VarChar
        internal static readonly SmiMetaData DefaultVariant              = new SmiMetaData(SqlDbType.Variant,          8016,                       0,    0,      SqlCompareOptions.None);     // SqlDbType.Variant
        internal static readonly SmiMetaData DefaultXml                  = new SmiMetaData(SqlDbType.Xml,              UnlimitedMaxLengthIndicator,0,    0,      DefaultStringCompareOptions);// SqlDbType.Xml
        internal static readonly SmiMetaData DefaultUdt_NoType           = new SmiMetaData(SqlDbType.Udt,              0,                          0,    0,      SqlCompareOptions.None);     // SqlDbType.Udt
        internal static readonly SmiMetaData DefaultStructured           = new SmiMetaData(SqlDbType.Structured,       0,                          0,    0,      SqlCompareOptions.None);     // SqlDbType.Structured
        internal static readonly SmiMetaData DefaultDate                 = new SmiMetaData(SqlDbType.Date,             3,                          10,   0,      SqlCompareOptions.None);     // SqlDbType.Date
        internal static readonly SmiMetaData DefaultTime                 = new SmiMetaData(SqlDbType.Time,             5,                          0,    7,      SqlCompareOptions.None);     // SqlDbType.Time
        internal static readonly SmiMetaData DefaultDateTime2            = new SmiMetaData(SqlDbType.DateTime2,        8,                          0,    7,      SqlCompareOptions.None);     // SqlDbType.DateTime2
        internal static readonly SmiMetaData DefaultDateTimeOffset       = new SmiMetaData(SqlDbType.DateTimeOffset,   10,                         0,    7,      SqlCompareOptions.None);     // SqlDbType.DateTimeOffset
        // No default for generic UDT

        // character defaults hook thread-local culture to get collation
        internal static SmiMetaData DefaultChar {
            get {
                return new SmiMetaData(
                        DefaultChar_NoCollation.SqlDbType,
                        DefaultChar_NoCollation.MaxLength,
                        DefaultChar_NoCollation.Precision,
                        DefaultChar_NoCollation.Scale,
                        System.Globalization.CultureInfo.CurrentCulture.LCID,
                        SqlCompareOptions.IgnoreCase | SqlCompareOptions.IgnoreKanaType | SqlCompareOptions.IgnoreWidth,
                        null
                        );
            }
        }

        internal static SmiMetaData DefaultNChar {
            get {
                return new SmiMetaData(
                        DefaultNChar_NoCollation.SqlDbType,
                        DefaultNChar_NoCollation.MaxLength,
                        DefaultNChar_NoCollation.Precision,
                        DefaultNChar_NoCollation.Scale,
                        System.Globalization.CultureInfo.CurrentCulture.LCID,
                        SqlCompareOptions.IgnoreCase | SqlCompareOptions.IgnoreKanaType | SqlCompareOptions.IgnoreWidth,
                        null
                        );
            }
        }

        internal static SmiMetaData DefaultNText {
            get {
                return new SmiMetaData(
                        DefaultNText_NoCollation.SqlDbType,
                        DefaultNText_NoCollation.MaxLength,
                        DefaultNText_NoCollation.Precision,
                        DefaultNText_NoCollation.Scale,
                        System.Globalization.CultureInfo.CurrentCulture.LCID,
                        SqlCompareOptions.IgnoreCase | SqlCompareOptions.IgnoreKanaType | SqlCompareOptions.IgnoreWidth,
                        null
                        );
            }
        }

        internal static SmiMetaData DefaultNVarChar {
            get {
                return new SmiMetaData(
                        DefaultNVarChar_NoCollation.SqlDbType,
                        DefaultNVarChar_NoCollation.MaxLength,
                        DefaultNVarChar_NoCollation.Precision,
                        DefaultNVarChar_NoCollation.Scale,
                        System.Globalization.CultureInfo.CurrentCulture.LCID,
                        SqlCompareOptions.IgnoreCase | SqlCompareOptions.IgnoreKanaType | SqlCompareOptions.IgnoreWidth,
                        null
                        );
            }
        }

        internal static SmiMetaData DefaultText {
            get {
                return new SmiMetaData(
                        DefaultText_NoCollation.SqlDbType,
                        DefaultText_NoCollation.MaxLength,
                        DefaultText_NoCollation.Precision,
                        DefaultText_NoCollation.Scale,
                        System.Globalization.CultureInfo.CurrentCulture.LCID,
                        SqlCompareOptions.IgnoreCase | SqlCompareOptions.IgnoreKanaType | SqlCompareOptions.IgnoreWidth,
                        null
                        );
            }
        }

        internal static SmiMetaData DefaultVarChar {
            get {
                return new SmiMetaData(
                        DefaultVarChar_NoCollation.SqlDbType,
                        DefaultVarChar_NoCollation.MaxLength,
                        DefaultVarChar_NoCollation.Precision,
                        DefaultVarChar_NoCollation.Scale,
                        System.Globalization.CultureInfo.CurrentCulture.LCID,
                        SqlCompareOptions.IgnoreCase | SqlCompareOptions.IgnoreKanaType | SqlCompareOptions.IgnoreWidth,
                        null
                        );
            }
        }

        // The one and only constructor for use by outside code.
        //
        //  Parameters that matter for given values of dbType (other parameters are ignored in favor of internal defaults).
        //  Thus, if dbType parameter value is SqlDbType.Decimal, the values of precision and scale passed in are used, but
        //  maxLength, localeId, compareOptions, etc are set to defaults for the Decimal type:
        //      SqlDbType.BigInt:               dbType
        //      SqlDbType.Binary:               dbType, maxLength
        //      SqlDbType.Bit:                  dbType
        //      SqlDbType.Char:                 dbType, maxLength, localeId, compareOptions
        //      SqlDbType.DateTime:             dbType
        //      SqlDbType.Decimal:              dbType, precision, scale
        //      SqlDbType.Float:                dbType
        //      SqlDbType.Image:                dbType
        //      SqlDbType.Int:                  dbType
        //      SqlDbType.Money:                dbType
        //      SqlDbType.NChar:                dbType, maxLength, localeId, compareOptions
        //      SqlDbType.NText:                dbType, localeId, compareOptions
        //      SqlDbType.NVarChar:             dbType, maxLength, localeId, compareOptions
        //      SqlDbType.Real:                 dbType
        //      SqlDbType.UniqueIdentifier:     dbType
        //      SqlDbType.SmallDateTime:        dbType
        //      SqlDbType.SmallInt:             dbType
        //      SqlDbType.SmallMoney:           dbType
        //      SqlDbType.Text:                 dbType, localeId, compareOptions
        //      SqlDbType.Timestamp:            dbType
        //      SqlDbType.TinyInt:              dbType
        //      SqlDbType.VarBinary:            dbType, maxLength
        //      SqlDbType.VarChar:              dbType, maxLength, localeId, compareOptions
        //      SqlDbType.Variant:              dbType
        //      PlaceHolder for value 24
        //      SqlDbType.Xml:                  dbType
        //      Placeholder for value 26
        //      Placeholder for value 27
        //      Placeholder for value 28
        //      SqlDbType.Udt:                  dbType, userDefinedType
        //

        [ObsoleteAttribute( "Not supported as of SMI v2.  Will be removed when v1 support dropped. Use ctor without columns param." )]
        internal SmiMetaData(
                                SqlDbType dbType, 
                                long maxLength,
                                byte precision, 
                                byte scale, 
                                long localeId, 
                                SqlCompareOptions compareOptions, 
                                Type userDefinedType, 
                                SmiMetaData[] columns) :
                          // Implement as calling the new ctor
                          this(
                                dbType,
                                maxLength,
                                precision,
                                scale, 
                                localeId, 
                                compareOptions, 
                                userDefinedType ) {
            Debug.Assert( null == columns, "Row types not supported" );
        }

        // SMI V100 (aka V3) constructor.  Superceded in V200.
        internal SmiMetaData(
                                SqlDbType dbType, 
                                long maxLength,
                                byte precision, 
                                byte scale, 
                                long localeId, 
                                SqlCompareOptions compareOptions, 
                                Type userDefinedType) :
                        this(   dbType,
                                maxLength,
                                precision,
                                scale,
                                localeId,
                                compareOptions,
                                userDefinedType,
                                false,
                                null, 
                                null ) {
        }

        // SMI V200 ctor.
        internal SmiMetaData(
                                SqlDbType dbType,
                                long maxLength,
                                byte precision,
                                byte scale,
                                long localeId,
                                SqlCompareOptions compareOptions,
                                Type userDefinedType,
                                bool isMultiValued,
                                IList<SmiExtendedMetaData> fieldTypes,
                                SmiMetaDataPropertyCollection extendedProperties)
            :
                        this(dbType,
                                maxLength,
                                precision,
                                scale,
                                localeId,
                                compareOptions,
                                userDefinedType,
                                null,
                                isMultiValued,
                                fieldTypes,
                                extendedProperties) {
        }

        // SMI V220 ctor.
        internal SmiMetaData(
                                SqlDbType dbType, 
                                long maxLength,
                                byte precision, 
                                byte scale, 
                                long localeId, 
                                SqlCompareOptions compareOptions, 
                                Type userDefinedType,
                                string udtAssemblyQualifiedName,
                                bool isMultiValued,
                                IList<SmiExtendedMetaData> fieldTypes,
                                SmiMetaDataPropertyCollection extendedProperties) {

            
            Debug.Assert( IsSupportedDbType(dbType), "Invalid SqlDbType: " + dbType );

            SetDefaultsForType( dbType );
            
            // 

            
            switch ( dbType ) {
                case SqlDbType.BigInt:
                case SqlDbType.Bit:
                case SqlDbType.DateTime:
                case SqlDbType.Float:
                case SqlDbType.Image:
                case SqlDbType.Int:
                case SqlDbType.Money:
                case SqlDbType.Real:
                case SqlDbType.SmallDateTime:
                case SqlDbType.SmallInt:
                case SqlDbType.SmallMoney:
                case SqlDbType.Timestamp:
                case SqlDbType.TinyInt:
                case SqlDbType.UniqueIdentifier:
                case SqlDbType.Variant:
                case SqlDbType.Xml:
                case SqlDbType.Date:
                    break;
                case SqlDbType.Binary:
                case SqlDbType.VarBinary:
                    _maxLength = maxLength;
                    break;
                case SqlDbType.Char:
                case SqlDbType.NChar:
                case SqlDbType.NVarChar:
                case SqlDbType.VarChar:
                    // locale and compare options are not validated until they get to the server
                    _maxLength = maxLength;
                    _localeId = localeId;
                    _compareOptions = compareOptions;
                    break;
                case SqlDbType.NText:
                case SqlDbType.Text:
                    _localeId = localeId;
                    _compareOptions = compareOptions;
                    break;
                case SqlDbType.Decimal:
                    Debug.Assert( MinPrecision <= precision && SqlDecimal.MaxPrecision >= precision, "Invalid precision: " + precision );
                    Debug.Assert( MinScale <= scale && SqlDecimal.MaxScale >= scale, "Invalid scale: " + scale );
                    Debug.Assert( scale <= precision, "Precision: " + precision + " greater than scale: " + scale );
                    _precision = precision;
                    _scale = scale;
                    _maxLength = __maxLenFromPrecision[precision - 1];
                    break;
                case SqlDbType.Udt:
                    // Assert modified for VSFTDEVDIV479492 - for SqlParameter both userDefinedType and udtAssemblyQualifiedName
                    // can be NULL, we are checking only maxLength if it will be used (i.e. userDefinedType is NULL)
                    Debug.Assert((null != userDefinedType) || (0 <= maxLength || UnlimitedMaxLengthIndicator == maxLength),
                            String.Format((IFormatProvider)null, "SmiMetaData.ctor: Udt name={0}, maxLength={1}", udtAssemblyQualifiedName, maxLength));
                    // Type not validated until matched to a server.  Could be null if extended metadata supplies three-part name!
                    _clrType = userDefinedType;
                    if (null != userDefinedType) {
                        _maxLength = SerializationHelperSql9.GetUdtMaxLength(userDefinedType);
                    }
                    else {
                        _maxLength = maxLength;
                    }
                    _udtAssemblyQualifiedName = udtAssemblyQualifiedName;
                    break;
                case SqlDbType.Structured:
                    if (null != fieldTypes) {
                        _fieldMetaData = (new List<SmiExtendedMetaData>(fieldTypes)).AsReadOnly();
                    }
                    _isMultiValued = isMultiValued;
                    _maxLength = _fieldMetaData.Count;
                    break;
                case SqlDbType.Time:
                    Debug.Assert(MinScale <= scale && scale <= MaxTimeScale, "Invalid time scale: " + scale);
                    _scale = scale;
                    _maxLength = 5 - __maxVarTimeLenOffsetFromScale[scale];
                    break;
                case SqlDbType.DateTime2:
                    Debug.Assert(MinScale <= scale && scale <= MaxTimeScale, "Invalid time scale: " + scale);
                    _scale = scale;
                    _maxLength = 8 - __maxVarTimeLenOffsetFromScale[scale];
                    break;
                case SqlDbType.DateTimeOffset:
                    Debug.Assert(MinScale <= scale && scale <= MaxTimeScale, "Invalid time scale: " + scale);
                    _scale = scale;
                    _maxLength = 10 - __maxVarTimeLenOffsetFromScale[scale];
                    break;
                default:
                    Debug.Assert( false, "How in the world did we get here? :" + dbType );
                    break;
            }

            if (null != extendedProperties) {
                extendedProperties.SetReadOnly();
                _extendedProperties = extendedProperties;
            }

            // properties and fields must meet the following conditions at this point:
            //  1) not null
            //  2) read only
            //  3) same number of columns in each list (0 count acceptable for properties that are "unused")
            Debug.Assert(null != _extendedProperties && _extendedProperties.IsReadOnly, "SmiMetaData.ctor: _extendedProperties is " + (null!=_extendedProperties?"writeable":"null"));
            Debug.Assert(null != _fieldMetaData && _fieldMetaData.IsReadOnly, "SmiMetaData.ctor: _fieldMetaData is " + (null!=_fieldMetaData?"writeable":"null"));
#if DEBUG
            ((SmiDefaultFieldsProperty)_extendedProperties[SmiPropertySelector.DefaultFields]).CheckCount(_fieldMetaData.Count);
            ((SmiOrderProperty)_extendedProperties[SmiPropertySelector.SortOrder]).CheckCount(_fieldMetaData.Count);
            ((SmiUniqueKeyProperty)_extendedProperties[SmiPropertySelector.UniqueKey]).CheckCount(_fieldMetaData.Count);
#endif
        }


        internal bool IsValidMaxLengthForCtorGivenType( SqlDbType dbType, long maxLength ) {
            bool result = true;
            switch( dbType ) {
                case SqlDbType.BigInt:
                case SqlDbType.Bit:
                case SqlDbType.DateTime:
                case SqlDbType.Float:
                case SqlDbType.Image:
                case SqlDbType.Int:
                case SqlDbType.Money:
                case SqlDbType.Real:
                case SqlDbType.SmallDateTime:
                case SqlDbType.SmallInt:
                case SqlDbType.SmallMoney:
                case SqlDbType.Timestamp:
                case SqlDbType.TinyInt:
                case SqlDbType.UniqueIdentifier:
                case SqlDbType.Variant:
                case SqlDbType.Xml:
                case SqlDbType.NText:
                case SqlDbType.Text:
                case SqlDbType.Decimal:
                case SqlDbType.Udt:
                case SqlDbType.Structured:  // 
                case SqlDbType.Date:
                case SqlDbType.Time:
                case SqlDbType.DateTime2:
                case SqlDbType.DateTimeOffset:
                    break;
                case SqlDbType.Binary:
                    result = 0 < maxLength && MaxBinaryLength >= maxLength;
                    break;
                case SqlDbType.VarBinary:
                    result = UnlimitedMaxLengthIndicator == maxLength || ( 0 < maxLength && MaxBinaryLength >= maxLength );
                    break;
                case SqlDbType.Char:
                    result = 0 < maxLength && MaxANSICharacters >= maxLength;
                    break;
                case SqlDbType.NChar:
                    result = 0 < maxLength && MaxUnicodeCharacters >= maxLength;
                    break;
                case SqlDbType.NVarChar:
                    result = UnlimitedMaxLengthIndicator == maxLength || ( 0 < maxLength && MaxUnicodeCharacters >= maxLength );
                    break;
                case SqlDbType.VarChar:
                    result = UnlimitedMaxLengthIndicator == maxLength || ( 0 < maxLength && MaxANSICharacters >= maxLength );
                    break;
                default:
                    Debug.Assert( false, "How in the world did we get here? :" + dbType );
                    break;
            }

            return result;
        }

        // Sql-style compare options for character types.
        internal SqlCompareOptions CompareOptions {
            get {   
                return _compareOptions;
            }
        }

        // LCID for type.  0 for non-character types.
        internal long LocaleId {
            get{
                return _localeId;
            }
        }

        // Units of length depend on type.
        //  NVarChar, NChar, NText: # of unicode characters
        //  Everything else: # of bytes
        internal long MaxLength {
            get { 
                return _maxLength;
            }
        }

        internal byte Precision {
            get {
                return _precision;
            }
        }

        internal byte Scale {
            get {
                return _scale;
            }
        }

        internal SqlDbType SqlDbType {
            get {
                return _databaseType;
            }
        }

        // Clr Type instance for user-defined types
        internal Type Type {
            get {
                // Fault-in UDT clr types on access if have assembly-qualified name
                if (null == _clrType && SqlDbType.Udt == _databaseType && _udtAssemblyQualifiedName != null) {
                    _clrType = Type.GetType(_udtAssemblyQualifiedName, true);
                }
                return _clrType;
            }
        }

        // Clr Type instance for user-defined types in cases where we don't want to throw if the assembly isn't available
        internal Type TypeWithoutThrowing {
            get {
                // Fault-in UDT clr types on access if have assembly-qualified name
                if (null == _clrType && SqlDbType.Udt == _databaseType && _udtAssemblyQualifiedName != null) {
                    _clrType = Type.GetType(_udtAssemblyQualifiedName, false);
                }
                return _clrType;
            }
        }

        internal string TypeName {
            get { 
                string result = null;
                if (SqlDbType.Udt == _databaseType) {
                    Debug.Assert(String.Empty == __typeNameByDatabaseType[(int)_databaseType], "unexpected udt?");
                    result = Type.FullName;
                }
                else {
                    result = __typeNameByDatabaseType[(int)_databaseType];
                    Debug.Assert(null != result, "unknown type name?");
                }
                return result;
            }
        }

        internal string AssemblyQualifiedName {
            get {
                string result = null;
                if (SqlDbType.Udt == _databaseType) {
                    // Fault-in assembly-qualified name if type is available
                    if (_udtAssemblyQualifiedName == null && _clrType != null) {
                        _udtAssemblyQualifiedName = _clrType.AssemblyQualifiedName;
                    }
                    result = _udtAssemblyQualifiedName;
                }
                return result;
            }
        }

        internal bool IsMultiValued {
            get {
                return _isMultiValued;
            }
        }

        // Returns read-only list of field metadata
        internal IList<SmiExtendedMetaData> FieldMetaData {
            get {
                return _fieldMetaData;
            }
        }

        // Returns read-only list of extended properties
        internal SmiMetaDataPropertyCollection ExtendedProperties {
            get {
                return _extendedProperties;
            }
        }

        internal static bool IsSupportedDbType(SqlDbType dbType) {
            // Hole in SqlDbTypes between Xml and Udt for non-WinFS scenarios.
            return (SqlDbType.BigInt <= dbType && SqlDbType.Xml >= dbType) || 
                    (SqlDbType.Udt <= dbType && SqlDbType.DateTimeOffset >= dbType);
        }

        // Only correct access point for defaults per SqlDbType.
        internal static SmiMetaData GetDefaultForType( SqlDbType dbType ) {
                Debug.Assert( IsSupportedDbType(dbType), "Unsupported SqlDbtype: " + dbType);

                return __defaultValues[(int)dbType];
        }

        // Private constructor used only to initialize default instance array elements.
        // DO NOT EXPOSE OUTSIDE THIS CLASS!
        private SmiMetaData (
                                SqlDbType         sqlDbType,
                                long              maxLength,
                                byte              precision,
                                byte              scale,
                                SqlCompareOptions compareOptions) {
            _databaseType      = sqlDbType;
            _maxLength         = maxLength;
            _precision         = precision;
            _scale             = scale;
            _compareOptions    = compareOptions;

            // defaults are the same for all types for the following attributes.
            _localeId           = 0; 
            _clrType            = null;
            _isMultiValued      = false;
            _fieldMetaData      = __emptyFieldList;
            _extendedProperties = SmiMetaDataPropertyCollection.EmptyInstance;
        }

        // static array of default-valued metadata ordered by corresponding SqlDbType.
        // NOTE: INDEXED BY SqlDbType ENUM!  MUST UPDATE THIS ARRAY WHEN UPDATING SqlDbType!
        //   ONLY ACCESS THIS GLOBAL FROM GetDefaultForType!
        private static SmiMetaData[] __defaultValues =
            {
                DefaultBigInt,                 // SqlDbType.BigInt
                DefaultBinary,                 // SqlDbType.Binary
                DefaultBit,                    // SqlDbType.Bit
                DefaultChar_NoCollation,       // SqlDbType.Char
                DefaultDateTime,               // SqlDbType.DateTime
                DefaultDecimal,                // SqlDbType.Decimal
                DefaultFloat,                  // SqlDbType.Float
                DefaultImage,                  // SqlDbType.Image
                DefaultInt,                    // SqlDbType.Int
                DefaultMoney,                  // SqlDbType.Money
                DefaultNChar_NoCollation,      // SqlDbType.NChar
                DefaultNText_NoCollation,      // SqlDbType.NText
                DefaultNVarChar_NoCollation,   // SqlDbType.NVarChar
                DefaultReal,                   // SqlDbType.Real
                DefaultUniqueIdentifier,       // SqlDbType.UniqueIdentifier
                DefaultSmallDateTime,          // SqlDbType.SmallDateTime
                DefaultSmallInt,               // SqlDbType.SmallInt
                DefaultSmallMoney,             // SqlDbType.SmallMoney
                DefaultText_NoCollation,       // SqlDbType.Text
                DefaultTimestamp,              // SqlDbType.Timestamp
                DefaultTinyInt,                // SqlDbType.TinyInt
                DefaultVarBinary,              // SqlDbType.VarBinary
                DefaultVarChar_NoCollation,    // SqlDbType.VarChar
                DefaultVariant,                // SqlDbType.Variant
                DefaultNVarChar_NoCollation,   // Placeholder for value 24
                DefaultXml,                    // SqlDbType.Xml
                DefaultNVarChar_NoCollation,   // Placeholder for value 26
                DefaultNVarChar_NoCollation,   // Placeholder for value 27
                DefaultNVarChar_NoCollation,   // Placeholder for value 28
                DefaultUdt_NoType,             // Generic Udt 
                DefaultStructured,             // Generic structured type
                DefaultDate,                   // SqlDbType.Date
                DefaultTime,                   // SqlDbType.Time
                DefaultDateTime2,              // SqlDbType.DateTime2
                DefaultDateTimeOffset,         // SqlDbType.DateTimeOffset
            };

        // static array of type names ordered by corresponding SqlDbType.
        // NOTE: INDEXED BY SqlDbType ENUM!  MUST UPDATE THIS ARRAY WHEN UPDATING SqlDbType!
        //   ONLY ACCESS THIS GLOBAL FROM get_TypeName!
        private static string[] __typeNameByDatabaseType =
            {
                "bigint",               // SqlDbType.BigInt
                "binary",               // SqlDbType.Binary
                "bit",                  // SqlDbType.Bit
                "char",                 // SqlDbType.Char
                "datetime",             // SqlDbType.DateTime
                "decimal",              // SqlDbType.Decimal
                "float",                // SqlDbType.Float
                "image",                // SqlDbType.Image
                "int",                  // SqlDbType.Int
                "money",                // SqlDbType.Money
                "nchar",                // SqlDbType.NChar
                "ntext",                // SqlDbType.NText
                "nvarchar",             // SqlDbType.NVarChar
                "real",                 // SqlDbType.Real
                "uniqueidentifier",     // SqlDbType.UniqueIdentifier
                "smalldatetime",        // SqlDbType.SmallDateTime
                "smallint",             // SqlDbType.SmallInt
                "smallmoney",           // SqlDbType.SmallMoney
                "text",                 // SqlDbType.Text
                "timestamp",            // SqlDbType.Timestamp
                "tinyint",              // SqlDbType.TinyInt
                "varbinary",            // SqlDbType.VarBinary
                "varchar",              // SqlDbType.VarChar
                "sql_variant",          // SqlDbType.Variant
                null,                   // placeholder for 24
                "xml",                  // SqlDbType.Xml
                null,                   // placeholder for 26
                null,                   // placeholder for 27
                null,                   // placeholder for 28
                String.Empty,           // SqlDbType.Udt  -- get type name from Type.FullName instead.
                String.Empty,           // Structured types have user-defined type names.
                "date",                 // SqlDbType.Date
                "time",                 // SqlDbType.Time
                "datetime2",            // SqlDbType.DateTime2
                "datetimeoffset",       // SqlDbType.DateTimeOffset
            };

        // Internal setter to be used by constructors only!  Modifies state!
        private void SetDefaultsForType( SqlDbType dbType )
            {
                SmiMetaData smdDflt = GetDefaultForType( dbType );
                _databaseType = dbType;
                _maxLength = smdDflt.MaxLength;
                _precision = smdDflt.Precision;
                _scale = smdDflt.Scale;
                _localeId = smdDflt.LocaleId;
                _compareOptions = smdDflt.CompareOptions;
                _clrType = null;
                _isMultiValued = smdDflt._isMultiValued;
                _fieldMetaData = smdDflt._fieldMetaData;            // This is ok due to immutability
                _extendedProperties = smdDflt._extendedProperties;  // This is ok due to immutability
            }

        internal string TraceString() {
            return TraceString(0);
        }
        virtual internal string TraceString(int indent) {
            string indentStr = new String(' ', indent);
            string fields = String.Empty;
            if (null != _fieldMetaData) {
                foreach(SmiMetaData fieldMd in _fieldMetaData) {
                    fields = String.Format(CultureInfo.InvariantCulture, 
                                "{0}{1}\n\t", fields, fieldMd.TraceString(indent+5));
                }
            }

            string properties = String.Empty;
            if (null != _extendedProperties) {
                foreach(SmiMetaDataProperty property in _extendedProperties.Values) {
                    properties = String.Format(CultureInfo.InvariantCulture, 
                                "{0}{1}                   {2}\n\t", properties, indentStr, property.TraceString());
                }
            }

            return String.Format(CultureInfo.InvariantCulture, "\n\t"
                               +"{0}            SqlDbType={1:g}\n\t"
                               +"{0}            MaxLength={2:d}\n\t"
                               +"{0}            Precision={3:d}\n\t"
                               +"{0}                Scale={4:d}\n\t"
                               +"{0}             LocaleId={5:x}\n\t"
                               +"{0}       CompareOptions={6:g}\n\t"
                               +"{0}                 Type={7}\n\t"
                               +"{0}          MultiValued={8}\n\t"
                               +"{0}               fields=\n\t{9}"
                               +"{0}           properties=\n\t{10}",
                                indentStr,
                                SqlDbType,
                                MaxLength,
                                Precision,
                                Scale,
                                LocaleId,
                                CompareOptions,
                                (null!=Type) ? Type.ToString():"<null>",
                                IsMultiValued,
                                fields,
                                properties);

        }
    }


    // SmiExtendedMetaData
    //
    //  Adds server-specific type extension information to base metadata, but still portable across a specific server.
    //
    internal class SmiExtendedMetaData : SmiMetaData {

        private string _name;           // context-dependant identifier, ie. parameter name for parameters, column name for columns, etc.

        // three-part name for typed xml schema and for udt names
        private string _typeSpecificNamePart1;
        private string _typeSpecificNamePart2;
        private string _typeSpecificNamePart3;

        [ObsoleteAttribute( "Not supported as of SMI v2.  Will be removed when v1 support dropped. Use ctor without columns param." )]
        internal SmiExtendedMetaData(
                                        SqlDbType dbType, 
                                        long maxLength,
                                        byte precision, 
                                        byte scale, 
                                        long localeId, 
                                        SqlCompareOptions compareOptions, 
                                        Type userDefinedType, 
                                        SmiMetaData[] columns, 
                                        string name, 
                                        string typeSpecificNamePart1, 
                                        string typeSpecificNamePart2, 
                                        string typeSpecificNamePart3) :
                                // Implement as calling the new ctor
                                this( 
                                        dbType, 
                                        maxLength, 
                                        precision, 
                                        scale, 
                                        localeId, 
                                        compareOptions, 
                                        userDefinedType, 
                                        name, 
                                        typeSpecificNamePart1, 
                                        typeSpecificNamePart2, 
                                        typeSpecificNamePart3 ) {
            Debug.Assert( null == columns, "Row types not supported" );
        }

        internal SmiExtendedMetaData(
                                        SqlDbType dbType, 
                                        long maxLength,
                                        byte precision, 
                                        byte scale, 
                                        long localeId, 
                                        SqlCompareOptions compareOptions, 
                                        Type userDefinedType, 
                                        string name, 
                                        string typeSpecificNamePart1, 
                                        string typeSpecificNamePart2, 
                                        string typeSpecificNamePart3) :
                                    this(
                                        dbType,
                                        maxLength,
                                        precision,
                                        scale,
                                        localeId,
                                        compareOptions,
                                        userDefinedType,
                                        false,
                                        null,
                                        null,
                                        name,
                                        typeSpecificNamePart1,
                                        typeSpecificNamePart2,
                                        typeSpecificNamePart3) {
        }

        // SMI V200 ctor.
        internal SmiExtendedMetaData(
                                        SqlDbType dbType,
                                        long maxLength,
                                        byte precision,
                                        byte scale,
                                        long localeId,
                                        SqlCompareOptions compareOptions,
                                        Type userDefinedType,
                                        bool isMultiValued,
                                        IList<SmiExtendedMetaData> fieldMetaData,
                                        SmiMetaDataPropertyCollection extendedProperties,
                                        string name,
                                        string typeSpecificNamePart1,
                                        string typeSpecificNamePart2,
                                        string typeSpecificNamePart3) :
                                this(   dbType,
                                        maxLength,
                                        precision,
                                        scale,
                                        localeId,
                                        compareOptions,
                                        userDefinedType,
                                        null,
                                        isMultiValued,
                                        fieldMetaData,
                                        extendedProperties,
                                        name,
                                        typeSpecificNamePart1,
                                        typeSpecificNamePart2,
                                        typeSpecificNamePart3) {
        }

        // SMI V220 ctor.
        internal SmiExtendedMetaData(
                                        SqlDbType dbType, 
                                        long maxLength,
                                        byte precision, 
                                        byte scale, 
                                        long localeId, 
                                        SqlCompareOptions compareOptions, 
                                        Type userDefinedType, 
                                        string udtAssemblyQualifiedName,
                                        bool isMultiValued,
                                        IList<SmiExtendedMetaData> fieldMetaData,
                                        SmiMetaDataPropertyCollection extendedProperties,
                                        string name, 
                                        string typeSpecificNamePart1, 
                                        string typeSpecificNamePart2, 
                                        string typeSpecificNamePart3 ):
                                    base( dbType,
                                        maxLength, 
                                        precision, 
                                        scale, 
                                        localeId, 
                                        compareOptions, 
                                        userDefinedType,
                                        udtAssemblyQualifiedName,
                                        isMultiValued,
                                        fieldMetaData,
                                        extendedProperties) {
            Debug.Assert(null == name || MaxNameLength >= name.Length, "Name is too long");
            
            _name = name;
            _typeSpecificNamePart1 = typeSpecificNamePart1;
            _typeSpecificNamePart2 = typeSpecificNamePart2;
            _typeSpecificNamePart3 = typeSpecificNamePart3;
        }

        internal string Name {
            get {
                return _name;
            }
        }

        internal string TypeSpecificNamePart1 {
            get {
                return _typeSpecificNamePart1;
            }
        }

        internal string TypeSpecificNamePart2 {
            get {
                return _typeSpecificNamePart2;
            }
        }

        internal string TypeSpecificNamePart3 {
            get {
                return _typeSpecificNamePart3;
            }
        }

        internal override string TraceString(int indent) {
            return String.Format(CultureInfo.InvariantCulture, 
                                 "{2}                 Name={0}"
                                +"{1}"
                                +"{2}TypeSpecificNamePart1='{3}'\n\t"
                                +"{2}TypeSpecificNamePart2='{4}'\n\t"
                                +"{2}TypeSpecificNamePart3='{5}'\n\t",
                                (null!=_name) ? _name : "<null>",
                                base.TraceString(indent),
                                new String(' ', indent),
                                (null!=TypeSpecificNamePart1) ? TypeSpecificNamePart1:"<null>",
                                (null!=TypeSpecificNamePart2) ? TypeSpecificNamePart2:"<null>",
                                (null!=TypeSpecificNamePart3) ? TypeSpecificNamePart3:"<null>");
        }
    }


    // SmiParameterMetaData
    //
    //  MetaData class to send parameter definitions to server.
    //  Sealed because we don't need to derive from it yet.
    // IMPORTANT DEVNOTE: This class is being used for parameter encryption functionality, to get the type_info TDS object from SqlParameter.
    // Please consider impact to that when changing this class. Refer to the callers of SqlParameter.GetMetadataForTypeInfo().
    internal sealed class SmiParameterMetaData : SmiExtendedMetaData {

        private ParameterDirection _direction;

        [ObsoleteAttribute( "Not supported as of SMI v2.  Will be removed when v1 support dropped. Use ctor without columns param." )]
        internal SmiParameterMetaData( 
                                        SqlDbType dbType, 
                                        long maxLength, 
                                        byte precision, 
                                        byte scale, 
                                        long  localeId, 
                                        SqlCompareOptions compareOptions, 
                                        Type userDefinedType, 
                                        SmiMetaData[] columns, 
                                        string name, 
                                        string typeSpecificNamePart1, 
                                        string typeSpecificNamePart2, 
                                        string typeSpecificNamePart3,
                                        ParameterDirection direction) :
                                // Implement as calling the new ctor
                                this ( 
                                        dbType, 
                                        maxLength, 
                                        precision, 
                                        scale, 
                                        localeId, 
                                        compareOptions, 
                                        userDefinedType, 
                                        name, 
                                        typeSpecificNamePart1, 
                                        typeSpecificNamePart2, 
                                        typeSpecificNamePart3,
                                        direction ) {
            Debug.Assert( null == columns, "Row types not supported" );
        }

        // SMI V100 (aka V3) ctor
        internal SmiParameterMetaData( 
                                        SqlDbType dbType, 
                                        long maxLength, 
                                        byte precision, 
                                        byte scale, 
                                        long  localeId, 
                                        SqlCompareOptions compareOptions, 
                                        Type userDefinedType, 
                                        string name, 
                                        string typeSpecificNamePart1, 
                                        string typeSpecificNamePart2, 
                                        string typeSpecificNamePart3,
                                        ParameterDirection direction) :
                                    this(
                                        dbType,
                                        maxLength, 
                                        precision, 
                                        scale, 
                                        localeId, 
                                        compareOptions, 
                                        userDefinedType,
                                        false,
                                        null,
                                        null,
                                        name, 
                                        typeSpecificNamePart1, 
                                        typeSpecificNamePart2,
                                        typeSpecificNamePart3,
                                        direction) {
        }
                                        
        // SMI V200 ctor.
        internal SmiParameterMetaData( 
                                        SqlDbType dbType, 
                                        long maxLength, 
                                        byte precision, 
                                        byte scale, 
                                        long  localeId, 
                                        SqlCompareOptions compareOptions, 
                                        Type userDefinedType, 
                                        bool isMultiValued,
                                        IList<SmiExtendedMetaData> fieldMetaData,
                                        SmiMetaDataPropertyCollection extendedProperties,
                                        string name, 
                                        string typeSpecificNamePart1, 
                                        string typeSpecificNamePart2, 
                                        string typeSpecificNamePart3,
                                        ParameterDirection direction) :
                                    this( dbType, 
                                        maxLength, 
                                        precision, 
                                        scale, 
                                        localeId, 
                                        compareOptions, 
                                        userDefinedType, 
                                        null,
                                        isMultiValued,
                                        fieldMetaData,
                                        extendedProperties,
                                        name, 
                                        typeSpecificNamePart1, 
                                        typeSpecificNamePart2,
                                        typeSpecificNamePart3,
                                        direction) {
        }

        // SMI V220 ctor.
        internal SmiParameterMetaData( 
                                        SqlDbType dbType, 
                                        long maxLength, 
                                        byte precision, 
                                        byte scale, 
                                        long  localeId, 
                                        SqlCompareOptions compareOptions, 
                                        Type userDefinedType,
                                        string udtAssemblyQualifiedName,
                                        bool isMultiValued,
                                        IList<SmiExtendedMetaData> fieldMetaData,
                                        SmiMetaDataPropertyCollection extendedProperties,
                                        string name, 
                                        string typeSpecificNamePart1, 
                                        string typeSpecificNamePart2, 
                                        string typeSpecificNamePart3,
                                        ParameterDirection direction) :
                                    base( dbType, 
                                        maxLength, 
                                        precision, 
                                        scale, 
                                        localeId, 
                                        compareOptions, 
                                        userDefinedType, 
                                        udtAssemblyQualifiedName,
                                        isMultiValued,
                                        fieldMetaData,
                                        extendedProperties,
                                        name, 
                                        typeSpecificNamePart1, 
                                        typeSpecificNamePart2,
                                        typeSpecificNamePart3) {
            Debug.Assert( ParameterDirection.Input == direction
                       || ParameterDirection.Output == direction 
                       || ParameterDirection.InputOutput == direction 
                       || ParameterDirection.ReturnValue == direction, "Invalid direction: " + direction );
            _direction = direction;
        }

        internal ParameterDirection Direction {
            get {
                return _direction;
            }
        }

        internal override string TraceString(int indent) {
            return String.Format(CultureInfo.InvariantCulture, "{0}"
                                +"{1}            Direction={2:g}\n\t",
                                base.TraceString(indent),
                                new String(' ', indent),
                                Direction);
        }
    }


    // SmiStorageMetaData
    //
    //  This class represents the addition of storage-level attributes to the heirarchy (i.e. attributes from 
    //  underlying table, source variables, or whatever).
    //
    //  Most values use Null (either IsNullable == true or CLR null) to indicate "Not specified" state.  Selection
    //  of which values allow "not specified" determined by backward compatibility.
    //
    //  Maps approximately to TDS' COLMETADATA token with TABNAME and part of COLINFO thrown in.
    internal class SmiStorageMetaData : SmiExtendedMetaData {

        // AllowsDBNull is the only value required to be specified.
        private bool        _allowsDBNull;      // could the column return nulls? equivalent to TDS's IsNullable bit
        private string      _serverName;        // underlying column's server
        private string      _catalogName;       // underlying column's database
        private string      _schemaName;        // underlying column's schema
        private string      _tableName;         // underlying column's table
        private string      _columnName;        // underlying column's name
        private SqlBoolean  _isKey;             // Is this one of a set of key columns that uniquely identify an underlying table?
        private bool        _isIdentity;        // Is this from an identity column
        private bool        _isColumnSet;       // Is this column the XML representation of a columnset?

        [ObsoleteAttribute( "Not supported as of SMI v2.  Will be removed when v1 support dropped. Use ctor without columns param." )]
        internal SmiStorageMetaData(
                                        SqlDbType dbType, 
                                        long maxLength, 
                                        byte precision, 
                                        byte scale, 
                                        long localeId, 
                                        SqlCompareOptions compareOptions,
                                        Type userDefinedType, 
                                        SmiMetaData[] columns, 
                                        string name, 
                                        string typeSpecificNamePart1, 
                                        string typeSpecificNamePart2, 
                                        string typeSpecificNamePart3,
                                        bool allowsDBNull, 
                                        string serverName, 
                                        string catalogName, 
                                        string schemaName, 
                                        string tableName, 
                                        string columnName, 
                                        SqlBoolean isKey, 
                                        bool isIdentity) :
                                // Implement as calling the new ctor
                                this ( 
                                        dbType, 
                                        maxLength, 
                                        precision, 
                                        scale, 
                                        localeId, 
                                        compareOptions, 
                                        userDefinedType, 
                                        name, 
                                        typeSpecificNamePart1, 
                                        typeSpecificNamePart2, 
                                        typeSpecificNamePart3,
                                        allowsDBNull,
                                        serverName,
                                        catalogName,
                                        schemaName,
                                        tableName,
                                        columnName,
                                        isKey,
                                        isIdentity) {
            Debug.Assert( null == columns, "Row types not supported" );
        }

        internal SmiStorageMetaData(
                                        SqlDbType dbType, 
                                        long maxLength, 
                                        byte precision, 
                                        byte scale, 
                                        long localeId, 
                                        SqlCompareOptions compareOptions,
                                        Type userDefinedType, 
                                        string name, 
                                        string typeSpecificNamePart1, 
                                        string typeSpecificNamePart2, 
                                        string typeSpecificNamePart3,
                                        bool allowsDBNull, 
                                        string serverName, 
                                        string catalogName, 
                                        string schemaName, 
                                        string tableName, 
                                        string columnName, 
                                        SqlBoolean isKey, 
                                        bool isIdentity) :
                                    this(dbType, 
                                        maxLength, 
                                        precision, 
                                        scale, 
                                        localeId, 
                                        compareOptions,
                                        userDefinedType,
                                        false,
                                        null,
                                        null,
                                        name, 
                                        typeSpecificNamePart1, 
                                        typeSpecificNamePart2,
                                        typeSpecificNamePart3,
                                        allowsDBNull,
                                        serverName,
                                        catalogName,
                                        schemaName,
                                        tableName,
                                        columnName,
                                        isKey,
                                        isIdentity) {
        }
                                        
        // SMI V200 ctor.
        internal SmiStorageMetaData(
                                        SqlDbType dbType, 
                                        long maxLength, 
                                        byte precision, 
                                        byte scale, 
                                        long localeId, 
                                        SqlCompareOptions compareOptions,
                                        Type userDefinedType, 
                                        bool isMultiValued,
                                        IList<SmiExtendedMetaData> fieldMetaData,
                                        SmiMetaDataPropertyCollection extendedProperties,
                                        string name, 
                                        string typeSpecificNamePart1, 
                                        string typeSpecificNamePart2, 
                                        string typeSpecificNamePart3,
                                        bool allowsDBNull, 
                                        string serverName, 
                                        string catalogName, 
                                        string schemaName, 
                                        string tableName, 
                                        string columnName, 
                                        SqlBoolean isKey, 
                                        bool isIdentity) :
                                this(   dbType, 
                                        maxLength, 
                                        precision, 
                                        scale, 
                                        localeId, 
                                        compareOptions, 
                                        userDefinedType, 
                                        null,
                                        isMultiValued,
                                        fieldMetaData,
                                        extendedProperties,
                                        name, 
                                        typeSpecificNamePart1, 
                                        typeSpecificNamePart2,
                                        typeSpecificNamePart3,
                                        allowsDBNull,
                                        serverName,
                                        catalogName,
                                        schemaName,
                                        tableName,
                                        columnName,
                                        isKey,
                                        isIdentity,
                                        false) {
        }

        // SMI V220 ctor.
        internal SmiStorageMetaData(
                                        SqlDbType dbType, 
                                        long maxLength, 
                                        byte precision, 
                                        byte scale, 
                                        long localeId, 
                                        SqlCompareOptions compareOptions,
                                        Type userDefinedType,
                                        string udtAssemblyQualifiedName,
                                        bool isMultiValued,
                                        IList<SmiExtendedMetaData> fieldMetaData,
                                        SmiMetaDataPropertyCollection extendedProperties,
                                        string name, 
                                        string typeSpecificNamePart1, 
                                        string typeSpecificNamePart2, 
                                        string typeSpecificNamePart3,
                                        bool allowsDBNull, 
                                        string serverName, 
                                        string catalogName, 
                                        string schemaName, 
                                        string tableName, 
                                        string columnName, 
                                        SqlBoolean isKey, 
                                        bool isIdentity,
                                        bool isColumnSet) :
                                    base( dbType, 
                                        maxLength, 
                                        precision, 
                                        scale, 
                                        localeId, 
                                        compareOptions, 
                                        userDefinedType,
                                        udtAssemblyQualifiedName,
                                        isMultiValued,
                                        fieldMetaData,
                                        extendedProperties,
                                        name, 
                                        typeSpecificNamePart1, 
                                        typeSpecificNamePart2,
                                        typeSpecificNamePart3) {
            _allowsDBNull = allowsDBNull;
            _serverName = serverName;
            _catalogName = catalogName;
            _schemaName = schemaName;
            _tableName = tableName;
            _columnName = columnName;
            _isKey = isKey;
            _isIdentity = isIdentity;
            _isColumnSet = isColumnSet;
        }

        internal bool AllowsDBNull {
            get {
                return _allowsDBNull;
            }
        }

        internal string ServerName {
            get {
                return _serverName;
            }
        }

        internal string CatalogName {
            get {
                return _catalogName;
            }
        }

        internal string SchemaName {
            get {
                return _schemaName;
            }
        }

        internal string TableName {
            get {
                return _tableName;
            }
        }

        internal string ColumnName {
            get {
                return _columnName;
            }
        }

        internal SqlBoolean IsKey {
            get {
                return _isKey;
            }
        }

        internal bool IsIdentity {
            get {
                return _isIdentity;
            }
        }

        internal bool IsColumnSet {
            get {
                return _isColumnSet;
            }
        }

        internal override string TraceString(int indent) {
            return String.Format(CultureInfo.InvariantCulture, "{0}"
                                +"{1}         AllowsDBNull={2}\n\t"
                                +"{1}           ServerName='{3}'\n\t"
                                +"{1}          CatalogName='{4}'\n\t"
                                +"{1}           SchemaName='{5}'\n\t"
                                +"{1}            TableName='{6}'\n\t"
                                +"{1}           ColumnName='{7}'\n\t"
                                +"{1}                IsKey={8}\n\t"
                                +"{1}           IsIdentity={9}\n\t",
                                base.TraceString(indent),
                                new String(' ', indent),
                                AllowsDBNull,
                                (null!=ServerName) ? ServerName:"<null>",
                                (null!=CatalogName) ? CatalogName:"<null>",
                                (null!=SchemaName) ? SchemaName:"<null>",
                                (null!=TableName) ? TableName:"<null>",
                                (null!=ColumnName) ? ColumnName:"<null>",
                                IsKey,
                                IsIdentity);
        }

    }

    // SmiQueryMetaData
    //
    //  Adds Query-specific attributes.
    //  Sealed since we don't need to extend it for now.
    //  Maps to full COLMETADATA + COLINFO + TABNAME tokens on TDS.
    internal class SmiQueryMetaData : SmiStorageMetaData {

        private bool _isReadOnly;
        private SqlBoolean _isExpression;
        private SqlBoolean _isAliased;
        private SqlBoolean _isHidden;

        [ObsoleteAttribute( "Not supported as of SMI v2.  Will be removed when v1 support dropped. Use ctor without columns param." )]
        internal SmiQueryMetaData(
                                        SqlDbType dbType, 
                                        long maxLength, 
                                        byte precision, 
                                        byte scale, 
                                        long localeId, 
                                        SqlCompareOptions compareOptions,
                                        Type userDefinedType, 
                                        SmiMetaData[] columns, 
                                        string name, 
                                        string typeSpecificNamePart1, 
                                        string typeSpecificNamePart2, 
                                        string typeSpecificNamePart3,
                                        bool allowsDBNull, 
                                        string serverName, 
                                        string catalogName, 
                                        string schemaName, 
                                        string tableName, 
                                        string columnName, 
                                        SqlBoolean isKey, 
                                        bool isIdentity, 
                                        bool isReadOnly, 
                                        SqlBoolean isExpression, 
                                        SqlBoolean isAliased, 
                                        SqlBoolean isHidden ) :
                                // Implement as calling the new ctor
                                this ( 
                                        dbType, 
                                        maxLength, 
                                        precision, 
                                        scale, 
                                        localeId, 
                                        compareOptions, 
                                        userDefinedType, 
                                        name, 
                                        typeSpecificNamePart1, 
                                        typeSpecificNamePart2, 
                                        typeSpecificNamePart3,
                                        allowsDBNull,
                                        serverName,
                                        catalogName,
                                        schemaName,
                                        tableName,
                                        columnName,
                                        isKey,
                                        isIdentity,
                                        isReadOnly,
                                        isExpression,
                                        isAliased,
                                        isHidden ) {
            Debug.Assert( null == columns, "Row types not supported" );
        }

        internal SmiQueryMetaData( SqlDbType dbType,
                                        long maxLength, 
                                        byte precision, 
                                        byte scale, 
                                        long localeId, 
                                        SqlCompareOptions compareOptions,
                                        Type userDefinedType, 
                                        string name,
                                        string typeSpecificNamePart1, 
                                        string typeSpecificNamePart2, 
                                        string typeSpecificNamePart3,
                                        bool allowsDBNull, 
                                        string serverName, 
                                        string catalogName, 
                                        string schemaName,
                                        string tableName, 
                                        string columnName, 
                                        SqlBoolean isKey,
                                        bool isIdentity, 
                                        bool isReadOnly, 
                                        SqlBoolean isExpression, 
                                        SqlBoolean isAliased, 
                                        SqlBoolean isHidden ) :
                                    this( dbType,
                                        maxLength, 
                                        precision, 
                                        scale, 
                                        localeId, 
                                        compareOptions, 
                                        userDefinedType, 
                                        false,
                                        null,
                                        null,
                                        name,
                                        typeSpecificNamePart1, 
                                        typeSpecificNamePart2,
                                        typeSpecificNamePart3,
                                        allowsDBNull, 
                                        serverName, 
                                        catalogName, 
                                        schemaName, 
                                        tableName, 
                                        columnName, 
                                        isKey, 
                                        isIdentity,
                                        isReadOnly,
                                        isExpression,
                                        isAliased,
                                        isHidden) {
        }

        // SMI V200 ctor.
        internal SmiQueryMetaData( SqlDbType dbType,
                                        long maxLength, 
                                        byte precision, 
                                        byte scale, 
                                        long localeId, 
                                        SqlCompareOptions compareOptions,
                                        Type userDefinedType, 
                                        bool isMultiValued,
                                        IList<SmiExtendedMetaData> fieldMetaData,
                                        SmiMetaDataPropertyCollection extendedProperties,
                                        string name,
                                        string typeSpecificNamePart1, 
                                        string typeSpecificNamePart2, 
                                        string typeSpecificNamePart3,
                                        bool allowsDBNull, 
                                        string serverName, 
                                        string catalogName, 
                                        string schemaName,
                                        string tableName, 
                                        string columnName, 
                                        SqlBoolean isKey,
                                        bool isIdentity,
                                        bool isReadOnly, 
                                        SqlBoolean isExpression, 
                                        SqlBoolean isAliased, 
                                        SqlBoolean isHidden) :
                                   this( dbType,
                                        maxLength, 
                                        precision, 
                                        scale, 
                                        localeId, 
                                        compareOptions, 
                                        userDefinedType, 
                                        null,
                                        isMultiValued,
                                        fieldMetaData,
                                        extendedProperties,
                                        name,
                                        typeSpecificNamePart1, 
                                        typeSpecificNamePart2,
                                        typeSpecificNamePart3,
                                        allowsDBNull, 
                                        serverName, 
                                        catalogName, 
                                        schemaName, 
                                        tableName, 
                                        columnName, 
                                        isKey, 
                                        isIdentity,
                                        false,
                                        isReadOnly, 
                                        isExpression, 
                                        isAliased, 
                                        isHidden ) {
        }
        // SMI V220 ctor.
        internal SmiQueryMetaData( SqlDbType dbType,
                                        long maxLength, 
                                        byte precision, 
                                        byte scale, 
                                        long localeId, 
                                        SqlCompareOptions compareOptions,
                                        Type userDefinedType, 
                                        string udtAssemblyQualifiedName,
                                        bool isMultiValued,
                                        IList<SmiExtendedMetaData> fieldMetaData,
                                        SmiMetaDataPropertyCollection extendedProperties,
                                        string name,
                                        string typeSpecificNamePart1, 
                                        string typeSpecificNamePart2, 
                                        string typeSpecificNamePart3,
                                        bool allowsDBNull, 
                                        string serverName, 
                                        string catalogName, 
                                        string schemaName,
                                        string tableName, 
                                        string columnName, 
                                        SqlBoolean isKey,
                                        bool isIdentity, 
                                        bool isColumnSet,
                                        bool isReadOnly, 
                                        SqlBoolean isExpression, 
                                        SqlBoolean isAliased, 
                                        SqlBoolean isHidden ) :
                                    base( dbType,
                                        maxLength, 
                                        precision, 
                                        scale, 
                                        localeId, 
                                        compareOptions, 
                                        userDefinedType, 
                                        udtAssemblyQualifiedName,
                                        isMultiValued,
                                        fieldMetaData,
                                        extendedProperties,
                                        name,
                                        typeSpecificNamePart1, 
                                        typeSpecificNamePart2,
                                        typeSpecificNamePart3,
                                        allowsDBNull, 
                                        serverName, 
                                        catalogName, 
                                        schemaName, 
                                        tableName, 
                                        columnName, 
                                        isKey, 
                                        isIdentity,
                                        isColumnSet ) {
        _isReadOnly = isReadOnly;
        _isExpression = isExpression;
        _isAliased = isAliased;
        _isHidden = isHidden;
        }

        internal bool IsReadOnly {
            get {
                return _isReadOnly;
            }
        }

        internal SqlBoolean IsExpression {
            get {
                return _isExpression;
            }
        }

        internal SqlBoolean IsAliased {
            get {
                return _isAliased;
            }
        }

        internal SqlBoolean IsHidden {
            get {
                return _isHidden;
            }
        }


    internal override string TraceString(int indent) {
        return String.Format(CultureInfo.InvariantCulture, "{0}"
                            +"{1}           IsReadOnly={2}\n\t"
                            +"{1}         IsExpression={3}\n\t"
                            +"{1}            IsAliased={4}\n\t"
                            +"{1}             IsHidden={5}",
                            base.TraceString(indent),
                            new String(' ', indent),
                            AllowsDBNull,
                            IsExpression,
                            IsAliased,
                            IsHidden);
    }

    }
}