public IASTNode Translate(ISessionFactoryImplementor sessionFactory, bool filter)
{
var requiredHqlParameters = new List <NamedParameterDescriptor>();
var queryModel = NhRelinqQueryParser.Parse(_expression);
var visitorParameters = new VisitorParameters(sessionFactory, _constantToParameterMap, requiredHqlParameters,
new QuerySourceNamer(), TargetType, QueryMode);
ExpressionToHqlTranslationResults = QueryModelVisitor.GenerateHqlQuery(queryModel, visitorParameters, true, ReturnType);
if (ExpressionToHqlTranslationResults.ExecuteResultTypeOverride != null)
{
Type = ExpressionToHqlTranslationResults.ExecuteResultTypeOverride;
}
ParameterDescriptors = requiredHqlParameters.AsReadOnly();
CanCachePlan = CanCachePlan &&
// If some constants do not have matching HQL parameters, their values from first query will
// be embedded in the plan and reused for subsequent queries: do not cache the plan.
!ParameterValuesByName
.Keys
.Except(requiredHqlParameters.Select(p => p.Name))
.Any();
return(ExpressionToHqlTranslationResults.Statement.AstNode);
}
public IASTNode Translate(ISessionFactoryImplementor sessionFactory, bool filter)
{
if (ExpressionToHqlTranslationResults != null)
{
// Query has already been translated. Arguments do not really matter, because queries are anyway tied
// to a single session factory and cannot switch from being a filter query (query on a mapped collection)
// or not.
return(DuplicateTree(ExpressionToHqlTranslationResults.Statement.AstNode));
}
var requiredHqlParameters = new List <NamedParameterDescriptor>();
var queryModel = NhRelinqQueryParser.Parse(_expression);
var visitorParameters = new VisitorParameters(sessionFactory, _constantToParameterMap, requiredHqlParameters,
new QuerySourceNamer(), TargetType, QueryMode);
ExpressionToHqlTranslationResults = QueryModelVisitor.GenerateHqlQuery(queryModel, visitorParameters, true, ReturnType);
if (ExpressionToHqlTranslationResults.ExecuteResultTypeOverride != null)
{
Type = ExpressionToHqlTranslationResults.ExecuteResultTypeOverride;
}
ParameterDescriptors = requiredHqlParameters.AsReadOnly();
CanCachePlan = CanCachePlan &&
// If some constants do not have matching HQL parameters, their values from first query will
// be embedded in the plan and reused for subsequent queries: do not cache the plan.
!ParameterValuesByName
.Keys
.Except(requiredHqlParameters.Select(p => p.Name))
.Any();
// The ast node may be altered by caller, duplicate it for preserving the original one.
return(DuplicateTree(ExpressionToHqlTranslationResults.Statement.AstNode));
}
private static bool IsEmptyList(HqlParameter source, VisitorParameters parameters)
{
var parameterName = source.NodesPreOrder.Single(n => n is HqlIdent).AstNode.Text;
var parameterValue = parameters.ConstantToParameterMap.Single(p => p.Value.Name == parameterName).Key.Value;
return(!((IEnumerable)parameterValue).Cast <object>().Any());
}
public void Process(SkipResultOperator resultOperator, QueryModelVisitor queryModelVisitor, IntermediateHqlTree tree)
{
VisitorParameters parameters = queryModelVisitor.VisitorParameters;
NamedParameter namedParameter;
/** https://nhibernate.jira.com/browse/NH-3021
* Temporary fix for Skip for dialects that support constant limiting only
* */
if (parameters.SessionFactory.Dialect.SupportsLimit && !parameters.SessionFactory.Dialect.SupportsVariableLimit)
{
tree.AddSkipClause(tree.TreeBuilder.Constant(resultOperator.GetConstantCount()));
return;
}
if (parameters.ConstantToParameterMap.TryGetValue(resultOperator.Count as ConstantExpression, out namedParameter))
{
parameters.RequiredHqlParameters.Add(new NamedParameterDescriptor(namedParameter.Name, null, false));
// tree.AddSkipClause(tree.TreeBuilder.Parameter(namedParameter.Name));
//}
//else
//{
// tree.AddSkipClause(tree.TreeBuilder.Constant(resultOperator.GetConstantCount()));
tree.AddSkipClause(tree.TreeBuilder.Parameter(namedParameter.Name));
}
else
{
tree.AddSkipClause(tree.TreeBuilder.Constant(resultOperator.GetConstantCount()));
//}
/* end of fix */
}
}
private static bool IsEmptyList(HqlParameter source, VisitorParameters parameters)
{
var parameterName = source.NodesPreOrder.Single(n => n is HqlIdent).AstNode.Text;
// Multiple constants may be linked to the same parameter, take the first matching parameter
var parameterValue = parameters.ConstantToParameterMap.First(p => p.Value.Name == parameterName).Key.Value;
return(!((IEnumerable)parameterValue).Cast <object>().Any());
}
private void AssertResult(
IQueryable query,
bool rewriteQuery,
bool supported,
string expectedEntityName,
string expectedMemberPath,
Predicate <IType> expectedMemberType,
Predicate <IAbstractComponentType> expectedComponentType = null,
bool nullability = true)
{
expectedComponentType = expectedComponentType ?? (o => o == null);
var expression = query.Expression;
var preTransformResult = NhRelinqQueryParser.PreTransform(expression, new PreTransformationParameters(QueryMode.Select, Sfi));
expression = preTransformResult.Expression;
var constantToParameterMap = ExpressionParameterVisitor.Visit(preTransformResult);
var queryModel = NhRelinqQueryParser.Parse(expression);
var requiredHqlParameters = new List <NamedParameterDescriptor>();
var visitorParameters = new VisitorParameters(
Sfi,
constantToParameterMap,
requiredHqlParameters,
new QuerySourceNamer(),
expression.Type,
QueryMode.Select);
if (rewriteQuery)
{
QueryModelVisitor.GenerateHqlQuery(
queryModel,
visitorParameters,
true,
NhLinqExpressionReturnType.Scalar);
}
var found = _tryGetMappedType(
Sfi,
queryModel.SelectClause.Selector,
out var memberType,
out var entityPersister,
out var componentType,
out var memberPath);
Assert.That(found, Is.EqualTo(supported), $"Expression should be {(supported ? "supported" : "unsupported")}");
Assert.That(entityPersister?.EntityName, Is.EqualTo(expectedEntityName), "Invalid entity name");
Assert.That(memberPath, Is.EqualTo(expectedMemberPath), "Invalid member path");
Assert.That(() => expectedMemberType(memberType), $"Invalid member type: {memberType?.Name ?? "null"}");
Assert.That(() => expectedComponentType(componentType), $"Invalid component type: {componentType?.Name ?? "null"}");
if (found)
{
Assert.That(_tryGetMappedNullability(Sfi, queryModel.SelectClause.Selector, out var isNullable), Is.True, "Expression should be supported");
Assert.That(nullability, Is.EqualTo(isNullable), "Nullability is not correct");
}
}
public IASTNode Translate(ISessionFactoryImplementor sessionFactory, bool filter)
{
var requiredHqlParameters = new List <NamedParameterDescriptor>();
var querySourceNamer = new QuerySourceNamer();
var queryModel = NhRelinqQueryParser.Parse(_expression);
var visitorParameters = new VisitorParameters(sessionFactory, _constantToParameterMap, requiredHqlParameters, querySourceNamer);
ExpressionToHqlTranslationResults = QueryModelVisitor.GenerateHqlQuery(queryModel, visitorParameters, true);
ParameterDescriptors = requiredHqlParameters.AsReadOnly();
return(ExpressionToHqlTranslationResults.Statement.AstNode);
}
/// <summary>
/// Get the mapped type for the given expression.
/// </summary>
/// <param name="parameters">The query parameters.</param>
/// <param name="expression">The expression.</param>
/// <returns>The mapped type of the expression or <see langword="null"/> when the mapped type was not
/// found and the <paramref name="expression"/> type is <see cref="object"/>.</returns>
internal static IType GetType(VisitorParameters parameters, Expression expression)
{
if (expression is ConstantExpression constantExpression &&
parameters.ConstantToParameterMap.TryGetValue(constantExpression, out var param))
{
return(param.Type);
}
if (TryGetMappedType(parameters.SessionFactory, expression, out var type, out _, out _, out _))
{
return(type);
}
return(expression.Type == typeof(object) ? null : TypeFactory.HeuristicType(expression.Type));
}
public void Process(SkipResultOperator resultOperator, QueryModelVisitor queryModelVisitor, IntermediateHqlTree tree)
{
VisitorParameters parameters = queryModelVisitor.VisitorParameters;
NamedParameter namedParameter;
if (parameters.ConstantToParameterMap.TryGetValue(resultOperator.Count as ConstantExpression, out namedParameter))
{
parameters.RequiredHqlParameters.Add(new NamedParameterDescriptor(namedParameter.Name, null, false));
tree.AddSkipClause(tree.TreeBuilder.Parameter(namedParameter.Name));
}
else
{
tree.AddSkipClause(tree.TreeBuilder.Constant(resultOperator.GetConstantCount()));
}
}
public static void ReWrite(QueryModel queryModel, VisitorParameters parameters)
{
var visitor = new AddJoinsReWriter(parameters.SessionFactory, queryModel);
visitor.VisitQueryModel(queryModel);
}
public QueryModelVisitorBase CreateVisitor(VisitorParameters parameters)
{
return(new CustomVisitor());
}
public QueryModelVisitorBase CreateVisitor(VisitorParameters parameters)
{
return(new NodaTimeQueryModelVisitor());
}
