How to use

ExplainType

in

com.facebook.presto.sql.tree

@Override
public Node visitExplainType(SqlBaseParser.ExplainTypeContext context)
{
  switch (context.value.getType()) {
    case SqlBaseLexer.LOGICAL:
      return new ExplainType(getLocation(context), ExplainType.Type.LOGICAL);
    case SqlBaseLexer.DISTRIBUTED:
      return new ExplainType(getLocation(context), ExplainType.Type.DISTRIBUTED);
    case SqlBaseLexer.VALIDATE:
      return new ExplainType(getLocation(context), ExplainType.Type.VALIDATE);
    case SqlBaseLexer.IO:
      return new ExplainType(getLocation(context), ExplainType.Type.IO);
  }
  throw new IllegalArgumentException("Unsupported EXPLAIN type: " + context.value.getText());
}

@Override
protected Void visitExplain(Explain node, Integer indent)
{
  builder.append("EXPLAIN ");
  if (node.isAnalyze()) {
    builder.append("ANALYZE ");
  }
  List<String> options = new ArrayList<>();
  for (ExplainOption option : node.getOptions()) {
    if (option instanceof ExplainType) {
      options.add("TYPE " + ((ExplainType) option).getType());
    }
    else if (option instanceof ExplainFormat) {
      options.add("FORMAT " + ((ExplainFormat) option).getType());
    }
    else {
      throw new UnsupportedOperationException("unhandled explain option: " + option);
    }
  }
  if (!options.isEmpty()) {
    builder.append("(");
    Joiner.on(", ").appendTo(builder, options);
    builder.append(")");
  }
  builder.append("\n");
  process(node.getStatement(), indent);
  return null;
}

if (node.getOptions().stream().anyMatch(option -> !option.equals(new ExplainType(DISTRIBUTED)))) {
  throw new SemanticException(NOT_SUPPORTED, node, "EXPLAIN ANALYZE only supports TYPE DISTRIBUTED option");
  planType = ((ExplainType) option).getType();
  break;

@Override
protected Scope visitExplain(Explain node, Optional<Scope> scope)
    throws SemanticException
{
  checkState(node.isAnalyze(), "Non analyze explain should be rewritten to Query");
  if (node.getOptions().stream().anyMatch(option -> !option.equals(new ExplainType(DISTRIBUTED)))) {
    throw new SemanticException(NOT_SUPPORTED, node, "EXPLAIN ANALYZE only supports TYPE DISTRIBUTED option");
  }
  process(node.getStatement(), scope);
  analysis.setUpdateType(null);
  return createAndAssignScope(node, scope, Field.newUnqualified("Query Plan", VARCHAR));
}

@Override
protected Node visitExplain(Explain node, Void context)
    throws SemanticException
{
  if (node.isAnalyze()) {
    Statement statement = (Statement) process(node.getStatement(), context);
    return new Explain(statement, node.isAnalyze(), node.isVerbose(), node.getOptions());
  }
  ExplainType.Type planType = LOGICAL;
  ExplainFormat.Type planFormat = TEXT;
  List<ExplainOption> options = node.getOptions();
  for (ExplainOption option : options) {
    if (option instanceof ExplainType) {
      planType = ((ExplainType) option).getType();
      // Use JSON as the default format for EXPLAIN (TYPE IO).
      if (planType == IO) {
        planFormat = JSON;
      }
      break;
    }
  }
  for (ExplainOption option : options) {
    if (option instanceof ExplainFormat) {
      planFormat = ((ExplainFormat) option).getType();
      break;
    }
  }
  return getQueryPlan(node, planType, planFormat);
}

@Test
public void testExplainVerboseTypeLogical()
{
  assertStatement("EXPLAIN VERBOSE (type LOGICAL) SELECT * FROM t",
      new Explain(simpleQuery(selectList(new AllColumns()), table(QualifiedName.of("t"))), false, true, ImmutableList.of(new ExplainType(ExplainType.Type.LOGICAL))));
}

@Override
protected Void visitExplain(Explain node, Integer indent) {
  builder.append("EXPLAIN ");
  if (node.isAnalyze()) {
    builder.append("ANALYZE ");
  }
  List<String> options = new ArrayList<>();
  for (ExplainOption option : node.getOptions()) {
    if (option instanceof ExplainType) {
      options.add("TYPE " + ((ExplainType) option).getType());
    } else if (option instanceof ExplainFormat) {
      options.add("FORMAT " + ((ExplainFormat) option).getType());
    } else {
      throw new UnsupportedOperationException("unhandled explain option: " + option);
    }
  }
  if (!options.isEmpty()) {
    builder.append("(");
    Joiner.on(", ").appendTo(builder, options);
    builder.append(")");
  }
  builder.append("\n");
  process(node.getStatement(), indent);
  return null;
}

@Test
public void testExplainAnalyzeTypeDistributed()
{
  assertStatement("EXPLAIN ANALYZE (type DISTRIBUTED) SELECT * FROM t",
      new Explain(simpleQuery(selectList(new AllColumns()), table(QualifiedName.of("t"))), true, false, ImmutableList.of(new ExplainType(ExplainType.Type.DISTRIBUTED))));
}

@Override
protected Void visitExplain(Explain node, Integer indent)
{
  builder.append("EXPLAIN ");
  List<String> options = new ArrayList<>();
  for (ExplainOption option : node.getOptions()) {
    if (option instanceof ExplainType) {
      options.add("TYPE " + ((ExplainType) option).getType());
    }
    else if (option instanceof ExplainFormat) {
      options.add("FORMAT " + ((ExplainFormat) option).getType());
    }
    else {
      throw new UnsupportedOperationException("unhandled explain option: " + option);
    }
  }
  if (!options.isEmpty()) {
    builder.append("(");
    Joiner.on(", ").appendTo(builder, options);
    builder.append(")");
  }
  builder.append("\n");
  process(node.getStatement(), indent);
  return null;
}

@Test
public void testExplainAnalyzeVerboseTypeDistributed()
{
  assertStatement("EXPLAIN ANALYZE VERBOSE (type DISTRIBUTED) SELECT * FROM t",
      new Explain(simpleQuery(selectList(new AllColumns()), table(QualifiedName.of("t"))), true, true, ImmutableList.of(new ExplainType(ExplainType.Type.DISTRIBUTED))));
}

@Override
protected Void visitExplain(Explain node, Integer indent)
{
  builder.append("EXPLAIN ");
  if (node.isAnalyze()) {
    builder.append("ANALYZE ");
  }
  List<String> options = new ArrayList<>();
  for (ExplainOption option : node.getOptions()) {
    if (option instanceof ExplainType) {
      options.add("TYPE " + ((ExplainType) option).getType());
    }
    else if (option instanceof ExplainFormat) {
      options.add("FORMAT " + ((ExplainFormat) option).getType());
    }
    else {
      throw new UnsupportedOperationException("unhandled explain option: " + option);
    }
  }
  if (!options.isEmpty()) {
    builder.append("(");
    Joiner.on(", ").appendTo(builder, options);
    builder.append(")");
  }
  builder.append("\n");
  process(node.getStatement(), indent);
  return null;
}

@Test
public void testExplain()
{
  assertStatement("EXPLAIN SELECT * FROM t",
      new Explain(simpleQuery(selectList(new AllColumns()), table(QualifiedName.of("t"))), false, false, ImmutableList.of()));
  assertStatement("EXPLAIN (TYPE LOGICAL) SELECT * FROM t",
      new Explain(
          simpleQuery(selectList(new AllColumns()), table(QualifiedName.of("t"))),
          false,
          false,
          ImmutableList.of(new ExplainType(ExplainType.Type.LOGICAL))));
  assertStatement("EXPLAIN (TYPE LOGICAL, FORMAT TEXT) SELECT * FROM t",
      new Explain(
          simpleQuery(selectList(new AllColumns()), table(QualifiedName.of("t"))),
          false,
          false,
          ImmutableList.of(
              new ExplainType(ExplainType.Type.LOGICAL),
              new ExplainFormat(ExplainFormat.Type.TEXT))));
}

@Override
protected Void visitExplain(Explain node, Integer indent)
{
  builder.append("EXPLAIN ");
  if (node.isAnalyze()) {
    builder.append("ANALYZE ");
  }
  List<String> options = new ArrayList<>();
  for (ExplainOption option : node.getOptions()) {
    if (option instanceof ExplainType) {
      options.add("TYPE " + ((ExplainType) option).getType());
    }
    else if (option instanceof ExplainFormat) {
      options.add("FORMAT " + ((ExplainFormat) option).getType());
    }
    else {
      throw new UnsupportedOperationException("unhandled explain option: " + option);
    }
  }
  if (!options.isEmpty()) {
    builder.append("(");
    Joiner.on(", ").appendTo(builder, options);
    builder.append(")");
  }
  builder.append("\n");
  process(node.getStatement(), indent);
  return null;
}

@Override
public Node visitExplainType(SqlBaseParser.ExplainTypeContext context)
{
  switch (context.value.getType()) {
    case SqlBaseLexer.LOGICAL:
      return new ExplainType(getLocation(context), ExplainType.Type.LOGICAL);
    case SqlBaseLexer.DISTRIBUTED:
      return new ExplainType(getLocation(context), ExplainType.Type.DISTRIBUTED);
  }
  throw new IllegalArgumentException("Unsupported EXPLAIN type: " + context.value.getText());
}

@Override
public Node visitExplainType(SqlBaseParser.ExplainTypeContext context)
{
  switch (context.value.getType()) {
    case SqlBaseLexer.LOGICAL:
      return new ExplainType(getLocation(context), ExplainType.Type.LOGICAL);
    case SqlBaseLexer.DISTRIBUTED:
      return new ExplainType(getLocation(context), ExplainType.Type.DISTRIBUTED);
    case SqlBaseLexer.VALIDATE:
      return new ExplainType(getLocation(context), ExplainType.Type.VALIDATE);
    case SqlBaseLexer.IO:
      return new ExplainType(getLocation(context), ExplainType.Type.IO);
  }
  throw new IllegalArgumentException("Unsupported EXPLAIN type: " + context.value.getText());
}

@Test
public void testExplainAnalyzeVerboseTypeDistributed()
{
  assertStatement("EXPLAIN ANALYZE VERBOSE (type DISTRIBUTED) SELECT * FROM t",
      new Explain(simpleQuery(selectList(new AllColumns()), table(QualifiedName.of("t"))), true, true, ImmutableList.of(new ExplainType(ExplainType.Type.DISTRIBUTED))));
}

@Test
public void testExplainVerboseTypeLogical()
{
  assertStatement("EXPLAIN VERBOSE (type LOGICAL) SELECT * FROM t",
      new Explain(simpleQuery(selectList(new AllColumns()), table(QualifiedName.of("t"))), false, true, ImmutableList.of(new ExplainType(ExplainType.Type.LOGICAL))));
}

@Test
public void testExplainAnalyzeTypeDistributed()
{
  assertStatement("EXPLAIN ANALYZE (type DISTRIBUTED) SELECT * FROM t",
      new Explain(simpleQuery(selectList(new AllColumns()), table(QualifiedName.of("t"))), true, false, ImmutableList.of(new ExplainType(ExplainType.Type.DISTRIBUTED))));
}

@Test
public void testExplain()
    throws Exception
{
  assertStatement("EXPLAIN SELECT * FROM t",
      new Explain(simpleQuery(selectList(new AllColumns()), table(QualifiedName.of("t"))), false, ImmutableList.of()));
  assertStatement("EXPLAIN (TYPE LOGICAL) SELECT * FROM t",
      new Explain(
          simpleQuery(selectList(new AllColumns()), table(QualifiedName.of("t"))),
          false,
          ImmutableList.of(new ExplainType(ExplainType.Type.LOGICAL))));
  assertStatement("EXPLAIN (TYPE LOGICAL, FORMAT TEXT) SELECT * FROM t",
      new Explain(
          simpleQuery(selectList(new AllColumns()), table(QualifiedName.of("t"))),
          false,
          ImmutableList.of(
              new ExplainType(ExplainType.Type.LOGICAL),
              new ExplainFormat(ExplainFormat.Type.TEXT))));
}

@Test
public void testExplain()
{
  assertStatement("EXPLAIN SELECT * FROM t",
      new Explain(simpleQuery(selectList(new AllColumns()), table(QualifiedName.of("t"))), false, false, ImmutableList.of()));
  assertStatement("EXPLAIN (TYPE LOGICAL) SELECT * FROM t",
      new Explain(
          simpleQuery(selectList(new AllColumns()), table(QualifiedName.of("t"))),
          false,
          false,
          ImmutableList.of(new ExplainType(ExplainType.Type.LOGICAL))));
  assertStatement("EXPLAIN (TYPE LOGICAL, FORMAT TEXT) SELECT * FROM t",
      new Explain(
          simpleQuery(selectList(new AllColumns()), table(QualifiedName.of("t"))),
          false,
          false,
          ImmutableList.of(
              new ExplainType(ExplainType.Type.LOGICAL),
              new ExplainFormat(ExplainFormat.Type.TEXT))));
}