@Override
protected String visitSearchedCaseExpression(SearchedCaseExpression node,Void context)
{
    ImmutableList.Builder<String> parts = ImmutableList.builder();
    parts.add("CASE").add("\n");
    for (WhenClause whenClause : node.getWhenClauses()) {
        parts.add(process(whenClause,context)).add("\n");
    }
    if (node.getDefaultValue() != null) {
        parts.add("ELSE")
                .add(process(node.getDefaultValue(),context)).add("\n");
    }
    parts.add("END").add("\n");

    return "(" + Joiner.on(' ').join(parts.build()) + ")";
}

@Override
protected String visitSearchedCaseExpression(SearchedCaseExpression node,StackableAstVisitorContext<Integer> indent)
{
    ImmutableList.Builder<String> parts = ImmutableList.builder();
    parts.add("CASE");
    for (WhenClause whenClause : node.getWhenClauses()) {
        parts.add(process(whenClause,indent));
    }

    node.getDefaultValue()
            .ifPresent((value) -> parts.add("ELSE").add(process(value,indent)));

    parts.add("END");

    return "(" + Joiner.on(' ').join(parts.build()) + ")";
}

@Override
protected String visitSearchedCaseExpression(SearchedCaseExpression node,Boolean unmangleNames)
{
    ImmutableList.Builder<String> parts = ImmutableList.builder();
    parts.add("CASE");
    for (WhenClause whenClause : node.getWhenClauses()) {
        parts.add(process(whenClause,unmangleNames));
    }

    node.getDefaultValue()
            .ifPresent((value) -> parts.add("ELSE").add(process(value,unmangleNames)));

    parts.add("END");

    return "(" + Joiner.on(' ').join(parts.build()) + ")";
}

@Override
protected String visitSearchedCaseExpression(SearchedCaseExpression node,unmangleNames)));

    parts.add("END");

    return "(" + Joiner.on(' ').join(parts.build()) + ")";
}

protected static String processFuncNullifzero(Formatter formatter,FunctionCall node) {
    Expression x = node.getArguments().get(0);

    List<WhenClause> listWhen = new ArrayList<WhenClause>();
    ComparisonExpression ce = new ComparisonExpression(ComparisonExpression.Type.EQUAL,x,new LongLiteral("0"));
    WhenClause wc = new WhenClause(ce,new NullLiteral());
    listWhen.add(wc);
    SearchedCaseExpression sce = new SearchedCaseExpression(listWhen,x);
    return formatter.process(sce,null);
}

@Override
protected RowExpression visitSearchedCaseExpression(SearchedCaseExpression node,Void context)
{
    /*
        Translates an expression like:

            case when cond1 then value1
                 when cond2 then value2
                 when cond3 then value3
                 else value4
            end

        To:

            IF(cond1,value1,IF(cond2,value2,If(cond3,value3,value4)))

     */
    RowExpression expression = node.getDefaultValue()
            .map((value) -> process(value,context))
            .orElse(constantNull(types.get(node)));

    for (WhenClause clause : Lists.reverse(node.getWhenClauses())) {
        expression = call(
                Signatures.ifSignature(types.get(node)),types.get(node),process(clause.getoperand(),context),process(clause.getResult(),expression);
    }

    return expression;
}

@Override
protected Object visitSearchedCaseExpression(SearchedCaseExpression node,Object context)
{
    Object defaultResult = processWithExceptionHandling(node.getDefaultValue().orElse(null),context);

    List<WhenClause> whenClauses = new ArrayList<>();
    for (WhenClause whenClause : node.getWhenClauses()) {
        Object whenoperand = processWithExceptionHandling(whenClause.getoperand(),context);
        Object result = processWithExceptionHandling(whenClause.getResult(),context);

        if (whenoperand instanceof Expression) {
            // cannot fully evaluate,add updated whenClause
            whenClauses.add(new WhenClause(
                    toExpression(whenoperand,type(whenClause.getoperand())),toExpression(result,type(whenClause.getResult()))));
        }
        else if (Boolean.TRUE.equals(whenoperand)) {
            // condition is true,use this as defaultResult
            defaultResult = result;
            break;
        }
    }

    if (whenClauses.isEmpty()) {
        return defaultResult;
    }

    Expression resultExpression = (defaultResult == null) ? null : toExpression(defaultResult,type(node));
    return new SearchedCaseExpression(whenClauses,Optional.ofNullable(resultExpression));
}

@Override
public Expression rewriteIfExpression(IfExpression node,Void context,ExpressionTreeRewriter<Void> treeRewriter)
{
    Expression condition = treeRewriter.rewrite(node.getCondition(),context);
    Expression trueValue = treeRewriter.rewrite(node.getTrueValue(),context);

    Optional<Expression> falseValue = node.getFalseValue()
            .map((value) -> treeRewriter.rewrite(value,context));

    return new SearchedCaseExpression(ImmutableList.of(new WhenClause(condition,trueValue)),falseValue);
}

@Override
protected Boolean visitSearchedCaseExpression(SearchedCaseExpression node,Void context)
{
    for (WhenClause whenClause : node.getWhenClauses()) {
        if (!process(whenClause.getoperand(),context) || !process(whenClause.getResult(),context)) {
            return false;
        }
    }

    return !node.getDefaultValue().isPresent() || process(node.getDefaultValue().get(),context);
}

@Override
public Node visitSearchedCase(sqlbaseParser.SearchedCaseContext context)
{
    return new SearchedCaseExpression(
            getLocation(context),visit(context.whenClause(),WhenClause.class),visitIfPresent(context.elseExpression,Expression.class));
}

@Override
protected OrderBy visitSortItem(SortItem si,QueryState state){
    String orderKey = null;
    if(si.getSortKey() instanceof DereferenceExpression){
        orderKey = SelectParser.visitDereferenceExpression((DereferenceExpression)si.getSortKey());
    }else if (si.getSortKey() instanceof FunctionCall){
        orderKey = si.getSortKey().toString().replaceAll("\"","");
    }else if(si.getSortKey() instanceof SearchedCaseExpression){
        //... order by CASE WHEN field IS NULL THEN 1 ELSE 0 END
        // Todo: improve this quick and dirty implementation
        SearchedCaseExpression sce = (SearchedCaseExpression)si.getSortKey();
        for(WhenClause when : sce.getWhenClauses()){
            orderKey = SelectParser.visitDereferenceExpression(
                    (DereferenceExpression)((IsNullPredicate)when.getoperand()).getValue());
        }
    }else if(si.getSortKey() instanceof QualifiednameReference){
        orderKey = ((QualifiednameReference)si.getSortKey()).getName().toString();
    }else {
        state.addException("Order statement with type '"+si.getSortKey().getClass().getName()+"' is not supported");
        return null;
    }
    // fix case
    orderKey = heading.findOriginal(state.originalsql()+";",orderKey,"order by.+","\\W");
    // remove any table reference or alias
    if(orderKey.contains(".")){
        String prefix = orderKey.split("\\.")[0];
        for(QuerySource tr : state.getSources()){
            if(tr.getAlias() != null){
                if(prefix.equals(tr.getAlias())) orderKey = orderKey.substring(orderKey.indexOf('.')+1);
            }else if (tr.getSource() != null && prefix.equals(tr.getSource())) orderKey = orderKey.substring(orderKey.indexOf('.')+1);
        }
    }
    // select column to order on
    Column column = state.getheading().getColumnByLabel(orderKey);
    if(column != null){
        if(si.getordering().toString().startsWith("ASC")){
            return new OrderBy(column.getColumn(),SortOrder.ASC,column.getIndex());
        }else{
            return new OrderBy(column.getColumn(),SortOrder.DESC,column.getIndex());
        }
    }else{
        state.addException("Order key '"+orderKey+"' is not specified in SELECT clause");
        return null;
    }
}

public static Expression caseWhen(Expression operand,Expression result)
{
    return new SearchedCaseExpression(ImmutableList.of(new WhenClause(operand,result)),Optional.empty());
}

public static QueryRunner createLocalQueryRunner()
        throws Exception
{
    Session defaultSession = testSessionBuilder()
            .setCatalog("slack")
            .setSchema("default")
            .build();

    QueryRunner queryRunner = new distributedQueryRunner(defaultSession,1);
    queryRunner.installPlugin(new SlackPlugin());

    queryRunner.createCatalog(
            "slack","slack",ImmutableMap.of("token",System.getenv("SLACK_TOKEN")));

    return queryRunner;
}

public static QueryRunner createLocalQueryRunner()
        throws Exception
{
    Session defaultSession = testSessionBuilder()
            .setCatalog("github")
            .setSchema("default")
            .build();

    QueryRunner queryRunner = new distributedQueryRunner(defaultSession,1);
    queryRunner.installPlugin(new GithubPlugin());

    queryRunner.createCatalog(
            "github","github",System.getenv("GITHUB_TOKEN")));

    return queryRunner;
}

private static QueryRunner createLocalQueryRunner()
        throws Exception
{
    Session defaultSession = TestingSession.testSessionBuilder()
            .setCatalog("twitter")
            .setSchema("default")
            .build();

    QueryRunner queryRunner = new distributedQueryRunner(defaultSession,1);
    queryRunner.installPlugin(new TwitterPlugin());

    queryRunner.createCatalog(
            "twitter","twitter",ImmutableMap.of(
                    "customer_key",System.getenv("TWITTER_CUSTOMER_KEY"),"customer_secret",System.getenv("TWITTER_CUSTOMER_SECRET"),"token",System.getenv("TWITTER_TOKEN"),"secret",System.getenv("TWITTER_SECRET")));

    return queryRunner;
}

private static LocalQueryRunner createLocalQueryRunner()
{
    Session defaultSession = testSessionBuilder()
            .setCatalog("tpch")
            .setSchema(TINY_SCHEMA_NAME)
            .build();

    LocalQueryRunner localQueryRunner = new LocalQueryRunner(defaultSession);
    InMemoryNodeManager nodeManager = localQueryRunner.getNodeManager();
    localQueryRunner.createCatalog("tpch",new TpchConnectorFactory(nodeManager,1),ImmutableMap.<String,String>of());

    HyperLogLogPlugin plugin = new HyperLogLogPlugin();
    for (Type type : plugin.getTypes()) {
        localQueryRunner.getTypeManager().addType(type);
    }
    for (ParametricType parametricType : plugin.getParametricTypes()) {
        localQueryRunner.getTypeManager().addParametricType(parametricType);
    }

    localQueryRunner.getMetadata().addFunctions(extractFunctions(plugin.getFunctions()));

    return localQueryRunner;
}

@Override
public List<QualifiedobjectName> listTables(Session session,QualifiedTablePrefix prefix)
{
    requireNonNull(prefix,"prefix is null");

    String schemaNameOrNull = prefix.getSchemaName().orElse(null);
    Set<QualifiedobjectName> tables = new LinkedHashSet<>();
    for (ConnectorEntry entry : allConnectorsFor(prefix.getCatalogName())) {
        ConnectorMetadata Metadata = entry.getMetadata(session);
        ConnectorSession connectorSession = session.toConnectorSession(entry.getCatalog());
        for (QualifiedobjectName tableName : transform(Metadata.listTables(connectorSession,schemaNameOrNull),convertFromSchemaTableName(prefix.getCatalogName()))) {
            tables.add(tableName);
        }
    }
    return ImmutableList.copyOf(tables);
}

public StatementAnalyzer(
        Analysis analysis,Metadata Metadata,sqlParser sqlParser,AccessControl accessControl,Session session,boolean experimentalSyntaxEnabled,Optional<QueryExplainer> queryExplainer)
{
    this.analysis = requireNonNull(analysis,"analysis is null");
    this.Metadata = requireNonNull(Metadata,"Metadata is null");
    this.sqlParser = requireNonNull(sqlParser,"sqlParser is null");
    this.accessControl = requireNonNull(accessControl,"accessControl is null");
    this.session = requireNonNull(session,"session is null");
    this.experimentalSyntaxEnabled = experimentalSyntaxEnabled;
    this.queryExplainer = requireNonNull(queryExplainer,"queryExplainer is null");
}

public static LocalQueryRunner createLocalQueryRunner()
{
    Session session = testSessionBuilder()
            .setCatalog("raptor")
            .setSchema("benchmark")
            .build();
    LocalQueryRunner localQueryRunner = new LocalQueryRunner(session);

    // add tpch
    InMemoryNodeManager nodeManager = localQueryRunner.getNodeManager();
    localQueryRunner.createCatalog("tpch",String>of());

    // add raptor
    ConnectorFactory raptorConnectorFactory = createraptorConnectorFactory(TPCH_CACHE_DIR,nodeManager);
    localQueryRunner.createCatalog("raptor",raptorConnectorFactory,ImmutableMap.of());

    if (!localQueryRunner.tableExists(session,"orders")) {
        localQueryRunner.execute("CREATE TABLE orders AS SELECT * FROM tpch.sf1.orders");
    }
    if (!localQueryRunner.tableExists(session,"lineitem")) {
        localQueryRunner.execute("CREATE TABLE lineitem AS SELECT * FROM tpch.sf1.lineitem");
    }
    return localQueryRunner;
}

public String getGraphvizPlan(Session session,Statement statement,Type planType)
{
    DataDeFinitionTask<?> task = dataDeFinitionTask.get(statement.getClass());
    if (task != null) {
        // todo format as graphviz
        return explainTask(statement,task);
    }

    switch (planType) {
        case LOGICAL:
            Plan plan = getLogicalPlan(session,statement);
            return PlanPrinter.graphvizLogicalPlan(plan.getRoot(),plan.getTypes());
        case distributeD:
            SubPlan subPlan = getdistributedplan(session,statement);
            return PlanPrinter.graphvizdistributedplan(subPlan);
    }
    throw new IllegalArgumentException("Unhandled plan type: " + planType);
}

@Override
public List<QualifiedobjectName> listViews(Session session,"prefix is null");

    String schemaNameOrNull = prefix.getSchemaName().orElse(null);
    Set<QualifiedobjectName> views = new LinkedHashSet<>();
    for (ConnectorEntry entry : allConnectorsFor(prefix.getCatalogName())) {
        ConnectorMetadata Metadata = entry.getMetadata(session);
        ConnectorSession connectorSession = session.toConnectorSession(entry.getCatalog());
        for (QualifiedobjectName tableName : transform(Metadata.listViews(connectorSession,convertFromSchemaTableName(prefix.getCatalogName()))) {
            views.add(tableName);
        }
    }
    return ImmutableList.copyOf(views);
}

public static ExpressionAnalysis analyzeExpressionsWithSymbols(
        Session session,Map<Symbol,Type> types,Iterable<? extends Expression> expressions)
{
    List<Field> fields = DependencyExtractor.extractUnique(expressions).stream()
            .map(symbol -> {
                Type type = types.get(symbol);
                checkArgument(type != null,"No type for symbol %s",symbol);
                return Field.newUnqualified(symbol.getName(),type);
            })
            .collect(toImmutableList());

    return analyzeExpressions(session,Metadata,sqlParser,new RelationType(fields),expressions);
}

public static RowExpression translate(
        Expression expression,FunctionKind functionKind,IdentityHashMap<Expression,FunctionRegistry functionRegistry,TypeManager typeManager,boolean optimize)
{
    RowExpression result = new Visitor(functionKind,types,typeManager,session.getTimeZoneKey()).process(expression,null);

    requireNonNull(result,"translated expression is null");

    if (optimize) {
        Expressionoptimizer optimizer = new Expressionoptimizer(functionRegistry,session);
        return optimizer.optimize(result);
    }

    return result;
}

public Query(Session session,String query,QueryManager queryManager,ExchangeClient exchangeClient)
{
    requireNonNull(session,"session is null");
    requireNonNull(query,"query is null");
    requireNonNull(queryManager,"queryManager is null");
    requireNonNull(exchangeClient,"exchangeClient is null");

    this.session = session;
    this.queryManager = queryManager;

    QueryInfo queryInfo = queryManager.createquery(session,query);
    queryId = queryInfo.getQueryId();
    this.exchangeClient = exchangeClient;
}

@Override
public CompletableFuture<?> execute(RenaMetable statement,TransactionManager transactionManager,QueryStateMachine stateMachine)
{
    Session session = stateMachine.getSession();
    QualifiedobjectName tableName = createQualifiedobjectName(session,statement,statement.getSource());
    Optional<TableHandle> tableHandle = Metadata.getTableHandle(session,tableName);
    if (!tableHandle.isPresent()) {
        throw new SemanticException(MISSING_TABLE,"Table '%s' does not exist",tableName);
    }

    QualifiedobjectName target = createQualifiedobjectName(session,statement.getTarget());
    if (!Metadata.getCatalogNames().containsKey(target.getCatalogName())) {
        throw new SemanticException(MISSING_CATALOG,"Target catalog '%s' does not exist",target.getCatalogName());
    }
    if (Metadata.getTableHandle(session,target).isPresent()) {
        throw new SemanticException(TABLE_ALREADY_EXISTS,"Target table '%s' already exists",target);
    }
    if (!tableName.getCatalogName().equals(target.getCatalogName())) {
        throw new SemanticException(NOT_SUPPORTED,"Table rename across catalogs is not supported");
    }
    accessControl.checkCanRenaMetable(session.getrequiredTransactionId(),session.getIdentity(),tableName,target);

    Metadata.renaMetable(session,tableHandle.get(),target);

    return completedFuture(null);
}

@POST
@Produces(MediaType.APPLICATION_JSON)
public Response createquery(String query,@Context HttpServletRequest servletRequest)
{
    assertRequest(!isNullOrEmpty(query),"sql query is empty");

    Session session = createSessionForRequest(servletRequest,accessControl,sessionPropertyManager,queryIdGenerator.createNextQueryId());
    ClientSession clientSession = session.toClientSession(serverUri(),false,new Duration(2,MINUTES));

    StatementClient client = new StatementClient(httpClient,queryResultsCodec,clientSession,query);

    List<Column> columns = getColumns(client);
    Iterator<List<Object>> iterator = flatten(new ResultsPageIterator(client));
    SimpleQueryResults results = new SimpleQueryResults(columns,iterator);

    return Response.ok(results,MediaType.APPLICATION_JSON_TYPE).build();
}

private Operator interpretedFilterProject(Expression filter,Expression projection,Session session)
{
    FilterFunction filterFunction = new InterpretedFilterFunction(
            filter,SYMBOL_TYPES,INPUT_MAPPING,sql_PARSER,session
    );

    ProjectionFunction projectionFunction = new InterpretedProjectionFunction(
            projection,session
    );

    OperatorFactory operatorFactory = new FilterandProjectOperator.FilterandProjectOperatorFactory(0,new PlanNodeId("test"),new GenericPageProcessor(filterFunction,ImmutableList.of(projectionFunction)),toTypes(
            ImmutableList.of(projectionFunction)));
    return operatorFactory.createOperator(createDriverContext(session));
}

public String getPlan(Session session,Type planType)
{
    DataDeFinitionTask<?> task = dataDeFinitionTask.get(statement.getClass());
    if (task != null) {
        return explainTask(statement,statement);
            return PlanPrinter.textLogicalPlan(plan.getRoot(),plan.getTypes(),session);
        case distributeD:
            SubPlan subPlan = getdistributedplan(session,statement);
            return PlanPrinter.textdistributedplan(subPlan,session);
    }
    throw new IllegalArgumentException("Unhandled plan type: " + planType);
}

public StandaloneQueryRunner(Session defaultSession)
        throws Exception
{
    requireNonNull(defaultSession,"defaultSession is null");

    try {
        server = createTestingPrestoServer();
    }
    catch (Exception e) {
        close();
        throw e;
    }

    this.prestoClient = new TestingPrestoClient(server,defaultSession);

    refreshNodes();

    server.getMetadata().addFunctions(AbstractTestQueries.CUSTOM_FUNCTIONS);

    SessionPropertyManager sessionPropertyManager = server.getMetadata().getSessionPropertyManager();
    sessionPropertyManager.addSystemSessionProperties(AbstractTestQueries.TEST_SYstem_PROPERTIES);
    sessionPropertyManager.addConnectorSessionProperties("catalog",AbstractTestQueries.TEST_CATALOG_PROPERTIES);
}

public sqlTaskExecution create(Session session,QueryContext queryContext,TaskStateMachine taskStateMachine,SharedBuffer sharedBuffer,PlanFragment fragment,List<TaskSource> sources)
{
    boolean verboseStats = getVerboseStats(session);
    TaskContext taskContext = queryContext.addTaskContext(
            taskStateMachine,session,requireNonNull(operatorPreAllocatedMemory,"operatorPreAllocatedMemory is null"),verboseStats,cpuTimerEnabled);

    return createsqlTaskExecution(
            taskStateMachine,taskContext,sharedBuffer,fragment,sources,planner,taskExecutor,taskNotificationExecutor,queryMonitor);
}

private static distributedQueryRunner createqueryRunner()
        throws Exception
{
    Session session = testSessionBuilder()
            .setSource("test")
            .setCatalog("tpch")
            .setSchema("tiny")
            .build();

    distributedQueryRunner queryRunner = new distributedQueryRunner(session,4,ImmutableMap.of("optimizer.optimize-hash-generation","false"));

    try {
        queryRunner.installPlugin(new TpchPlugin());
        queryRunner.createCatalog("tpch","tpch");

        queryRunner.installPlugin(new SampledTpchPlugin());
        queryRunner.createCatalog("tpch_sampled","tpch_sampled");

        return queryRunner;
    }
    catch (Exception e) {
        queryRunner.close();
        throw e;
    }
}

/**
 * Returns list of queues to enter,or null if query does not match rule
 */
public List<QueryQueueDeFinition> match(Session session)
{
    if (userRegex != null && !userRegex.matcher(session.getUser()).matches()) {
        return null;
    }
    if (sourceRegex != null) {
        String source = session.getSource().orElse("");
        if (!sourceRegex.matcher(source).matches()) {
            return null;
        }
    }

    for (Map.Entry<String,Pattern> entry : sessionPropertyRegexes.entrySet()) {
        String value = session.getSystemProperties().getorDefault(entry.getKey(),"");
        if (!entry.getValue().matcher(value).matches()) {
            return null;
        }
    }

    return queues;
}

@Override
public DataDeFinitionExecution<?> createqueryExecution(
        QueryId queryId,Statement statement)
{
    URI self = locationFactory.createqueryLocation(queryId);

    DataDeFinitionTask<Statement> task = getTask(statement);
    checkArgument(task != null,"no task for statement: %s",statement.getClass().getSimpleName());

    QueryStateMachine stateMachine = QueryStateMachine.begin(queryId,query,self,task.isTransactionControl(),transactionManager,executor);
    stateMachine.setUpdateType(task.getName());
    return new DataDeFinitionExecution<>(task,stateMachine);
}

@Test
public void testNameExpansion()
{
    Session session = TestingSession.testSessionBuilder()
            .setIdentity(new Identity("bob",Optional.empty()))
            .setSource("the-internet")
            .build();

    QueryQueueDeFinition deFinition = new QueryQueueDeFinition("user.${USER}",1,1);
    assertEquals(deFinition.getExpandedTemplate(session),"user.bob");
    deFinition = new QueryQueueDeFinition("source.${SOURCE}","source.the-internet");
    deFinition = new QueryQueueDeFinition("${USER}.${SOURCE}","bob.the-internet");
    deFinition = new QueryQueueDeFinition("global","global");
}

private InternalTable buildTables(Session session,String catalogName,Map<String,NullableValue> filters)
{
    Set<QualifiedobjectName> tables = ImmutableSet.copyOf(getTablesList(session,catalogName,filters));
    Set<QualifiedobjectName> views = ImmutableSet.copyOf(getViewsList(session,filters));

    InternalTable.Builder table = InternalTable.builder(informationSchemaTableColumns(TABLE_TABLES));
    for (QualifiedobjectName name : union(tables,views)) {
        // if table and view names overlap,the view wins
        String type = views.contains(name) ? "VIEW" : "BASE TABLE";
        table.add(
                name.getCatalogName(),name.getSchemaName(),name.getobjectName(),type);
    }
    return table.build();
}

@Test
public void testStartTransactionExplicitModes()
        throws Exception
{
    Session session = sessionBuilder()
            .setClientTransactionSupport()
            .build();
    TransactionManager transactionManager = createTestTransactionManager();
    QueryStateMachine stateMachine = QueryStateMachine.begin(new QueryId("query"),"START TRANSACTION",URI.create("fake://uri"),true,executor);
    Assert.assertFalse(stateMachine.getSession().getTransactionId().isPresent());

    new StartTransactionTask().execute(new StartTransaction(ImmutableList.of(new Isolation(Isolation.Level.SERIALIZABLE),new TransactionAccessMode(true))),new AllowAllAccessControl(),stateMachine).join();
    Assert.assertFalse(stateMachine.getQueryInfoWithoutDetails().isClearTransactionId());
    Assert.assertTrue(stateMachine.getQueryInfoWithoutDetails().getStartedTransactionId().isPresent());
    Assert.assertEquals(transactionManager.getAllTransactionInfos().size(),1);

    TransactionInfo transactionInfo = transactionManager.getTransactionInfo(stateMachine.getQueryInfoWithoutDetails().getStartedTransactionId().get());
    Assert.assertEquals(transactionInfo.getIsolationLevel(),IsolationLevel.SERIALIZABLE);
    Assert.assertTrue(transactionInfo.isReadOnly());
    Assert.assertFalse(transactionInfo.isAutoCommitContext());
}

@Test
public void testCreateSession()
        throws Exception
{
    HttpServletRequest request = new MockHttpServletRequest(
            ImmutableListMultimap.<String,String>builder()
                    .put(PRESTO_USER,"testUser")
                    .put(PRESTO_SOURCE,"testSource")
                    .put(PRESTO_CATALOG,"testCatalog")
                    .put(PRESTO_SCHEMA,"testSchema")
                    .put(PRESTO_LANGUAGE,"zh-TW")
                    .put(PRESTO_TIME_ZONE,"Asia/Taipei")
                    .put(PRESTO_SESSION,QUERY_MAX_MEMORY + "=1GB")
                    .put(PRESTO_SESSION,distributeD_JOIN + "=true," + HASH_PARTITION_COUNT + " = 43")
                    .build(),"testRemote");

    Session session = createSessionForRequest(request,new SessionPropertyManager(),new QueryId("test_query_id"));

    assertEquals(session.getQueryId(),new QueryId("test_query_id"));
    assertEquals(session.getUser(),"testUser");
    assertEquals(session.getSource().get(),"testSource");
    assertEquals(session.getCatalog().get(),"testCatalog");
    assertEquals(session.getSchema().get(),"testSchema");
    assertEquals(session.getLocale(),Locale.TAIWAN);
    assertEquals(session.getTimeZoneKey(),getTimeZoneKey("Asia/Taipei"));
    assertEquals(session.getRemoteUserAddress().get(),"testRemote");
    assertEquals(session.getSystemProperties(),String>builder()
            .put(QUERY_MAX_MEMORY,"1GB")
            .put(distributeD_JOIN,"true")
            .put(HASH_PARTITION_COUNT,"43")
            .build());
}

public KafkaLoader(Producer<Long,Object> producer,String topicName,TestingPrestoServer prestoServer,Session defaultSession)
{
    super(prestoServer,defaultSession);

    this.topicName = topicName;
    this.producer = producer;
}

public Visitor(Metadata Metadata,sqlParser parser)
{
    this.Metadata = Metadata;
    this.session = session;
    this.types = types;
    this.parser = parser;
}

public static TaskContext createTaskContext(Executor executor,Session session)
{
    return createTaskContext(
            checkNotSameThreadExecutor(executor,"executor is null"),new DataSize(256,MEGABYTE));
}

@Override
public Optional<ColumnHandle> getSampleWeightColumnHandle(Session session,TableHandle tableHandle)
{
    requireNonNull(tableHandle,"tableHandle is null");
    ConnectorEntry entry = lookupConnectorFor(tableHandle);
    ConnectorMetadata Metadata = entry.getMetadata(session);
    ColumnHandle handle = Metadata.getSampleWeightColumnHandle(session.toConnectorSession(entry.getCatalog()),tableHandle.getConnectorHandle());

    return Optional.ofNullable(handle);
}

private static Session createSession(String schema)
{
    return testSessionBuilder()
            .setCatalog("raptor")
            .setSchema(schema)
            .setSystemProperties(ImmutableMap.of("columnar_processing_dictionary","true","dictionary_aggregation","true"))
            .build();
}

private boolean getVerboseStats(Session session)
{
    String verboseStats = session.getSystemProperties().get(VERBOSE_STATS_PROPERTY);
    if (verboseStats == null) {
        return this.verboseStats;
    }

    try {
        return Boolean.valueOf(verboseStats.toupperCase());
    }
    catch (IllegalArgumentException e) {
        throw new PrestoException(NOT_SUPPORTED,"Invalid property '" + VERBOSE_STATS_PROPERTY + "=" + verboseStats + "'");
    }
}

@Override
public Optional<Resolvedindex> resolveIndex(Session session,TableHandle tableHandle,Set<ColumnHandle> indexableColumns,Set<ColumnHandle> outputColumns,TupleDomain<ColumnHandle> tupleDomain)
{
    ConnectorEntry entry = lookupConnectorFor(tableHandle);
    ConnectorMetadata Metadata = entry.getMetadata(session);
    ConnectorTransactionHandle transaction = entry.getTransactionHandle(session);
    ConnectorSession connectorSession = session.toConnectorSession(entry.getCatalog());
    Optional<ConnectorResolvedindex> resolvedindex = Metadata.resolveIndex(connectorSession,tableHandle.getConnectorHandle(),indexableColumns,outputColumns,tupleDomain);
    return resolvedindex.map(resolved -> new Resolvedindex(tableHandle.getConnectorId(),transaction,resolved));
}

private Rewriter(SymbolAllocator symbolAllocator,PlanNodeIdAllocator idAllocator,Session session)
{
    this.symbolAllocator = requireNonNull(symbolAllocator,"symbolAllocator is null");
    this.idAllocator = requireNonNull(idAllocator,"idAllocator is null");
    this.Metadata = requireNonNull(Metadata,"Metadata is null");
    this.session = requireNonNull(session,"session is null");
}

@Test
public void fieldLength()
{
    Session session = testSessionBuilder()
            .setCatalog("blackhole")
            .setSchema("default")
            .build();

    assertthatQueryReturnsValue(
            format("CREATE TABLE nation WITH ( %s = 8,%s = 1,%s = 1 ) as SELECT * FROM tpch.tiny.nation",FIELD_LENGTH_PROPERTY,ROWS_PER_PAGE_PROPERTY,PAGES_PER_SPLIT_PROPERTY,SPLIT_COUNT_PROPERTY),25L,session);

    MaterializedResult rows = queryRunner.execute(session,"SELECT * FROM nation");
    assertEquals(rows.getRowCount(),1);
    MaterializedRow row = Iterables.getonlyElement(rows);
    assertEquals(row.getFieldCount(),4);
    assertEquals(row.getField(0),0L);
    assertEquals(row.getField(1),"********");
    assertEquals(row.getField(2),0L);
    assertEquals(row.getField(3),"********");

    assertthatQueryReturnsValue("DROP TABLE nation",true);
}

public static void copyTpchTables(
        QueryRunner queryRunner,String sourceCatalog,String sourceSchema,Iterable<TpchTable<?>> tables)
        throws Exception
{
    log.info("Loading data from %s.%s...",sourceCatalog,sourceSchema);
    long startTime = System.nanoTime();
    for (TpchTable<?> table : tables) {
        copyTable(queryRunner,sourceSchema,table.getTableName().toLowerCase(ENGLISH),session);
    }
    log.info("Loading from %s.%s complete in %s",nanosSince(startTime).toString(SECONDS));
}

public Analyzer(Session session,Optional<QueryExplainer> queryExplainer,boolean experimentalSyntaxEnabled)
{
    this.session = requireNonNull(session,"session is null");
    this.Metadata = requireNonNull(Metadata,"accessControl is null");
    this.queryExplainer = requireNonNull(queryExplainer,"query explainer is null");
    this.experimentalSyntaxEnabled = experimentalSyntaxEnabled;
}

public Rewriter(SymbolAllocator allocator,SymbolAllocator symbolAllocator,boolean distributedindexJoins,boolean distributedJoins,boolean preferStreamingOperators,boolean redistributeWrites)
{
    this.allocator = allocator;
    this.idAllocator = idAllocator;
    this.symbolAllocator = symbolAllocator;
    this.session = session;
    this.distributedindexJoins = distributedindexJoins;
    this.distributedJoins = distributedJoins;
    this.preferStreamingOperators = preferStreamingOperators;
    this.redistributeWrites = redistributeWrites;
}

@Override
public ConnectorPageSink createPageSink(Session session,InsertTableHandle tableHandle)
{
    // assumes connectorId and catalog are the same
    ConnectorSession connectorSession = session.toConnectorSession(tableHandle.getConnectorId());
    return providerFor(tableHandle.getConnectorId()).createPageSink(tableHandle.getTransactionHandle(),connectorSession,tableHandle.getConnectorHandle());
}

private QueryStateMachine(QueryId queryId,URI self,boolean autoCommit,Executor executor)
{
    this.queryId = requireNonNull(queryId,"queryId is null");
    this.query = requireNonNull(query,"query is null");
    this.session = requireNonNull(session,"session is null");
    this.self = requireNonNull(self,"self is null");
    this.autoCommit = autoCommit;
    this.transactionManager = requireNonNull(transactionManager,"transactionManager is null");

    this.queryState = new StateMachine<>("query " + query,executor,QUEUED,TERMINAL_QUERY_STATES);
}

public static Session createCassandraSession(String schema)
{
    return testSessionBuilder()
            .setCatalog("cassandra")
            .setSchema(schema)
            .build();
}

@Override
protected Void visitAddColumn(AddColumn node,Integer indent)
{
    builder.append("ALTER TABLE ")
            .append(node.getName())
            .append(" ADD COLUMN ")
            .append(node.getColumn().getName())
            .append(" ")
            .append(node.getColumn().getType());

    return null;
}

@Override
public CompletableFuture<?> execute(AddColumn statement,TransactionManager transactionManager,Metadata Metadata,AccessControl accessControl,QueryStateMachine stateMachine)
{
    Session session = stateMachine.getSession();
    QualifiedobjectName tableName = createQualifiedobjectName(session,statement,statement.getName());
    Optional<TableHandle> tableHandle = Metadata.getTableHandle(session,tableName);
    if (!tableHandle.isPresent()) {
        throw new SemanticException(MISSING_TABLE,"Table '%s' does not exist",tableName);
    }

    accessControl.checkCanAddColumns(session.getrequiredTransactionId(),session.getIdentity(),tableName);

    Map<String,ColumnHandle> columnHandles = Metadata.getColumnHandles(session,tableHandle.get());

    TableElement element = statement.getColumn();
    Type type = Metadata.getType(parseTypeSignature(element.getType()));
    if ((type == null) || type.equals(UNKNowN)) {
        throw new SemanticException(TYPE_MISMATCH,element,"UnkNown type for column '%s' ",element.getName());
    }
    if (columnHandles.containsKey(element.getName())) {
        throw new SemanticException(COLUMN_ALREADY_EXISTS,"Column '%s' already exists",element.getName());
    }

    Metadata.addColumn(session,tableHandle.get(),new ColumnMetadata(element.getName(),type,false));

    return completedFuture(null);
}

@Override
protected Void visitAddColumn(AddColumn node,Integer indent)
{
    builder.append("ALTER TABLE ")
            .append(node.getName())
            .append(" ADD COLUMN ")
            .append(node.getColumn().getName())
            .append(" ")
            .append(node.getColumn().getType());

    return null;
}

@Override
protected Void visitAddColumn(AddColumn node,Integer indent)
{
    builder.append("ALTER TABLE ")
            .append(node.getName())
            .append(" ADD COLUMN ")
            .append(node.getColumn().getName())
            .append(" ")
            .append(node.getColumn().getType());

    return null;
}

@Override
public Node visitAddColumn(sqlbaseParser.AddColumnContext context)
{
    return new AddColumn(getLocation(context),getQualifiedname(context.qualifiedname()),(TableElement) visit(context.tableElement()));
}

@Test
public void testAddColumn()
        throws Exception
{
    assertStatement("ALTER TABLE foo.t ADD COLUMN c bigint",new AddColumn(Qualifiedname.of("foo","t"),new TableElement("c","bigint")));
}

@Override
protected List<QuerySource> visitRelation(Relation node,QueryState state){
    if(node instanceof Join){
        return node.accept(this,state);
    }else if( node instanceof SampledRelation){
        state.addException("Sampled relations are not supported");
        return null;
    }else if( node instanceof AliasedRelation){
        AliasedRelation ar = (AliasedRelation)node;
        state.setkeyvalue("table_alias",ar.getAlias());
        List<QuerySource> relations = ar.getRelation().accept(this,state);
        for(QuerySource rr : relations) rr.setAlias(ar.getAlias());
        return relations;
    }else if( node instanceof QueryBody){
        return node.accept(this,state);
    }else{
        state.addException("Unable to parse node because it has an unkNown type :"+node.getClass());
        return null;
    }
}

@Override
protected RelationType visitAliasedRelation(AliasedRelation relation,AnalysisContext context)
{
    RelationType child = process(relation.getRelation(),context);

    // todo this check should be inside of TupleDescriptor.withAlias,but the exception needs the node object
    if (relation.getColumnNames() != null) {
        int totalColumns = child.getVisibleFieldCount();
        if (totalColumns != relation.getColumnNames().size()) {
            throw new SemanticException(MISMATCHED_COLUMN_ALIASES,relation,"Column alias list has %s entries but '%s' has %s columns available",relation.getColumnNames().size(),relation.getAlias(),totalColumns);
        }
    }

    RelationType descriptor = child.withAlias(relation.getAlias(),relation.getColumnNames());

    analysis.setoutputDescriptor(relation,descriptor);
    return descriptor;
}

@Override
protected Void visitAliasedRelation(AliasedRelation node,Integer indent)
{
    process(node.getRelation(),indent);

    builder.append(' ')
            .append(formatName(node.getAlias()));
    appendaliasColumns(builder,node.getColumnNames());

    return null;
}

@Override
protected RelationPlan visitAliasedRelation(AliasedRelation node,Void context)
{
    RelationPlan subPlan = process(node.getRelation(),context);

    RelationType outputDescriptor = analysis.getoutputDescriptor(node);

    return new RelationPlan(subPlan.getRoot(),outputDescriptor,subPlan.getoutputSymbols(),subPlan.getSampleWeight());
}

@Override
protected Void visitAliasedRelation(AliasedRelation node,indent);

    builder.append(' ')
            .append(node.getAlias());

    appendaliasColumns(builder,node.getColumnNames());

    return null;
}

@Override
public Node visitAliasedRelation(sqlbaseParser.AliasedRelationContext context)
{
    Relation child = (Relation) visit(context.relationPrimary());

    if (context.identifier() == null) {
        return child;
    }

    return new AliasedRelation(getLocation(context),child,context.identifier().getText(),getColumnAliases(context.columnAliases()));
}

@Override
protected Void visitAliasedRelation(AliasedRelation node,node.getColumnNames());

    return null;
}

public static Relation aliased(Relation relation,String alias,List<String> columnAliases)
{
    return new AliasedRelation(relation,alias,columnAliases);
}

@Override
protected Object visitArithmeticBinary(ArithmeticBinaryExpression node,Object context)
{
    Object left = process(node.getLeft(),context);
    if (left == null) {
        return null;
    }
    Object right = process(node.getRight(),context);
    if (right == null) {
        return null;
    }

    if (hasUnresolvedValue(left,right)) {
        return new ArithmeticBinaryExpression(node.getType(),toExpression(left,expressionTypes.get(node.getLeft())),toExpression(right,expressionTypes.get(node.getRight())));
    }

    return invokeOperator(OperatorType.valueOf(node.getType().name()),types(node.getLeft(),node.getRight()),ImmutableList.of(left,right));
}

private static ArithmeticBinaryExpression.Type getArithmeticBinaryOperator(Token operator)
{
    switch (operator.getType()) {
        case sqlbaseLexer.PLUS:
            return ArithmeticBinaryExpression.Type.ADD;
        case sqlbaseLexer.MINUS:
            return ArithmeticBinaryExpression.Type.SUBTRACT;
        case sqlbaseLexer.ASTERISK:
            return ArithmeticBinaryExpression.Type.MULTIPLY;
        case sqlbaseLexer.SLASH:
            return ArithmeticBinaryExpression.Type.DIVIDE;
        case sqlbaseLexer.PERCENT:
            return ArithmeticBinaryExpression.Type.MODULUS;
    }

    throw new UnsupportedOperationException("Unsupported operator: " + operator.getText());
}

@Override
protected RowExpression visitArithmeticBinary(ArithmeticBinaryExpression node,Void context)
{
    RowExpression left = process(node.getLeft(),context);
    RowExpression right = process(node.getRight(),context);

    return call(
            arithmeticExpressionSignature(node.getType(),types.get(node),left.getType(),right.getType()),left,right);
}

@Test
public void testArithmeticExpressionWithNulls()
{
    for (ArithmeticBinaryExpression.Type type : ArithmeticBinaryExpression.Type.values()) {
        assertProjection("NULL " + type.getValue() + " NULL",null);

        assertProjection("42 " + type.getValue() + " NULL",null);
        assertProjection("NULL " + type.getValue() + " 42",null);

        assertProjection("11.1 " + type.getValue() + " NULL",null);
        assertProjection("NULL " + type.getValue() + " 11.1",null);
    }
}

@Override
public Node visitArithmeticBinary(sqlbaseParser.ArithmeticBinaryContext context)
{
    return new ArithmeticBinaryExpression(
            getLocation(context.operator),getArithmeticBinaryOperator(context.operator),(Expression) visit(context.left),(Expression) visit(context.right));
}

@Override
protected String visitArithmeticBinary(ArithmeticBinaryExpression node,StackableAstVisitorContext<Integer> indent)
{
    return formatBinaryExpression(node.getType().getValue(),node.getLeft(),node.getRight(),indent);
}

public ArithmeticBinaryExpression.Type getType(){
    return type;
}

@Override
protected ICalculation visitArithmeticBinary(ArithmeticBinaryExpression node,QueryState state){
    ICalculation left = visitExpression(node.getLeft(),state);
    ICalculation right = visitExpression(node.getRight(),state);
    return new SimpleCalculation(left,right,node.getType());
}

public static Signature arithmeticExpressionSignature(ArithmeticBinaryExpression.Type expressionType,Type returnType,Type leftType,Type rightType)
{
    return internalOperator(expressionType.name(),returnType.getTypeSignature(),leftType.getTypeSignature(),rightType.getTypeSignature());
}

@Override
protected Boolean visitArithmeticBinary(ArithmeticBinaryExpression node,Void context)
{
    return process(node.getLeft(),context) && process(node.getRight(),context);
}

@Override
protected Type visitArithmeticBinary(ArithmeticBinaryExpression node,StackableAstVisitorContext<AnalysisContext> context)
{
    return getoperator(context,node,OperatorType.valueOf(node.getType().name()),node.getRight());
}

private static Expression add(Expression expression1,Expression expression2)
{
    return new ArithmeticBinaryExpression(ArithmeticBinaryExpression.Type.ADD,expression1,expression2);
}

private static Expression multiply(Expression expression1,Expression expression2)
{
    return new ArithmeticBinaryExpression(ArithmeticBinaryExpression.Type.MULTIPLY,expression2);
}

@Override
protected String visitArithmeticBinary(ArithmeticBinaryExpression node,Boolean unmangleNames)
{
    return formatBinaryExpression(node.getType().getValue(),unmangleNames);
}

@Test
public void testPrecedenceAndAssociativity()
        throws Exception
{
    assertExpression("1 AND 2 OR 3",new LogicalBinaryExpression(LogicalBinaryExpression.Type.OR,new LogicalBinaryExpression(LogicalBinaryExpression.Type.AND,new LongLiteral("1"),new LongLiteral("2")),new LongLiteral("3")));

    assertExpression("1 OR 2 AND 3",new LongLiteral("2"),new LongLiteral("3"))));

    assertExpression("NOT 1 AND 2",new NotExpression(new LongLiteral("1")),new LongLiteral("2")));

    assertExpression("NOT 1 OR 2",new LongLiteral("2")));

    assertExpression("-1 + 2",new ArithmeticBinaryExpression(ArithmeticBinaryExpression.Type.ADD,negative(new LongLiteral("1")),new LongLiteral("2")));

    assertExpression("1 - 2 - 3",new ArithmeticBinaryExpression(ArithmeticBinaryExpression.Type.SUBTRACT,new LongLiteral("3")));

    assertExpression("1 / 2 / 3",new ArithmeticBinaryExpression(ArithmeticBinaryExpression.Type.DIVIDE,new LongLiteral("3")));

    assertExpression("1 + 2 * 3",new ArithmeticBinaryExpression(ArithmeticBinaryExpression.Type.MULTIPLY,new LongLiteral("3"))));
}

@Override
protected String visitArithmeticBinary(ArithmeticBinaryExpression node,unmangleNames);
}