public IntermediateHqlTree(bool root, QueryMode mode)
{
_isRoot = root;
TreeBuilder = new HqlTreeBuilder();
if (mode == QueryMode.Delete)
{
_root = TreeBuilder.Delete(TreeBuilder.From());
}
else if (mode == QueryMode.Update)
{
_root = TreeBuilder.Update(TreeBuilder.From(), TreeBuilder.Set());
}
else if (mode == QueryMode.UpdateVersioned)
{
_root = TreeBuilder.Update(TreeBuilder.Versioned(), TreeBuilder.From(), TreeBuilder.Set());
}
else if (mode == QueryMode.Insert)
{
_root = TreeBuilder.Query(TreeBuilder.SelectFrom(TreeBuilder.From()));
_insertRoot = TreeBuilder.Insert(TreeBuilder.Into(), _root as HqlQuery);
}
else
{
_root = TreeBuilder.Query(TreeBuilder.SelectFrom(TreeBuilder.From()));
}
}
public override HqlTreeNode BuildHql(MethodInfo method, Expression targetObject, ReadOnlyCollection <Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor)
{
HqlExpression argument0Expression = visitor.Visit(arguments[0]).AsExpression();
HqlTreeNode result = treeBuilder.Cast(argument0Expression, method.ReturnType);
return(result);
}
public static IEnumerable <HqlTreeNode> Union(this HqlTreeNode first, IEnumerable <HqlTreeNode> rest)
{
yield return(first);
foreach (HqlTreeNode x in rest)
{
yield return(x);
}
}
public override HqlTreeNode BuildHql(MethodInfo method, Expression targetObjectExpr, ReadOnlyCollection <Expression> arguments,
HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor)
{
var exprs = McsGetStringLinqTranslator.TranslateParametersMcsGetString(method, targetObjectExpr, arguments);
var parameters = exprs.Select(e => visitor.Visit(e).AsExpression());
HqlTreeNode result = treeBuilder.MethodCall("mcs_get_string", parameters);
return(result);
}
private void ExecuteAddOrderBy(HqlTreeNode orderBy)
{
if (orderBy == null)
{
return;
}
if (_root.NodesPreOrder.All(x => x != orderBy))
{
_root.AddChild(orderBy);
}
}
private void ExecuteAddOrderBy(HqlTreeNode orderBy)
{
if (orderBy == null)
{
return;
}
if (!_root.NodesPreOrder.Any(x => x == orderBy))
{
_root.As <HqlQuery>().AddChild(orderBy);
}
}
private void DetectOuterExists()
{
if (_root is HqlExists)
{
_takeCount = TreeBuilder.Constant(1);
_root = Root.Children.First();
Expression <Func <IEnumerable <object>, bool> > x = l => l.Any();
_listTransformers.Add(x);
}
}
internal static HqlExpression ToArithmeticExpression(this HqlTreeNode node)
{
var hqlBooleanExpression = node as HqlBooleanExpression;
if (hqlBooleanExpression != null)
{
var builder = new HqlTreeBuilder();
return(builder.Case(new[] { builder.When(hqlBooleanExpression, builder.True()) }, builder.False()));
}
return((HqlExpression)node);
}
private void Process(
FetchRequestBase resultOperator,
QueryModelVisitor queryModelVisitor,
IntermediateHqlTree tree,
HqlTreeNode currentNode,
string sourceAlias)
{
var memberPath = tree.TreeBuilder.Dot(
tree.TreeBuilder.Ident(sourceAlias),
tree.TreeBuilder.Ident(resultOperator.RelationMember.Name));
Process(resultOperator, queryModelVisitor, tree, memberPath, currentNode, null);
}
public override HqlTreeNode BuildHql(MethodInfo method, Expression targetObject, ReadOnlyCollection <Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor)
{
HqlExpression value = visitor.Visit(arguments[0]).AsExpression();
HqlTreeNode inClauseNode = BuildInClause(arguments, treeBuilder, visitor);
HqlTreeNode inClause = treeBuilder.In(value, inClauseNode);
if (method.Name == "NotIn")
{
inClause = treeBuilder.BooleanNot((HqlBooleanExpression)inClause);
}
return(inClause);
}
private void ExecuteAddSkipClause(HqlExpression toSkip)
{
if (toSkip == null)
{
return;
}
// We should check the value instead delegate the behavior to the result SQL-> MSDN: If count is less than or equal to zero, all elements of source are yielded.
HqlQuery hqlQuery = _root.NodesPreOrder.OfType <HqlQuery>().First();
HqlTreeNode skipRoot = hqlQuery.Children.FirstOrDefault(n => n is HqlSkip);
if (skipRoot == null)
{
skipRoot = TreeBuilder.Skip(toSkip);
hqlQuery.AddChild(skipRoot);
}
}
private HqlTreeNode CreateCrossJoin(HqlTreeNode joinExpression, HqlAlias alias)
{
if (VisitorParameters.SessionFactory.Dialect.SupportsCrossJoin)
{
return(_hqlTree.TreeBuilder.CrossJoin(joinExpression.AsExpression(), alias));
}
// Simulate cross join as a inner join on 1=1
var join = _hqlTree.TreeBuilder.InnerJoin(joinExpression.AsExpression(), alias);
var onExpression = _hqlTree.TreeBuilder.Equality(
_hqlTree.TreeBuilder.True(),
_hqlTree.TreeBuilder.True());
join.AddChild(_hqlTree.TreeBuilder.With(onExpression));
return(join);
}
private void ExecuteAddTakeClause(HqlExpression toTake)
{
if (toTake == null)
{
return;
}
HqlQuery hqlQuery = _root.NodesPreOrder.OfType <HqlQuery>().First();
HqlTreeNode takeRoot = hqlQuery.Children.FirstOrDefault(n => n is HqlTake);
// were present we ignore the new value
if (takeRoot == null)
{
//We should check the value instead delegate the behavior to the result SQL-> MSDN: If count is less than or equal to zero, source is not enumerated and an empty IEnumerable<T> is returned.
takeRoot = TreeBuilder.Take(toTake);
hqlQuery.AddChild(takeRoot);
}
}
public ExpressionToHqlTranslationResults(HqlTreeNode statement,
IList <LambdaExpression> itemTransformers,
IList <LambdaExpression> listTransformers,
IList <LambdaExpression> postExecuteTransformers,
List <Action <IQuery, IDictionary <string, Tuple <object, IType> > > > additionalCriteria,
Type executeResultTypeOverride)
{
Statement = statement;
PostExecuteTransformer = MergeLambdasAndCompile(postExecuteTransformers);
var itemTransformer = MergeLambdasAndCompile <Func <object[], object> >(itemTransformers);
var listTransformer = MergeLambdasAndCompile <Func <IEnumerable <object>, object> >(listTransformers);
if (itemTransformer != null || listTransformer != null)
{
ResultTransformer = new ResultTransformer(itemTransformer, listTransformer);
}
AdditionalCriteria = additionalCriteria;
ExecuteResultTypeOverride = executeResultTypeOverride;
}
public override HqlTreeNode BuildHql(
MethodInfo method,
System.Linq.Expressions.Expression targetObject,
ReadOnlyCollection <System.Linq.Expressions.Expression> arguments,
HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor)
{
// Is there a better way to do this?
var factory = new ASTFactory(new ASTTreeAdaptor());
HqlTreeNode escapeCharNode = visitor.Visit(arguments[2]).AsExpression();
var escapeNode = new HqlEscape(factory, escapeCharNode);
HqlLikeWithEscape likeClauseNode =
new HqlLikeWithEscape(
factory,
visitor.Visit(arguments[0]).AsExpression(),
visitor.Visit(arguments[1]).AsExpression(),
escapeNode);
return(likeClauseNode);
}
private HqlTreeNode BuildInClause(ReadOnlyCollection <Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor)
{
ConstantExpression constantExpression = arguments[1] as ConstantExpression;
if (constantExpression == null)
{
HqlTreeNode result = BuildFromExpression(arguments[1], visitor);
return(result);
}
IEnumerable valueArray = (IEnumerable)constantExpression.Value;
Type elementType = GetElementType(valueArray);
if (elementType.IsValueType || elementType == typeof(string))
{
HqlTreeNode result = BuildFromArray(valueArray, treeBuilder, elementType);
return(result);
}
HqlTreeNode hqlTreeNode = BuildFromExpression(arguments[1], visitor);
return(hqlTreeNode);
}
public override HqlTreeNode BuildHql(MethodInfo method, System.Linq.Expressions.Expression targetObject, ReadOnlyCollection <System.Linq.Expressions.Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor)
{
var value = visitor.Visit(arguments[0]).AsExpression();
HqlTreeNode inClauseNode;
if (arguments[1] is ConstantExpression)
{
inClauseNode = BuildFromArray((Array)((ConstantExpression)arguments[1]).Value, treeBuilder);
}
else
{
inClauseNode = BuildFromExpression(arguments[1], visitor);
}
HqlTreeNode inClause = treeBuilder.In(value, inClauseNode);
if (method.Name == "NotIn")
{
inClause = treeBuilder.BooleanNot((HqlBooleanExpression)inClause);
}
return(inClause);
}
public void SetRoot(HqlTreeNode newRoot)
{
Root = newRoot;
}
private static HqlRange GetFromRangeClause(HqlTreeNode node)
{
return(node.NodesPreOrder.Single(n => n is HqlRange).As <HqlRange>());
}
private void Process(
FetchRequestBase resultOperator,
QueryModelVisitor queryModelVisitor,
IntermediateHqlTree tree,
HqlDot memberPath,
HqlTreeNode currentNode,
IType propType)
{
string alias = null;
if (resultOperator is FetchOneRequest)
{
if (propType == null)
{
var metadata = queryModelVisitor.VisitorParameters.SessionFactory
.GetClassMetadata(resultOperator.RelationMember.ReflectedType);
propType = metadata?.GetPropertyType(resultOperator.RelationMember.Name);
}
if (propType != null && !propType.IsAssociationType)
{
if (currentNode == null)
{
currentNode = tree.GetFromRangeClause()
?? throw new InvalidOperationException($"Property {resultOperator.RelationMember.Name} cannot be fetched for this type of query.");
}
currentNode.AddChild(tree.TreeBuilder.Fetch());
currentNode.AddChild(memberPath);
ComponentType componentType = null;
foreach (var innerFetch in resultOperator.InnerFetchRequests)
{
if (componentType == null)
{
componentType = propType as ComponentType;
if (componentType == null)
{
throw new InvalidOperationException(
$"Property {innerFetch.RelationMember.Name} cannot be fetched from a non component type property {resultOperator.RelationMember.Name}.");
}
}
var subTypeIndex = componentType.GetPropertyIndex(innerFetch.RelationMember.Name);
memberPath = tree.TreeBuilder.Dot(
memberPath,
tree.TreeBuilder.Ident(innerFetch.RelationMember.Name));
Process(innerFetch, queryModelVisitor, tree, memberPath, currentNode, componentType.Subtypes[subTypeIndex]);
}
return;
}
var relatedJoin = queryModelVisitor.RelatedJoinFetchRequests.FirstOrDefault(o => o.Value == resultOperator).Key;
if (relatedJoin != null)
{
alias = queryModelVisitor.VisitorParameters.QuerySourceNamer.GetName(relatedJoin);
}
}
if (alias == null)
{
alias = queryModelVisitor.Model.GetNewName("_");
currentNode = tree.TreeBuilder.LeftFetchJoin(memberPath, tree.TreeBuilder.Alias(alias));
tree.AddFromClause(currentNode);
}
tree.AddDistinctRootOperator();
foreach (var innerFetch in resultOperator.InnerFetchRequests)
{
Process(innerFetch, queryModelVisitor, tree, currentNode, alias);
}
}
public void AddSelectClause(HqlTreeNode select)
{
_root.NodesPreOrder.OfType <HqlSelectFrom>().First().AddChild(select);
}
public void AddFromClause(HqlTreeNode from)
{
_root.NodesPreOrder.OfType <HqlFrom>().First().AddChild(from);
}
public IntermediateHqlTree(bool root)
{
_isRoot = root;
TreeBuilder = new HqlTreeBuilder();
_root = TreeBuilder.Query(TreeBuilder.SelectFrom(TreeBuilder.From()));
}
public void AddFromClause(HqlTreeNode from)
{
Root.NodesPreOrder.Where(n => n is HqlFrom).First().AddChild(from);
}
private static HqlAlias GetFromAlias(HqlTreeNode node)
{
return(node.NodesPreOrder.Single(n => n is HqlRange).Children.Single(n => n is HqlAlias) as HqlAlias);
}
public void AddSelectClause(HqlTreeNode select)
{
Root.NodesPreOrder.Where(n => n is HqlSelectFrom).First().AddChild(select);
}
private static HqlRange GetFromRangeClause(HqlTreeNode node)
{
return(node.NodesPreOrder.OfType <HqlRange>().First());
}
