private static ParseResult AnalyzeCommandSemantics(
System.Data.Entity.Core.Common.EntitySql.AST.Node astExpr,
Perspective perspective,
ParserOptions parserOptions,
IEnumerable <DbParameterReferenceExpression> parameters)
{
return(CqlQuery.AnalyzeSemanticsCommon <ParseResult>(astExpr, perspective, parserOptions, parameters, (IEnumerable <DbVariableReferenceExpression>)null, (Func <SemanticAnalyzer, System.Data.Entity.Core.Common.EntitySql.AST.Node, ParseResult>)((analyzer, astExpression) => analyzer.AnalyzeCommand(astExpression))));
}
internal static ParseResult Compile(
string commandText,
Perspective perspective,
ParserOptions parserOptions,
IEnumerable <DbParameterReferenceExpression> parameters)
{
return(CqlQuery.CompileCommon <ParseResult>(commandText, parserOptions, (Func <System.Data.Entity.Core.Common.EntitySql.AST.Node, ParserOptions, ParseResult>)((astCommand, validatedParserOptions) => CqlQuery.AnalyzeCommandSemantics(astCommand, perspective, validatedParserOptions, parameters))));
}
private static DbLambda AnalyzeQueryExpressionSemantics(
System.Data.Entity.Core.Common.EntitySql.AST.Node astQueryCommand,
Perspective perspective,
ParserOptions parserOptions,
IEnumerable <DbParameterReferenceExpression> parameters,
IEnumerable <DbVariableReferenceExpression> variables)
{
return(CqlQuery.AnalyzeSemanticsCommon <DbLambda>(astQueryCommand, perspective, parserOptions, parameters, variables, (Func <SemanticAnalyzer, System.Data.Entity.Core.Common.EntitySql.AST.Node, DbLambda>)((analyzer, astExpr) => analyzer.AnalyzeQueryCommand(astExpr))));
}
private static TResult CompileCommon <TResult>(
string commandText,
ParserOptions parserOptions,
Func <System.Data.Entity.Core.Common.EntitySql.AST.Node, ParserOptions, TResult> compilationFunction)
where TResult : class
{
parserOptions = parserOptions ?? new ParserOptions();
return(compilationFunction(CqlQuery.Parse(commandText, parserOptions), parserOptions));
}
internal static DbLambda CompileQueryCommandLambda(
string queryCommandText,
Perspective perspective,
ParserOptions parserOptions,
IEnumerable <DbParameterReferenceExpression> parameters,
IEnumerable <DbVariableReferenceExpression> variables)
{
return(CqlQuery.CompileCommon <DbLambda>(queryCommandText, parserOptions, (Func <System.Data.Entity.Core.Common.EntitySql.AST.Node, ParserOptions, DbLambda>)((astCommand, validatedParserOptions) => CqlQuery.AnalyzeQueryExpressionSemantics(astCommand, perspective, validatedParserOptions, parameters, variables))));
}
/// <summary>
/// Parse a specific query with a specific set variables and produce a
/// <see cref="T:System.Data.Entity.Core.Common.CommandTrees.DbLambda" />
/// .
/// </summary>
/// <returns>
/// The <see cref="T:System.Data.Entity.Core.Common.EntitySql.ParseResult" /> containing
/// <see cref="T:System.Data.Entity.Core.Common.CommandTrees.DbCommandTree" />
/// and information describing inline function definitions if any.
/// </returns>
/// <param name="query">The query to be parsed.</param>
/// <param name="variables">The optional query variables.</param>
public DbLambda ParseLambda(
string query,
params DbVariableReferenceExpression[] variables)
{
Check.NotNull <string>(query, nameof(query));
if (variables != null)
{
IEnumerable <DbVariableReferenceExpression> enumerableArgument = (IEnumerable <DbVariableReferenceExpression>)variables;
EntityUtil.CheckArgumentContainsNull <DbVariableReferenceExpression>(ref enumerableArgument, nameof(variables));
}
return(CqlQuery.CompileQueryCommandLambda(query, this._perspective, (ParserOptions)null, (IEnumerable <DbParameterReferenceExpression>)null, (IEnumerable <DbVariableReferenceExpression>)variables));
}
/// <summary>Parse the specified query with the specified parameters.</summary>
/// <returns>
/// The <see cref="T:System.Data.Entity.Core.Common.EntitySql.ParseResult" /> containing
/// <see cref="T:System.Data.Entity.Core.Common.CommandTrees.DbCommandTree" />
/// and information describing inline function definitions if any.
/// </returns>
/// <param name="query">The EntitySQL query to be parsed.</param>
/// <param name="parameters">The optional query parameters.</param>
public ParseResult Parse(
string query,
params DbParameterReferenceExpression[] parameters)
{
Check.NotNull <string>(query, nameof(query));
if (parameters != null)
{
IEnumerable <DbParameterReferenceExpression> enumerableArgument = (IEnumerable <DbParameterReferenceExpression>)parameters;
EntityUtil.CheckArgumentContainsNull <DbParameterReferenceExpression>(ref enumerableArgument, nameof(parameters));
}
return(CqlQuery.Compile(query, this._perspective, (ParserOptions)null, (IEnumerable <DbParameterReferenceExpression>)parameters));
}
/// <summary>Parse the specified query with the specified parameters.</summary>
/// <returns>
/// The <see cref="T:System.Data.Entity.Core.Common.EntitySql.ParseResult" /> containing
/// <see
/// cref="T:System.Data.Entity.Core.Common.CommandTrees.DbCommandTree" />
/// and information describing inline function definitions if any.
/// </returns>
/// <param name="query">The EntitySQL query to be parsed.</param>
/// <param name="parameters">The optional query parameters.</param>
public ParseResult Parse(string query, params DbParameterReferenceExpression[] parameters)
{
Check.NotNull(query, "query");
if (parameters != null)
{
IEnumerable <DbParameterReferenceExpression> paramsEnum = parameters;
EntityUtil.CheckArgumentContainsNull(ref paramsEnum, "parameters");
}
var result = CqlQuery.Compile(query, _perspective, null /* parser options - use default */, parameters);
return(result);
}
/// <summary>
/// Parse a specific query with a specific set variables and produce a
/// <see
/// cref="T:System.Data.Entity.Core.Common.CommandTrees.DbLambda" />
/// .
/// </summary>
/// <returns>
/// The <see cref="T:System.Data.Entity.Core.Common.EntitySql.ParseResult" /> containing
/// <see
/// cref="T:System.Data.Entity.Core.Common.CommandTrees.DbCommandTree" />
/// and information describing inline function definitions if any.
/// </returns>
/// <param name="query">The query to be parsed.</param>
/// <param name="variables">The optional query variables.</param>
public DbLambda ParseLambda(string query, params DbVariableReferenceExpression[] variables)
{
Check.NotNull(query, "query");
if (variables != null)
{
IEnumerable <DbVariableReferenceExpression> varsEnum = variables;
EntityUtil.CheckArgumentContainsNull(ref varsEnum, "variables");
}
var result = CqlQuery.CompileQueryCommandLambda(
query, _perspective, null /* parser options - use default */, null /* parameters */, variables);
return(result);
}
