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) { // 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 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(System.Reflection.MethodInfo method, Expression targetObject, System.Collections.ObjectModel.ReadOnlyCollection <Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { return(treeBuilder.LessThan( visitor.Visit(arguments[0]).AsExpression(), visitor.Visit(arguments[1]).AsExpression())); }
private HqlTreeNode BuildFromArray(Array valueArray, HqlTreeBuilder treeBuilder) { var elementType = valueArray.GetType().GetElementType(); if (!elementType.IsValueType && elementType != typeof(string)) { throw new ArgumentException("Only primitives and strings can be used"); } Type enumUnderlyingType = elementType.IsEnum ? Enum.GetUnderlyingType(elementType) : null; var variants = new HqlExpression[valueArray.Length]; for (int index = 0; index < valueArray.Length; index++) { var variant = valueArray.GetValue(index); var val = variant; if (elementType.IsEnum) { val = Convert.ChangeType(variant, enumUnderlyingType); } variants[index] = treeBuilder.Constant(val); } return(treeBuilder.ExpressionSubTreeHolder(variants)); }
public override HqlTreeNode BuildHql(MethodInfo method, Expression targetObject, ReadOnlyCollection <Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { return(treeBuilder.Cast(visitor.Visit(arguments[0]).AsExpression(), typeof(Int64))); }
public override HqlTreeNode BuildHql( MemberInfo member, Expression expression, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { return(treeBuilder.MethodCall(_hqlFunctions[member])); }
/// <summary> /// Overrides the BuildHql method to add an expression that supports Linq querying of the supported methods. /// </summary> public override HqlTreeNode BuildHql(MethodInfo method, Expression targetObject, ReadOnlyCollection <Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { var source = visitor.Visit(arguments[0]).AsExpression(); var property = treeBuilder.Ident("Currency"); return(treeBuilder.Dot(source, property)); }
public override HqlTreeNode BuildHql( MethodInfo method, Expression targetObject, ReadOnlyCollection <Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { return(treeBuilder.MethodCall("new_uuid")); }
public override HqlTreeNode BuildHql( MethodInfo method, System.Linq.Expressions.Expression targetObject, ReadOnlyCollection <System.Linq.Expressions.Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { IEnumerable <HqlExpression> args = arguments.Select(a => visitor.Visit(a)).Cast <HqlExpression>(); return(treeBuilder.MethodCall("localize", args)); }
public override HqlTreeNode BuildHql(MethodInfo method, Expression targetObject, ReadOnlyCollection <Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { // Just have to skip, HQL does not need 'explanations' on // null conversion. return(visitor.Visit(arguments[0]).AsExpression()); }
public override HqlTreeNode BuildHql(MethodInfo method, Expression targetObject, ReadOnlyCollection <Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { // Just have to transmit the argument "as is", HQL does not need a specific call // for null conversion. return(visitor.Visit(arguments[0]).AsExpression()); }
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); }
public override HqlTreeNode BuildHql( MethodInfo method, Expression targetObject, ReadOnlyCollection <System.Linq.Expressions.Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { return(treeBuilder.BooleanMethodCall( "similar to", arguments.Select(visitor.Visit).Cast <HqlExpression>())); }
public override HqlTreeNode BuildHql(MethodInfo method, System.Linq.Expressions.Expression targetObject, ReadOnlyCollection <System.Linq.Expressions.Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { var args = new[] { visitor.Visit(arguments[0]).AsExpression(), visitor.Visit(arguments[1]).AsExpression() }; return(treeBuilder.BooleanMethodCall("contains", args)); }
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 static HqlExpression ConvertBooleanToCase(HqlExpression node) { if (node is HqlBooleanExpression) { var builder = new HqlTreeBuilder(); return(builder.Case( new HqlWhen[] { builder.When(node, builder.True()) }, builder.False())); } return(node); }
public override HqlTreeNode BuildHql( MethodInfo method, Expression targetObject, ReadOnlyCollection <Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { var propertyName = (string)((ConstantExpression)arguments[1]).Value; return(treeBuilder.Dot( visitor.Visit(arguments[0]).AsExpression(), treeBuilder.Ident(propertyName)).AsExpression()); }
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() })); }
public override HqlTreeNode BuildHql( MethodInfo method, Expression targetObject, ReadOnlyCollection <Expression> arguments, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { if (method == _nextDouble) { return(treeBuilder.MethodCall(_randomFunctionName)); } switch (arguments.Count) { case 0: return(treeBuilder.Cast( treeBuilder.MethodCall( _floorFunctionName, treeBuilder.Multiply( treeBuilder.MethodCall(_randomFunctionName), treeBuilder.Constant(int.MaxValue))), typeof(int))); case 1: return(treeBuilder.Cast( treeBuilder.MethodCall( _floorFunctionName, treeBuilder.Multiply( treeBuilder.MethodCall(_randomFunctionName), visitor.Visit(arguments[0]).AsExpression())), typeof(int))); case 2: var minValue = visitor.Visit(arguments[0]).AsExpression(); var maxValue = visitor.Visit(arguments[1]).AsExpression(); return(treeBuilder.Cast( treeBuilder.Add( treeBuilder.MethodCall( _floorFunctionName, treeBuilder.Multiply( treeBuilder.MethodCall(_randomFunctionName), treeBuilder.Subtract(maxValue, minValue))), minValue), typeof(int))); default: throw new NotSupportedException(); } }
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, 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); }
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 BuildFromArray(IEnumerable valueArray, HqlTreeBuilder treeBuilder, Type elementType) { Type enumUnderlyingType = elementType.IsEnum ? Enum.GetUnderlyingType(elementType) : null; IList <HqlTreeNode> variants = new List <HqlTreeNode>(); foreach (object variant in valueArray) { object val = variant; if (elementType.IsEnum) { val = Convert.ChangeType(variant, enumUnderlyingType); } HqlConstant hqlConstant = treeBuilder.Constant(val); variants.Add(hqlConstant); } return(treeBuilder.ExpressionSubTreeHolder(variants)); }
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 HqlTreeNode BuildHql(MemberInfo member, Expression expression, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor) { var type = MappingHelper.GetType(visitor, expression); if (type == null) { throw new System.Exception(); } var exposingType = type.AsNodaType(); if (exposingType == null) { throw new System.Exception(); } if (!_transformers.TryGetValue(exposingType.GetType(), out var transformer)) { throw new NotImplementedException($"No transformer has been implemented for {member}, using {exposingType}"); } var hqlExpression = visitor.Visit(expression).AsExpression(); //var args = arguments.Select(visitor.Visit).Select(x => x.AsExpression()).ToList().AsReadOnly(); return(transformer.BuildHql(hqlExpression, new List <HqlExpression>().AsReadOnly(), treeBuilder)); }
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).ToArithmeticExpression(), visitor.Visit(rhs).ToArithmeticExpression())); }
public IntermediateHqlTree(bool root) { _root = root; TreeBuilder = new HqlTreeBuilder(); Root = TreeBuilder.Query(TreeBuilder.SelectFrom(TreeBuilder.From())); }
public static HqlElements Elements(this HqlTreeBuilder treeBuilder, HqlExpression dictionary) { var factory = (IASTFactory)treeBuilder.GetType().GetField("_factory", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(treeBuilder); return(new HqlElements(factory, dictionary)); }
public EqualityHqlGenerator(VisitorParameters parameters) { _parameters = parameters; _hqlTreeBuilder = new HqlTreeBuilder(); }