private static Exception AmbiguousMetadataMemberName(
ErrorContext errCtx,
string name,
MetadataNamespace ns1,
MetadataNamespace ns2)
{
string errorMessage = Strings.AmbiguousMetadataMemberName((object)name, (object)ns1.Name, (object)ns2?.Name);
throw EntitySqlException.Create(errCtx, errorMessage, (Exception)null);
}
// <summary>
// Adds a non-aliased namespace import.
// </summary>
internal void AddNamespaceImport(MetadataNamespace @namespace, ErrorContext errCtx)
{
if (_namespaces.Contains(@namespace))
{
var message = Strings.NamespaceAlreadyImported(@namespace.Name);
throw EntitySqlException.Create(errCtx, message, null);
}
_namespaces.Add(@namespace);
}
private static bool ConvertBooleanLiteralValue(ErrorContext errCtx, string booleanLiteralValue)
{
bool result = false;
if (!bool.TryParse(booleanLiteralValue, out result))
{
string errorMessage = Strings.InvalidLiteralFormat((object)"Boolean", (object)booleanLiteralValue);
throw EntitySqlException.Create(errCtx, errorMessage, (Exception)null);
}
return(result);
}
/// <summary>
/// Converts boolean literal value.
/// </summary>
private static bool ConvertBooleanLiteralValue(ErrorContext errCtx, string booleanLiteralValue)
{
var result = false;
if (!Boolean.TryParse(booleanLiteralValue, out result))
{
var message = Strings.InvalidLiteralFormat("Boolean", booleanLiteralValue);
throw EntitySqlException.Create(errCtx, message, null);
}
return(result);
}
internal NamespaceImport(BuiltInExpr bltInExpr)
{
this._namespaceAlias = (Identifier)null;
Identifier identifier = bltInExpr.Arg1 as Identifier;
if (identifier == null)
{
throw EntitySqlException.Create(bltInExpr.Arg1.ErrCtx, Strings.InvalidNamespaceAlias, (Exception)null);
}
this._namespaceAlias = identifier;
this._namespaceName = bltInExpr.Arg2;
}
// <summary>
// Reports incompatible type error
// </summary>
internal static void ReportIncompatibleCommonType(ErrorContext errCtx, TypeUsage leftType, TypeUsage rightType)
{
//
// 'navigate' through the type structure in order to find where the incompability is
//
ReportIncompatibleCommonType(errCtx, leftType, rightType, leftType, rightType);
//
// if we hit this point, throw the generic incompatible type error message
//
throw EntitySqlException.Create(errCtx, Strings.ArgumentTypesAreIncompatible(leftType.Identity, rightType.Identity), null);
}
// <summary>
// Maps operator to respective token
// </summary>
// <param name="oper"> operator lexeme </param>
// <returns> Token </returns>
internal Token MapOperator(string oper)
{
if (InternalOperatorDictionary.ContainsKey(oper))
{
return(NewToken(InternalOperatorDictionary[oper], new TerminalToken(oper, _iPos)));
}
else
{
var errorMessage = Strings.InvalidOperatorSymbol;
throw EntitySqlException.Create(_query, errorMessage, _iPos, null, false, null);
}
}
internal void AddAliasedNamespaceImport(
string alias,
MetadataNamespace @namespace,
ErrorContext errCtx)
{
if (this._aliasedNamespaces.ContainsKey(alias))
{
string errorMessage = Strings.NamespaceAliasAlreadyUsed((object)alias);
throw EntitySqlException.Create(errCtx, errorMessage, (Exception)null);
}
this._aliasedNamespaces.Add(alias, @namespace);
}
private static System.Data.Entity.Core.Common.EntitySql.AST.Node Parse(
string commandText,
ParserOptions parserOptions)
{
Check.NotEmpty(commandText, nameof(commandText));
System.Data.Entity.Core.Common.EntitySql.AST.Node node = new CqlParser(parserOptions, true).Parse(commandText);
if (node == null)
{
throw EntitySqlException.Create(commandText, Strings.InvalidEmptyQuery, 0, (string)null, false, (Exception)null);
}
return(node);
}
private static DateTimeOffset ConvertDateTimeOffsetLiteralValue(ErrorContext errCtx, string datetimeLiteralValue)
{
var datetimeParts = datetimeLiteralValue.Split(_datetimeOffsetSeparators, StringSplitOptions.RemoveEmptyEntries);
Debug.Assert(datetimeParts.Length >= 7, "datetime literal value must have at least 7 parts");
int year;
int month;
int day;
GetDateParts(datetimeLiteralValue, datetimeParts, out year, out month, out day);
int hour;
int minute;
int second;
int ticks;
//Copy the time parts into a different array since the last two parts will be handled in this method.
var timeParts = new String[datetimeParts.Length - 2];
Array.Copy(datetimeParts, timeParts, datetimeParts.Length - 2);
GetTimeParts(datetimeLiteralValue, timeParts, 3, out hour, out minute, out second, out ticks);
Debug.Assert(year >= 1 && year <= 9999);
Debug.Assert(month >= 1 && month <= 12);
Debug.Assert(day >= 1 && day <= 31);
Debug.Assert(hour >= 0 && hour <= 24);
Debug.Assert(minute >= 0 && minute <= 59);
Debug.Assert(second >= 0 && second <= 59);
Debug.Assert(ticks >= 0 && ticks <= 9999999);
var offsetHours = Int32.Parse(datetimeParts[datetimeParts.Length - 2], NumberStyles.Integer, CultureInfo.InvariantCulture);
var offsetMinutes = Int32.Parse(datetimeParts[datetimeParts.Length - 1], NumberStyles.Integer, CultureInfo.InvariantCulture);
var offsetTimeSpan = new TimeSpan(offsetHours, offsetMinutes, 0);
//If DateTimeOffset had a negative offset, we should negate the timespan
if (datetimeLiteralValue.IndexOf('+')
== -1)
{
offsetTimeSpan = offsetTimeSpan.Negate();
}
var dateTime = new DateTime(year, month, day, hour, minute, second, 0);
dateTime = dateTime.AddTicks(ticks);
try
{
return(new DateTimeOffset(dateTime, offsetTimeSpan));
}
catch (ArgumentOutOfRangeException e)
{
var message = Strings.InvalidDateTimeOffsetLiteral(datetimeLiteralValue);
throw EntitySqlException.Create(errCtx, message, e);
}
}
/// <summary>
/// Resolve entity set or function import <paramref name="name" /> in the <paramref name="entityContainer" />
/// </summary>
internal ExpressionResolution ResolveEntityContainerMemberAccess(EntityContainer entityContainer, string name, ErrorContext errCtx)
{
ExpressionResolution resolution;
if (TryResolveEntityContainerMemberAccess(entityContainer, name, out resolution))
{
return(resolution);
}
else
{
var message = Strings.MemberDoesNotBelongToEntityContainer(name, entityContainer.Name);
throw EntitySqlException.Create(errCtx, message, null);
}
}
private void yyerror(string s)
{
if (s.Equals(_internalYaccSyntaxErrorMessage, StringComparison.Ordinal))
{
var errorPosition = _lexer.IPos;
string syntaxContextInfo = null;
var term = _lexer.YYText;
if (!String.IsNullOrEmpty(term))
{
syntaxContextInfo = Strings.LocalizedTerm;
ErrorContext errCtx = null;
var astNode = yylval as Node;
if (null != astNode &&
(null != astNode.ErrCtx) &&
(!String.IsNullOrEmpty(astNode.ErrCtx.ErrorContextInfo)))
{
errCtx = astNode.ErrCtx;
errorPosition = Math.Min(errorPosition, errorPosition - term.Length);
}
if ((yylval is CqlLexer.TerminalToken) &&
CqlLexer.IsReservedKeyword(term) &&
!(astNode is Identifier))
{
syntaxContextInfo = Strings.LocalizedKeyword;
term = term.ToUpperInvariant();
errorPosition = Math.Min(errorPosition, errorPosition - term.Length);
}
else if (null != errCtx)
{
syntaxContextInfo = EntityRes.GetString(errCtx.ErrorContextInfo);
}
syntaxContextInfo = String.Format(CultureInfo.CurrentCulture, "{0} '{1}'", syntaxContextInfo, term);
}
var errorMessage = Strings.GenericSyntaxError;
throw EntitySqlException.Create(
_query,
errorMessage,
errorPosition,
syntaxContextInfo,
false,
null);
}
var errorPosition1 = _lexer.IPos;
throw EntitySqlException.Create(_query, s, errorPosition1, null, false, null);
}
internal ExpressionResolution ResolveEntityContainerMemberAccess(
EntityContainer entityContainer,
string name,
ErrorContext errCtx)
{
ExpressionResolution resolution;
if (this.TryResolveEntityContainerMemberAccess(entityContainer, name, out resolution))
{
return(resolution);
}
string entityContainer1 = Strings.MemberDoesNotBelongToEntityContainer((object)name, (object)entityContainer.Name);
throw EntitySqlException.Create(errCtx, entityContainer1, (Exception)null);
}
internal void DeclareInlineFunction(string name, InlineFunctionInfo functionInfo)
{
List <InlineFunctionInfo> inlineFunctionInfoList;
if (!this._functionDefinitions.TryGetValue(name, out inlineFunctionInfoList))
{
inlineFunctionInfoList = new List <InlineFunctionInfo>();
this._functionDefinitions.Add(name, inlineFunctionInfoList);
}
if (inlineFunctionInfoList.Exists((Predicate <InlineFunctionInfo>)(overload => overload.Parameters.Select <DbVariableReferenceExpression, TypeUsage>((Func <DbVariableReferenceExpression, TypeUsage>)(p => p.ResultType)).SequenceEqual <TypeUsage>(functionInfo.Parameters.Select <DbVariableReferenceExpression, TypeUsage>((Func <DbVariableReferenceExpression, TypeUsage>)(p => p.ResultType)), (IEqualityComparer <TypeUsage>)TypeResolver.TypeUsageStructuralComparer.Instance))))
{
throw EntitySqlException.Create(functionInfo.FunctionDefAst.ErrCtx, Strings.DuplicatedInlineFunctionOverload((object)name), (Exception)null);
}
inlineFunctionInfoList.Add(functionInfo);
}
// <summary>
// Constructs an aliased expression node.
// </summary>
internal AliasedExpr(Node expr, Identifier alias)
{
DebugCheck.NotNull(expr);
DebugCheck.NotNull(alias);
if (String.IsNullOrEmpty(alias.Name))
{
var errCtx = alias.ErrCtx;
var message = Strings.InvalidEmptyIdentifier;
throw EntitySqlException.Create(errCtx, message, null);
}
_expr = expr;
_alias = alias;
}
/// <summary>
/// Initializes aliased import.
/// </summary>
internal NamespaceImport(BuiltInExpr bltInExpr)
{
_namespaceAlias = null;
var aliasId = bltInExpr.Arg1 as Identifier;
if (aliasId == null)
{
var errCtx = bltInExpr.Arg1.ErrCtx;
var message = Strings.InvalidNamespaceAlias;
throw EntitySqlException.Create(errCtx, message, null);
}
_namespaceAlias = aliasId;
_namespaceName = bltInExpr.Arg2;
}
// <summary>
// Initializes parameter
// </summary>
// <remarks>
// <exception cref="System.Data.Entity.Core.EntityException">Thrown if the parameter name does not conform to the expected format</exception>
// </remarks>
internal QueryParameter(string parameterName, string query, int inputPos)
: base(query, inputPos)
{
_name = parameterName.Substring(1);
//
// valid parameter format is: @({LETTER})(_|{LETTER}|{DIGIT})*
//
if (_name.StartsWith("_", StringComparison.OrdinalIgnoreCase) ||
Char.IsDigit(_name, 0))
{
var errCtx = ErrCtx;
var message = Strings.InvalidParameterFormat(_name);
throw EntitySqlException.Create(errCtx, message, null);
}
}
internal Identifier(string name, bool isEscaped, string query, int inputPos)
: base(query, inputPos)
{
if (!isEscaped)
{
bool isIdentifierASCII = true;
if (!CqlLexer.IsLetterOrDigitOrUnderscore(name, out isIdentifierASCII))
{
if (isIdentifierASCII)
{
throw EntitySqlException.Create(this.ErrCtx, Strings.InvalidSimpleIdentifier((object)name), (Exception)null);
}
throw EntitySqlException.Create(this.ErrCtx, Strings.InvalidSimpleIdentifierNonASCII((object)name), (Exception)null);
}
}
this._name = name;
this._isEscaped = isEscaped;
}
// <summary>
// Maps punctuator to respective token
// </summary>
// <param name="punct"> punctuator </param>
// <returns> Token </returns>
internal Token MapPunctuator(string punct)
{
if (InternalPunctuatorDictionary.ContainsKey(punct))
{
ResetSymbolAsIdentifierState(true);
if (punct.Equals(".", StringComparison.OrdinalIgnoreCase))
{
_symbolAsIdentifierState = true;
}
return(NewToken(InternalPunctuatorDictionary[punct], new TerminalToken(punct, _iPos)));
}
else
{
var errorMessage = Strings.InvalidPunctuatorSymbol;
throw EntitySqlException.Create(_query, errorMessage, _iPos, null, false, null);
}
}
internal static void ReportFunctionOverloadError(
MethodExpr functionExpr,
EdmFunction functionType,
List <TypeUsage> argTypes)
{
string str = "";
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append(functionType.Name).Append("(");
for (int index = 0; index < argTypes.Count; ++index)
{
stringBuilder.Append(str);
stringBuilder.Append(argTypes[index] != null ? argTypes[index].EdmType.FullName : "NULL");
str = ", ";
}
stringBuilder.Append(")");
Func <object, object, object, string> func = !TypeSemantics.IsAggregateFunction(functionType) ? (TypeHelpers.IsCanonicalFunction(functionType) ? new Func <object, object, object, string>(Strings.NoCanonicalFunctionOverloadMatch) : new Func <object, object, object, string>(Strings.NoFunctionOverloadMatch)) : (TypeHelpers.IsCanonicalFunction(functionType) ? new Func <object, object, object, string>(Strings.NoCanonicalAggrFunctionOverloadMatch) : new Func <object, object, object, string>(Strings.NoAggrFunctionOverloadMatch));
throw EntitySqlException.Create(functionExpr.ErrCtx.CommandText, func((object)functionType.NamespaceName, (object)functionType.Name, (object)stringBuilder.ToString()), functionExpr.ErrCtx.InputPosition, Strings.CtxFunction((object)functionType.Name), false, (Exception)null);
}
private bool TryResolveAsRefPropertyAccess(
DbExpression valueExpr,
string name,
ErrorContext errCtx,
out DbExpression propertyExpr)
{
propertyExpr = (DbExpression)null;
if (!TypeSemantics.IsReferenceType(valueExpr.ResultType))
{
return(false);
}
DbExpression valueExpr1 = (DbExpression)valueExpr.Deref();
TypeUsage resultType = valueExpr1.ResultType;
if (this.TryResolveAsPropertyAccess(valueExpr1, name, out propertyExpr))
{
return(true);
}
string errorMessage = Strings.InvalidDeRefProperty((object)name, (object)resultType.EdmType.FullName, (object)valueExpr.ResultType.EdmType.FullName);
throw EntitySqlException.Create(errCtx, errorMessage, (Exception)null);
}
internal MetadataMember ResolveMetadataMemberAccess(
MetadataMember qualifier,
string name,
ErrorContext errCtx)
{
string fullName = TypeResolver.GetFullName(qualifier.Name, name);
if (qualifier.MetadataMemberClass == MetadataMemberClass.Namespace)
{
MetadataType type;
if (this.TryGetTypeFromMetadata(fullName, out type))
{
return((MetadataMember)type);
}
MetadataFunctionGroup functionGroup;
if (this.TryGetFunctionFromMetadata(qualifier.Name, name, out functionGroup))
{
return((MetadataMember)functionGroup);
}
return((MetadataMember) new MetadataNamespace(fullName));
}
if (qualifier.MetadataMemberClass == MetadataMemberClass.Type)
{
MetadataType metadataType = (MetadataType)qualifier;
if (TypeSemantics.IsEnumerationType(metadataType.TypeUsage))
{
EnumMember outMember;
if (this._perspective.TryGetEnumMember((EnumType)metadataType.TypeUsage.EdmType, name, this._parserOptions.NameComparisonCaseInsensitive, out outMember))
{
return((MetadataMember) new MetadataEnumMember(fullName, metadataType.TypeUsage, outMember));
}
string errorMessage = Strings.NotAMemberOfType((object)name, (object)qualifier.Name);
throw EntitySqlException.Create(errCtx, errorMessage, (Exception)null);
}
}
string errorMessage1 = Strings.InvalidMetadataMemberClassResolution((object)qualifier.Name, (object)qualifier.MetadataMemberClassName, (object)MetadataNamespace.NamespaceClassName);
throw EntitySqlException.Create(errCtx, errorMessage1, (Exception)null);
}
// <summary>
// Reports function overload resolution error.
// </summary>
internal static void ReportFunctionOverloadError(MethodExpr functionExpr, EdmFunction functionType, List <TypeUsage> argTypes)
{
var strDelim = "";
var sb = new StringBuilder();
sb.Append(functionType.Name).Append("(");
for (var i = 0; i < argTypes.Count; i++)
{
sb.Append(strDelim);
sb.Append(argTypes[i] != null ? argTypes[i].EdmType.FullName : "NULL");
strDelim = ", ";
}
sb.Append(")");
Func <object, object, object, string> formatString;
if (TypeSemantics.IsAggregateFunction(functionType))
{
formatString = TypeHelpers.IsCanonicalFunction(functionType)
? Strings.NoCanonicalAggrFunctionOverloadMatch
: (Func <object, object, object, string>)Strings.NoAggrFunctionOverloadMatch;
}
else
{
formatString = TypeHelpers.IsCanonicalFunction(functionType)
? Strings.NoCanonicalFunctionOverloadMatch
: (Func <object, object, object, string>)Strings.NoFunctionOverloadMatch;
}
throw EntitySqlException.Create(
functionExpr.ErrCtx.CommandText,
formatString(functionType.NamespaceName, functionType.Name, sb.ToString()),
functionExpr.ErrCtx.InputPosition,
Strings.CtxFunction(functionType.Name),
false,
null);
}
// <summary>
// Parse eSQL command string into an AST
// </summary>
// <param name="commandText"> eSQL command </param>
// <param name="parserOptions">
// parser options <seealso cref="ParserOptions" />
// </param>
// <returns> Ast </returns>
// <exception cref="System.Data.Entity.Core.EntityException">Thrown when Syntatic or Semantic rules are violated and the query cannot be accepted</exception>
// <remarks>
// This method is not thread safe.
// </remarks>
// <seealso cref="ParserOptions" />
private static Node Parse(string commandText, ParserOptions parserOptions)
{
// The common practice is to make the null check at the public surface,
// however this method is a convergence zone from multiple public entry points and it makes sense to
// check for null once, here.
Check.NotEmpty(commandText, "commandText");
//
// Create Parser
//
var cqlParser = new CqlParser(parserOptions, true);
//
// Invoke parser
//
var astExpr = cqlParser.Parse(commandText);
if (null == astExpr)
{
throw EntitySqlException.Create(commandText, Strings.InvalidEmptyQuery, 0, null, false, null);
}
return(astExpr);
}
// <summary>
// handles escaped identifiers
// ch will always be translated i.e. normalized.
// </summary>
internal Token HandleEscapedIdentifiers()
{
var ch = YYText[0];
while (ch != YY_EOF)
{
if (ch == ']')
{
yy_mark_end();
ch = yy_advance();
if (ch != ']')
{
yy_to_mark();
ResetSymbolAsIdentifierState(true);
return(MapIdentifierOrKeyword(YYText.Replace("]]", "]")));
}
}
ch = yy_advance();
}
Debug.Assert(ch == YY_EOF, "ch == YY_EOF");
var errorMessage = Strings.InvalidEscapedIdentifierUnbalanced(YYText);
throw EntitySqlException.Create(_query, errorMessage, _iPos, null, false, null);
}
internal ValueExpression ResolvePropertyAccess(
DbExpression valueExpr,
string name,
ErrorContext errCtx)
{
DbExpression propertyExpr;
if (this.TryResolveAsPropertyAccess(valueExpr, name, out propertyExpr))
{
return(new ValueExpression(propertyExpr));
}
if (this.TryResolveAsRefPropertyAccess(valueExpr, name, errCtx, out propertyExpr))
{
return(new ValueExpression(propertyExpr));
}
if (TypeSemantics.IsCollectionType(valueExpr.ResultType))
{
string errorMessage = Strings.NotAMemberOfCollection((object)name, (object)valueExpr.ResultType.EdmType.FullName);
throw EntitySqlException.Create(errCtx, errorMessage, (Exception)null);
}
string errorMessage1 = Strings.NotAMemberOfType((object)name, (object)valueExpr.ResultType.EdmType.FullName);
throw EntitySqlException.Create(errCtx, errorMessage1, (Exception)null);
}
private Token MapUnescapedIdentifier(string symbol)
{
// Validate before calling ResetSymbolAsIdentifierState(...) because it will reset _symbolAsInlineFunctionNameState
var invalidIdentifier = InternalInvalidAliasNames.Contains(symbol);
if (_symbolAsInlineFunctionNameState)
{
invalidIdentifier |= InternalInvalidInlineFunctionNames.Contains(symbol);
}
ResetSymbolAsIdentifierState(true);
if (invalidIdentifier)
{
var errorMessage = Strings.InvalidAliasName(symbol);
throw EntitySqlException.Create(_query, errorMessage, _iPos, null, false, null);
}
else
{
var id = new Identifier(symbol, false, _query, _iPos);
id.ErrCtx.ErrorContextInfo = EntityRes.CtxIdentifier;
return(NewToken(CqlParser.IDENTIFIER, id));
}
}
/// <summary>
/// If <paramref name="valueExpr" /> returns a reference, then deref and try resolving <paramref name="name" /> as a property of the dereferenced value.
/// </summary>
private bool TryResolveAsRefPropertyAccess(DbExpression valueExpr, string name, ErrorContext errCtx, out DbExpression propertyExpr)
{
DebugCheck.NotNull(valueExpr);
propertyExpr = null;
if (TypeSemantics.IsReferenceType(valueExpr.ResultType))
{
DbExpression derefExpr = valueExpr.Deref();
var derefExprType = derefExpr.ResultType;
if (TryResolveAsPropertyAccess(derefExpr, name, out propertyExpr))
{
return(true);
}
else
{
var message = Strings.InvalidDeRefProperty(name, derefExprType.EdmType.FullName, valueExpr.ResultType.EdmType.FullName);
throw EntitySqlException.Create(errCtx, message, null);
}
}
return(false);
}
private static DateTimeOffset ConvertDateTimeOffsetLiteralValue(
ErrorContext errCtx,
string datetimeLiteralValue)
{
string[] datetimeParts1 = datetimeLiteralValue.Split(Literal._datetimeOffsetSeparators, StringSplitOptions.RemoveEmptyEntries);
int year;
int month;
int day;
Literal.GetDateParts(datetimeLiteralValue, datetimeParts1, out year, out month, out day);
string[] datetimeParts2 = new string[datetimeParts1.Length - 2];
Array.Copy((Array)datetimeParts1, (Array)datetimeParts2, datetimeParts1.Length - 2);
int hour;
int minute;
int second;
int ticks;
Literal.GetTimeParts(datetimeLiteralValue, datetimeParts2, 3, out hour, out minute, out second, out ticks);
TimeSpan offset = new TimeSpan(int.Parse(datetimeParts1[datetimeParts1.Length - 2], NumberStyles.Integer, (IFormatProvider)CultureInfo.InvariantCulture), int.Parse(datetimeParts1[datetimeParts1.Length - 1], NumberStyles.Integer, (IFormatProvider)CultureInfo.InvariantCulture), 0);
if (datetimeLiteralValue.IndexOf('+') == -1)
{
offset = offset.Negate();
}
DateTime dateTime = new DateTime(year, month, day, hour, minute, second, 0).AddTicks((long)ticks);
try
{
return(new DateTimeOffset(dateTime, offset));
}
catch (ArgumentOutOfRangeException ex)
{
string errorMessage = Strings.InvalidDateTimeOffsetLiteral((object)datetimeLiteralValue);
throw EntitySqlException.Create(errCtx, errorMessage, (Exception)ex);
}
}
private static Exception AmbiguousMetadataMemberName(ErrorContext errCtx, string name, MetadataNamespace ns1, MetadataNamespace ns2)
{
var message = Strings.AmbiguousMetadataMemberName(name, ns1.Name, ns2 != null ? ns2.Name : null);
throw EntitySqlException.Create(errCtx, message, null);
}