Imported Upstream version 5.4.0.167

Former-commit-id: 5624ac747d633e885131e8349322922b6a59baaa

mcs/class/System.Data/corefx/DBCommandBuilder.cs

@@ -0,0 +1,91 @@
+namespace System.Data.Common
+{
+	partial class DbCommandBuilder
+	{
+		// open connection is required by OleDb/OdbcCommandBuilder.QuoteIdentifier and UnquoteIdentifier 
+		// to get literals quotes from the driver
+		internal DbConnection GetConnection()
+		{
+			DbDataAdapter adapter = DataAdapter;
+			if (adapter != null)
+			{
+				DbCommand select = adapter.SelectCommand;
+				if (select != null)
+				{
+					return select.Connection;
+				}
+			}
+
+			return null;
+		}
+
+        static internal string[] ParseProcedureName(string name, string quotePrefix, string quoteSuffix) {
+            // Procedure may consist of up to four parts:
+            // 0) Server
+            // 1) Catalog
+            // 2) Schema
+            // 3) ProcedureName
+            //
+            // Parse the string into four parts, allowing the last part to contain '.'s.
+            // If less than four period delimited parts, use the parts from procedure backwards.
+            //
+            const string Separator = ".";
+
+            string[] qualifiers = new string[4];
+            if (!ADP.IsEmpty(name)) {
+                bool useQuotes = !ADP.IsEmpty(quotePrefix) && !ADP.IsEmpty(quoteSuffix);
+
+                int currentPos = 0, parts;
+                for(parts = 0; (parts < qualifiers.Length) && (currentPos < name.Length); ++parts) {
+                    int startPos = currentPos;
+
+                    // does the part begin with a quotePrefix?
+                    if (useQuotes && (name.IndexOf(quotePrefix, currentPos, quotePrefix.Length, StringComparison.Ordinal) == currentPos)) {
+                        currentPos += quotePrefix.Length; // move past the quotePrefix
+
+                        // search for the quoteSuffix (or end of string)
+                        while (currentPos < name.Length) {
+                            currentPos = name.IndexOf(quoteSuffix, currentPos, StringComparison.Ordinal);
+                            if (currentPos < 0) {
+                                // error condition, no quoteSuffix
+                                currentPos = name.Length;
+                                break;
+                            }
+                            else {
+                                currentPos += quoteSuffix.Length; // move past the quoteSuffix
+
+                                // is this a double quoteSuffix?
+                                if ((currentPos < name.Length) && (name.IndexOf(quoteSuffix, currentPos, quoteSuffix.Length, StringComparison.Ordinal) == currentPos)) {
+                                    // a second quoteSuffix, continue search for terminating quoteSuffix
+                                    currentPos += quoteSuffix.Length; // move past the second quoteSuffix
+                                }
+                                else {
+                                    // found the terminating quoteSuffix
+                                    break;
+                                }
+                            }
+                        }
+                    }
+
+                    // search for separator (either no quotePrefix or already past quoteSuffix)
+                    if (currentPos < name.Length) {
+                        currentPos = name.IndexOf(Separator, currentPos, StringComparison.Ordinal);
+                        if ((currentPos < 0) || (parts == qualifiers.Length-1)) {
+                            // last part that can be found
+                            currentPos = name.Length;
+                        }
+                    }
+
+                    qualifiers[parts] = name.Substring(startPos, currentPos-startPos);
+                    currentPos += Separator.Length;
+                }
+
+                // allign the qualifiers if we had less than MaxQualifiers
+                for(int j = qualifiers.Length-1; 0 <= j; --j) {
+                    qualifiers[j] = ((0 < parts) ? qualifiers[--parts] : null);
+                }
+            }
+            return qualifiers;
+        }
+	}
+}

mcs/class/System.Data/corefx/DataView.cs

@@ -0,0 +1,40 @@
+namespace System.Data
+{
+	partial class DataView
+	{
+        /// <summary>
+        /// Allow construction of DataView with <see cref="System.Predicate&lt;DataRow&gt;"/> and <see cref="System.Comparison&lt;DataRow&gt;"/>
+        /// </summary>
+        /// <remarks>This is a copy of the other DataView ctor and needs to be kept in sync</remarks>
+        internal DataView(DataTable table, System.Predicate<DataRow> predicate, System.Comparison<DataRow> comparison, DataViewRowState RowState) {
+            GC.SuppressFinalize(this);
+            Bid.Trace("<ds.DataView.DataView|API> %d#, table=%d, RowState=%d{ds.DataViewRowState}\n",
+                           ObjectID, (table != null) ? table.ObjectID : 0, (int)RowState);
+            if (table == null)
+                throw ExceptionBuilder.CanNotUse();
+
+            this._dvListener = new DataViewListener(this);
+            this._locked = false;
+            this._table = table;
+            _dvListener.RegisterMetaDataEvents(this._table);
+
+            if ((((int)RowState) &
+                 ((int)~(DataViewRowState.CurrentRows | DataViewRowState.OriginalRows))) != 0) {
+                throw ExceptionBuilder.RecordStateRange();
+            }
+            else if (( ((int)RowState) & ((int)DataViewRowState.ModifiedOriginal) ) != 0 &&
+                     ( ((int)RowState) &  ((int)DataViewRowState.ModifiedCurrent) ) != 0
+                    ) {
+                throw ExceptionBuilder.SetRowStateFilter();
+            }
+            _comparison = comparison;
+            SetIndex2("", RowState, ((null != predicate) ? new RowPredicateFilter(predicate) : null), true);
+        }
+
+		/// <summary>This method exists for LinqDataView to keep a level of abstraction away from the RBTree</summary>
+		internal Range FindRecords<TKey, TRow>(Index.ComparisonBySelector<TKey, TRow> comparison, TKey key) where TRow : DataRow
+		{
+			return _index.FindRecords(comparison, key);
+		}
+	}
+}

mcs/class/System.Data/corefx/DbConnection.cs

@@ -0,0 +1,7 @@
+namespace System.Data.Common
+{
+	partial class DbConnection
+	{
+		internal DbProviderFactory ProviderFactory => DbProviderFactory;
+	}
+}

mcs/class/System.Data/corefx/FieldNameLookup.cs

@@ -0,0 +1,16 @@
+namespace System.Data.ProviderBase
+{
+	partial class FieldNameLookup
+	{
+		public int IndexOfName(string fieldName)
+		{
+			if (null == _fieldNameLookup)
+			{
+				GenerateLookup();
+			}
+			// via case sensitive search, first match with lowest ordinal matches
+			object value = _fieldNameLookup[fieldName];
+			return ((null != value) ? (int)value : -1);
+		}
+	}
+}

mcs/class/System.Data/corefx/Index.cs

@@ -0,0 +1,21 @@
+namespace System.Data
+{
+	partial class Index
+	{
+		internal delegate int ComparisonBySelector<TKey,TRow>(TKey key, TRow row) where TRow:DataRow;
+
+		/// <summary>This method exists for LinqDataView to keep a level of abstraction away from the RBTree</summary>
+		internal Range FindRecords<TKey,TRow>(ComparisonBySelector<TKey,TRow> comparison, TKey key) where TRow:DataRow
+		{
+			int x = _records.root;
+			while (IndexTree.NIL != x)
+			{
+				int c = comparison(key, (TRow)_table._recordManager[_records.Key(x)]);
+				if (c == 0) { break; }
+				if (c < 0) { x = _records.Left(x); }
+				else { x = _records.Right(x); }
+			}
+			return GetRangeFromNode(x);
+		}
+	}
+}