Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Data/Microsoft/SqlServer/Server/SmiMetaDataProperty.cs

@@ -0,0 +1,261 @@
+//------------------------------------------------------------------------------
+// <copyright file="SmiMetaData.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+// <owner current="true" primary="true">[....]</owner>
+// <owner current="true" primary="false">[....]</owner>
+//------------------------------------------------------------------------------
+
+namespace Microsoft.SqlServer.Server {
+
+    using System;
+    using System.Collections.Generic;
+    using System.Data;
+    using System.Data.Common;
+    using System.Data.SqlClient;
+    using System.Diagnostics;
+    using System.Globalization;
+
+    // SmiMetaDataProperty defines an extended, optional property to be used on the SmiMetaData class
+    //  This approach to adding properties is added combat the growing number of sparsely-used properties 
+    //  that are specially handled on the base classes
+
+    internal enum SmiPropertySelector {
+        DefaultFields = 0x0,
+        SortOrder = 0x1,
+        UniqueKey = 0x2,
+    }
+
+    // Simple collection for properties.  Could extend to IDictionary support if needed in future.
+    internal class SmiMetaDataPropertyCollection {
+        private const int               SelectorCount = 3;  // number of elements in SmiPropertySelector
+
+        private SmiMetaDataProperty[]   _properties;
+        private bool                    _isReadOnly;
+
+        internal static readonly SmiMetaDataPropertyCollection EmptyInstance;
+
+        // Singleton empty instances to ensure each property is always non-null
+        private static readonly SmiDefaultFieldsProperty    __emptyDefaultFields = new SmiDefaultFieldsProperty(new List<bool>());
+        private static readonly SmiOrderProperty            __emptySortOrder = new SmiOrderProperty(new List<SmiOrderProperty.SmiColumnOrder>());
+        private static readonly SmiUniqueKeyProperty        __emptyUniqueKey = new SmiUniqueKeyProperty(new List<bool>());
+
+        static SmiMetaDataPropertyCollection() {
+            EmptyInstance = new SmiMetaDataPropertyCollection();
+            EmptyInstance.SetReadOnly();
+        }
+
+        internal SmiMetaDataPropertyCollection() {
+            _properties = new SmiMetaDataProperty[SelectorCount];
+            _isReadOnly = false;
+            _properties[(int)SmiPropertySelector.DefaultFields]  = __emptyDefaultFields;
+            _properties[(int)SmiPropertySelector.SortOrder]      = __emptySortOrder;
+            _properties[(int)SmiPropertySelector.UniqueKey]      = __emptyUniqueKey;
+        }
+
+        internal SmiMetaDataProperty this[SmiPropertySelector key] {
+            get {
+                return _properties[(int)key];
+            }
+            set {
+                if (null == value) {
+                    throw ADP.InternalError(ADP.InternalErrorCode.InvalidSmiCall);
+                }
+                EnsureWritable();
+                _properties[(int)key] = value;
+            }
+        }
+
+        internal bool IsReadOnly {
+            get {
+                return _isReadOnly;
+            }
+        }
+
+        internal IEnumerable<SmiMetaDataProperty> Values {
+            get {
+                return new List<SmiMetaDataProperty>(_properties);
+            }
+        }
+
+        // Allow switching to read only, but not back.
+        internal void SetReadOnly() {
+            _isReadOnly = true;
+        }
+
+        private void EnsureWritable() {
+            if (IsReadOnly) {
+                throw System.Data.Common.ADP.InternalError(System.Data.Common.ADP.InternalErrorCode.InvalidSmiCall);
+            }
+        }
+    }
+
+    // Base class for properties
+    internal abstract class SmiMetaDataProperty {
+        internal abstract string TraceString();
+    }
+
+    // Property defining a list of column ordinals that define a unique key
+    internal class SmiUniqueKeyProperty : SmiMetaDataProperty {
+        private IList<bool> _columns;
+
+        internal SmiUniqueKeyProperty(IList<bool> columnIsKey) {
+            _columns = new List<bool>(columnIsKey).AsReadOnly();
+        }
+
+        // indexed by column ordinal indicating for each column whether it is key or not
+        internal bool this[int ordinal] {
+            get {
+                if (_columns.Count <= ordinal) {
+                    return false;
+                }
+                else {
+                    return _columns[ordinal];
+                }
+            }
+        }
+
+        [Conditional("DEBUG")]
+        internal void CheckCount(int countToMatch) {
+            Debug.Assert(0 == _columns.Count || countToMatch == _columns.Count, 
+                    "SmiDefaultFieldsProperty.CheckCount: DefaultFieldsProperty size (" + _columns.Count +
+                    ") not equal to checked size (" + countToMatch + ")" );
+        }
+
+        internal override string TraceString() {
+            string returnValue = "UniqueKey(";
+            bool delimit = false;
+            for (int columnOrd = 0; columnOrd < _columns.Count; columnOrd++) {
+                if (delimit) {
+                    returnValue += ",";
+                }
+                else {
+                    delimit = true;
+                }
+                if (_columns[columnOrd]) {
+                    returnValue += columnOrd.ToString(CultureInfo.InvariantCulture);
+                }
+            }
+            returnValue += ")";
+
+            return returnValue;
+        }
+    }
+
+    // Property defining a sort order for a set of columns (by ordinal and ASC/DESC).
+    internal class SmiOrderProperty : SmiMetaDataProperty {
+        internal struct SmiColumnOrder {
+            internal int SortOrdinal;
+            internal SortOrder Order;
+
+            internal string TraceString() {
+                return String.Format(CultureInfo.InvariantCulture, "{0} {1}", SortOrdinal, Order);
+            }
+        }
+
+        private IList<SmiColumnOrder> _columns;
+
+        internal SmiOrderProperty(IList<SmiColumnOrder> columnOrders) {
+            _columns = new List<SmiColumnOrder>(columnOrders).AsReadOnly();
+        }
+
+        // Readonly list of the columnorder instances making up the sort order
+        //  order in list indicates precedence
+        internal SmiColumnOrder this[int ordinal] {
+            get {
+                if (_columns.Count <= ordinal) {
+                    SmiColumnOrder order = new SmiColumnOrder();
+                    order.Order = SortOrder.Unspecified;
+                    order.SortOrdinal = -1;
+                    return order;
+                }
+                else {
+                    return _columns[ordinal];
+                }
+            }
+        }
+
+
+        [Conditional("DEBUG")]
+        internal void CheckCount(int countToMatch) {
+            Debug.Assert(0 == _columns.Count || countToMatch == _columns.Count, 
+                    "SmiDefaultFieldsProperty.CheckCount: DefaultFieldsProperty size (" + _columns.Count +
+                    ") not equal to checked size (" + countToMatch + ")" );
+        }
+
+        internal override string TraceString() {
+            string returnValue = "SortOrder(";
+            bool delimit = false;
+            foreach(SmiColumnOrder columnOrd in _columns) {
+                if (delimit) {
+                    returnValue += ",";
+                }
+                else {
+                    delimit = true;
+                }
+
+                if (System.Data.SqlClient.SortOrder.Unspecified != columnOrd.Order) {
+                    returnValue += columnOrd.TraceString();
+                }
+            }
+            returnValue += ")";
+
+            return returnValue;
+         }
+    }
+
+    // property defining inheritance relationship(s)
+    internal class SmiDefaultFieldsProperty : SmiMetaDataProperty {
+        #region private fields
+
+        private IList<bool>     _defaults;
+
+        #endregion
+
+        #region internal interface
+
+        internal SmiDefaultFieldsProperty(IList<bool> defaultFields) {
+            _defaults = new List<bool>(defaultFields).AsReadOnly();
+        }
+
+        internal bool this[int ordinal] {
+            get {
+                if (_defaults.Count <= ordinal) {
+                    return false;
+                }
+                else {
+                    return _defaults[ordinal];
+                }
+            }
+        }
+
+        [Conditional("DEBUG")]
+        internal void CheckCount(int countToMatch) {
+            Debug.Assert(0 == _defaults.Count || countToMatch == _defaults.Count, 
+                    "SmiDefaultFieldsProperty.CheckCount: DefaultFieldsProperty size (" + _defaults.Count +
+                    ") not equal to checked size (" + countToMatch + ")" );
+        }
+
+        internal override string TraceString() {
+            string returnValue = "DefaultFields(";
+            bool delimit = false;
+            for(int columnOrd = 0; columnOrd < _defaults.Count; columnOrd++) {
+                if (delimit) {
+                    returnValue += ",";
+                }
+                else {
+                    delimit = true;
+                }
+
+                if (_defaults[columnOrd]) {
+                    returnValue += columnOrd;
+                }
+            }
+            returnValue += ")";
+
+            return returnValue;
+         }
+
+        #endregion
+    }
+}