public UngroupedAndUnaggregatedColumnFinder(ExpressionNode[] groupByExpressions) { _groupByExpressions = groupByExpressions; // Special handling for the case the user entered something like this: // // SELECT * // FROM Employees e // GROUP BY e // // In this case, all columns from e are implicitly grouped. if (_groupByExpressions == null) { _groupedTableRefs = new TableRefBinding[0]; } else { List<TableRefBinding> groupedTableRefList = new List<TableRefBinding>(); foreach (ExpressionNode groupByExpression in _groupByExpressions) { ColumnExpression exprAsColumn = groupByExpression as ColumnExpression; if (exprAsColumn != null && exprAsColumn.Column.ColumnBinding is RowColumnBinding) { TableRefBinding groupedTableRef = exprAsColumn.Column.TableRefBinding; if (!groupedTableRefList.Contains(groupedTableRef)) groupedTableRefList.Add(groupedTableRef); } } _groupedTableRefs = groupedTableRefList.ToArray(); } }
public FunctionInvocationExpression(Identifier identifier, ExpressionNode[] arguments, bool hasStarModifier) : this() { _name = identifier; _arguments = arguments; _hasAsteriskModifier = hasStarModifier; }
public CastExpression(ExpressionNode expression, Type targetType) { _expression = expression; _typeReference = new TypeReference(); _typeReference.TypeName = targetType.AssemblyQualifiedName; _typeReference.ResolvedType = targetType; }
private static AlgebraNode WrapWithFilter(AlgebraNode input, ExpressionNode predicate) { if (predicate == null) return input; FilterAlgebraNode filterAlgebraNode = new FilterAlgebraNode(); filterAlgebraNode.Input = input; filterAlgebraNode.Predicate = predicate; return filterAlgebraNode; }
private static bool AndPartHasOuterReference(ExpressionNode andPart, RowBufferEntry[] definedValues) { RowBufferEntry[] rowBufferEntries = AstUtil.GetRowBufferEntryReferences(andPart); foreach (RowBufferEntry rowBufferEntry in rowBufferEntries) { if (!ArrayHelpers.Contains(definedValues, rowBufferEntry)) return true; } return false; }
public static int FindStructuralEquivalentExpression(ExpressionNode[] expressions, ExpressionNode expr) { for (int i = 0; i < expressions.Length; i++) { ExpressionNode node = expressions[i]; if (node.IsStructuralEqualTo(expr)) return i; } return -1; }
private static bool NeedParentheses(ExpressionNode childExpression, int parentPrecedence, bool isRightOperand) { // If childExpression is also an operator expression we may need parentheses. // // This depends on the precedence and associativity of the child operator. // Since we have unary, binary and ternary operators we extract theses pieces // of information using casts. int childPrecedence; bool isRightAssociative; OperatorExpression expressionOperatorExpression = childExpression as OperatorExpression; if (expressionOperatorExpression != null) { // It is a binary or unary operator. childPrecedence = expressionOperatorExpression.Op.Precedence; isRightAssociative = expressionOperatorExpression.Op.IsRightAssociative; } else { // Special handling for the only ternary operator. BetweenExpression expressionAsBetweenExpression = childExpression as BetweenExpression; if (expressionAsBetweenExpression != null) { childPrecedence = Operator.BETWEEN_PRECEDENCE; isRightAssociative = false; } else { return false; } } // Analyze precedences. if (childPrecedence < parentPrecedence) return true; if (childPrecedence == parentPrecedence) { if (isRightOperand && !isRightAssociative) return true; if (!isRightOperand && isRightAssociative) return true; } return false; }
private static bool SemiJoinDoesNotDependOn(JoinAlgebraNode.JoinOperator op, ExpressionNode part, RowBufferEntry[] leftDefinedValues, RowBufferEntry[] rightDefinedValues) { if (op == JoinAlgebraNode.JoinOperator.LeftSemiJoin || op == JoinAlgebraNode.JoinOperator.LeftAntiSemiJoin) { return AstUtil.ExpressionDoesNotReference(part, rightDefinedValues); } if (op == JoinAlgebraNode.JoinOperator.RightSemiJoin || op == JoinAlgebraNode.JoinOperator.RightAntiSemiJoin) { return AstUtil.ExpressionDoesNotReference(part, leftDefinedValues); } return true; }
public static RuntimeExpression CreateCompiled(ExpressionNode expressionNode) { string expressionSource = expressionNode.GenerateSource(); ILEmitContext ilEmitContext = new ILEmitContext(expressionSource); ILParameterRegisterer ilParameterRegisterer = new ILParameterRegisterer(ilEmitContext); ilParameterRegisterer.Visit(expressionNode); ILTranslator ilTranslator = new ILTranslator(ilEmitContext); ilTranslator.Visit(expressionNode); CompiledExpressionDelegate compiledExpressionDelegate = ilEmitContext.CreateDelegate(); object[] arguments = ilEmitContext.GetArguments(); return new CompiledRuntimeExpression(expressionSource, expressionNode.ExpressionType, compiledExpressionDelegate, arguments); }
public UnaryExpression(UnaryOperator op, ExpressionNode operand) { _op = op; _operand = operand; }
void IErrorReporter.AggregateContainsColumnsFromDifferentQueries(ExpressionNode aggregateArgument) { string message = String.Format(CultureInfo.CurrentCulture, Resources.AggregateContainsColumnsFromDifferentQueries, aggregateArgument.GenerateSource()); HandleError(ErrorId.AggregateContainsColumnsFromDifferentQueries, message); }
public OrderByColumn(ExpressionNode expression, SortOrder sortOrder) : this() { _expression = expression; _sortOrder = sortOrder; }
private ExpressionNode ResolveExpression(ExpressionNode expressionBeforeDot) { ExpressionNode resolvedExpression = _normalizer.VisitExpression(expressionBeforeDot); return _resolver.VisitExpression(resolvedExpression); }
private ExpressionNode ParsePrimaryExpression() { switch (_token.Id) { case TokenId.NULL: NextToken(); return LiteralExpression.FromNull(); case TokenId.TRUE: case TokenId.FALSE: return ParseBooleanLiteral(); case TokenId.Date: return ParseDateLiteral(); case TokenId.Number: return ParseNumberLiteral(); case TokenId.String: return LiteralExpression.FromString(ParseString()); case TokenId.EXISTS: { ExistsSubselect result = new ExistsSubselect(); NextToken(); Match(TokenId.LeftParentheses); result.Query = ParseQuery(); Match(TokenId.RightParentheses); return result; } case TokenId.ParameterMarker: { _rangeRecorder.Begin(); NextToken(); Identifier name = ParseIdentifier(); SourceRange nameSourceRange = _rangeRecorder.End(); ParameterExpression result = new ParameterExpression(); result.Name = name; result.NameSourceRange = nameSourceRange; return result; } case TokenId.CAST: { NextToken(); CastExpression castExpression = new CastExpression(); Match(TokenId.LeftParentheses); castExpression.Expression = ParseExpression(); Match(TokenId.AS); castExpression.TypeReference = ParseTypeReference(); Match(TokenId.RightParentheses); return castExpression; } case TokenId.CASE: { NextToken(); CaseExpression caseExpression = new CaseExpression(); if (_token.Id != TokenId.WHEN && _token.Id != TokenId.ELSE && _token.Id != TokenId.END) caseExpression.InputExpression = ParseExpression(); List<ExpressionNode> whenExpressionList = new List<ExpressionNode>(); List<ExpressionNode> expressionList = new List<ExpressionNode>(); if (_token.Id != TokenId.WHEN) { Match(TokenId.WHEN); } else { while (_token.Id == TokenId.WHEN) { NextToken(); whenExpressionList.Add(ParseExpression()); Match(TokenId.THEN); expressionList.Add(ParseExpression()); } } caseExpression.WhenExpressions = whenExpressionList.ToArray(); caseExpression.ThenExpressions = expressionList.ToArray(); if (_token.Id == TokenId.ELSE) { NextToken(); caseExpression.ElseExpression = ParseExpression(); } Match(TokenId.END); return caseExpression; } case TokenId.COALESCE: { NextToken(); CoalesceExpression coalesceExpression = new CoalesceExpression(); coalesceExpression.Expressions = ParseExpressionList(); return coalesceExpression; } case TokenId.NULLIF: { NextToken(); NullIfExpression nullIfExpression = new NullIfExpression(); Match(TokenId.LeftParentheses); nullIfExpression.LeftExpression = ParseExpression(); Match(TokenId.Comma); nullIfExpression.RightExpression = ParseExpression(); Match(TokenId.RightParentheses); return nullIfExpression; } case TokenId.Identifier: { _rangeRecorder.Begin(); Identifier name = ParseIdentifier(); SourceRange nameSourceRange = _rangeRecorder.End(); if (_token.Id != TokenId.LeftParentheses) { NameExpression result = new NameExpression(); result.Name = name; result.NameSourceRange = nameSourceRange; return result; } else { bool hasAsteriskModifier; ExpressionNode[] args; if (_lookahead.Id != TokenId.Multiply) { hasAsteriskModifier = false; args = ParseExpressionList(); } else { NextToken(); NextToken(); Match(TokenId.RightParentheses); hasAsteriskModifier = true; args = new ExpressionNode[0]; } FunctionInvocationExpression result = new FunctionInvocationExpression(); result.Name = name; result.NameSourceRange = nameSourceRange; result.Arguments = args; result.HasAsteriskModifier = hasAsteriskModifier; return result; } } case TokenId.LeftParentheses: { NextToken(); ExpressionNode expr; if (_token.Id != TokenId.SELECT) { expr = ParseExpression(); } else { SingleRowSubselect singleRowSubselect = new SingleRowSubselect(); singleRowSubselect.Query = ParseQuery(); expr = singleRowSubselect; } Match(TokenId.RightParentheses); return expr; } default: { _errorReporter.SimpleExpressionExpected(_token.Range, _token.Text); return LiteralExpression.FromNull(); } } }
public static ExpressionNode[] SplitCondition(LogicalOperator logicalOperator, ExpressionNode condition) { PartExtractor partExtractor = new PartExtractor(logicalOperator); partExtractor.Visit(condition); return partExtractor.GetParts(); }
private void EmitCall(MethodInfo method, ExpressionNode instance, params ExpressionNode[] args) { ParameterInfo[] parameterInfos = method.GetParameters(); int instanceLocalIndex = -1; if (instance != null) { instanceLocalIndex = DeclareLocal(); } int[] argLocalIndexes = new int[args.Length]; for (int i = 0; i < args.Length; i++) { argLocalIndexes[i] = DeclareLocal(); } if (instance != null) { Visit(instance); _ilEmitContext.ILGenerator.Emit(OpCodes.Stloc, instanceLocalIndex); } for (int i = 0; i < args.Length; i++) { Visit(args[i]); _ilEmitContext.ILGenerator.Emit(OpCodes.Stloc, argLocalIndexes[i]); } Label loadNullLabel = _ilEmitContext.ILGenerator.DefineLabel(); Label finishLabel = _ilEmitContext.ILGenerator.DefineLabel(); if (instance != null) { _ilEmitContext.ILGenerator.Emit(OpCodes.Ldloc, instanceLocalIndex); _ilEmitContext.ILGenerator.Emit(OpCodes.Brfalse, loadNullLabel); } for (int i = 0; i < args.Length; i++) { _ilEmitContext.ILGenerator.Emit(OpCodes.Ldloc, argLocalIndexes[i]); _ilEmitContext.ILGenerator.Emit(OpCodes.Brfalse, loadNullLabel); } if (instance != null) { _ilEmitContext.ILGenerator.Emit(OpCodes.Ldloc, instanceLocalIndex); EmitThisArgumentPointer(instance.ExpressionType); } for (int i = 0; i < args.Length; i++) { _ilEmitContext.ILGenerator.Emit(OpCodes.Ldloc, argLocalIndexes[i]); if (parameterInfos[i].ParameterType != typeof(object)) { EmitConversion(parameterInfos[i].ParameterType); } } EmitRawCall(method, instance == null ? null : instance.ExpressionType); if (method.ReturnType.IsValueType) { _ilEmitContext.ILGenerator.Emit(OpCodes.Box, method.ReturnType); } _ilEmitContext.ILGenerator.Emit(OpCodes.Br, finishLabel); _ilEmitContext.ILGenerator.MarkLabel(loadNullLabel); _ilEmitContext.ILGenerator.Emit(OpCodes.Ldnull); _ilEmitContext.ILGenerator.MarkLabel(finishLabel); }
public static RuntimeExpression CreateInterpreded(ExpressionNode expressionNode) { return(new InterpretedRuntimeExpression(expressionNode)); }
public InterpretedRuntimeExpression(ExpressionNode expressionNode) { _expressionNode = expressionNode; }
public static RuntimeExpression CreateInterpreded(ExpressionNode expressionNode) { return new InterpretedRuntimeExpression(expressionNode); }
public override ExpressionNode VisitCaseExpression(CaseExpression expression) { // NOTE: It is assumed that simple case expressions are already transformed into // searched case expressions, i.e. // CASE // WHEN Pred1 THEN Expr1 ... // WHEN PredN THEN ExprN // [ELSE ElseExpr] // END List<ExpressionNode> processedWhenExpressions = new List<ExpressionNode>(); for (int i = 0; i < expression.WhenExpressions.Length; i++) { SetWhenPassthru(processedWhenExpressions); expression.WhenExpressions[i] = VisitExpression(expression.WhenExpressions[i]); processedWhenExpressions.Add(expression.WhenExpressions[i]); SetThenPassthru(processedWhenExpressions); expression.ThenExpressions[i] = VisitExpression(expression.ThenExpressions[i]); } if (expression.ElseExpression != null) { SetWhenPassthru(processedWhenExpressions); expression.ElseExpression = VisitExpression(expression.ElseExpression); } _currentPassthruPredicate = null; return expression; }
void IErrorReporter.CannotCast(ExpressionNode expression, Type targetType) { string message = String.Format(CultureInfo.CurrentCulture, Resources.CannotCast, expression.GenerateSource(), FormattingHelpers.FormatType(expression.ExpressionType), FormattingHelpers.FormatType(targetType)); HandleError(ErrorId.CannotCast, message); }
void IErrorReporter.AsteriskModifierNotAllowed(SourceRange sourceRange, ExpressionNode functionInvocation) { string message = String.Format(CultureInfo.CurrentCulture, Resources.AsteriskModifierNotAllowed, functionInvocation.GenerateSource()); HandleError(sourceRange, ErrorId.AsteriskModifierNotAllowed, message); }
public void Push(ExpressionNode expression) { _expressionStack.Push(expression); }
public static bool IsNull(ExpressionNode expression) { ConstantExpression constantExpression = expression as ConstantExpression; return (constantExpression != null && constantExpression.IsNullValue); }
private void SetWhenPassthru(ICollection<ExpressionNode> processedWhenExpressions) { if (processedWhenExpressions.Count == 0) { _currentPassthruPredicate = null; } else { foreach (ExpressionNode processedWhenExpression in processedWhenExpressions) { ExpressionNode clonedExpr = (ExpressionNode) processedWhenExpression.Clone(); _expressionBuilder.Push(clonedExpr); } _expressionBuilder.PushNAry(LogicalOperator.Or); _currentPassthruPredicate = _expressionBuilder.Pop(); } }
void IErrorReporter.WhenMustEvaluateToBoolIfCaseInputIsOmitted(ExpressionNode whenExpression) { string message = String.Format(CultureInfo.CurrentCulture, Resources.WhenMustEvaluateToBoolIfCaseInputIsOmitted, whenExpression.GenerateSource(), FormattingHelpers.FormatType(typeof(bool))); HandleError(ErrorId.WhenMustEvaluateToBoolIfCaseInputIsOmitted, message); }
private RuntimeExpression CreateRuntimeExpression(ExpressionNode expression, params BoundRowBufferEntrySet[] boundRowBufferEntrySets) { // Update row buffer references List<BoundRowBufferEntrySet> boundRowBufferEntrySetList = new List<BoundRowBufferEntrySet>(); boundRowBufferEntrySetList.AddRange(boundRowBufferEntrySets); foreach (BoundRowBufferEntrySet outerreferenceBoundRowBufferEntrySet in _outerReferenceStack) boundRowBufferEntrySetList.Add(outerreferenceBoundRowBufferEntrySet); boundRowBufferEntrySets = boundRowBufferEntrySetList.ToArray(); RowBufferEntryExpressionUpdater rowBufferEntryExpressionUpdater = new RowBufferEntryExpressionUpdater(boundRowBufferEntrySets); expression = rowBufferEntryExpressionUpdater.VisitExpression(expression); #if COMPILE_IL return ExpressionCompiler.CreateCompiled(expression); #else return ExpressionCompiler.CreateInterpreded(expression); #endif }
private static ExpressionNode ReplaceAlreadyComputedSubsequences(ExpressionNode expression, IEnumerable<ComputedValueDefinition> alreadyComputedBufferedValues) { ComputedSubsequenceReplacer replacer = new ComputedSubsequenceReplacer(alreadyComputedBufferedValues); return replacer.VisitExpression(expression); }
public IsNullExpression(bool negated, ExpressionNode expression) { _negated = negated; _expression = expression; }
public SelectColumn(ExpressionNode expression, Identifier columnAlias) { _expression = expression; _alias = columnAlias; }
private ExpressionNode ParseSubExpression(ExpressionNode left, int precedence) { if (left == null) { // No left operand, so we parse one and take care about leading unary operators if (_token.Info.UnaryOperator != null) { UnaryOperator op = _token.Info.UnaryOperator; NextToken(); ExpressionNode expr = ParseSubExpression(null, op.Precedence); left = new UnaryExpression(op, expr); } else { left = ParseSimpleExpression(); } } while (_token.Id != TokenId.Eof) { // Special handling for NOT BETWEEN, NOT IN, NOT LIKE, NOT SIMILAR TO, and NOT SOUNDSLIKE. bool negated = false; if (_token.Id == TokenId.NOT) { if (_lookahead.Id == TokenId.BETWEEN || _lookahead.Id == TokenId.IN || _lookahead.Id == TokenId.LIKE || _lookahead.Id == TokenId.SIMILAR || _lookahead.Id == TokenId.SOUNDSLIKE) { NextToken(); negated = true; } } // Special handling for the only ternary operator BETWEEN if (_token.Id == TokenId.BETWEEN) { NextToken(); ExpressionNode lowerBound = ParseSubExpression(null, Operator.BETWEEN_PRECEDENCE); Match(TokenId.AND); ExpressionNode upperBound = ParseSubExpression(null, Operator.BETWEEN_PRECEDENCE); left = new BetweenExpression(left, lowerBound, upperBound); } else { // If there is no binary operator we are finished if (_token.Info.BinaryOperator == null) break; BinaryOperator binaryOp = _token.Info.BinaryOperator; // Precedence is lower, parse it later if (binaryOp.Precedence < precedence) break; // Precedence is equal, but operator ist not right associative, parse it later if (binaryOp.Precedence == precedence && !binaryOp.IsRightAssociative) break; // Precedence is higher NextToken(); // Special handling for SIMILAR TO if (binaryOp == BinaryOperator.SimilarTo) Match(TokenId.TO); if (binaryOp == BinaryOperator.In) { // Special handling for IN InExpression inExpression = new InExpression(); inExpression.Left = left; inExpression.RightExpressions = ParseSimpleQueryExpressionList(); left = inExpression; } else if (_token.Id == TokenId.ANY || _token.Id == TokenId.SOME || _token.Id == TokenId.ALL) { // Special handling for ANY (SOME) and ALL if (binaryOp != BinaryOperator.Equal && binaryOp != BinaryOperator.NotEqual && binaryOp != BinaryOperator.Less && binaryOp != BinaryOperator.LessOrEqual && binaryOp != BinaryOperator.Greater && binaryOp != BinaryOperator.GreaterOrEqual) { _errorReporter.InvalidOperatorForAllAny(_token.Range, binaryOp); } AllAnySubselect allAnySubselect = new AllAnySubselect(); allAnySubselect.Left = left; allAnySubselect.Op = binaryOp; allAnySubselect.Type = (_token.Id == TokenId.ALL) ? AllAnySubselect.AllAnyType.All : AllAnySubselect.AllAnyType.Any; NextToken(); Match(TokenId.LeftParentheses); allAnySubselect.Query = ParseQuery(); Match(TokenId.RightParentheses); left = allAnySubselect; } else { left = new BinaryExpression(binaryOp, left, ParseSubExpression(null, binaryOp.Precedence)); } } // Special handling for negated expressions (see above) if (negated) left = new UnaryExpression(UnaryOperator.LogicalNot, left); } return left; }
private static void CreateBufferedValue(ExpressionNode expression, ICollection<ComputedValueDefinition> computedColumnList, ICollection<RowBufferEntry> columnList, IEnumerable<ComputedValueDefinition> alreadyComputedBufferedValues) { if (alreadyComputedBufferedValues != null) expression = ReplaceAlreadyComputedSubsequences(expression, alreadyComputedBufferedValues); foreach (ComputedValueDefinition computedBufferedValue in computedColumnList) { if (expression.IsStructuralEqualTo(computedBufferedValue.Expression)) { columnList.Add(computedBufferedValue.Target); return; } } RowBufferEntryExpression rowBufferExpression = expression as RowBufferEntryExpression; if (rowBufferExpression != null) { columnList.Add(rowBufferExpression.RowBufferEntry); } else { RowBufferEntry rowBufferEntry = new RowBufferEntry(expression.ExpressionType); columnList.Add(rowBufferEntry); ComputedValueDefinition computedValue = new ComputedValueDefinition(); computedValue.Target = rowBufferEntry; computedValue.Expression = expression; computedColumnList.Add(computedValue); } }