public HqlTreeNode BuildHql(MethodInfo method, Expression targetObject, ReadOnlyCollection<Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { return treeBuilder.Like( visitor.Visit(arguments[0]).AsExpression(), visitor.Visit(arguments[1]).AsExpression()); }
public override HqlTreeNode BuildHql(MethodInfo method, Expression targetObject, ReadOnlyCollection<Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { HqlExpression targetExpression = visitor.Visit(targetObject).AsExpression(); HqlExpression argument0Expression = visitor.Visit(arguments[0]).AsExpression(); HqlEquality result = treeBuilder.Equality(targetExpression, argument0Expression); return result; }
public override HqlTreeNode BuildHql( MethodInfo method, Expression targetObject, ReadOnlyCollection<Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { // Get the StringComparison argument. var comparison = (StringComparison)(arguments[1].As<ConstantExpression>().Value); if (comparison == StringComparison.CurrentCultureIgnoreCase || comparison == StringComparison.InvariantCultureIgnoreCase || comparison == StringComparison.OrdinalIgnoreCase) { // If the comparison calls for us to ignore the case, use SQL LOWER() return treeBuilder.Equality( treeBuilder.MethodCall("lower", new[] { visitor.Visit(targetObject).AsExpression() }), treeBuilder.MethodCall("lower", new[] { visitor.Visit(arguments[0]).AsExpression() })); } // Otherwise use the database's default string comparison mechanism. return treeBuilder.Equality( visitor.Visit(targetObject).AsExpression(), visitor.Visit(arguments[0]).AsExpression()); }
public ProjectionEvaluator(ParameterAggregator parameterAggregator, System.Type inputType, Func<Expression, bool> predicate) { _parameterAggregator = parameterAggregator; _inputParameter = Expression.Parameter(inputType, "input"); _predicate = predicate; _hqlTreeBuilder = new HqlTreeBuilder(); _stack = new HqlNodeStack(_hqlTreeBuilder); }
public override HqlTreeNode BuildHql(MethodInfo method, Expression targetObject, ReadOnlyCollection<Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { IEnumerable<HqlExpression> args = visitor.Visit(targetObject) .Union(arguments.Select(a => visitor.Visit(a))) .Cast<HqlExpression>(); return treeBuilder.MethodCall(_name, args); }
public override HqlTreeNode BuildHql(MethodInfo method, Expression targetObject, ReadOnlyCollection<Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { return treeBuilder.Like( visitor.Visit(targetObject).AsExpression(), treeBuilder.Concat( treeBuilder.Constant("%"), visitor.Visit(arguments[0]).AsExpression())); }
public override HqlTreeNode BuildHql(MethodInfo method, Expression targetObject, ReadOnlyCollection<Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { Expression lhs = arguments.Count == 1 ? targetObject : arguments[0]; Expression rhs = arguments.Count == 1 ? arguments[0] : arguments[1]; return treeBuilder.Equality( visitor.Visit(lhs).AsExpression(), visitor.Visit(rhs).AsExpression()); }
public override HqlTreeNode BuildHql(MethodInfo method, Expression targetObject, ReadOnlyCollection<Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { var arg = visitor.Visit(arguments[0]).AsExpression(); var mt = treeBuilder.MethodCall("hid_Parse", arg); return mt; }
public override HqlTreeNode BuildHql(MethodInfo method, Expression targetObject, ReadOnlyCollection<Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { // HqlGeneratorExpressionTreeVisitor.VisitConstantExpression will always return an HqlEquality // instead of HqlParameter for argument that is of type bool. // Use the HqlParameter that exists as first children to the HqlEquality as second argument into treeBuilder.Equality return treeBuilder.Equality( visitor.Visit(targetObject).AsExpression(), visitor.Visit(arguments[0]).Children.First().AsExpression()); }
private static HqlExpression GetRhs(MethodInfo method, ReadOnlyCollection<Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { if (arguments.Count > 0) return visitor.Visit(arguments[0]).AsExpression(); var returnType = method.ReturnType; var instance = returnType.IsValueType ? Activator.CreateInstance(returnType) : null; return treeBuilder.Constant(instance); }
public override HqlTreeNode BuildHql(MethodInfo method, Expression targetObject, ReadOnlyCollection<Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { IEnumerable<HqlExpression> args = arguments.Select(a => visitor.Visit(a)) .Cast<HqlExpression>(); return treeBuilder.BooleanMethodCall("FREETEXT", args); }
public override HqlTreeNode BuildHql(MethodInfo method, Expression targetObject, ReadOnlyCollection<Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { var arg = visitor.Visit(arguments[0]).AsExpression(); var c1 = visitor.Visit(arguments[1]).AsExpression(); var c2 = visitor.Visit(arguments[2]).AsExpression(); var mt = treeBuilder.MethodCall("hid_GetReparentedValue", arg, c1, c2); return mt; }
public override HqlTreeNode BuildHql(MethodInfo method, Expression targetObject, ReadOnlyCollection<Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { return treeBuilder.Concat( new[] { visitor.Visit(arguments[0]).AsExpression(), visitor.Visit(arguments[1]).AsExpression(), visitor.Visit(arguments[2]).AsExpression() }); }
public override HqlTreeNode BuildHql(MethodInfo method, Expression targetObject, ReadOnlyCollection<Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { var arg = visitor.Visit(arguments[0]).AsExpression(); var parent = visitor.Visit(arguments[1]).AsExpression(); var mt = treeBuilder.BooleanMethodCall("hid_IsDescendantOf", new[] {arg, parent}); return mt; }
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; }
public override HqlTreeNode BuildHql(MethodInfo method, Expression expression, ReadOnlyCollection<Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { string function = method.Name.ToLowerInvariant(); HqlExpression firstArgument = visitor.Visit(arguments[0]).AsExpression(); if (arguments.Count == 2) { return treeBuilder.MethodCall(function, firstArgument, visitor.Visit(arguments[1]).AsExpression()); } return treeBuilder.MethodCall(function, firstArgument); }
public override HqlTreeNode BuildHql(MethodInfo method, Expression targetObject, ReadOnlyCollection<Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { string leadingOrTrailing = "TRAILING"; if (method.Name == "TrimLeading") leadingOrTrailing = "LEADING"; return treeBuilder.MethodCall("Trim", treeBuilder.Ident(leadingOrTrailing), visitor.Visit(arguments[1]).AsExpression(), treeBuilder.Ident("FROM"), visitor.Visit(arguments[0]).AsExpression()); }
/// <summary> /// /// </summary> /// <param name="method"></param> /// <param name="targetObject">Should be an ISecurable</param> /// <param name="arguments">Not sure what the heck arg[0] is, but arg[1] is the entityName</param> /// <param name="treeBuilder"></param> /// <param name="visitor"></param> /// <returns></returns> public override HqlTreeNode BuildHql( MethodInfo method, Expression targetObject, ReadOnlyCollection<Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { // This works, but it pulls the entity into memory, which is not what we want. Expression<Func<ISecurable, string, bool>> IsAllowedExpression = (x, name) => x.IsLoadableFor(name); return visitor.Visit(IsAllowedExpression); }
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); }
public static HqlExpression ConvertBooleanToCase(HqlExpression node) { if (node is HqlBooleanExpression) { var builder = new HqlTreeBuilder(); return builder.Case( new[] {builder.When(node, builder.True())}, builder.False()); } return node; }
///<summary> /// ///</summary> ///<param name="method"></param> ///<param name="targetObject">Should be an ISecurable</param> ///<param name="arguments">Not sure what the heck arg[0] is, but arg[1] is the entityName</param> ///<param name="treeBuilder"></param> ///<param name="visitor"></param> ///<returns></returns> public override HqlTreeNode BuildHql( MethodInfo method, Expression targetObject, ReadOnlyCollection<Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { // arguments[0] is a System.Linq.Expressions.Expression // arguments[1] is our constant value var expr = arguments[0]; // This doesn't really help us right now, but log it just in case... if (expr is Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression) { Console.WriteLine( "ReferencedQuerySource: {0}", ((Remotion.Linq.Clauses.Expressions.QuerySourceReferenceExpression)expr).ReferencedQuerySource ); } // Getting somewhere? // expr.Type is Spc.Ofp.Tubs.DAL.Entities.Trip Console.WriteLine("Expression type: {0}", expr.Type); // HqlAlias is "AccessControl" (entity property), "ace" (name used in expression) ? // HqlExpression is equality expression ? var aceAlias = treeBuilder.Alias("AccessControl as ace"); var entityName = ((ConstantExpression)arguments[1]).Value; Console.WriteLine("entityName: {0}", entityName); var equality = treeBuilder.Equality( treeBuilder.Alias("ace.EntityName"), treeBuilder.Constant(entityName) ); var joinExpression = treeBuilder.Join(equality, aceAlias); // This doesn't actually do anything... return visitor.Visit(expr).AsExpression(); /* * var dc = DetachedCriteria.For<T>() .CreateAlias("AccessControl", "ace", JoinType.InnerJoin) .Add(NHibernate.Criterion.Expression.Eq("ace.EntityName", this._entityName)); */ }
public override HqlTreeNode BuildHql(MethodInfo method, Expression targetObject, ReadOnlyCollection<Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { /* HqlDot hqlDot = (HqlDot)visitor.Visit(arguments[0]).AsExpression(); List<HqlTreeNode> hqlTreeNodes = hqlDot.Children.ToList(); FieldInfo fieldInfo = typeof(HqlTreeNode).GetField("_node", BindingFlags.NonPublic | BindingFlags.Instance); HqlIdent node1 = (HqlIdent)hqlTreeNodes[0]; IASTNode tableNode = (IASTNode)fieldInfo.GetValue(node1); string tableText = tableNode.Text; HqlIdent node2 = (HqlIdent)hqlTreeNodes[1]; IASTNode columnNode = (IASTNode)fieldInfo.GetValue(node2); string columnText = columnNode.Text; string format = string.Format("{0}.{1} (+)", tableText, columnText); //return treeBuilder.AnyValueConstant(format); return treeBuilder.AnyValueConstant("customer1_.ID (+)"); */ HqlAnyValueConstant expression0 = treeBuilder.AnyValueConstant("+"); HqlExpression expression1 = visitor.Visit(arguments[0]).AsExpression(); List<HqlExpression> expressions = new List<HqlExpression>(); expressions.Add(expression0); expressions.Add(expression1); return treeBuilder.BooleanMethodCall("", expressions); //treeBuilder.Equality(); //HqlMethodCall leftSign = treeBuilder.MethodCall("", treeBuilder.Plus()); /* return expression2; HqlDot dot = (HqlDot) expression2; //return treeBuilder.AnyValueConstant(" ", expression1, expression2); return expression1; /* return expression2; */ //return leftSign; //return treeBuilder.Space(leftSign, ); }
public override HqlTreeNode BuildHql( MethodInfo method, Expression targetObject, ReadOnlyCollection<Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { var left = treeBuilder.Cast(visitor.Visit(targetObject).AsExpression(), typeof(string)); var right = treeBuilder.Cast(visitor.Visit(arguments.First()).AsExpression(), typeof(string)); var leftSubstring = treeBuilder.MethodCall("substring", left, treeBuilder.Constant(4)); var rightSubstring = treeBuilder.MethodCall("substring", right, treeBuilder.Constant(4)); var equals = treeBuilder.Equality(leftSubstring, rightSubstring); return equals; }
public override HqlTreeNode BuildHql(MethodInfo method, Expression targetObject, ReadOnlyCollection<Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { var comparison = (StringComparison)(arguments[1].As<ConstantExpression>().Value); if (comparison == StringComparison.CurrentCultureIgnoreCase || comparison == StringComparison.InvariantCultureIgnoreCase || comparison == StringComparison.OrdinalIgnoreCase) { return treeBuilder.Equality( treeBuilder.MethodCall("lower", new[] { visitor.Visit(targetObject).AsExpression() }), treeBuilder.MethodCall("lower", new[] { visitor.Visit(arguments[0]).AsExpression() })); } return treeBuilder.Equality( visitor.Visit(targetObject).AsExpression(), visitor.Visit(arguments[0]).AsExpression()); }
public static HqlBooleanExpression ToBooleanExpression(this HqlTreeNode node) { var hqlDot = node as HqlDot; if (hqlDot != null) { return(new HqlBooleanDot(hqlDot.Factory, hqlDot)); } var hqlBooleanExpression = node as HqlBooleanExpression; if (hqlBooleanExpression != null) { return(hqlBooleanExpression); } var builder = new HqlTreeBuilder(); return(builder.Equality(node.AsExpression(), builder.True())); }
public HqlTreeNode BuildHql(MethodInfo method, Expression targetObject, ReadOnlyCollection<Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { if (arguments.Count == 2) { return treeBuilder.Like( visitor.Visit(arguments[0]).AsExpression(), visitor.Visit(arguments[1]).AsExpression()); } if (arguments[2].NodeType == ExpressionType.Constant) { var escapeCharExpression = (ConstantExpression)arguments[2]; return treeBuilder.Like( visitor.Visit(arguments[0]).AsExpression(), visitor.Visit(arguments[1]).AsExpression(), treeBuilder.Constant(escapeCharExpression.Value)); } throw new ArgumentException("The escape character must be specified as literal value or a string variable"); }
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, Expression targetObject, ReadOnlyCollection<Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { // All has two arguments. Arg 1 is the source and arg 2 is the predicate var predicate = (LambdaExpression) arguments[1]; return treeBuilder.BooleanNot( treeBuilder.Exists( treeBuilder.Query( treeBuilder.SelectFrom( treeBuilder.From( treeBuilder.Range( visitor.Visit(arguments[0]), treeBuilder.Alias(predicate.Parameters[0].Name)) ) ), treeBuilder.Where( treeBuilder.BooleanNot(visitor.Visit(arguments[1]).AsBooleanExpression()) ) ) ) ); }
public override HqlTreeNode BuildHql(MethodInfo method, Expression targetObject, ReadOnlyCollection<Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { // There is a problem with NHibernate when an identifier matches an entity's name. The resulting // SQL may be null in that situation. The searchTable's name is split in 2 identifiers to mitigate the problem. string searchTable = (string)((ConstantExpression)arguments[2]).Value; var searchTableFullName = searchTable.Split('.'); if (searchTableFullName.Length != 2) throw new FrameworkException("FullTextSearch table name '" + searchTable + "' must have format 'schema.table'."); string searchColumns = (string)((ConstantExpression)arguments[3]).Value; var parameters = new HqlExpression[] { visitor.Visit(arguments[0]).AsExpression(), visitor.Visit(arguments[1]).AsExpression(), treeBuilder.Ident(searchTableFullName[0]), treeBuilder.Ident(searchTableFullName[1]), treeBuilder.Ident(searchColumns), }; return treeBuilder.BooleanMethodCall("FullTextSearch", parameters); }
public override HqlTreeNode BuildHql(MethodInfo method, Expression targetObject, ReadOnlyCollection<Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { // Instance CompareTo() or static string.Compare()? Expression lhs = arguments.Count == 1 ? targetObject : arguments[0]; Expression rhs = arguments.Count == 1 ? arguments[0] : arguments[1]; HqlExpression lhs1 = visitor.Visit(lhs).AsExpression(); HqlExpression rhs1 = visitor.Visit(rhs).AsExpression(); HqlExpression lhs2 = visitor.Visit(lhs).AsExpression(); HqlExpression rhs2 = visitor.Visit(rhs).AsExpression(); // CASE WHEN (table.[Name] = N'Foo') THEN 0 // WHEN (table.[Name] > N'Foo') THEN 1 // ELSE -1 END return treeBuilder.Case( new[] { treeBuilder.When(treeBuilder.Equality(lhs1, rhs1), treeBuilder.Constant(0)), treeBuilder.When(treeBuilder.GreaterThan(lhs2, rhs2), treeBuilder.Constant(1)) }, treeBuilder.Constant(-1)); }
public override HqlTreeNode BuildHql(MethodInfo method, Expression targetObject, ReadOnlyCollection<Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { HqlAlias alias = null; HqlWhere where = null; if (arguments.Count > 1) { var expr = (LambdaExpression) arguments[1]; alias = treeBuilder.Alias(expr.Parameters[0].Name); where = treeBuilder.Where(visitor.Visit(arguments[1]).AsExpression()); } return treeBuilder.Exists( treeBuilder.Query( treeBuilder.SelectFrom( treeBuilder.From( treeBuilder.Range( visitor.Visit(arguments[0]), alias) ) ), where)); }
public override HqlTreeNode BuildHql(MemberInfo member, Expression expression, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { return treeBuilder.MethodCall("length", visitor.Visit(expression).AsExpression()); }
public override NHibernate.Hql.Ast.HqlTreeNode BuildHql(System.Reflection.MethodInfo method, System.Linq.Expressions.Expression targetObject, System.Collections.ObjectModel.ReadOnlyCollection <System.Linq.Expressions.Expression> arguments, NHibernate.Hql.Ast.HqlTreeBuilder treeBuilder, NHibernate.Linq.Visitors.IHqlExpressionVisitor visitor) { //return treeBuilder.Constant(0); return(treeBuilder.Case(new HqlWhen[] { treeBuilder.When( treeBuilder.LessThan(visitor.Visit(arguments[0]).AsExpression(), visitor.Visit(arguments[1]).AsExpression()), treeBuilder.Constant(-1)), treeBuilder.When( treeBuilder.GreaterThan(visitor.Visit(arguments[0]).AsExpression(), visitor.Visit(arguments[1]).AsExpression()), treeBuilder.Constant(1)) }, treeBuilder.Constant(0))); }