Purge more Invariant culture usages

fredericDelaporte · hazzik · commit f27fb4833661 · 2018-05-14T23:44:36.000+12:00
Comparing SQL keywords should be done with ordinal comparisons. But invariant comparisons are kept for object names, because at least with SQL Server these comparisons are collation sensitive. (So ideally object names comparisons should even have their culture configurable...) An undue current culture comparison for SqlString.EndsWithCaseInsensitive is also fixed. Follow-up to #1567.
diff --git a/src/NHibernate/Dialect/Function/AnsiTrimEmulationFunction.cs b/src/NHibernate/Dialect/Function/AnsiTrimEmulationFunction.cs
@@ -98,8 +98,8 @@ public SqlString Render(IList args, ISessionFactoryImplementor factory)
 				//      so we trim leading and trailing spaces
 				return BothSpaceTrim.Render(args, factory);
 			}
-			
-			if (StringHelper.EqualsCaseInsensitive("from", firstArg))
+
+			if ("from".Equals(firstArg, StringComparison.OrdinalIgnoreCase))
 			{
 				// we have the form: trim(from trimSource).
 				//      This is functionally equivalent to trim(trimSource)
@@ -118,15 +118,15 @@ public SqlString Render(IList args, ISessionFactoryImplementor factory)
 			// trim-specification has been specified.  we handle the
 			// exception to that explicitly
 			int potentialTrimCharacterArgIndex = 1;
-			if (StringHelper.EqualsCaseInsensitive("leading", firstArg))
+			if ("leading".Equals(firstArg, StringComparison.OrdinalIgnoreCase))
 			{
 				trailing = false;
 			}
-			else if (StringHelper.EqualsCaseInsensitive("trailing", firstArg))
+			else if ("trailing".Equals(firstArg, StringComparison.OrdinalIgnoreCase))
 			{
 				leading = false;
 			}
-			else if (StringHelper.EqualsCaseInsensitive("both", firstArg))
+			else if ("both".Equals(firstArg, StringComparison.OrdinalIgnoreCase))
 			{
 			}
 			else
@@ -135,7 +135,7 @@ public SqlString Render(IList args, ISessionFactoryImplementor factory)
 			}
 
 			object potentialTrimCharacter = args[potentialTrimCharacterArgIndex];
-			if (StringHelper.EqualsCaseInsensitive("from", potentialTrimCharacter.ToString()))
+			if ("from".Equals(potentialTrimCharacter.ToString(), StringComparison.OrdinalIgnoreCase))
 			{
 				trimCharacter = "' '";
 				trimSource = args[potentialTrimCharacterArgIndex + 1];
@@ -148,7 +148,7 @@ public SqlString Render(IList args, ISessionFactoryImplementor factory)
 			else
 			{
 				trimCharacter = potentialTrimCharacter;
-				if (StringHelper.EqualsCaseInsensitive("from", args[potentialTrimCharacterArgIndex + 1].ToString()))
+				if ("from".Equals(args[potentialTrimCharacterArgIndex + 1].ToString(), StringComparison.OrdinalIgnoreCase))
 				{
 					trimSource = args[potentialTrimCharacterArgIndex + 2];
 				}
diff --git a/src/NHibernate/Dialect/Function/CastFunction.cs b/src/NHibernate/Dialect/Function/CastFunction.cs
@@ -92,7 +92,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/ClassicAggregateFunction.cs b/src/NHibernate/Dialect/Function/ClassicAggregateFunction.cs
@@ -77,8 +77,8 @@ public SqlString Render(IList args, ISessionFactoryImplementor factory)
 			if (args.Count > 1)
 			{
 				object firstArg = args[0];
-				if (!StringHelper.EqualsCaseInsensitive("distinct", firstArg.ToString()) &&
-				    !StringHelper.EqualsCaseInsensitive("all", firstArg.ToString()))
+				if (!"distinct".Equals(firstArg.ToString(), StringComparison.OrdinalIgnoreCase) &&
+				    !"all".Equals(firstArg.ToString(), StringComparison.OrdinalIgnoreCase))
 				{
 					throw new QueryException(string.Format("Aggregate {0}(): token unknow {1}.", name, firstArg));
 				}
diff --git a/src/NHibernate/Driver/NDataReader.cs b/src/NHibernate/Driver/NDataReader.cs
@@ -612,7 +612,7 @@ public int GetOrdinal(string colName)
 
 				foreach (KeyValuePair<string, int> pair in fieldNameToIndex)
 				{
-					if (StringHelper.EqualsCaseInsensitive(pair.Key, colName))
+					if (string.Equals(pair.Key, colName, StringComparison.InvariantCultureIgnoreCase))
 					{
 						return pair.Value;
 					}
diff --git a/src/NHibernate/Hql/QuerySplitter.cs b/src/NHibernate/Hql/QuerySplitter.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Collections;
 using System.Collections.Generic;
 using System.Text;
 using NHibernate.Engine;
@@ -60,7 +59,6 @@ public static string[] ConcreteQueries(string query, ISessionFactoryImplementor
 			string next = null;
 
 			templateQuery.Append(tokens[0]);
-			bool isSelectClause = StringHelper.EqualsCaseInsensitive("select", tokens[0]);
 
 			for (int i = 1; i < tokens.Length; i++)
 			{
@@ -70,9 +68,6 @@ public static string[] ConcreteQueries(string query, ISessionFactoryImplementor
 					last = tokens[i - 1].ToLowerInvariant();
 				}
 
-				// select-range is terminated by declaration of "from"
-				isSelectClause = !StringHelper.EqualsCaseInsensitive("from", tokens[i]);
-
 				string token = tokens[i];
 				if (!ParserHelper.IsWhitespace(token) || last == null)
 				{
@@ -120,11 +115,5 @@ public static string[] ConcreteQueries(string query, ISessionFactoryImplementor
 			}
 			return results;
 		}
-
-		private static bool IsPossiblyClassName(string last, string next)
-		{
-			return ParserHelper.EntityClass.Equals(last) ||
-				   (beforeClassTokens.Contains(last) && !notAfterClassTokens.Contains(next));
-		}
 	}
 }
diff --git a/src/NHibernate/Mapping/Column.cs b/src/NHibernate/Mapping/Column.cs
@@ -155,7 +155,7 @@ private string GetAlias(int maxAliasLength)
 			//    But I will leave it like this for now to make it look similar. /Oskar 2016-08-20
 			bool useRawName = name.Length + suffix.Length <= usableLength &&
 			                  !_quoted &&
-			                  !StringHelper.EqualsCaseInsensitive(name, "rowid");
+			                  !"rowid".Equals(name, StringComparison.OrdinalIgnoreCase);
 			if (!useRawName)
 			{
 				if (suffix.Length >= usableLength)
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);
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
@@ -131,15 +131,15 @@ private IEnumerable<ColumnDefinition> ParseColumnDefinitions(IEnumerator<SqlToke
 					case SqlTokenType.Text:
 						if (blockLevel != 0) break;
 
-						if (token.Equals(",", StringComparison.InvariantCultureIgnoreCase))
+						if (token.Equals(",", StringComparison.Ordinal))
 						{
 							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)
 							{
@@ -148,7 +148,7 @@ private IEnumerable<ColumnDefinition> ParseColumnDefinitions(IEnumerator<SqlToke
 							yield break;
 						}
 
-						if (token.Equals("as", StringComparison.InvariantCultureIgnoreCase))
+						if (token.Equals("as", StringComparison.OrdinalIgnoreCase))
 						{
 							columnEndToken = prevToken;
 						}
@@ -237,8 +237,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;
@@ -269,7 +269,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
diff --git a/src/NHibernate/SqlCommand/Parser/SqlTokenizerExtensions.cs b/src/NHibernate/SqlCommand/Parser/SqlTokenizerExtensions.cs
@@ -23,7 +23,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;
 					}
 				}
@@ -34,9 +34,7 @@ public static bool TryParseUntil(this IEnumerator<SqlToken> tokenEnum, string ke
 
 		public static bool TryParseUntilFirstMsSqlSelectColumn(this IEnumerator<SqlToken> tokenEnum)
 		{
-			SqlToken selectToken;
-			bool isDistinct;
-			return TryParseUntilFirstMsSqlSelectColumn(tokenEnum, out selectToken, out isDistinct);
+			return TryParseUntilFirstMsSqlSelectColumn(tokenEnum, out _, out _);
 		}
 
 		public static bool TryParseUntilFirstMsSqlSelectColumn(this IEnumerator<SqlToken> tokenEnum, out SqlToken selectToken, out bool isDistinct)
@@ -100,9 +98,7 @@ public static bool TryParseUntilFirstOrderColumn(this IEnumerator<SqlToken> toke
 				orderToken = tokenEnum.Current;
 				if (tokenEnum.MoveNext())
 				{
-					return tokenEnum.Current.Equals("by", StringComparison.InvariantCultureIgnoreCase)
-						? tokenEnum.MoveNext()
-						: false;
+					return tokenEnum.Current.Equals("by", StringComparison.OrdinalIgnoreCase) && tokenEnum.MoveNext();
 				}
 			}
 
diff --git a/src/NHibernate/SqlCommand/SqlString.cs b/src/NHibernate/SqlCommand/SqlString.cs
@@ -374,7 +374,7 @@ public bool EndsWithCaseInsensitive(string value)
 		{
 			return value != null
 				&& value.Length <= _length
-				&& IndexOf(value, _length - value.Length, value.Length, StringComparison.CurrentCultureIgnoreCase) >= 0;
+				&& IndexOf(value, _length - value.Length, value.Length, StringComparison.InvariantCultureIgnoreCase) >= 0;
 		}
 
 		public IEnumerable<Parameter> GetParameters()
diff --git a/src/NHibernate/SqlCommand/SubselectClauseExtractor.cs b/src/NHibernate/SqlCommand/SubselectClauseExtractor.cs
@@ -111,7 +111,7 @@ public static bool HasOrderBy(SqlString subselect)
 		private int FindFromClauseInPart(string part)
 		{
 			int afterLastClosingParenIndex = 0;
-			int fromIndex = StringHelper.IndexOfCaseInsensitive(part, FromClauseToken);
+			int fromIndex = part.IndexOf(FromClauseToken, StringComparison.OrdinalIgnoreCase);
 			
 			for (int i = 0; i < part.Length; i++)
 			{
@@ -133,13 +133,13 @@ private int FindFromClauseInPart(string part)
 					}
 
 					afterLastClosingParenIndex = i + 1;
-					fromIndex = StringHelper.IndexOfCaseInsensitive(part, FromClauseToken, afterLastClosingParenIndex);
+					fromIndex = part.IndexOf(FromClauseToken, afterLastClosingParenIndex, StringComparison.OrdinalIgnoreCase);
 				}
 			}
 
 			if (afterLastClosingParenIndex == 0)
 			{
-				fromIndex = StringHelper.IndexOfCaseInsensitive(part, FromClauseToken);
+				fromIndex = part.IndexOf(FromClauseToken, StringComparison.OrdinalIgnoreCase);
 			}
 
 			if(parenNestCount > 0)
@@ -163,7 +163,7 @@ private void CheckLastPartForOrderByClause()
 			}
 
 			string partString = part as string;
-			int index = StringHelper.LastIndexOfCaseInsensitive(partString, OrderByToken);
+			int index = partString.LastIndexOf(OrderByToken, StringComparison.OrdinalIgnoreCase);
 			if (index >= 0)
 			{
 				lastOrderByPartIndex = builder.Count - 1;
@@ -175,8 +175,7 @@ private void CheckLastPartForOrderByClause()
 
 		private void IgnoreOrderByInSubselect(string partString)
 		{
-			int index;
-			index = StringHelper.LastIndexOfCaseInsensitive(partString, ")");
+			var index = partString.LastIndexOf(")", StringComparison.Ordinal);
 			if (index >= 0 && ParenIsAfterLastOrderBy(index))
 			{
 				lastOrderByPartIndex = -1;
diff --git a/src/NHibernate/Type/CharBooleanType.cs b/src/NHibernate/Type/CharBooleanType.cs
@@ -37,7 +37,7 @@ public override object Get(DbDataReader rs, int index, ISessionImplementor sessi
 			}
 			else
 			{
-				return StringHelper.EqualsCaseInsensitive(code, TrueString);
+				return code.Equals(TrueString, StringComparison.InvariantCultureIgnoreCase);
 			}
 		}
 
@@ -68,11 +68,11 @@ public override string ObjectToSQLString(object value, Dialect.Dialect dialect)
 		/// <returns></returns>
 		public override object StringToObject(String xml)
 		{
-			if (StringHelper.EqualsCaseInsensitive(TrueString, xml))
+			if (string.Equals(TrueString, xml, StringComparison.InvariantCultureIgnoreCase))
 			{
 				return true;
 			}
-			else if (StringHelper.EqualsCaseInsensitive(FalseString, xml))
+			else if (string.Equals(FalseString, xml, StringComparison.InvariantCultureIgnoreCase))
 			{
 				return false;
 			}
@@ -82,4 +82,4 @@ public override object StringToObject(String xml)
 			}
 		}
 	}
-}
+}
diff --git a/src/NHibernate/Util/StringHelper.cs b/src/NHibernate/Util/StringHelper.cs
@@ -658,31 +658,43 @@ public static string Unroot(string qualifiedName)
 			return (loc < 0) ? qualifiedName : qualifiedName.Substring(loc + 1);
 		}
 
+		// Since 5.2
+		[Obsolete("This method has no more usage and will be removed in a future version")]
 		public static bool EqualsCaseInsensitive(string a, string b)
 		{
 			return StringComparer.InvariantCultureIgnoreCase.Compare(a, b) == 0;
 		}
 
+		// Since 5.2
+		[Obsolete("This method has no more usage and will be removed in a future version")]
 		public static int IndexOfCaseInsensitive(string source, string value)
 		{
 			return source.IndexOf(value, StringComparison.InvariantCultureIgnoreCase);
 		}
 
+		// Since 5.2
+		[Obsolete("This method has no more usage and will be removed in a future version")]
 		public static int IndexOfCaseInsensitive(string source, string value, int startIndex)
 		{
 			return source.IndexOf(value, startIndex, StringComparison.InvariantCultureIgnoreCase);
 		}
 
+		// Since 5.2
+		[Obsolete("This method has no more usage and will be removed in a future version")]
 		public static int IndexOfCaseInsensitive(string source, string value, int startIndex, int count)
 		{
 			return source.IndexOf(value, startIndex, count, StringComparison.InvariantCultureIgnoreCase);
 		}
 
+		// Since 5.2
+		[Obsolete("This method has no more usage and will be removed in a future version")]
 		public static int LastIndexOfCaseInsensitive(string source, string value)
 		{
 			return source.LastIndexOf(value, StringComparison.InvariantCultureIgnoreCase);
 		}
 
+		// Since 5.2
+		[Obsolete("This method has no more usage and will be removed in a future version")]
 		public static bool StartsWithCaseInsensitive(string source, string prefix)
 		{
 			return source.StartsWith(prefix, StringComparison.InvariantCultureIgnoreCase);

Original file line number	Diff line number	Diff line change
`@@ -98,8 +98,8 @@ public SqlString Render(IList args, ISessionFactoryImplementor factory)`
`98`	`98`	`// so we trim leading and trailing spaces`
`99`	`99`	`return BothSpaceTrim.Render(args, factory);`
`100`	`100`	`}`
`101`		`-`
`102`		`- if (StringHelper.EqualsCaseInsensitive("from", firstArg))`
	`101`	`+`
	`102`	`+ if ("from".Equals(firstArg, StringComparison.OrdinalIgnoreCase))`
`103`	`103`	`{`
`104`	`104`	`// we have the form: trim(from trimSource).`
`105`	`105`	`// This is functionally equivalent to trim(trimSource)`
`@@ -118,15 +118,15 @@ public SqlString Render(IList args, ISessionFactoryImplementor factory)`
`118`	`118`	`// trim-specification has been specified. we handle the`
`119`	`119`	`// exception to that explicitly`
`120`	`120`	`int potentialTrimCharacterArgIndex = 1;`
`121`		`- if (StringHelper.EqualsCaseInsensitive("leading", firstArg))`
	`121`	`+ if ("leading".Equals(firstArg, StringComparison.OrdinalIgnoreCase))`
`122`	`122`	`{`
`123`	`123`	`trailing = false;`
`124`	`124`	`}`
`125`		`- else if (StringHelper.EqualsCaseInsensitive("trailing", firstArg))`
	`125`	`+ else if ("trailing".Equals(firstArg, StringComparison.OrdinalIgnoreCase))`
`126`	`126`	`{`
`127`	`127`	`leading = false;`
`128`	`128`	`}`
`129`		`- else if (StringHelper.EqualsCaseInsensitive("both", firstArg))`
	`129`	`+ else if ("both".Equals(firstArg, StringComparison.OrdinalIgnoreCase))`
`130`	`130`	`{`
`131`	`131`	`}`
`132`	`132`	`else`
`@@ -135,7 +135,7 @@ public SqlString Render(IList args, ISessionFactoryImplementor factory)`
`135`	`135`	`}`
`136`	`136`
`137`	`137`	`object potentialTrimCharacter = args[potentialTrimCharacterArgIndex];`
`138`		`- if (StringHelper.EqualsCaseInsensitive("from", potentialTrimCharacter.ToString()))`
	`138`	`+ if ("from".Equals(potentialTrimCharacter.ToString(), StringComparison.OrdinalIgnoreCase))`
`139`	`139`	`{`
`140`	`140`	`trimCharacter = "' '";`
`141`	`141`	`trimSource = args[potentialTrimCharacterArgIndex + 1];`
`@@ -148,7 +148,7 @@ public SqlString Render(IList args, ISessionFactoryImplementor factory)`
`148`	`148`	`else`
`149`	`149`	`{`
`150`	`150`	`trimCharacter = potentialTrimCharacter;`
`151`		`- if (StringHelper.EqualsCaseInsensitive("from", args[potentialTrimCharacterArgIndex + 1].ToString()))`
	`151`	`+ if ("from".Equals(args[potentialTrimCharacterArgIndex + 1].ToString(), StringComparison.OrdinalIgnoreCase))`
`152`	`152`	`{`
`153`	`153`	`trimSource = args[potentialTrimCharacterArgIndex + 2];`
`154`	`154`	`}`
Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,7 @@ protected virtual bool CastingIsRequired(string sqlType)`
`92`	`92`
`93`	`93`	`bool IFunctionGrammar.IsSeparator(string token)`
`94`	`94`	`{`
`95`		`- return "as".Equals(token, StringComparison.InvariantCultureIgnoreCase);`
	`95`	`+ return "as".Equals(token, StringComparison.OrdinalIgnoreCase);`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`bool IFunctionGrammar.IsKnownArgument(string token)`
Original file line number	Diff line number	Diff line change
`@@ -77,8 +77,8 @@ public SqlString Render(IList args, ISessionFactoryImplementor factory)`
`77`	`77`	`if (args.Count > 1)`
`78`	`78`	`{`
`79`	`79`	`object firstArg = args[0];`
`80`		`- if (!StringHelper.EqualsCaseInsensitive("distinct", firstArg.ToString()) &&`
`81`		`- !StringHelper.EqualsCaseInsensitive("all", firstArg.ToString()))`
	`80`	`+ if (!"distinct".Equals(firstArg.ToString(), StringComparison.OrdinalIgnoreCase) &&`
	`81`	`+ !"all".Equals(firstArg.ToString(), StringComparison.OrdinalIgnoreCase))`
`82`	`82`	`{`
`83`	`83`	`throw new QueryException(string.Format("Aggregate {0}(): token unknow {1}.", name, firstArg));`
`84`	`84`	`}`
Original file line number	Diff line number	Diff line change
`@@ -612,7 +612,7 @@ public int GetOrdinal(string colName)`
`612`	`612`
`613`	`613`	`foreach (KeyValuePair<string, int> pair in fieldNameToIndex)`
`614`	`614`	`{`
`615`		`- if (StringHelper.EqualsCaseInsensitive(pair.Key, colName))`
	`615`	`+ if (string.Equals(pair.Key, colName, StringComparison.InvariantCultureIgnoreCase))`
`616`	`616`	`{`
`617`	`617`	`return pair.Value;`
`618`	`618`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,4 @@`
`1`	`1`	`using System;`
`2`		`-using System.Collections;`
`3`	`2`	`using System.Collections.Generic;`
`4`	`3`	`using System.Text;`
`5`	`4`	`using NHibernate.Engine;`
`@@ -60,7 +59,6 @@ public static string[] ConcreteQueries(string query, ISessionFactoryImplementor`
`60`	`59`	`string next = null;`
`61`	`60`
`62`	`61`	`templateQuery.Append(tokens[0]);`
`63`		`- bool isSelectClause = StringHelper.EqualsCaseInsensitive("select", tokens[0]);`
`64`	`62`
`65`	`63`	`for (int i = 1; i < tokens.Length; i++)`
`66`	`64`	`{`
`@@ -70,9 +68,6 @@ public static string[] ConcreteQueries(string query, ISessionFactoryImplementor`
`70`	`68`	`last = tokens[i - 1].ToLowerInvariant();`
`71`	`69`	`}`
`72`	`70`
`73`		`- // select-range is terminated by declaration of "from"`
`74`		`- isSelectClause = !StringHelper.EqualsCaseInsensitive("from", tokens[i]);`
`75`		`-`
`76`	`71`	`string token = tokens[i];`
`77`	`72`	`if (!ParserHelper.IsWhitespace(token) \|\| last == null)`
`78`	`73`	`{`
`@@ -120,11 +115,5 @@ public static string[] ConcreteQueries(string query, ISessionFactoryImplementor`
`120`	`115`	`}`
`121`	`116`	`return results;`
`122`	`117`	`}`
`123`		`-`
`124`		`- private static bool IsPossiblyClassName(string last, string next)`
`125`		`- {`
`126`		`- return ParserHelper.EntityClass.Equals(last) \|\|`
`127`		`- (beforeClassTokens.Contains(last) && !notAfterClassTokens.Contains(next));`
`128`		`- }`
`129`	`118`	`}`
`130`	`119`	`}`
Original file line number	Diff line number	Diff line change
`@@ -155,7 +155,7 @@ private string GetAlias(int maxAliasLength)`
`155`	`155`	`// But I will leave it like this for now to make it look similar. /Oskar 2016-08-20`
`156`	`156`	`bool useRawName = name.Length + suffix.Length <= usableLength &&`
`157`	`157`	`!_quoted &&`
`158`		`- !StringHelper.EqualsCaseInsensitive(name, "rowid");`
	`158`	`+ !"rowid".Equals(name, StringComparison.OrdinalIgnoreCase);`
`159`	`159`	`if (!useRawName)`
`160`	`160`	`{`
`161`	`161`	`if (suffix.Length >= usableLength)`
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);`
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
`@@ -131,15 +131,15 @@ private IEnumerable<ColumnDefinition> ParseColumnDefinitions(IEnumerator<SqlToke`
`131`	`131`	`case SqlTokenType.Text:`
`132`	`132`	`if (blockLevel != 0) break;`
`133`	`133`
`134`		`- if (token.Equals(",", StringComparison.InvariantCultureIgnoreCase))`
	`134`	`+ if (token.Equals(",", StringComparison.Ordinal))`
`135`	`135`	`{`
`136`	`136`	`if (columnAliasToken != null)`
`137`	`137`	`{`
`138`	`138`	`yield return ParseSelectColumnDefinition(columnBeginToken, columnEndToken ?? columnAliasToken, columnAliasToken);`
`139`	`139`	`}`
`140`	`140`	`}`
`141`	`141`
`142`		`- if (token.Equals("from", StringComparison.InvariantCultureIgnoreCase))`
	`142`	`+ if (token.Equals("from", StringComparison.OrdinalIgnoreCase))`
`143`	`143`	`{`
`144`	`144`	`if (columnAliasToken != null)`
`145`	`145`	`{`
`@@ -148,7 +148,7 @@ private IEnumerable<ColumnDefinition> ParseColumnDefinitions(IEnumerator<SqlToke`
`148`	`148`	`yield break;`
`149`	`149`	`}`
`150`	`150`
`151`		`- if (token.Equals("as", StringComparison.InvariantCultureIgnoreCase))`
	`151`	`+ if (token.Equals("as", StringComparison.OrdinalIgnoreCase))`
`152`	`152`	`{`
`153`	`153`	`columnEndToken = prevToken;`
`154`	`154`	`}`
`@@ -237,8 +237,8 @@ private IEnumerable<OrderDefinition> ParseOrderDefinitions(IEnumerator<SqlToken>`
`237`	`237`	`case SqlTokenType.Text:`
`238`	`238`	`if (blockLevel != 0) break;`
`239`	`239`
`240`		`- if (token.Equals("asc", StringComparison.InvariantCultureIgnoreCase)`
`241`		`- \|\| token.Equals("desc", StringComparison.InvariantCultureIgnoreCase))`
	`240`	`+ if (token.Equals("asc", StringComparison.OrdinalIgnoreCase)`
	`241`	`+ \|\| token.Equals("desc", StringComparison.OrdinalIgnoreCase))`
`242`	`242`	`{`
`243`	`243`	`orderEndToken = prevToken;`
`244`	`244`	`directionToken = token;`
`@@ -269,7 +269,7 @@ private IEnumerable<OrderDefinition> ParseOrderDefinitions(IEnumerator<SqlToken>`
`269`	`269`	`private OrderDefinition ParseOrderDefinition(SqlToken beginToken, SqlToken endToken, SqlToken directionToken)`
`270`	`270`	`{`
`271`	`271`	`var isDescending = directionToken != null &&`
`272`		`- directionToken.Equals("desc", StringComparison.InvariantCultureIgnoreCase);`
	`272`	`+ directionToken.Equals("desc", StringComparison.OrdinalIgnoreCase);`
`273`	`273`
`274`	`274`	`var columnNameOrIndex = beginToken == endToken`
`275`	`275`	`? beginToken.Value`