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();
}
