How to use io.prestosql.sql

public List<SqlPathElement> getParsedPath()
{
  if (parsedPath == null) {
    parsePath();
  }
  return parsedPath;
}

public static Expression combinePredicates(LogicalBinaryExpression.Operator operator, Collection<Expression> expressions)
{
  if (operator == LogicalBinaryExpression.Operator.AND) {
    return combineConjuncts(expressions);
  }
  return combineDisjuncts(expressions);
}

private String formatBinaryExpression(String operator, Expression left, Expression right)
{
  return '(' + process(left, null) + ' ' + operator + ' ' + process(right, null) + ')';
}

  @Test(expectedExceptions = ParsingException.class, expectedExceptionsMessageRegExp = "\\Qline 1:9: mismatched input '.'. Expecting: ',', <EOF>\\E")
  public void testInvalidPath()
  {
    SqlEnvironmentConfig config = new SqlEnvironmentConfig().setPath("too.many.qualifiers");
    new SqlPath(config.getPath()).getParsedPath();
  }
}

private RowExpression translateAndOptimize(Expression expression)
{
  return translateAndOptimize(expression, getExpressionTypes(expression));
}

public static Expression and(Collection<Expression> expressions)
{
  return binaryExpression(LogicalBinaryExpression.Operator.AND, expressions);
}

public static List<Expression> extractConjuncts(Expression expression)
{
  return extractPredicates(LogicalBinaryExpression.Operator.AND, expression);
}

public static String formatExpression(Expression expression, Optional<List<Expression>> parameters)
{
  return new Formatter(parameters).process(expression, null);
}

@Override
protected Void visitOrderBy(OrderBy node, Integer indent)
{
  append(indent, formatOrderBy(node, parameters))
      .append('\n');
  return null;
}

public static Expression filterDeterministicConjuncts(Expression expression)
{
  return filterConjuncts(expression, DeterminismEvaluator::isDeterministic);
}

public static Expression combineDisjuncts(Collection<Expression> expressions)
{
  return combineDisjunctsWithDefault(expressions, FALSE_LITERAL);
}

private static void assertNormalize(Expression expression)
{
  assertNormalize(expression, expression);
}

  @Test(expectedExceptions = ParsingException.class, expectedExceptionsMessageRegExp = "\\Qline 1:9: mismatched input '.'. Expecting: ',', <EOF>\\E")
  public void testInvalidPath()
  {
    SqlEnvironmentConfig config = new SqlEnvironmentConfig().setPath("too.many.qualifiers");
    new SqlPath(config.getPath()).getParsedPath();
  }
}

public static Expression combinePredicates(LogicalBinaryExpression.Operator operator, Collection<Expression> expressions)
{
  if (operator == LogicalBinaryExpression.Operator.AND) {
    return combineConjuncts(expressions);
  }
  return combineDisjuncts(expressions);
}

private RowExpression translateAndOptimize(Expression expression)
{
  return translateAndOptimize(expression, getExpressionTypes(expression));
}

public static Expression or(Collection<Expression> expressions)
{
  return binaryExpression(LogicalBinaryExpression.Operator.OR, expressions);
}

public static List<Expression> extractDisjuncts(Expression expression)
{
  return extractPredicates(LogicalBinaryExpression.Operator.OR, expression);
}

public List<SqlPathElement> getParsedPath()
{
  if (parsedPath == null) {
    parsePath();
  }
  return parsedPath;
}

private String formatBinaryExpression(String operator, Expression left, Expression right)
{
  return '(' + process(left, null) + ' ' + operator + ' ' + process(right, null) + ')';
}

public static Expression filterDeterministicConjuncts(Expression expression)
{
  return filterConjuncts(expression, DeterminismEvaluator::isDeterministic);
}