Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
  /*
2
   * Licensed under the Apache License, Version 2.0 (the "License");
3
   * you may not use this file except in compliance with the License.
4
   * You may obtain a copy of the License at
5
   *
6
   *     http://www.apache.org/licenses/LICENSE-2.0
7
   *
8
   * Unless required by applicable law or agreed to in writing, software
9
   * distributed under the License is distributed on an "AS IS" BASIS,
10
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11
  * See the License for the specific language governing permissions and
12
  * limitations under the License.
13
  */
14
 package com.facebook.presto.sql.planner;
15
 
64
 import org.joni.Regex;
65
 
70
 import java.util.List;
71
 import java.util.Set;
72
 
73
 import static com.facebook.presto.spi.StandardErrorCode.NOT_SUPPORTED;
74
 import static com.facebook.presto.spi.type.TypeSignature.parseTypeSignature;
75
 import static com.facebook.presto.sql.planner.LiteralInterpreter.toExpression;
76
 import static com.facebook.presto.sql.planner.LiteralInterpreter.toExpressions;
77
 import static com.google.common.base.Preconditions.checkNotNull;
78
 import static com.google.common.base.Preconditions.checkState;
79
 import static com.google.common.base.Predicates.instanceOf;
80
 import static com.google.common.collect.Iterables.any;
81
 import static java.nio.charset.StandardCharsets.UTF_8;
82
 
83
 public class ExpressionInterpreter
84
 {
85
     private final Expression expression;
86
     private final Metadata metadata;
87
     private final ConnectorSession session;
88
     private final boolean optimize;
89
     private final IdentityHashMap<Expression, Type> expressionTypes;
90
 
91
     private final Visitor visitor;
92
 
93
     // identity-based cache for LIKE expressions with constant pattern and escape char
94
     private final IdentityHashMap<LikePredicate, Regex> likePatternCache = new IdentityHashMap<>();
95
     private final IdentityHashMap<InListExpression, Set<Object>> inListCache = new IdentityHashMap<>();
96
 
97
     public static ExpressionInterpreter expressionInterpreter(Expression expression, Metadata metadata, Session session, IdentityHashMap<Expression, Type> expressionTypes)
98
     {
99
         checkNotNull(expression, "expression is null");
100
        checkNotNull(metadata, "metadata is null");
101
        checkNotNull(session, "session is null");
103
        return new ExpressionInterpreter(expression, metadata, session, expressionTypes, false);
104
    }
106
    public static ExpressionInterpreter expressionOptimizer(Expression expression, Metadata metadata, Session session, IdentityHashMap<Expression, Type> expressionTypes)
107
    {
108
        checkNotNull(expression, "expression is null");
109
        checkNotNull(metadata, "metadata is null");
110
        checkNotNull(session, "session is null");
112
        return new ExpressionInterpreter(expression, metadata, session, expressionTypes, true);
113
    }
115
    private ExpressionInterpreter(Expression expression, Metadata metadata, Session session, IdentityHashMap<Expression, Type> expressionTypes, boolean optimize)
116
    {
117
        this. = expression;
118
        this. = metadata;
119
        this. = session.toConnectorSession();
120
        this. = expressionTypes;
121
        this. = optimize;
123
        this. = new Visitor();
124
    }
126
    public Object evaluate(RecordCursor inputs)
127
    {
128
        checkState(!, "evaluate(RecordCursor) not allowed for optimizer");
129
        return .process(, inputs);
130
    }
132
    public Object evaluate(int position, Block... inputs)
133
    {
134
        checkState(!, "evaluate(int, Block...) not allowed for optimizer");
135
        return .process(, new PagePositionContext(position, inputs));
136
    }
138
    public Object optimize(SymbolResolver inputs)
139
    {
140
        checkState(, "evaluate(SymbolResolver) not allowed for interpreter");
141
        return .process(, inputs);
142
    }
144
    @SuppressWarnings("FloatingPointEquality")
145
    private class Visitor
146
            extends AstVisitor<Object, Object>
147
    {
148
        @Override
149
        public Object visitInputReference(InputReference node, Object context)
150
        {
151
            Type type = .get(node);
153
            int channel = node.getChannel();
154
            if (context instanceof PagePositionContext) {
155
                PagePositionContext pagePositionContext = (PagePositionContext) context;
156
                int position = pagePositionContext.getPosition();
157
                Block block = pagePositionContext.getBlock(channel);
159
                if (block.isNull(position)) {
160
                    return null;
161
                }
163
                Class<?> javaType = type.getJavaType();
164
                if (javaType == boolean.class) {
165
                    return type.getBoolean(block, position);
166
                }
167
                else if (javaType == long.class) {
168
                    return type.getLong(block, position);
169
                }
170
                else if (javaType == double.class) {
171
                    return type.getDouble(block, position);
172
                }
173
                else if (javaType == Slice.class) {
174
                    return type.getSlice(block, position);
175
                }
176
                else {
177
                    throw new UnsupportedOperationException("not yet implemented");
178
                }
179
            }
180
            else if (context instanceof RecordCursor) {
181
                RecordCursor cursor = (RecordCursor) context;
182
                if (cursor.isNull(channel)) {
183
                    return null;
184
                }
186
                Class<?> javaType = type.getJavaType();
187
                if (javaType == boolean.class) {
188
                    return cursor.getBoolean(channel);
189
                }
190
                else if (javaType == long.class) {
191
                    return cursor.getLong(channel);
192
                }
193
                else if (javaType == double.class) {
194
                    return cursor.getDouble(channel);
195
                }
196
                else if (javaType == Slice.class) {
197
                    return cursor.getSlice(channel);
198
                }
199
                else {
200
                    throw new UnsupportedOperationException("not yet implemented");
201
                }
202
            }
203
            throw new UnsupportedOperationException("Inputs or cursor myst be set");
204
        }
206
        @Override
207
        protected Object visitQualifiedNameReference(QualifiedNameReference node, Object context)
208
        {
209
            if (node.getName().getPrefix().isPresent()) {
210
                // not a symbol
211
                return node;
212
            }
214
            Symbol symbol = Symbol.fromQualifiedName(node.getName());
215
            return ((SymbolResolver) context).getValue(symbol);
216
        }
218
        @Override
219
        protected Object visitLiteral(Literal node, Object context)
220
        {
221
            return LiteralInterpreter.evaluate(, , node);
222
        }
224
        @Override
225
        protected Object visitIsNullPredicate(IsNullPredicate node, Object context)
226
        {
227
            Object value = process(node.getValue(), context);
229
            if (value instanceof Expression) {
230
                return new IsNullPredicate(toExpression(value, .get(node.getValue())));
231
            }
233
            return value == null;
234
        }
236
        @Override
237
        protected Object visitIsNotNullPredicate(IsNotNullPredicate node, Object context)
238
        {
239
            Object value = process(node.getValue(), context);
241
            if (value instanceof Expression) {
242
                return new IsNotNullPredicate(toExpression(value, .get(node.getValue())));
243
            }
245
            return value != null;
246
        }
248
        @Override
249
        protected Object visitSearchedCaseExpression(SearchedCaseExpression node, Object context)
250
        {
251
            Expression resultClause = node.getDefaultValue().orElse(null);
252
            for (WhenClause whenClause : node.getWhenClauses()) {
253
                Object value = process(whenClause.getOperand(), context);
254
                if (value instanceof Expression) {
255
                    // TODO: optimize this case
256
                    return node;
257
                }
259
                if (..equals(value)) {
260
                    resultClause = whenClause.getResult();
261
                    break;
262
                }
263
            }
265
            if (resultClause == null) {
266
                return null;
267
            }
269
            Object result = process(resultClause, context);
270
            if (result instanceof Expression) {
271
                return node;
272
            }
273
            return result;
274
        }
276
        @Override
277
        protected Object visitSimpleCaseExpression(SimpleCaseExpression node, Object context)
278
        {
279
            Object operand = process(node.getOperand(), context);
280
            if (operand instanceof Expression) {
281
                // TODO: optimize this case
282
                return node;
283
            }
285
            Expression resultClause = node.getDefaultValue().orElse(null);
286
            if (operand != null) {
287
                for (WhenClause whenClause : node.getWhenClauses()) {
288
                    Object value = process(whenClause.getOperand(), context);
289
                    if (value == null) {
290
                        continue;
291
                    }
292
                    if (value instanceof Expression) {
293
                        // TODO: optimize this case
294
                        return node;
295
                    }
297
                    if ((Boolean) invokeOperator(., types(node.getOperand(), whenClause.getOperand()), ImmutableList.of(operand, value))) {
298
                        resultClause = whenClause.getResult();
299
                        break;
300
                    }
301
                }
302
            }
303
            if (resultClause == null) {
304
                return null;
305
            }
307
            Object result = process(resultClause, context);
308
            if (result instanceof Expression) {
309
                return node;
310
            }
311
            return result;
312
        }
314
        @Override
315
        protected Object visitCoalesceExpression(CoalesceExpression node, Object context)
316
        {
317
            for (Expression expression : node.getOperands()) {
318
                Object value = process(expression, context);
320
                if (value instanceof Expression) {
321
                    // TODO: optimize this case
322
                    return node;
323
                }
325
                if (value != null) {
326
                    return value;
327
                }
328
            }
329
            return null;
330
        }
332
        @Override
333
        protected Object visitInPredicate(InPredicate node, Object context)
334
        {
335
            Object value = process(node.getValue(), context);
336
            if (value == null) {
337
                return null;
338
            }
340
            Expression valueListExpression = node.getValueList();
341
            if (!(valueListExpression instanceof InListExpression)) {
342
                if (!) {
343
                    throw new UnsupportedOperationException("IN predicate value list type not yet implemented: " + valueListExpression.getClass().getName());
344
                }
345
                return node;
346
            }
347
            InListExpression valueList = (InListExpression) valueListExpression;
349
            Set<Object> set = .get(valueList);
351
            // We use the presence of the node in the map to indicate that we've already done
352
            // the analysis below. If the value is null, it means that we can't apply the HashSet
353
            // optimization
354
            if (!.containsKey(valueList)) {
355
                if (Iterables.all(valueList.getValues(), ExpressionInterpreter::isNullLiteral)) {
356
                    // if all elements are constant, create a set with them
357
                    set = new HashSet<>();
358
                    for (Expression expression : valueList.getValues()) {
359
                        set.add(process(expression, context));
360
                    }
361
                }
362
                .put(valueList, set);
363
            }
365
            if (set != null && !(value instanceof Expression)) {
366
                return set.contains(value);
367
            }
369
            boolean hasUnresolvedValue = false;
370
            if (value instanceof Expression) {
371
                hasUnresolvedValue = true;
372
            }
374
            boolean hasNullValue = false;
375
            boolean found = false;
376
            List<Object> values = new ArrayList<>(valueList.getValues().size());
377
            List<Type> types = new ArrayList<>(valueList.getValues().size());
378
            for (Expression expression : valueList.getValues()) {
379
                Object inValue = process(expression, context);
380
                if (value instanceof Expression || inValue instanceof Expression) {
381
                    hasUnresolvedValue = true;
382
                    values.add(inValue);
383
                    types.add(.get(expression));
384
                    continue;
385
                }
387
                if (inValue == null) {
388
                    hasNullValue = true;
389
                }
390
                else if (!found && (Boolean) invokeOperator(., types(node.getValue(), expression), ImmutableList.of(value, inValue))) {
391
                    // in does not short-circuit so we must evaluate all value in the list
392
                    found = true;
393
                }
394
            }
395
            if (found) {
396
                return true;
397
            }
399
            if (hasUnresolvedValue) {
400
                Type type = .get(node.getValue());
401
                return new InPredicate(toExpression(value, type), new InListExpression(toExpressions(values, types)));
402
            }
403
            if (hasNullValue) {
404
                return null;
405
            }
406
            return false;
407
        }
409
        @Override
410
        protected Object visitArithmeticUnary(ArithmeticUnaryExpression node, Object context)
411
        {
412
            Object value = process(node.getValue(), context);
413
            if (value == null) {
414
                return null;
415
            }
416
            if (value instanceof Expression) {
417
                return new ArithmeticUnaryExpression(node.getSign(), toExpression(value, .get(node.getValue())));
418
            }
420
            switch (node.getSign()) {
421
                case :
422
                    return value;
423
                case :
424
                    FunctionInfo operatorInfo = .resolveOperator(., types(node.getValue()));
426
                    MethodHandle handle = operatorInfo.getMethodHandle();
427
                    if (handle.type().parameterCount() > 0 && handle.type().parameterType(0) == ConnectorSession.class) {
428
                        handle = handle.bindTo();
429
                    }
430
                    try {
431
                        return handle.invokeWithArguments(value);
432
                    }
433
                    catch (Throwable throwable) {
434
                        Throwables.propagateIfInstanceOf(throwable, RuntimeException.class);
435
                        Throwables.propagateIfInstanceOf(throwable, Error.class);
436
                        throw new RuntimeException(throwable.getMessage(), throwable);
437
                    }
438
            }
440
            throw new UnsupportedOperationException("Unsupported unary operator: " + node.getSign());
441
        }
443
        @Override
444
        protected Object visitArithmeticBinary(ArithmeticBinaryExpression node, Object context)
445
        {
446
            Object left = process(node.getLeft(), context);
447
            if (left == null) {
448
                return null;
449
            }
450
            Object right = process(node.getRight(), context);
451
            if (right == null) {
452
                return null;
453
            }
455
            if (hasUnresolvedValue(left, right)) {
456
                return new ArithmeticBinaryExpression(node.getType(), toExpression(left, .get(node.getLeft())), toExpression(right, .get(node.getRight())));
457
            }
459
            return invokeOperator(OperatorType.valueOf(node.getType().name()), types(node.getLeft(), node.getRight()), ImmutableList.of(left, right));
460
        }
462
        @Override
463
        protected Object visitComparisonExpression(ComparisonExpression node, Object context)
464
        {
465
            ComparisonExpression.Type type = node.getType();
467
            Object left = process(node.getLeft(), context);
468
            if (left == null && !(type == ..)) {
469
                return null;
470
            }
472
            Object right = process(node.getRight(), context);
473
            if (type == ..) {
474
                if (left == null && right == null) {
475
                    return false;
476
                }
477
                else if (left == null || right == null) {
478
                    return true;
479
                }
480
            }
481
            else if (right == null) {
482
                return null;
483
            }
485
            if (hasUnresolvedValue(left, right)) {
486
                return new ComparisonExpression(type, toExpression(left, .get(node.getLeft())), toExpression(right, .get(node.getRight())));
487
            }
489
            if (type == ..) {
490
                type = ..;
491
            }
493
            return invokeOperator(OperatorType.valueOf(type.name()), types(node.getLeft(), node.getRight()), ImmutableList.of(left, right));
494
        }
496
        @Override
497
        protected Object visitBetweenPredicate(BetweenPredicate node, Object context)
498
        {
499
            Object value = process(node.getValue(), context);
500
            if (value == null) {
501
                return null;
502
            }
503
            Object min = process(node.getMin(), context);
504
            if (min == null) {
505
                return null;
506
            }
507
            Object max = process(node.getMax(), context);
508
            if (max == null) {
509
                return null;
510
            }
512
            if (hasUnresolvedValue(value, min, max)) {
513
                return new BetweenPredicate(
514
                        toExpression(value, .get(node.getValue())),
515
                        toExpression(min, .get(node.getMin())),
516
                        toExpression(max, .get(node.getMax())));
517
            }
519
            return invokeOperator(., types(node.getValue(), node.getMin(), node.getMax()), ImmutableList.of(value, min, max));
520
        }
522
        @Override
523
        protected Object visitNullIfExpression(NullIfExpression node, Object context)
524
        {
525
            Object first = process(node.getFirst(), context);
526
            if (first == null) {
527
                return null;
528
            }
529
            Object second = process(node.getSecond(), context);
530
            if (second == null) {
531
                return first;
532
            }
534
            Type firstType = .get(node.getFirst());
535
            Type secondType = .get(node.getSecond());
537
            if (hasUnresolvedValue(first, second)) {
538
                return new NullIfExpression(toExpression(first, firstType), toExpression(second, secondType));
539
            }
541
            Type commonType = FunctionRegistry.getCommonSuperType(firstType, secondType).get();
543
            FunctionInfo firstCast = .getFunctionRegistry().getCoercion(firstType, commonType);
544
            FunctionInfo secondCast = .getFunctionRegistry().getCoercion(secondType, commonType);
546
            // cast(first as <common type>) == cast(second as <common type>)
547
            boolean equal = (Boolean) invokeOperator(
548
                    .,
549
                    ImmutableList.of(commonType, commonType),
550
                    ImmutableList.of(
551
                            invoke(, firstCast.getMethodHandle(), ImmutableList.of(first)),
552
                            invoke(, secondCast.getMethodHandle(), ImmutableList.of(second))));
554
            if (equal) {
555
                return null;
556
            }
557
            else {
558
                return first;
559
            }
560
        }
562
        @Override
563
        protected Object visitNotExpression(NotExpression node, Object context)
564
        {
565
            Object value = process(node.getValue(), context);
566
            if (value == null) {
567
                return null;
568
            }
570
            if (value instanceof Expression) {
571
                return new NotExpression(toExpression(value, .get(node.getValue())));
572
            }
574
            return !(Boolean) value;
575
        }
577
        @Override
578
        protected Object visitLogicalBinaryExpression(LogicalBinaryExpression node, Object context)
579
        {
580
            Object left = process(node.getLeft(), context);
581
            Object right = process(node.getRight(), context);
583
            switch (node.getType()) {
584
                case : {
585
                    // if either left or right is false, result is always false regardless of nulls
586
                    if (..equals(left) || ..equals(right)) {
587
                        return left;
588
                    }
590
                    if (..equals(right) || ..equals(left)) {
591
                        return right;
592
                    }
593
                }
594
                case : {
595
                    // if either left or right is true, result is always true regardless of nulls
596
                    if (..equals(left) || ..equals(right)) {
597
                        return left;
598
                    }
600
                    if (..equals(right) || ..equals(left)) {
601
                        return right;
602
                    }
603
                }
604
            }
606
            if (left == null && right == null) {
607
                return null;
608
            }
610
            return new LogicalBinaryExpression(node.getType(),
611
                    toExpression(left, .get(node.getLeft())),
612
                    toExpression(right, .get(node.getRight())));
613
        }
615
        @Override
616
        protected Object visitBooleanLiteral(BooleanLiteral node, Object context)
617
        {
618
            return node.equals(.);
619
        }
621
        @Override
622
        protected Object visitFunctionCall(FunctionCall node, Object context)
623
        {
624
            List<Type> argumentTypes = new ArrayList<>();
625
            List<Object> argumentValues = new ArrayList<>();
626
            for (Expression expression : node.getArguments()) {
627
                Object value = process(expression, context);
628
                Type type = .get(expression);
629
                argumentValues.add(value);
630
                argumentTypes.add(type);
631
            }
632
            FunctionInfo function = .resolveFunction(node.getName(), Lists.transform(argumentTypes, Type::getTypeSignature), false);
633
            for (int i = 0; i < argumentValues.size(); i++) {
634
                Object value = argumentValues.get(i);
635
                if (value == null && !function.getNullableArguments().get(i)) {
636
                    return null;
637
                }
638
            }
640
            // do not optimize non-deterministic functions
641
            if ( && (!function.isDeterministic() || hasUnresolvedValue(argumentValues))) {
642
                return new FunctionCall(node.getName(), node.getWindow(), node.isDistinct(), toExpressions(argumentValues, argumentTypes));
643
            }
644
            return invoke(, function.getMethodHandle(), argumentValues);
645
        }
647
        @Override
648
        protected Object visitLikePredicate(LikePredicate node, Object context)
649
        {
650
            Object value = process(node.getValue(), context);
652
            if (value == null) {
653
                return null;
654
            }
656
            if (value instanceof Slice &&
657
                    node.getPattern() instanceof StringLiteral &&
658
                    (node.getEscape() instanceof StringLiteral || node.getEscape() == null)) {
659
                // fast path when we know the pattern and escape are constant
660
                return LikeFunctions.like((Slice) value, getConstantPattern(node));
661
            }
663
            Object pattern = process(node.getPattern(), context);
665
            if (pattern == null) {
666
                return null;
667
            }
669
            Object escape = null;
670
            if (node.getEscape() != null) {
671
                escape = process(node.getEscape(), context);
673
                if (escape == null) {
674
                    return null;
675
                }
676
            }
678
            if (value instanceof Slice &&
679
                    pattern instanceof Slice &&
680
                    (escape == null || escape instanceof Slice)) {
681
                Regex regex;
682
                if (escape == null) {
683
                    regex = LikeFunctions.likePattern((Slice) pattern);
684
                }
685
                else {
686
                    regex = LikeFunctions.likePattern((Slice) pattern, (Slice) escape);
687
                }
689
                return LikeFunctions.like((Slice) value, regex);
690
            }
692
            // if pattern is a constant without % or _ replace with a comparison
693
            if (pattern instanceof Slice && escape == null) {
694
                String stringPattern = ((Slice) pattern).toString();
695
                if (!stringPattern.contains("%") && !stringPattern.contains("_")) {
696
                    return new ComparisonExpression(..,
697
                            toExpression(value, .get(node.getValue())),
698
                            toExpression(pattern, .get(node.getPattern())));
699
                }
700
            }
702
            Expression optimizedEscape = null;
703
            if (node.getEscape() != null) {
704
                optimizedEscape = toExpression(escape, .get(node.getEscape()));
705
            }
707
            return new LikePredicate(
708
                    toExpression(value, .get(node.getValue())),
709
                    toExpression(pattern, .get(node.getPattern())),
710
                    optimizedEscape);
711
        }
713
        private Regex getConstantPattern(LikePredicate node)
714
        {
715
            Regex result = .get(node);
717
            if (result == null) {
718
                StringLiteral pattern = (StringLiteral) node.getPattern();
719
                StringLiteral escape = (StringLiteral) node.getEscape();
721
                if (escape == null) {
722
                    result = LikeFunctions.likePattern(pattern.getSlice());
723
                }
724
                else {
725
                    result = LikeFunctions.likePattern(pattern.getSlice(), escape.getSlice());
726
                }
728
                .put(node, result);
729
            }
731
            return result;
732
        }
734
        @Override
735
        public Object visitCast(Cast node, Object context)
736
        {
737
            Object value = process(node.getExpression(), context);
739
            if (value instanceof Expression) {
740
                return new Cast((Expression) value, node.getType(), node.isSafe());
741
            }
743
            // hack!!! don't optimize CASTs for types that cannot be represented in the SQL AST
744
            // TODO: this will not be an issue when we migrate to RowExpression tree for this, which allows arbitrary literals.
745
            if ( && !FunctionRegistry.isSupportedLiteralType(.get(node))) {
746
                return new Cast(toExpression(value, .get(node.getExpression())), node.getType(), node.isSafe());
747
            }
749
            if (value == null) {
750
                return null;
751
            }
753
            Type type = .getType(parseTypeSignature(node.getType()));
754
            if (type == null) {
755
                throw new IllegalArgumentException("Unsupported type: " + node.getType());
756
            }
758
            FunctionInfo operatorInfo = .getFunctionRegistry().getCoercion(.get(node.getExpression()), type);
760
            try {
761
                return invoke(, operatorInfo.getMethodHandle(), ImmutableList.of(value));
762
            }
763
            catch (RuntimeException e) {
764
                if (node.isSafe()) {
765
                    return null;
766
                }
767
                throw e;
768
            }
769
        }
771
        @Override
772
        protected Object visitArrayConstructor(ArrayConstructor node, Object context)
773
        {
774
            return visitFunctionCall(new FunctionCall(QualifiedName.of(.), node.getValues()), context);
775
        }
777
        @Override
778
        protected Object visitRow(Row node, Object context)
779
        {
780
            throw new UnsupportedOperationException("Row expressions not yet supported");
781
        }
783
        @Override
784
        protected Object visitSubscriptExpression(SubscriptExpression node, Object context)
785
        {
786
            Object base = process(node.getBase(), context);
787
            if (base == null) {
788
                return null;
789
            }
790
            Object index = process(node.getIndex(), context);
791
            if (index == null) {
792
                return null;
793
            }
795
            if (hasUnresolvedValue(base, index)) {
796
                return new SubscriptExpression(toExpression(base, .get(node.getBase())), toExpression(index, .get(node.getIndex())));
797
            }
799
            return invokeOperator(., types(node.getBase(), node.getIndex()), ImmutableList.of(base, index));
800
        }
802
        @Override
803
        protected Object visitExpression(Expression node, Object context)
804
        {
805
            throw new PrestoException(, "not yet implemented: " + node.getClass().getName());
806
        }
808
        @Override
809
        protected Object visitNode(Node node, Object context)
810
        {
811
            throw new UnsupportedOperationException("Evaluator visitor can only handle Expression nodes");
812
        }
814
        private List<Type> types(Expression... types)
815
        {
816
            return ImmutableList.copyOf(Iterables.transform(ImmutableList.copyOf(types), Functions.forMap()));
817
        }
819
        private boolean hasUnresolvedValue(Object... values)
820
        {
821
            return hasUnresolvedValue(ImmutableList.copyOf(values));
822
        }
824
        private boolean hasUnresolvedValue(List<Object> values)
825
        {
826
            return any(values, instanceOf(Expression.class));
827
        }
829
        private Object invokeOperator(OperatorType operatorType, List<? extends Type> argumentTypes, List<Object> argumentValues)
830
        {
831
            FunctionInfo operatorInfo = .resolveOperator(operatorType, argumentTypes);
832
            return invoke(, operatorInfo.getMethodHandle(), argumentValues);
833
        }
834
    }
836
    private static class PagePositionContext
837
    {
838
        private final int position;
839
        private final Block[] blocks;
841
        private PagePositionContext(int position, Block[] blocks)
842
        {
843
            this. = position;
844
            this. = blocks;
845
        }
847
        public Block getBlock(int channel)
848
        {
849
            return [channel];
850
        }
852
        public int getPosition()
853
        {
854
            return ;
855
        }
856
    }
858
    public static Object invoke(ConnectorSession session, MethodHandle handle, List<Object> argumentValues)
859
    {
860
        if (handle.type().parameterCount() > 0 && handle.type().parameterType(0) == ConnectorSession.class) {
861
            handle = handle.bindTo(session);
862
        }
863
        try {
864
            return handle.invokeWithArguments(argumentValues);
865
        }
866
        catch (Throwable throwable) {
867
            if (throwable instanceof InterruptedException) {
868
                Thread.currentThread().interrupt();
869
            }
870
            throw Throwables.propagate(throwable);
871
        }
872
    }
874
    private static boolean isNullLiteral(Expression entry)
875
    {
876
        return entry instanceof Literal && !(entry instanceof NullLiteral);
877
    }