Port lazy initialize hidden column map to netfx (#1443)

Wraith2 · web-flow · commit a4974d448c42 · 2022-10-04T17:21:04.000-07:00
diff --git a/src/Microsoft.Data.SqlClient/netfx/src/Microsoft/Data/SqlClient/SqlDataReader.cs b/src/Microsoft.Data.SqlClient/netfx/src/Microsoft/Data/SqlClient/SqlDataReader.cs
@@ -329,8 +329,8 @@ internal virtual SmiExtendedMetaData[] GetInternalSmiMetaData()
 
             if (null != metaData && 0 < metaData.Length)
             {
-                metaDataReturn = new SmiExtendedMetaData[metaData.visibleColumns];
-
+                metaDataReturn = new SmiExtendedMetaData[metaData.VisibleColumnCount];
+                int returnIndex = 0;
                 for (int index = 0; index < metaData.Length; index++)
                 {
                     _SqlMetaData colMetaData = metaData[index];
@@ -369,7 +369,7 @@ internal virtual SmiExtendedMetaData[] GetInternalSmiMetaData()
                             length /= ADP.CharSize;
                         }
 
-                        metaDataReturn[index] = new SmiQueryMetaData(
+                        metaDataReturn[returnIndex] = new SmiQueryMetaData(
                                                         colMetaData.type,
                                                         length,
                                                         colMetaData.precision,
@@ -397,6 +397,7 @@ internal virtual SmiExtendedMetaData[] GetInternalSmiMetaData()
                                                         colMetaData.IsDifferentName,
                                                         colMetaData.IsHidden
                                                         );
+                        returnIndex += 1;
                     }
                 }
             }
@@ -458,7 +459,7 @@ override public int VisibleFieldCount
                 {
                     return 0;
                 }
-                return (md.visibleColumns);
+                return md.VisibleColumnCount;
             }
         }
 
@@ -1352,31 +1353,6 @@ private bool TryConsumeMetaData()
                 Debug.Assert(!ignored, "Parser read a row token while trying to read metadata");
             }
 
-            // we hide hidden columns from the user so build an internal map
-            // that compacts all hidden columns from the array
-            if (null != _metaData)
-            {
-
-                if (_snapshot != null && object.ReferenceEquals(_snapshot._metadata, _metaData))
-                {
-                    _metaData = (_SqlMetaDataSet)_metaData.Clone();
-                }
-
-                _metaData.visibleColumns = 0;
-
-                Debug.Assert(null == _metaData.indexMap, "non-null metaData indexmap");
-                int[] indexMap = new int[_metaData.Length];
-                for (int i = 0; i < indexMap.Length; ++i)
-                {
-                    indexMap[i] = _metaData.visibleColumns;
-
-                    if (!(_metaData[i].IsHidden))
-                    {
-                        _metaData.visibleColumns++;
-                    }
-                }
-                _metaData.indexMap = indexMap;
-            }
 
             return true;
         }
@@ -1690,15 +1666,15 @@ override public DataTable GetSchemaTable()
                 try
                 {
                     statistics = SqlStatistics.StartTimer(Statistics);
-                    if (null == _metaData || null == _metaData.schemaTable)
+                    if (null == _metaData || null == _metaData._schemaTable)
                     {
                         if (null != this.MetaData)
                         {
-                            _metaData.schemaTable = BuildSchemaTable();
-                            Debug.Assert(null != _metaData.schemaTable, "No schema information yet!");
+                            _metaData._schemaTable = BuildSchemaTable();
+                            Debug.Assert(null != _metaData._schemaTable, "No schema information yet!");
                         }
                     }
-                    return _metaData?.schemaTable;
+                    return _metaData?._schemaTable;
                 }
                 finally
                 {
@@ -2994,11 +2970,11 @@ virtual public int GetSqlValues(object[] values)
 
                 SetTimeout(_defaultTimeoutMilliseconds);
 
-                int copyLen = (values.Length < _metaData.visibleColumns) ? values.Length : _metaData.visibleColumns;
+                int copyLen = (values.Length < _metaData.VisibleColumnCount) ? values.Length : _metaData.VisibleColumnCount;
 
                 for (int i = 0; i < copyLen; i++)
                 {
-                    values[_metaData.indexMap[i]] = GetSqlValueInternal(i);
+                    values[_metaData.GetVisibleColumnIndex(i)] = GetSqlValueInternal(i);
                 }
                 return copyLen;
             }
@@ -3398,7 +3374,7 @@ override public int GetValues(object[] values)
 
                 CheckMetaDataIsReady();
 
-                int copyLen = (values.Length < _metaData.visibleColumns) ? values.Length : _metaData.visibleColumns;
+                int copyLen = (values.Length < _metaData.VisibleColumnCount) ? values.Length : _metaData.VisibleColumnCount;
                 int maximumColumn = copyLen - 1;
 
                 SetTimeout(_defaultTimeoutMilliseconds);
@@ -3414,12 +3390,19 @@ override public int GetValues(object[] values)
                 for (int i = 0; i < copyLen; i++)
                 {
                     // Get the usable, TypeSystem-compatible value from the iternal buffer
-                    values[_metaData.indexMap[i]] = GetValueFromSqlBufferInternal(_data[i], _metaData[i]);
+                    int fieldIndex = _metaData.GetVisibleColumnIndex(i);
+                    values[i] = GetValueFromSqlBufferInternal(_data[fieldIndex], _metaData[fieldIndex]);
 
                     // If this is sequential access, then we need to wipe the internal buffer
                     if ((sequentialAccess) && (i < maximumColumn))
                     {
                         _data[i].Clear();
+                        if (fieldIndex > i && fieldIndex > 0)
+                        {
+                            // if we jumped an index forward because of a hidden column see if the buffer before the 
+                            // current one was populated by the seek forward and clear it if it was
+                            _data[fieldIndex - 1].Clear();
+                        }
                     }
                 }
 
@@ -4767,7 +4750,7 @@ internal bool TrySetMetaData(_SqlMetaDataSet metaData, bool moreInfo)
             _tableNames = null;
             if (_metaData != null)
             {
-                _metaData.schemaTable = null;
+                _metaData._schemaTable = null;
                 _data = SqlBuffer.CreateBufferArray(metaData.Length);
             }
 
diff --git a/src/Microsoft.Data.SqlClient/netfx/src/Microsoft/Data/SqlClient/TdsParser.cs b/src/Microsoft.Data.SqlClient/netfx/src/Microsoft/Data/SqlClient/TdsParser.cs
@@ -5094,7 +5094,6 @@ internal bool TryProcessAltMetaData(int cColumns, TdsParserStateObject stateObj,
 
             metaData = null;
             _SqlMetaDataSet altMetaDataSet = new _SqlMetaDataSet(cColumns, null);
-            int[] indexMap = new int[cColumns];
 
             if (!stateObj.TryReadUInt16(out altMetaDataSet.id))
             {
@@ -5191,12 +5190,8 @@ internal bool TryProcessAltMetaData(int cColumns, TdsParserStateObject stateObj,
                             break;
                     }
                 }
-                indexMap[i] = i;
             }
 
-            altMetaDataSet.indexMap = indexMap;
-            altMetaDataSet.visibleColumns = cColumns;
-
             metaData = altMetaDataSet;
             return true;
         }
diff --git a/src/Microsoft.Data.SqlClient/netfx/src/Microsoft/Data/SqlClient/TdsParserHelperClasses.cs b/src/Microsoft.Data.SqlClient/netfx/src/Microsoft/Data/SqlClient/TdsParserHelperClasses.cs
@@ -511,73 +511,130 @@ public object Clone()
         }
     }
 
-    sealed internal class _SqlMetaDataSet : ICloneable
+    sealed internal class _SqlMetaDataSet 
     {
         internal ushort id;             // for altrow-columns only
-        internal int[] indexMap;
-        internal int visibleColumns;
-        internal DataTable schemaTable;
+        internal DataTable _schemaTable;
         internal readonly SqlTceCipherInfoTable cekTable; // table of "column encryption keys" used for this metadataset
-        internal readonly _SqlMetaData[] metaDataArray;
+        internal readonly _SqlMetaData[] _metaDataArray;
+        private int _hiddenColumnCount;
+        private int[] _visibleColumnMap;
 
         internal _SqlMetaDataSet(int count, SqlTceCipherInfoTable cipherTable)
         {
+            _hiddenColumnCount = -1;
             cekTable = cipherTable;
-            metaDataArray = new _SqlMetaData[count];
-            for (int i = 0; i < metaDataArray.Length; ++i)
+            _metaDataArray = new _SqlMetaData[count];
+            for (int i = 0; i < _metaDataArray.Length; ++i)
             {
-                metaDataArray[i] = new _SqlMetaData(i);
+                _metaDataArray[i] = new _SqlMetaData(i);
             }
         }
 
         private _SqlMetaDataSet(_SqlMetaDataSet original)
         {
-            this.id = original.id;
-            // although indexMap is not immutable, in practice it is initialized once and then passed around
-            this.indexMap = original.indexMap;
-            this.visibleColumns = original.visibleColumns;
-            this.schemaTable = original.schemaTable;
-            if (original.metaDataArray == null)
+            id = original.id;
+            _hiddenColumnCount = original._hiddenColumnCount;
+            _visibleColumnMap = original._visibleColumnMap;
+            _schemaTable = original._schemaTable;
+            if (original._metaDataArray == null)
             {
-                metaDataArray = null;
+                _metaDataArray = null;
             }
             else
             {
-                metaDataArray = new _SqlMetaData[original.metaDataArray.Length];
-                for (int idx = 0; idx < metaDataArray.Length; idx++)
+                _metaDataArray = new _SqlMetaData[original._metaDataArray.Length];
+                for (int idx = 0; idx < _metaDataArray.Length; idx++)
                 {
-                    metaDataArray[idx] = (_SqlMetaData)original.metaDataArray[idx].Clone();
+                    _metaDataArray[idx] = (_SqlMetaData)original._metaDataArray[idx].Clone();
                 }
             }
         }
 
+        internal int VisibleColumnCount
+        {
+            get
+            {
+                if (_hiddenColumnCount == -1)
+                {
+                    SetupHiddenColumns();
+                }
+                return Length - _hiddenColumnCount;
+            }
+        }
+
         internal int Length
         {
             get
             {
-                return metaDataArray.Length;
+                return _metaDataArray.Length;
             }
         }
 
         internal _SqlMetaData this[int index]
         {
             get
             {
-                return metaDataArray[index];
+                return _metaDataArray[index];
             }
             set
             {
                 Debug.Assert(null == value, "used only by SqlBulkCopy");
-                metaDataArray[index] = value;
+                _metaDataArray[index] = value;
             }
         }
 
-        public object Clone()
+        public int GetVisibleColumnIndex(int index)
+        {
+            if (_hiddenColumnCount == -1)
+            {
+                SetupHiddenColumns();
+            }
+            if (_visibleColumnMap is null)
+            {
+                return index;
+            }
+            else
+            {
+                return _visibleColumnMap[index];
+            }
+        }
+
+        public _SqlMetaDataSet Clone()
         {
             return new _SqlMetaDataSet(this);
         }
+
+        private void SetupHiddenColumns()
+        {
+            int hiddenColumnCount = 0;
+            for (int index = 0; index < Length; index++)
+            {
+                if (_metaDataArray[index].IsHidden)
+                {
+                    hiddenColumnCount += 1;
+                }
+            }
+
+            if (hiddenColumnCount > 0)
+            {
+                int[] visibleColumnMap = new int[Length - hiddenColumnCount];
+                int mapIndex = 0;
+                for (int metaDataIndex = 0; metaDataIndex < Length; metaDataIndex++)
+                {
+                    if (!_metaDataArray[metaDataIndex].IsHidden)
+                    {
+                        visibleColumnMap[mapIndex] = metaDataIndex;
+                        mapIndex += 1;
+                    }
+                }
+                _visibleColumnMap = visibleColumnMap;
+            }
+            _hiddenColumnCount = hiddenColumnCount;
+        }
     }
 
+
     sealed internal class _SqlMetaDataSetCollection : ICloneable
     {
         private readonly List<_SqlMetaDataSet> altMetaDataSetArray;
@@ -622,10 +679,10 @@ internal _SqlMetaDataSet GetAltMetaData(int id)
         public object Clone()
         {
             _SqlMetaDataSetCollection result = new _SqlMetaDataSetCollection();
-            result.metaDataSet = metaDataSet == null ? null : (_SqlMetaDataSet)metaDataSet.Clone();
+            result.metaDataSet = metaDataSet == null ? null : metaDataSet.Clone();
             foreach (_SqlMetaDataSet set in altMetaDataSetArray)
             {
-                result.altMetaDataSetArray.Add((_SqlMetaDataSet)set.Clone());
+                result.altMetaDataSetArray.Add(set.Clone());
             }
             return result;
         }

Original file line number	Diff line number	Diff line change
`@@ -329,8 +329,8 @@ internal virtual SmiExtendedMetaData[] GetInternalSmiMetaData()`
`329`	`329`
`330`	`330`	`if (null != metaData && 0 < metaData.Length)`
`331`	`331`	`{`
`332`		`- metaDataReturn = new SmiExtendedMetaData[metaData.visibleColumns];`
`333`		`-`
	`332`	`+ metaDataReturn = new SmiExtendedMetaData[metaData.VisibleColumnCount];`
	`333`	`+ int returnIndex = 0;`
`334`	`334`	`for (int index = 0; index < metaData.Length; index++)`
`335`	`335`	`{`
`336`	`336`	`_SqlMetaData colMetaData = metaData[index];`
`@@ -369,7 +369,7 @@ internal virtual SmiExtendedMetaData[] GetInternalSmiMetaData()`
`369`	`369`	`length /= ADP.CharSize;`
`370`	`370`	`}`
`371`	`371`
`372`		`- metaDataReturn[index] = new SmiQueryMetaData(`
	`372`	`+ metaDataReturn[returnIndex] = new SmiQueryMetaData(`
`373`	`373`	`colMetaData.type,`
`374`	`374`	`length,`
`375`	`375`	`colMetaData.precision,`
`@@ -397,6 +397,7 @@ internal virtual SmiExtendedMetaData[] GetInternalSmiMetaData()`
`397`	`397`	`colMetaData.IsDifferentName,`
`398`	`398`	`colMetaData.IsHidden`
`399`	`399`	`);`
	`400`	`+ returnIndex += 1;`
`400`	`401`	`}`
`401`	`402`	`}`
`402`	`403`	`}`
`@@ -458,7 +459,7 @@ override public int VisibleFieldCount`
`458`	`459`	`{`
`459`	`460`	`return 0;`
`460`	`461`	`}`
`461`		`- return (md.visibleColumns);`
	`462`	`+ return md.VisibleColumnCount;`
`462`	`463`	`}`
`463`	`464`	`}`
`464`	`465`
`@@ -1352,31 +1353,6 @@ private bool TryConsumeMetaData()`
`1352`	`1353`	`Debug.Assert(!ignored, "Parser read a row token while trying to read metadata");`
`1353`	`1354`	`}`
`1354`	`1355`
`1355`		`- // we hide hidden columns from the user so build an internal map`
`1356`		`- // that compacts all hidden columns from the array`
`1357`		`- if (null != _metaData)`
`1358`		`- {`
`1359`		`-`
`1360`		`- if (_snapshot != null && object.ReferenceEquals(_snapshot._metadata, _metaData))`
`1361`		`- {`
`1362`		`- _metaData = (_SqlMetaDataSet)_metaData.Clone();`
`1363`		`- }`
`1364`		`-`
`1365`		`- _metaData.visibleColumns = 0;`
`1366`		`-`
`1367`		`- Debug.Assert(null == _metaData.indexMap, "non-null metaData indexmap");`
`1368`		`- int[] indexMap = new int[_metaData.Length];`
`1369`		`- for (int i = 0; i < indexMap.Length; ++i)`
`1370`		`- {`
`1371`		`- indexMap[i] = _metaData.visibleColumns;`
`1372`		`-`
`1373`		`- if (!(_metaData[i].IsHidden))`
`1374`		`- {`
`1375`		`- _metaData.visibleColumns++;`
`1376`		`- }`
`1377`		`- }`
`1378`		`- _metaData.indexMap = indexMap;`
`1379`		`- }`
`1380`	`1356`
`1381`	`1357`	`return true;`
`1382`	`1358`	`}`
`@@ -1690,15 +1666,15 @@ override public DataTable GetSchemaTable()`
`1690`	`1666`	`try`
`1691`	`1667`	`{`
`1692`	`1668`	`statistics = SqlStatistics.StartTimer(Statistics);`
`1693`		`- if (null == _metaData \|\| null == _metaData.schemaTable)`
	`1669`	`+ if (null == _metaData \|\| null == _metaData._schemaTable)`
`1694`	`1670`	`{`
`1695`	`1671`	`if (null != this.MetaData)`
`1696`	`1672`	`{`
`1697`		`- _metaData.schemaTable = BuildSchemaTable();`
`1698`		`- Debug.Assert(null != _metaData.schemaTable, "No schema information yet!");`
	`1673`	`+ _metaData._schemaTable = BuildSchemaTable();`
	`1674`	`+ Debug.Assert(null != _metaData._schemaTable, "No schema information yet!");`
`1699`	`1675`	`}`
`1700`	`1676`	`}`
`1701`		`- return _metaData?.schemaTable;`
	`1677`	`+ return _metaData?._schemaTable;`
`1702`	`1678`	`}`
`1703`	`1679`	`finally`
`1704`	`1680`	`{`
`@@ -2994,11 +2970,11 @@ virtual public int GetSqlValues(object[] values)`
`2994`	`2970`
`2995`	`2971`	`SetTimeout(_defaultTimeoutMilliseconds);`
`2996`	`2972`
`2997`		`- int copyLen = (values.Length < _metaData.visibleColumns) ? values.Length : _metaData.visibleColumns;`
	`2973`	`+ int copyLen = (values.Length < _metaData.VisibleColumnCount) ? values.Length : _metaData.VisibleColumnCount;`
`2998`	`2974`
`2999`	`2975`	`for (int i = 0; i < copyLen; i++)`
`3000`	`2976`	`{`
`3001`		`- values[_metaData.indexMap[i]] = GetSqlValueInternal(i);`
	`2977`	`+ values[_metaData.GetVisibleColumnIndex(i)] = GetSqlValueInternal(i);`
`3002`	`2978`	`}`
`3003`	`2979`	`return copyLen;`
`3004`	`2980`	`}`
`@@ -3398,7 +3374,7 @@ override public int GetValues(object[] values)`
`3398`	`3374`
`3399`	`3375`	`CheckMetaDataIsReady();`
`3400`	`3376`
`3401`		`- int copyLen = (values.Length < _metaData.visibleColumns) ? values.Length : _metaData.visibleColumns;`
	`3377`	`+ int copyLen = (values.Length < _metaData.VisibleColumnCount) ? values.Length : _metaData.VisibleColumnCount;`
`3402`	`3378`	`int maximumColumn = copyLen - 1;`
`3403`	`3379`
`3404`	`3380`	`SetTimeout(_defaultTimeoutMilliseconds);`
`@@ -3414,12 +3390,19 @@ override public int GetValues(object[] values)`
`3414`	`3390`	`for (int i = 0; i < copyLen; i++)`
`3415`	`3391`	`{`
`3416`	`3392`	`// Get the usable, TypeSystem-compatible value from the iternal buffer`
`3417`		`- values[_metaData.indexMap[i]] = GetValueFromSqlBufferInternal(_data[i], _metaData[i]);`
	`3393`	`+ int fieldIndex = _metaData.GetVisibleColumnIndex(i);`
	`3394`	`+ values[i] = GetValueFromSqlBufferInternal(_data[fieldIndex], _metaData[fieldIndex]);`
`3418`	`3395`
`3419`	`3396`	`// If this is sequential access, then we need to wipe the internal buffer`
`3420`	`3397`	`if ((sequentialAccess) && (i < maximumColumn))`
`3421`	`3398`	`{`
`3422`	`3399`	`_data[i].Clear();`
	`3400`	`+ if (fieldIndex > i && fieldIndex > 0)`
	`3401`	`+ {`
	`3402`	`+ // if we jumped an index forward because of a hidden column see if the buffer before the`
	`3403`	`+ // current one was populated by the seek forward and clear it if it was`
	`3404`	`+ _data[fieldIndex - 1].Clear();`
	`3405`	`+ }`
`3423`	`3406`	`}`
`3424`	`3407`	`}`
`3425`	`3408`
`@@ -4767,7 +4750,7 @@ internal bool TrySetMetaData(_SqlMetaDataSet metaData, bool moreInfo)`
`4767`	`4750`	`_tableNames = null;`
`4768`	`4751`	`if (_metaData != null)`
`4769`	`4752`	`{`
`4770`		`- _metaData.schemaTable = null;`
	`4753`	`+ _metaData._schemaTable = null;`
`4771`	`4754`	`_data = SqlBuffer.CreateBufferArray(metaData.Length);`
`4772`	`4755`	`}`
`4773`	`4756`
Original file line number	Diff line number	Diff line change
`@@ -5094,7 +5094,6 @@ internal bool TryProcessAltMetaData(int cColumns, TdsParserStateObject stateObj,`
`5094`	`5094`
`5095`	`5095`	`metaData = null;`
`5096`	`5096`	`_SqlMetaDataSet altMetaDataSet = new _SqlMetaDataSet(cColumns, null);`
`5097`		`- int[] indexMap = new int[cColumns];`
`5098`	`5097`
`5099`	`5098`	`if (!stateObj.TryReadUInt16(out altMetaDataSet.id))`
`5100`	`5099`	`{`
`@@ -5191,12 +5190,8 @@ internal bool TryProcessAltMetaData(int cColumns, TdsParserStateObject stateObj,`
`5191`	`5190`	`break;`
`5192`	`5191`	`}`
`5193`	`5192`	`}`
`5194`		`- indexMap[i] = i;`
`5195`	`5193`	`}`
`5196`	`5194`
`5197`		`- altMetaDataSet.indexMap = indexMap;`
`5198`		`- altMetaDataSet.visibleColumns = cColumns;`
`5199`		`-`
`5200`	`5195`	`metaData = altMetaDataSet;`
`5201`	`5196`	`return true;`
`5202`	`5197`	`}`
Original file line number	Diff line number	Diff line change
`@@ -511,73 +511,130 @@ public object Clone()`
`511`	`511`	`}`
`512`	`512`	`}`
`513`	`513`
`514`		`- sealed internal class _SqlMetaDataSet : ICloneable`
	`514`	`+ sealed internal class _SqlMetaDataSet`
`515`	`515`	`{`
`516`	`516`	`internal ushort id; // for altrow-columns only`
`517`		`- internal int[] indexMap;`
`518`		`- internal int visibleColumns;`
`519`		`- internal DataTable schemaTable;`
	`517`	`+ internal DataTable _schemaTable;`
`520`	`518`	`internal readonly SqlTceCipherInfoTable cekTable; // table of "column encryption keys" used for this metadataset`
`521`		`- internal readonly _SqlMetaData[] metaDataArray;`
	`519`	`+ internal readonly _SqlMetaData[] _metaDataArray;`
	`520`	`+ private int _hiddenColumnCount;`
	`521`	`+ private int[] _visibleColumnMap;`
`522`	`522`
`523`	`523`	`internal _SqlMetaDataSet(int count, SqlTceCipherInfoTable cipherTable)`
`524`	`524`	`{`
	`525`	`+ _hiddenColumnCount = -1;`
`525`	`526`	`cekTable = cipherTable;`
`526`		`- metaDataArray = new _SqlMetaData[count];`
`527`		`- for (int i = 0; i < metaDataArray.Length; ++i)`
	`527`	`+ _metaDataArray = new _SqlMetaData[count];`
	`528`	`+ for (int i = 0; i < _metaDataArray.Length; ++i)`
`528`	`529`	`{`
`529`		`- metaDataArray[i] = new _SqlMetaData(i);`
	`530`	`+ _metaDataArray[i] = new _SqlMetaData(i);`
`530`	`531`	`}`
`531`	`532`	`}`
`532`	`533`
`533`	`534`	`private _SqlMetaDataSet(_SqlMetaDataSet original)`
`534`	`535`	`{`
`535`		`- this.id = original.id;`
`536`		`- // although indexMap is not immutable, in practice it is initialized once and then passed around`
`537`		`- this.indexMap = original.indexMap;`
`538`		`- this.visibleColumns = original.visibleColumns;`
`539`		`- this.schemaTable = original.schemaTable;`
`540`		`- if (original.metaDataArray == null)`
	`536`	`+ id = original.id;`
	`537`	`+ _hiddenColumnCount = original._hiddenColumnCount;`
	`538`	`+ _visibleColumnMap = original._visibleColumnMap;`
	`539`	`+ _schemaTable = original._schemaTable;`
	`540`	`+ if (original._metaDataArray == null)`
`541`	`541`	`{`
`542`		`- metaDataArray = null;`
	`542`	`+ _metaDataArray = null;`
`543`	`543`	`}`
`544`	`544`	`else`
`545`	`545`	`{`
`546`		`- metaDataArray = new _SqlMetaData[original.metaDataArray.Length];`
`547`		`- for (int idx = 0; idx < metaDataArray.Length; idx++)`
	`546`	`+ _metaDataArray = new _SqlMetaData[original._metaDataArray.Length];`
	`547`	`+ for (int idx = 0; idx < _metaDataArray.Length; idx++)`
`548`	`548`	`{`
`549`		`- metaDataArray[idx] = (_SqlMetaData)original.metaDataArray[idx].Clone();`
	`549`	`+ _metaDataArray[idx] = (_SqlMetaData)original._metaDataArray[idx].Clone();`
`550`	`550`	`}`
`551`	`551`	`}`
`552`	`552`	`}`
`553`	`553`
	`554`	`+ internal int VisibleColumnCount`
	`555`	`+ {`
	`556`	`+ get`
	`557`	`+ {`
	`558`	`+ if (_hiddenColumnCount == -1)`
	`559`	`+ {`
	`560`	`+ SetupHiddenColumns();`
	`561`	`+ }`
	`562`	`+ return Length - _hiddenColumnCount;`
	`563`	`+ }`
	`564`	`+ }`
	`565`	`+`
`554`	`566`	`internal int Length`
`555`	`567`	`{`
`556`	`568`	`get`
`557`	`569`	`{`
`558`		`- return metaDataArray.Length;`
	`570`	`+ return _metaDataArray.Length;`
`559`	`571`	`}`
`560`	`572`	`}`
`561`	`573`
`562`	`574`	`internal _SqlMetaData this[int index]`
`563`	`575`	`{`
`564`	`576`	`get`
`565`	`577`	`{`
`566`		`- return metaDataArray[index];`
	`578`	`+ return _metaDataArray[index];`
`567`	`579`	`}`
`568`	`580`	`set`
`569`	`581`	`{`
`570`	`582`	`Debug.Assert(null == value, "used only by SqlBulkCopy");`
`571`		`- metaDataArray[index] = value;`
	`583`	`+ _metaDataArray[index] = value;`
`572`	`584`	`}`
`573`	`585`	`}`
`574`	`586`
`575`		`- public object Clone()`
	`587`	`+ public int GetVisibleColumnIndex(int index)`
	`588`	`+ {`
	`589`	`+ if (_hiddenColumnCount == -1)`
	`590`	`+ {`
	`591`	`+ SetupHiddenColumns();`
	`592`	`+ }`
	`593`	`+ if (_visibleColumnMap is null)`
	`594`	`+ {`
	`595`	`+ return index;`
	`596`	`+ }`
	`597`	`+ else`
	`598`	`+ {`
	`599`	`+ return _visibleColumnMap[index];`
	`600`	`+ }`
	`601`	`+ }`
	`602`	`+`
	`603`	`+ public _SqlMetaDataSet Clone()`
`576`	`604`	`{`
`577`	`605`	`return new _SqlMetaDataSet(this);`
`578`	`606`	`}`
	`607`	`+`
	`608`	`+ private void SetupHiddenColumns()`
	`609`	`+ {`
	`610`	`+ int hiddenColumnCount = 0;`
	`611`	`+ for (int index = 0; index < Length; index++)`
	`612`	`+ {`
	`613`	`+ if (_metaDataArray[index].IsHidden)`
	`614`	`+ {`
	`615`	`+ hiddenColumnCount += 1;`
	`616`	`+ }`
	`617`	`+ }`
	`618`	`+`
	`619`	`+ if (hiddenColumnCount > 0)`
	`620`	`+ {`
	`621`	`+ int[] visibleColumnMap = new int[Length - hiddenColumnCount];`
	`622`	`+ int mapIndex = 0;`
	`623`	`+ for (int metaDataIndex = 0; metaDataIndex < Length; metaDataIndex++)`
	`624`	`+ {`
	`625`	`+ if (!_metaDataArray[metaDataIndex].IsHidden)`
	`626`	`+ {`
	`627`	`+ visibleColumnMap[mapIndex] = metaDataIndex;`
	`628`	`+ mapIndex += 1;`
	`629`	`+ }`
	`630`	`+ }`
	`631`	`+ _visibleColumnMap = visibleColumnMap;`
	`632`	`+ }`
	`633`	`+ _hiddenColumnCount = hiddenColumnCount;`
	`634`	`+ }`
`579`	`635`	`}`
`580`	`636`
	`637`	`+`
`581`	`638`	`sealed internal class _SqlMetaDataSetCollection : ICloneable`
`582`	`639`	`{`
`583`	`640`	`private readonly List<_SqlMetaDataSet> altMetaDataSetArray;`
`@@ -622,10 +679,10 @@ internal _SqlMetaDataSet GetAltMetaData(int id)`
`622`	`679`	`public object Clone()`
`623`	`680`	`{`
`624`	`681`	`_SqlMetaDataSetCollection result = new _SqlMetaDataSetCollection();`
`625`		`- result.metaDataSet = metaDataSet == null ? null : (_SqlMetaDataSet)metaDataSet.Clone();`
	`682`	`+ result.metaDataSet = metaDataSet == null ? null : metaDataSet.Clone();`
`626`	`683`	`foreach (_SqlMetaDataSet set in altMetaDataSetArray)`
`627`	`684`	`{`
`628`		`- result.altMetaDataSetArray.Add((_SqlMetaDataSet)set.Clone());`
	`685`	`+ result.altMetaDataSetArray.Add(set.Clone());`
`629`	`686`	`}`
`630`	`687`	`return result;`
`631`	`688`	`}`