Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.facebook.presto.sql.relational.optimizer;
 
 
 import java.util.List;
 
 import static com.facebook.presto.sql.relational.Expressions.call;
 import static com.facebook.presto.sql.relational.Expressions.constant;
 import static com.facebook.presto.sql.relational.Expressions.constantNull;
 import static com.facebook.presto.sql.relational.Signatures.CAST;
 import static com.facebook.presto.sql.relational.Signatures.COALESCE;
 import static com.facebook.presto.sql.relational.Signatures.IF;
 import static com.facebook.presto.sql.relational.Signatures.IN;
 import static com.facebook.presto.sql.relational.Signatures.IS_NULL;
 import static com.facebook.presto.sql.relational.Signatures.NULL_IF;
 import static com.facebook.presto.sql.relational.Signatures.SWITCH;
 import static com.facebook.presto.sql.relational.Signatures.TRY_CAST;
 import static com.facebook.presto.util.ImmutableCollectors.toImmutableList;
 import static com.google.common.base.Predicates.instanceOf;
 
 public class ExpressionOptimizer
 {
     private final FunctionRegistry registry;
     private final TypeManager typeManager;
     private final ConnectorSession session;
 
     public ExpressionOptimizer(FunctionRegistry registryTypeManager typeManagerSession session)
     {
         this. = registry;
         this. = typeManager;
         this. = session.toConnectorSession();
     }
 
     public RowExpression optimize(RowExpression expression)
     {
         return expression.accept(new Visitor(), null);
     }
 
     private class Visitor
             implements RowExpressionVisitor<VoidRowExpression>
     {
         @Override
         public RowExpression visitInputReference(InputReferenceExpression referenceVoid context)
         {
             return reference;
         }
 
         @Override
         public RowExpression visitConstant(ConstantExpression literalVoid context)
         {
             return literal;
         }
 
         @Override
         public RowExpression visitCall(CallExpression callfinal Void context)
         {
             FunctionInfo function;
             Signature signature = call.getSignature();
 
             if (signature.getName().equals()) {
                 if (call.getArguments().get(0).getType().equals(.)) {
                     return constantNull(call.getType());
                 }
                 function = .getCoercion(call.getArguments().get(0).getType(), call.getType());
             }
             else {
                 switch (signature.getName()) {
                     // TODO: optimize these special forms
                     case :
                     case :
                     case :
                    case "WHEN":
                    case :
                    case :
                    case "IS_DISTINCT_FROM":
                    case :
                    case "AND":
                    case "OR":
                    case :
                        List<RowExpressionarguments = call.getArguments().stream()
                                .map(argument -> argument.accept(thisnull))
                                .collect(toImmutableList());
                        return call(signaturecall.getType(), arguments);
                    default:
                        function = .getExactFunction(signature);
                        if (function == null) {
                            // TODO: temporary hack to deal with magic timestamp literal functions which don't have an "exact" form and need to be "resolved"
                            function = .resolveFunction(QualifiedName.of(signature.getName()), signature.getArgumentTypes(), false);
                        }
                }
            }
            List<RowExpressionarguments = call.getArguments().stream()
                    .map(argument -> argument.accept(thiscontext))
                    .collect(toImmutableList());
            if (Iterables.all(argumentsinstanceOf(ConstantExpression.class)) && function.isDeterministic()) {
                MethodHandle method = function.getMethodHandle();
                if (method.type().parameterCount() > 0 && method.type().parameterType(0) == ConnectorSession.class) {
                    method = method.bindTo();
                }
                int index = 0;
                List<ObjectconstantArguments = new ArrayList<>();
                for (RowExpression argument : arguments) {
                    Object value = ((ConstantExpressionargument).getValue();
                    // if any argument is null, return null
                    if (value == null && !function.getNullableArguments().get(index)) {
                        return constantNull(call.getType());
                    }
                    constantArguments.add(value);
                    index++;
                }
                try {
                    return constant(method.invokeWithArguments(constantArguments), call.getType());
                }
                catch (Throwable e) {
                    if (e instanceof InterruptedException) {
                        Thread.currentThread().interrupt();
                    }
                    // Do nothing. As a result, this specific tree will be left untouched. But irrelevant expressions will continue to get evaluated and optimized.
                }
            }
            return call(signature.getType(signature.getReturnType()), arguments);
        }
    }
New to GrepCode? Check out our FAQ X