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.analyzer;
 
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 
 public class Analysis
 {
     private Query query;
 
     private final IdentityHashMap<TableQuerynamedQueries = new IdentityHashMap<>();
 
     private TupleDescriptor outputDescriptor;
     private final IdentityHashMap<NodeTupleDescriptoroutputDescriptors = new IdentityHashMap<>();
     private final IdentityHashMap<ExpressionMap<QualifiedNameInteger>> resolvedNames = new IdentityHashMap<>();
 
     private final IdentityHashMap<QuerySpecificationExpressionwhere = new IdentityHashMap<>();
     private final IdentityHashMap<QuerySpecificationExpressionhaving = new IdentityHashMap<>();
     private final IdentityHashMap<NodeList<FieldOrExpression>> orderByExpressions = new IdentityHashMap<>();
     private final IdentityHashMap<NodeList<FieldOrExpression>> outputExpressions = new IdentityHashMap<>();
 
     private final IdentityHashMap<JoinExpressionjoins = new IdentityHashMap<>();
     private final SetMultimap<NodeInPredicateinPredicates = HashMultimap.create();
     private final IdentityHashMap<JoinJoinInPredicatesjoinInPredicates = new IdentityHashMap<>();
 
     private final IdentityHashMap<TableTableHandletables = new IdentityHashMap<>();
 
     private final IdentityHashMap<ExpressionBooleanrowFieldAccesors = new IdentityHashMap<>();
     private final IdentityHashMap<ExpressionTypetypes = new IdentityHashMap<>();
     private final IdentityHashMap<ExpressionTypecoercions = new IdentityHashMap<>();
     private final IdentityHashMap<FunctionCallFunctionInfofunctionInfo = new IdentityHashMap<>();
 
     private final IdentityHashMap<FieldColumnHandlecolumns = new IdentityHashMap<>();
 
     private final IdentityHashMap<SampledRelationDoublesampleRatios = new IdentityHashMap<>();
 
     // for create table
     private Optional<QualifiedTableNamecreateTableDestination = Optional.empty();
 
     // for insert
     private Optional<TableHandleinsertTarget = Optional.empty();
 
     public Query getQuery()
     {
         return ;
     }
 
     public void setQuery(Query query)
     {
         this. = query;
     }
 
     public void addResolvedNames(Expression expressionMap<QualifiedNameIntegermappings)
     {
         .put(expressionmappings);
     }
 
    public Map<QualifiedNameIntegergetResolvedNames(Expression expression)
    {
        return .get(expression);
    }
    public void setAggregates(QuerySpecification nodeList<FunctionCallaggregates)
    {
        this..put(nodeaggregates);
    }
    {
        return .get(query);
    }
    {
        return new IdentityHashMap<>();
    }
    public boolean isRowFieldAccessor(QualifiedNameReference qualifiedNameReference)
    {
        return .containsKey(qualifiedNameReference);
    }
    public Type getType(Expression expression)
    {
        Preconditions.checkArgument(.containsKey(expression), "Expression not analyzed: %s"expression);
        return .get(expression);
    }
    public Type getCoercion(Expression expression)
    {
        return .get(expression);
    }
    public void setGroupByExpressions(QuerySpecification nodeList<FieldOrExpressionexpressions)
    {
        .put(nodeexpressions);
    }
    {
        return .get(node);
    }
    public void setWhere(QuerySpecification nodeExpression expression)
    {
        .put(nodeexpression);
    }
    public Expression getWhere(QuerySpecification node)
    {
        return .get(node);
    }
    public void setOrderByExpressions(Node nodeList<FieldOrExpressionitems)
    {
        .put(nodeitems);
    }
    {
        return .get(node);
    }
    public void setOutputExpressions(Node nodeList<FieldOrExpressionexpressions)
    {
        .put(nodeexpressions);
    }
    {
        return .get(node);
    }
    public void setHaving(QuerySpecification nodeExpression expression)
    {
        .put(nodeexpression);
    }
    public void setJoinCriteria(Join nodeExpression criteria)
    {
        .put(nodecriteria);
    }
    public Expression getJoinCriteria(Join join)
    {
        return .get(join);
    }
    public void addInPredicates(Query nodeSet<InPredicateinPredicates)
    {
        this..putAll(nodeinPredicates);
    }
    public void addInPredicates(QuerySpecification nodeSet<InPredicateinPredicates)
    {
        this..putAll(nodeinPredicates);
    }
    public Set<InPredicategetInPredicates(Query node)
    {
        return .get(node);
    }
    {
        return .get(node);
    }
    public void addJoinInPredicates(Join nodeJoinInPredicates joinInPredicates)
    {
        this..put(nodejoinInPredicates);
    }
    {
        return .get(node);
    }
    public void setWindowFunctions(QuerySpecification nodeList<FunctionCallfunctions)
    {
        .put(nodefunctions);
    }
    {
        return ;
    }
    {
        return .get(query);
    }
    public void setOutputDescriptor(TupleDescriptor descriptor)
    {
         = descriptor;
    }
    {
        return ;
    }
    public void setOutputDescriptor(Node nodeTupleDescriptor descriptor)
    {
        .put(nodedescriptor);
    }
    {
        Preconditions.checkState(.containsKey(node), "Output descriptor missing for %s. Broken analysis?"node);
        return .get(node);
    }
    public TableHandle getTableHandle(Table table)
    {
        return .get(table);
    }
    public void registerTable(Table tableTableHandle handle)
    {
        .put(tablehandle);
    }
    public FunctionInfo getFunctionInfo(FunctionCall function)
    {
        return .get(function);
    }
    {
        .putAll(infos);
    }
    public void addTypes(IdentityHashMap<ExpressionTypetypes)
    {
        this..putAll(types);
    }
    public void addRowFieldAccessors(IdentityHashMap<ExpressionBooleanrowFieldAccesors)
    {
        this..putAll(rowFieldAccesors);
    }
    public void addCoercion(Expression expressionType type)
    {
        this..put(expressiontype);
    }
    public void addCoercions(IdentityHashMap<ExpressionTypecoercions)
    {
        this..putAll(coercions);
    }
    public Expression getHaving(QuerySpecification query)
    {
        return .get(query);
    }
    public void setColumn(Field fieldColumnHandle handle)
    {
        .put(fieldhandle);
    }
    public ColumnHandle getColumn(Field field)
    {
        return .get(field);
    }
    public void setCreateTableDestination(QualifiedTableName destination)
    {
        this. = Optional.of(destination);
    }
    {
        return ;
    }
    public void setInsertTarget(TableHandle target)
    {
        this. = Optional.of(target);
    }
    {
        return ;
    }
    public Query getNamedQuery(Table table)
    {
        return .get(table);
    }
    public void registerNamedQuery(Table tableReferenceQuery query)
    {
        checkNotNull(tableReference"tableReference is null");
        checkNotNull(query"query is null");
        .put(tableReferencequery);
    }
    public void setSampleRatio(SampledRelation relationdouble ratio)
    {
        .put(relationratio);
    }
    public double getSampleRatio(SampledRelation relation)
    {
        Preconditions.checkState(.containsKey(relation), "Sample ratio missing for %s. Broken analysis?"relation);
        return .get(relation);
    }
    public static class JoinInPredicates
    {
        private final Set<InPredicateleftInPredicates;
        private final Set<InPredicaterightInPredicates;
        public JoinInPredicates(Set<InPredicateleftInPredicatesSet<InPredicaterightInPredicates)
        {
            this. = ImmutableSet.copyOf(checkNotNull(leftInPredicates"leftInPredicates is null"));
            this. = ImmutableSet.copyOf(checkNotNull(rightInPredicates"rightInPredicates is null"));
        }
        public Set<InPredicategetLeftInPredicates()
        {
            return ;
        }
        public Set<InPredicategetRightInPredicates()
        {
            return ;
        }
        @Override
        public int hashCode()
        {
            return Objects.hashCode();
        }
        @Override
        public boolean equals(Object obj)
        {
            if (this == obj) {
                return true;
            }
            if (obj == null || getClass() != obj.getClass()) {
                return false;
            }
            final JoinInPredicates other = (JoinInPredicatesobj;
            return Objects.equal(this.other.leftInPredicates) &&
                    Objects.equal(this.other.rightInPredicates);
        }
    }
New to GrepCode? Check out our FAQ X