NH-3807 - Replace use of InvariantCultureIgnoreCase with OrdinalIgnoreCase.

ngbrown · ngbrown · commit 59da1f32822b · 2016-08-21T14:47:53.000-07:00
StringComparison.InvariantCultureIgnoreCase and StringComparer.InvariantCultureIgnoreCase has been removed from CoreClr.
diff --git a/src/NHibernate.Test/NHSpecificTest/NH732/Fixture.cs b/src/NHibernate.Test/NHSpecificTest/NH732/Fixture.cs
@@ -70,12 +70,12 @@ public System.Type ReturnedType
 		
 		public new bool Equals(object x, object y)
 		{
-			return StringComparer.InvariantCultureIgnoreCase.Equals((string)x, (string)y);
+			return StringComparer.OrdinalIgnoreCase.Equals((string)x, (string)y);
 		}
 
 		public int GetHashCode(object x)
 		{
-			return StringComparer.InvariantCultureIgnoreCase.GetHashCode((string)x);
+			return StringComparer.OrdinalIgnoreCase.GetHashCode((string)x);
 		}
 
 		public object NullSafeGet(DbDataReader rs, string[] names, object owner)
diff --git a/src/NHibernate/Cfg/Mappings.cs b/src/NHibernate/Cfg/Mappings.cs
@@ -538,7 +538,7 @@ public void AddColumnBinding(string logicalName, Column finalColumn, Table table
 			if (oldFinalName != null &&
 					!(finalColumn.IsQuoted
 							? oldFinalName.Equals(finalColumn.GetQuotedName())
-							: oldFinalName.Equals(finalColumn.GetQuotedName(), StringComparison.InvariantCultureIgnoreCase)))
+							: oldFinalName.Equals(finalColumn.GetQuotedName(), StringComparison.OrdinalIgnoreCase)))
 			{
 				//TODO possibly relax that
 				throw new MappingException("Same logical column name referenced by different physical ones: " + table.Name + "."
diff --git a/src/NHibernate/Dialect/Function/CastFunction.cs b/src/NHibernate/Dialect/Function/CastFunction.cs
@@ -93,7 +93,7 @@ protected virtual bool CastingIsRequired(string sqlType)
 
 		bool IFunctionGrammar.IsSeparator(string token)
 		{
-			return "as".Equals(token, StringComparison.InvariantCultureIgnoreCase);
+			return "as".Equals(token, StringComparison.OrdinalIgnoreCase);
 		}
 
 		bool IFunctionGrammar.IsKnownArgument(string token)
diff --git a/src/NHibernate/Dialect/Function/SQLFunctionRegistry.cs b/src/NHibernate/Dialect/Function/SQLFunctionRegistry.cs
@@ -12,7 +12,7 @@ public SQLFunctionRegistry(Dialect dialect, IDictionary<string, ISQLFunction> us
 		{
 			this.dialect = dialect;
 			this.userFunctions = new Dictionary<string, ISQLFunction>(userFunctions,
-				StringComparer.InvariantCultureIgnoreCase);
+				StringComparer.OrdinalIgnoreCase);
 		}
 
 		public ISQLFunction FindSQLFunction(string functionName)
diff --git a/src/NHibernate/Hql/Ast/ANTLR/Tree/FromClause.cs b/src/NHibernate/Hql/Ast/ANTLR/Tree/FromClause.cs
@@ -325,7 +325,7 @@ private FromElement FindIntendedAliasedFromElementBasedOnCrazyJPARequirements(st
 			foreach (var entry in _fromElementByClassAlias)
 			{
 				string alias = entry.Key;
-				if (string.Equals(alias, specifiedAlias, StringComparison.InvariantCultureIgnoreCase))
+				if (string.Equals(alias, specifiedAlias, StringComparison.OrdinalIgnoreCase))
 				{
 					return entry.Value;
 				}
diff --git a/src/NHibernate/Mapping/ByCode/SimpleModelInspector.cs b/src/NHibernate/Mapping/ByCode/SimpleModelInspector.cs
@@ -353,10 +353,10 @@ protected bool CanReadCantWriteInBaseType(PropertyInfo property)
 		protected bool MatchPoIdPattern(MemberInfo subject)
 		{
 			var name = subject.Name;
-			return name.Equals("id", StringComparison.InvariantCultureIgnoreCase)
-						 || name.Equals("poid", StringComparison.InvariantCultureIgnoreCase)
-						 || name.Equals("oid", StringComparison.InvariantCultureIgnoreCase)
-						 || (name.StartsWith(subject.DeclaringType.Name) && name.Equals(subject.DeclaringType.Name + "id", StringComparison.InvariantCultureIgnoreCase));
+			return name.Equals("id", StringComparison.OrdinalIgnoreCase)
+						 || name.Equals("poid", StringComparison.OrdinalIgnoreCase)
+						 || name.Equals("oid", StringComparison.OrdinalIgnoreCase)
+						 || (name.StartsWith(subject.DeclaringType.Name) && name.Equals(subject.DeclaringType.Name + "id", StringComparison.OrdinalIgnoreCase));
 		}
 
 		protected bool MatchComponentPattern(System.Type subject)
@@ -1083,4 +1083,4 @@ public void IsDynamicComponent(Func<MemberInfo, bool, bool> match)
 			isDynamicComponent = match;
 		}
 	}
-}
+}
diff --git a/src/NHibernate/Mapping/ManyToOne.cs b/src/NHibernate/Mapping/ManyToOne.cs
@@ -73,7 +73,7 @@ public void CreatePropertyRefConstraints(IDictionary<string, PersistentClass> pe
 				if (property == null)
 					throw new MappingException("Could not find property " + ReferencedPropertyName + " on " + ReferencedEntityName);
 
-				if (!HasFormula && !"none".Equals(ForeignKeyName, StringComparison.InvariantCultureIgnoreCase))
+				if (!HasFormula && !"none".Equals(ForeignKeyName, StringComparison.OrdinalIgnoreCase))
 				{
 
 					IEnumerable<Column> ce = new SafetyEnumerable<Column>(property.ColumnIterator);
@@ -92,4 +92,4 @@ public void CreatePropertyRefConstraints(IDictionary<string, PersistentClass> pe
 			}
 		}
 	}
-}
+}
diff --git a/src/NHibernate/Mapping/ReferenceDependantValue.cs b/src/NHibernate/Mapping/ReferenceDependantValue.cs
@@ -24,7 +24,7 @@ public IEnumerable<Column> ReferenceColumns
 
 		public override void CreateForeignKeyOfEntity(string entityName)
 		{
-			if (!HasFormula && !string.Equals("none", ForeignKeyName, StringComparison.InvariantCultureIgnoreCase))
+			if (!HasFormula && !string.Equals("none", ForeignKeyName, StringComparison.OrdinalIgnoreCase))
 			{
 				var referencedColumns = new List<Column>(_prototype.ColumnSpan);
 				foreach (Column column in _prototype.ColumnIterator)
diff --git a/src/NHibernate/Mapping/SimpleValue.cs b/src/NHibernate/Mapping/SimpleValue.cs
@@ -75,7 +75,7 @@ public virtual bool IsComposite
 
 		public virtual void CreateForeignKeyOfEntity(string entityName)
 		{
-			if (!HasFormula && ! "none".Equals(ForeignKeyName, StringComparison.InvariantCultureIgnoreCase))
+			if (!HasFormula && ! "none".Equals(ForeignKeyName, StringComparison.OrdinalIgnoreCase))
 			{
 				ForeignKey fk = table.CreateForeignKey(ForeignKeyName, ConstraintColumns, entityName);
 				fk.CascadeDeleteEnabled = cascadeDeleteEnabled;
diff --git a/src/NHibernate/SqlCommand/Parser/MsSqlSelectParser.cs b/src/NHibernate/SqlCommand/Parser/MsSqlSelectParser.cs
@@ -134,15 +134,15 @@ private IEnumerable<ColumnDefinition> ParseColumnDefinitions(IEnumerator<SqlToke
 					case SqlTokenType.Text:
 						if (blockLevel != 0) break;
 
-						if (token.Equals(",", StringComparison.InvariantCultureIgnoreCase))
+						if (token.Equals(",", StringComparison.OrdinalIgnoreCase))
 						{
 							if (columnAliasToken != null)
 							{
 								yield return ParseSelectColumnDefinition(columnBeginToken, columnEndToken ?? columnAliasToken, columnAliasToken);
 							}
 						}
 
-						if (token.Equals("from", StringComparison.InvariantCultureIgnoreCase))
+						if (token.Equals("from", StringComparison.OrdinalIgnoreCase))
 						{
 							if (columnAliasToken != null)
 							{
@@ -151,7 +151,7 @@ private IEnumerable<ColumnDefinition> ParseColumnDefinitions(IEnumerator<SqlToke
 							yield break;
 						}
 
-						if (token.Equals("as", StringComparison.InvariantCultureIgnoreCase))
+						if (token.Equals("as", StringComparison.OrdinalIgnoreCase))
 						{
 							columnEndToken = prevToken;
 						}
@@ -240,8 +240,8 @@ private IEnumerable<OrderDefinition> ParseOrderDefinitions(IEnumerator<SqlToken>
 					case SqlTokenType.Text:
 						if (blockLevel != 0) break;
 
-						if (token.Equals("asc", StringComparison.InvariantCultureIgnoreCase)
-							|| token.Equals("desc", StringComparison.InvariantCultureIgnoreCase))
+						if (token.Equals("asc", StringComparison.OrdinalIgnoreCase)
+							|| token.Equals("desc", StringComparison.OrdinalIgnoreCase))
 						{
 							orderEndToken = prevToken;
 							directionToken = token;
@@ -272,7 +272,7 @@ private IEnumerable<OrderDefinition> ParseOrderDefinitions(IEnumerator<SqlToken>
 		private OrderDefinition ParseOrderDefinition(SqlToken beginToken, SqlToken endToken, SqlToken directionToken)
 		{
 			var isDescending = directionToken != null &&
-							   directionToken.Equals("desc", StringComparison.InvariantCultureIgnoreCase);
+							   directionToken.Equals("desc", StringComparison.OrdinalIgnoreCase);
 
 			var columnNameOrIndex = beginToken == endToken
 				? beginToken.Value
@@ -301,8 +301,8 @@ private bool TryGetColumnDefinition(string columnNameOrIndex, out ColumnDefiniti
 
 				foreach (var column in _columns)
 				{
-					if (columnNameOrIndex.Equals(column.Name, StringComparison.InvariantCultureIgnoreCase)
-						|| columnNameOrIndex.Equals(column.Alias, StringComparison.InvariantCultureIgnoreCase))
+					if (columnNameOrIndex.Equals(column.Name, StringComparison.OrdinalIgnoreCase)
+						|| columnNameOrIndex.Equals(column.Alias, StringComparison.OrdinalIgnoreCase))
 					{
 						result = column;
 						return true;
@@ -316,9 +316,9 @@ private bool TryGetColumnDefinition(string columnNameOrIndex, out ColumnDefiniti
 				var text = Sql.ToString(sqlIndex, sqlLength);
 				foreach (var column in _columns)
 				{
-					if (text.Equals(column.Name, StringComparison.InvariantCultureIgnoreCase) ||
-						text.Equals(column.Alias, StringComparison.InvariantCultureIgnoreCase) ||
-						text.Equals(Sql.ToString(column.SqlIndex, column.SqlLength), StringComparison.InvariantCultureIgnoreCase))
+					if (text.Equals(column.Name, StringComparison.OrdinalIgnoreCase) ||
+						text.Equals(column.Alias, StringComparison.OrdinalIgnoreCase) ||
+						text.Equals(Sql.ToString(column.SqlIndex, column.SqlLength), StringComparison.OrdinalIgnoreCase))
 					{
 						result = column;
 						return true;
diff --git a/src/NHibernate/SqlCommand/Parser/SqlTokenizerExtensions.cs b/src/NHibernate/SqlCommand/Parser/SqlTokenizerExtensions.cs
@@ -22,7 +22,7 @@ public static bool TryParseUntil(this IEnumerator<SqlToken> tokenEnum, string ke
 							nestLevel--;
 							break;
 						case SqlTokenType.Text:
-							if (nestLevel == 0 && token.Equals(keyword, StringComparison.InvariantCultureIgnoreCase)) return true;
+							if (nestLevel == 0 && token.Equals(keyword, StringComparison.OrdinalIgnoreCase)) return true;
 							break;
 					}
 				}
@@ -49,18 +49,18 @@ public static bool TryParseUntilFirstMsSqlSelectColumn(this IEnumerator<SqlToken
 				if (!tokenEnum.MoveNext()) return false;
 
 				// [ DISTINCT | ALL ]
-				if (tokenEnum.Current.Equals("distinct", StringComparison.InvariantCultureIgnoreCase))
+				if (tokenEnum.Current.Equals("distinct", StringComparison.OrdinalIgnoreCase))
 				{
 					isDistinct = true;
 					if (!tokenEnum.MoveNext()) return false;
 				}
-				else if	(tokenEnum.Current.Equals("all", StringComparison.InvariantCultureIgnoreCase))
+				else if	(tokenEnum.Current.Equals("all", StringComparison.OrdinalIgnoreCase))
 				{
 					if (!tokenEnum.MoveNext()) return false;
 				}
 
 				// [ TOP { integer | ( expression ) } [PERCENT] [ WITH TIES ] ] 
-				if (tokenEnum.Current.Equals("top", StringComparison.InvariantCultureIgnoreCase))
+				if (tokenEnum.Current.Equals("top", StringComparison.OrdinalIgnoreCase))
 				{
 					if (!tokenEnum.MoveNext()) return false;
 					if (tokenEnum.Current.TokenType == SqlTokenType.BracketOpen)
@@ -72,14 +72,14 @@ public static bool TryParseUntilFirstMsSqlSelectColumn(this IEnumerator<SqlToken
 					}
 					if (!tokenEnum.MoveNext()) return false;
 
-					if (tokenEnum.Current.Equals("percent", StringComparison.InvariantCultureIgnoreCase))
+					if (tokenEnum.Current.Equals("percent", StringComparison.OrdinalIgnoreCase))
 					{
 						if (!tokenEnum.MoveNext()) return false;
 					}
-					if (tokenEnum.Current.Equals("with", StringComparison.InvariantCultureIgnoreCase))
+					if (tokenEnum.Current.Equals("with", StringComparison.OrdinalIgnoreCase))
 					{
 						if (!tokenEnum.MoveNext()) return false;
-						if (tokenEnum.Current.Equals("ties", StringComparison.InvariantCultureIgnoreCase))
+						if (tokenEnum.Current.Equals("ties", StringComparison.OrdinalIgnoreCase))
 						{
 							if (!tokenEnum.MoveNext()) return false;
 						}
@@ -99,7 +99,7 @@ public static bool TryParseUntilFirstOrderColumn(this IEnumerator<SqlToken> toke
 				orderToken = tokenEnum.Current;
 				if (tokenEnum.MoveNext())
 				{
-					return tokenEnum.Current.Equals("by", StringComparison.InvariantCultureIgnoreCase)
+					return tokenEnum.Current.Equals("by", StringComparison.OrdinalIgnoreCase)
 						? tokenEnum.MoveNext()
 						: false;
 				}
diff --git a/src/NHibernate/SqlCommand/SqlString.cs b/src/NHibernate/SqlCommand/SqlString.cs
@@ -382,7 +382,7 @@ public bool EndsWith(string value)
 		{
 			return value != null
 				&& value.Length <= _length
-				&& IndexOf(value, _length - value.Length, value.Length, StringComparison.InvariantCulture) >= 0;
+				&& IndexOf(value, _length - value.Length, value.Length, StringComparison.Ordinal) >= 0;
 		}
 
 		public bool EndsWithCaseInsensitive(string value)
@@ -416,7 +416,7 @@ public int GetParameterCount()
 		/// if not found.</returns>
 		public int IndexOfCaseInsensitive(string text)
 		{
-			return IndexOf(text, 0, _length, StringComparison.InvariantCultureIgnoreCase);
+			return IndexOf(text, 0, _length, StringComparison.OrdinalIgnoreCase);
 		}
 
 		/// <summary>
@@ -488,7 +488,7 @@ public SqlString Insert(int index, SqlString sql)
 		/// if not found.</returns>
 		public int LastIndexOfCaseInsensitive(string text)
 		{
-			return LastIndexOf(text, 0, _length, StringComparison.InvariantCultureIgnoreCase);
+			return LastIndexOf(text, 0, _length, StringComparison.OrdinalIgnoreCase);
 		}
 
 		/// <summary>
@@ -583,7 +583,7 @@ private IEnumerable<SqlString> SplitParts(string splitter)
 			var startIndex = 0;
 			while (startIndex < _length)
 			{
-				var splitterIndex = IndexOf(splitter, startIndex, _length - startIndex, StringComparison.InvariantCultureIgnoreCase);
+				var splitterIndex = IndexOf(splitter, startIndex, _length - startIndex, StringComparison.OrdinalIgnoreCase);
 				if (splitterIndex < 0) break;
 
 				yield return new SqlString(this, _sqlStartIndex + startIndex, splitterIndex - startIndex);
@@ -606,7 +606,7 @@ public bool StartsWithCaseInsensitive(string value)
 		{
 			return value != null
 				&& value.Length <= _length
-				&& IndexOf(value, 0, value.Length, StringComparison.InvariantCultureIgnoreCase) >= 0;
+				&& IndexOf(value, 0, value.Length, StringComparison.OrdinalIgnoreCase) >= 0;
 		}
 
 		/// <summary>
@@ -619,7 +619,7 @@ public bool EqualsCaseInsensitive(string value)
 		{
 			return value != null
 				&& value.Length == _length
-				&& IndexOf(value, 0, value.Length, StringComparison.InvariantCultureIgnoreCase) >= 0;
+				&& IndexOf(value, 0, value.Length, StringComparison.OrdinalIgnoreCase) >= 0;
 		}
 
 		/// <summary>
@@ -1046,4 +1046,4 @@ public override string ToString()
 			}
 		}
 	}
-}
+}
diff --git a/src/NHibernate/Tool/hbm2ddl/DatabaseMetadata.cs b/src/NHibernate/Tool/hbm2ddl/DatabaseMetadata.cs
@@ -80,7 +80,7 @@ public ITableMetadata GetTableMetadata(string name, string schema, string catalo
 				foreach (DataRow tableRow in rows)
 				{
 					string tableName = Convert.ToString(tableRow[meta.ColumnNameForTableName]);
-					if (name.Equals(tableName, StringComparison.InvariantCultureIgnoreCase))
+					if (name.Equals(tableName, StringComparison.OrdinalIgnoreCase))
 					{
 						table = meta.GetTableMetadata(tableRow, extras);
 						tables[identifier] = table;
diff --git a/src/NHibernate/Util/CollectionHelper.cs b/src/NHibernate/Util/CollectionHelper.cs
@@ -339,7 +339,7 @@ public static int GetHashCode(IEnumerable coll)
 		/// </remarks>
 		public static IDictionary<string, T> CreateCaseInsensitiveHashtable<T>()
 		{
-			return new Dictionary<string, T>(StringComparer.InvariantCultureIgnoreCase);
+			return new Dictionary<string, T>(StringComparer.OrdinalIgnoreCase);
 		}
 
 		/// <summary>
@@ -352,7 +352,7 @@ public static IDictionary<string, T> CreateCaseInsensitiveHashtable<T>()
 		/// </remarks>
 		public static IDictionary<string, T> CreateCaseInsensitiveHashtable<T>(IDictionary<string, T> dictionary)
 		{
-			return new Dictionary<string, T>(dictionary, StringComparer.InvariantCultureIgnoreCase);
+			return new Dictionary<string, T>(dictionary, StringComparer.OrdinalIgnoreCase);
 		}
 
 		// ~~~~~~~~~~~~~~~~~~~~~~ Generics ~~~~~~~~~~~~~~~~~~~~~~
diff --git a/src/NHibernate/Util/StringHelper.cs b/src/NHibernate/Util/StringHelper.cs
@@ -634,32 +634,32 @@ public static string Unroot(string qualifiedName)
 
 		public static bool EqualsCaseInsensitive(string a, string b)
 		{
-			return StringComparer.InvariantCultureIgnoreCase.Compare(a, b) == 0;
+			return StringComparer.OrdinalIgnoreCase.Compare(a, b) == 0;
 		}
 
 		public static int IndexOfCaseInsensitive(string source, string value)
 		{
-			return source.IndexOf(value, StringComparison.InvariantCultureIgnoreCase);
+			return source.IndexOf(value, StringComparison.OrdinalIgnoreCase);
 		}
 
 		public static int IndexOfCaseInsensitive(string source, string value, int startIndex)
 		{
-			return source.IndexOf(value, startIndex, StringComparison.InvariantCultureIgnoreCase);
+			return source.IndexOf(value, startIndex, StringComparison.OrdinalIgnoreCase);
 		}
 
 		public static int IndexOfCaseInsensitive(string source, string value, int startIndex, int count)
 		{
-			return source.IndexOf(value, startIndex, count, StringComparison.InvariantCultureIgnoreCase);
+			return source.IndexOf(value, startIndex, count, StringComparison.OrdinalIgnoreCase);
 		}
 
 		public static int LastIndexOfCaseInsensitive(string source, string value)
 		{
-			return source.LastIndexOf(value, StringComparison.InvariantCultureIgnoreCase);
+			return source.LastIndexOf(value, StringComparison.OrdinalIgnoreCase);
 		}
 
 		public static bool StartsWithCaseInsensitive(string source, string prefix)
 		{
-			return source.StartsWith(prefix, StringComparison.InvariantCultureIgnoreCase);
+			return source.StartsWith(prefix, StringComparison.OrdinalIgnoreCase);
 		}
 
 		/// <summary>

Original file line number	Diff line number	Diff line change
`@@ -70,12 +70,12 @@ public System.Type ReturnedType`
`70`	`70`
`71`	`71`	`public new bool Equals(object x, object y)`
`72`	`72`	`{`
`73`		`- return StringComparer.InvariantCultureIgnoreCase.Equals((string)x, (string)y);`
	`73`	`+ return StringComparer.OrdinalIgnoreCase.Equals((string)x, (string)y);`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`public int GetHashCode(object x)`
`77`	`77`	`{`
`78`		`- return StringComparer.InvariantCultureIgnoreCase.GetHashCode((string)x);`
	`78`	`+ return StringComparer.OrdinalIgnoreCase.GetHashCode((string)x);`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`public object NullSafeGet(DbDataReader rs, string[] names, object owner)`
Original file line number	Diff line number	Diff line change
`@@ -538,7 +538,7 @@ public void AddColumnBinding(string logicalName, Column finalColumn, Table table`
`538`	`538`	`if (oldFinalName != null &&`
`539`	`539`	`!(finalColumn.IsQuoted`
`540`	`540`	`? oldFinalName.Equals(finalColumn.GetQuotedName())`
`541`		`- : oldFinalName.Equals(finalColumn.GetQuotedName(), StringComparison.InvariantCultureIgnoreCase)))`
	`541`	`+ : oldFinalName.Equals(finalColumn.GetQuotedName(), StringComparison.OrdinalIgnoreCase)))`
`542`	`542`	`{`
`543`	`543`	`//TODO possibly relax that`
`544`	`544`	`throw new MappingException("Same logical column name referenced by different physical ones: " + table.Name + "."`
Original file line number	Diff line number	Diff line change
`@@ -93,7 +93,7 @@ protected virtual bool CastingIsRequired(string sqlType)`
`93`	`93`
`94`	`94`	`bool IFunctionGrammar.IsSeparator(string token)`
`95`	`95`	`{`
`96`		`- return "as".Equals(token, StringComparison.InvariantCultureIgnoreCase);`
	`96`	`+ return "as".Equals(token, StringComparison.OrdinalIgnoreCase);`
`97`	`97`	`}`
`98`	`98`
`99`	`99`	`bool IFunctionGrammar.IsKnownArgument(string token)`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ public SQLFunctionRegistry(Dialect dialect, IDictionary<string, ISQLFunction> us`
`12`	`12`	`{`
`13`	`13`	`this.dialect = dialect;`
`14`	`14`	`this.userFunctions = new Dictionary<string, ISQLFunction>(userFunctions,`
`15`		`- StringComparer.InvariantCultureIgnoreCase);`
	`15`	`+ StringComparer.OrdinalIgnoreCase);`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`public ISQLFunction FindSQLFunction(string functionName)`
Original file line number	Diff line number	Diff line change
`@@ -325,7 +325,7 @@ private FromElement FindIntendedAliasedFromElementBasedOnCrazyJPARequirements(st`
`325`	`325`	`foreach (var entry in _fromElementByClassAlias)`
`326`	`326`	`{`
`327`	`327`	`string alias = entry.Key;`
`328`		`- if (string.Equals(alias, specifiedAlias, StringComparison.InvariantCultureIgnoreCase))`
	`328`	`+ if (string.Equals(alias, specifiedAlias, StringComparison.OrdinalIgnoreCase))`
`329`	`329`	`{`
`330`	`330`	`return entry.Value;`
`331`	`331`	`}`
Original file line number	Diff line number	Diff line change
`@@ -353,10 +353,10 @@ protected bool CanReadCantWriteInBaseType(PropertyInfo property)`
`353`	`353`	`protected bool MatchPoIdPattern(MemberInfo subject)`
`354`	`354`	`{`
`355`	`355`	`var name = subject.Name;`
`356`		`- return name.Equals("id", StringComparison.InvariantCultureIgnoreCase)`
`357`		`- \|\| name.Equals("poid", StringComparison.InvariantCultureIgnoreCase)`
`358`		`- \|\| name.Equals("oid", StringComparison.InvariantCultureIgnoreCase)`
`359`		`- \|\| (name.StartsWith(subject.DeclaringType.Name) && name.Equals(subject.DeclaringType.Name + "id", StringComparison.InvariantCultureIgnoreCase));`
	`356`	`+ return name.Equals("id", StringComparison.OrdinalIgnoreCase)`
	`357`	`+ \|\| name.Equals("poid", StringComparison.OrdinalIgnoreCase)`
	`358`	`+ \|\| name.Equals("oid", StringComparison.OrdinalIgnoreCase)`
	`359`	`+ \|\| (name.StartsWith(subject.DeclaringType.Name) && name.Equals(subject.DeclaringType.Name + "id", StringComparison.OrdinalIgnoreCase));`
`360`	`360`	`}`
`361`	`361`
`362`	`362`	`protected bool MatchComponentPattern(System.Type subject)`
`@@ -1083,4 +1083,4 @@ public void IsDynamicComponent(Func<MemberInfo, bool, bool> match)`
`1083`	`1083`	`isDynamicComponent = match;`
`1084`	`1084`	`}`
`1085`	`1085`	`}`
`1086`		`-}`
	`1086`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ public void CreatePropertyRefConstraints(IDictionary<string, PersistentClass> pe`
`73`	`73`	`if (property == null)`
`74`	`74`	`throw new MappingException("Could not find property " + ReferencedPropertyName + " on " + ReferencedEntityName);`
`75`	`75`
`76`		`- if (!HasFormula && !"none".Equals(ForeignKeyName, StringComparison.InvariantCultureIgnoreCase))`
	`76`	`+ if (!HasFormula && !"none".Equals(ForeignKeyName, StringComparison.OrdinalIgnoreCase))`
`77`	`77`	`{`
`78`	`78`
`79`	`79`	`IEnumerable<Column> ce = new SafetyEnumerable<Column>(property.ColumnIterator);`
`@@ -92,4 +92,4 @@ public void CreatePropertyRefConstraints(IDictionary<string, PersistentClass> pe`
`92`	`92`	`}`
`93`	`93`	`}`
`94`	`94`	`}`
`95`		`-}`
	`95`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ public IEnumerable<Column> ReferenceColumns`
`24`	`24`
`25`	`25`	`public override void CreateForeignKeyOfEntity(string entityName)`
`26`	`26`	`{`
`27`		`- if (!HasFormula && !string.Equals("none", ForeignKeyName, StringComparison.InvariantCultureIgnoreCase))`
	`27`	`+ if (!HasFormula && !string.Equals("none", ForeignKeyName, StringComparison.OrdinalIgnoreCase))`
`28`	`28`	`{`
`29`	`29`	`var referencedColumns = new List<Column>(_prototype.ColumnSpan);`
`30`	`30`	`foreach (Column column in _prototype.ColumnIterator)`
Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@ public virtual bool IsComposite`
`75`	`75`
`76`	`76`	`public virtual void CreateForeignKeyOfEntity(string entityName)`
`77`	`77`	`{`
`78`		`- if (!HasFormula && ! "none".Equals(ForeignKeyName, StringComparison.InvariantCultureIgnoreCase))`
	`78`	`+ if (!HasFormula && ! "none".Equals(ForeignKeyName, StringComparison.OrdinalIgnoreCase))`
`79`	`79`	`{`
`80`	`80`	`ForeignKey fk = table.CreateForeignKey(ForeignKeyName, ConstraintColumns, entityName);`
`81`	`81`	`fk.CascadeDeleteEnabled = cascadeDeleteEnabled;`
Original file line number	Diff line number	Diff line change
`@@ -134,15 +134,15 @@ private IEnumerable<ColumnDefinition> ParseColumnDefinitions(IEnumerator<SqlToke`
`134`	`134`	`case SqlTokenType.Text:`
`135`	`135`	`if (blockLevel != 0) break;`
`136`	`136`
`137`		`- if (token.Equals(",", StringComparison.InvariantCultureIgnoreCase))`
	`137`	`+ if (token.Equals(",", StringComparison.OrdinalIgnoreCase))`
`138`	`138`	`{`
`139`	`139`	`if (columnAliasToken != null)`
`140`	`140`	`{`
`141`	`141`	`yield return ParseSelectColumnDefinition(columnBeginToken, columnEndToken ?? columnAliasToken, columnAliasToken);`
`142`	`142`	`}`
`143`	`143`	`}`
`144`	`144`
`145`		`- if (token.Equals("from", StringComparison.InvariantCultureIgnoreCase))`
	`145`	`+ if (token.Equals("from", StringComparison.OrdinalIgnoreCase))`
`146`	`146`	`{`
`147`	`147`	`if (columnAliasToken != null)`
`148`	`148`	`{`
`@@ -151,7 +151,7 @@ private IEnumerable<ColumnDefinition> ParseColumnDefinitions(IEnumerator<SqlToke`
`151`	`151`	`yield break;`
`152`	`152`	`}`
`153`	`153`
`154`		`- if (token.Equals("as", StringComparison.InvariantCultureIgnoreCase))`
	`154`	`+ if (token.Equals("as", StringComparison.OrdinalIgnoreCase))`
`155`	`155`	`{`
`156`	`156`	`columnEndToken = prevToken;`
`157`	`157`	`}`
`@@ -240,8 +240,8 @@ private IEnumerable<OrderDefinition> ParseOrderDefinitions(IEnumerator<SqlToken>`
`240`	`240`	`case SqlTokenType.Text:`
`241`	`241`	`if (blockLevel != 0) break;`
`242`	`242`
`243`		`- if (token.Equals("asc", StringComparison.InvariantCultureIgnoreCase)`
`244`		`- \|\| token.Equals("desc", StringComparison.InvariantCultureIgnoreCase))`
	`243`	`+ if (token.Equals("asc", StringComparison.OrdinalIgnoreCase)`
	`244`	`+ \|\| token.Equals("desc", StringComparison.OrdinalIgnoreCase))`
`245`	`245`	`{`
`246`	`246`	`orderEndToken = prevToken;`
`247`	`247`	`directionToken = token;`
`@@ -272,7 +272,7 @@ private IEnumerable<OrderDefinition> ParseOrderDefinitions(IEnumerator<SqlToken>`
`272`	`272`	`private OrderDefinition ParseOrderDefinition(SqlToken beginToken, SqlToken endToken, SqlToken directionToken)`
`273`	`273`	`{`
`274`	`274`	`var isDescending = directionToken != null &&`
`275`		`- directionToken.Equals("desc", StringComparison.InvariantCultureIgnoreCase);`
	`275`	`+ directionToken.Equals("desc", StringComparison.OrdinalIgnoreCase);`
`276`	`276`
`277`	`277`	`var columnNameOrIndex = beginToken == endToken`
`278`	`278`	`? beginToken.Value`
`@@ -301,8 +301,8 @@ private bool TryGetColumnDefinition(string columnNameOrIndex, out ColumnDefiniti`
`301`	`301`
`302`	`302`	`foreach (var column in _columns)`
`303`	`303`	`{`
`304`		`- if (columnNameOrIndex.Equals(column.Name, StringComparison.InvariantCultureIgnoreCase)`
`305`		`- \|\| columnNameOrIndex.Equals(column.Alias, StringComparison.InvariantCultureIgnoreCase))`
	`304`	`+ if (columnNameOrIndex.Equals(column.Name, StringComparison.OrdinalIgnoreCase)`
	`305`	`+ \|\| columnNameOrIndex.Equals(column.Alias, StringComparison.OrdinalIgnoreCase))`
`306`	`306`	`{`
`307`	`307`	`result = column;`
`308`	`308`	`return true;`
`@@ -316,9 +316,9 @@ private bool TryGetColumnDefinition(string columnNameOrIndex, out ColumnDefiniti`
`316`	`316`	`var text = Sql.ToString(sqlIndex, sqlLength);`
`317`	`317`	`foreach (var column in _columns)`
`318`	`318`	`{`
`319`		`- if (text.Equals(column.Name, StringComparison.InvariantCultureIgnoreCase) \|\|`
`320`		`- text.Equals(column.Alias, StringComparison.InvariantCultureIgnoreCase) \|\|`
`321`		`- text.Equals(Sql.ToString(column.SqlIndex, column.SqlLength), StringComparison.InvariantCultureIgnoreCase))`
	`319`	`+ if (text.Equals(column.Name, StringComparison.OrdinalIgnoreCase) \|\|`
	`320`	`+ text.Equals(column.Alias, StringComparison.OrdinalIgnoreCase) \|\|`
	`321`	`+ text.Equals(Sql.ToString(column.SqlIndex, column.SqlLength), StringComparison.OrdinalIgnoreCase))`
`322`	`322`	`{`
`323`	`323`	`result = column;`
`324`	`324`	`return true;`