Java SqlParserPos类代码示例

import org.apache.calcite.sql.parser.SqlParserPos; //导入依赖的package包/类
private RelDataType createCalciteTypeWithNullability(RelDataTypeFactory typeFactory,
                                                     SqlTypeName sqlTypeName,
                                                     boolean isNullable) {
  RelDataType type;
  if (sqlTypeName == SqlTypeName.INTERVAL_DAY_TIME) {
    type = typeFactory.createSqlIntervalType(
        new SqlIntervalQualifier(
            TimeUnit.DAY,
            TimeUnit.MINUTE,
            SqlParserPos.ZERO));
  } else if (sqlTypeName == SqlTypeName.INTERVAL_YEAR_MONTH) {
    type = typeFactory.createSqlIntervalType(
        new SqlIntervalQualifier(
            TimeUnit.YEAR,
            TimeUnit.MONTH,
           SqlParserPos.ZERO));
  } else if (sqlTypeName == SqlTypeName.VARCHAR) {
    type = typeFactory.createSqlType(sqlTypeName, TypeHelper.VARCHAR_DEFAULT_CAST_LEN);
  } else {
    type = typeFactory.createSqlType(sqlTypeName);
  }
  return typeFactory.createTypeWithNullability(type, isNullable);
}
 

import org.apache.calcite.sql.parser.SqlParserPos; //导入依赖的package包/类
/** Rewrite the parse tree as SELECT ... FROM INFORMATION_SCHEMA.SCHEMATA ... */
@Override
public SqlNode rewrite(SqlNode sqlNode) throws RelConversionException, ForemanSetupException {
  SqlShowSchemas node = unwrap(sqlNode, SqlShowSchemas.class);
  List<SqlNode> selectList =
      ImmutableList.of((SqlNode) new SqlIdentifier(SCHS_COL_SCHEMA_NAME, SqlParserPos.ZERO));

  SqlNode fromClause = new SqlIdentifier(
      ImmutableList.of(IS_SCHEMA_NAME, TAB_SCHEMATA), null, SqlParserPos.ZERO, null);

  SqlNode where = null;
  final SqlNode likePattern = node.getLikePattern();
  if (likePattern != null) {
    where = DrillParserUtil.createCondition(new SqlIdentifier(SCHS_COL_SCHEMA_NAME, SqlParserPos.ZERO),
                                            SqlStdOperatorTable.LIKE, likePattern);
  } else if (node.getWhereClause() != null) {
    where = node.getWhereClause();
  }

  return new SqlSelect(SqlParserPos.ZERO, null, new SqlNodeList(selectList, SqlParserPos.ZERO),
      fromClause, where, null, null, null, null, null, null);
}
 

import org.apache.calcite.sql.parser.SqlParserPos; //导入依赖的package包/类
@JsonCreator
public FieldType(
    @JsonProperty("name")                       String name,
    @JsonProperty("type")                       SqlTypeName type,
    @JsonProperty("precision")                  Integer precision,
    @JsonProperty("scale")                      Integer scale,
    @JsonProperty("startUnit")                  TimeUnit startUnit,
    @JsonProperty("endUnit")                    TimeUnit endUnit,
    @JsonProperty("fractionalSecondPrecision")  Integer fractionalSecondPrecision,
    @JsonProperty("isNullable")                 Boolean isNullable) {
  this.name = name;
  this.type = type;
  this.precision = precision;
  this.scale = scale;
  this.intervalQualifier =
      null == startUnit
      ? null
      : new SqlIntervalQualifier(
          startUnit, precision, endUnit, fractionalSecondPrecision, SqlParserPos.ZERO );

  // Property "isNullable" is not part of the initial view definition and
  // was added in DRILL-2342.  If the default value is null, consider it as
  // "true".  It is safe to default to "nullable" than "required" type.
  this.isNullable = isNullable == null ? true : isNullable;
}
 

import org.apache.calcite.sql.parser.SqlParserPos; //导入依赖的package包/类
public SqlCreateTable(
    SqlParserPos pos,
    SqlIdentifier tblName,
    SqlNodeList fieldList,
    PartitionDistributionStrategy partitionDistributionStrategy,
    SqlNodeList partitionColumns,
    SqlNodeList formatOptions,
    SqlLiteral singleWriter,
    SqlNode query,
    SqlNodeList sortFieldList,
    SqlNodeList distributionColumns) {
  super(pos);
  this.tblName = tblName;
  this.fieldList = fieldList;
  this.partitionDistributionStrategy = partitionDistributionStrategy;
  this.partitionColumns = partitionColumns;
  this.formatOptions = formatOptions;
  this.singleWriter = singleWriter;
  this.query = query;
  this.sortColumns = sortFieldList;
  this.distributionColumns = distributionColumns;
}
 

import org.apache.calcite.sql.parser.SqlParserPos; //导入依赖的package包/类
public static UserException.Builder parseError(String query, SqlParseException ex) {
  final SqlParserPos pos = ex.getPos();
  if (pos == null) {
    return UserException
        .parseError(ex)
        .addContext("SQL Query", query);
  } else {
    return UserException
        .parseError(ex)
        .addContext("SQL Query", query)
        .addContext("startLine", pos.getLineNum())
        .addContext("startColumn", pos.getColumnNum())
        .addContext("endLine", pos.getEndLineNum())
        .addContext("endColumn", pos.getEndColumnNum());
  }
}
 

import org.apache.calcite.sql.parser.SqlParserPos; //导入依赖的package包/类
/**
 *
 * @param sql
 *          the SQL sent to the server
 * @param pos
 *          the position of the error
 * @return The sql with a ^ character under the error
 */
static String formatSQLParsingError(String sql, SqlParserPos pos) {
  StringBuilder sb = new StringBuilder();
  String[] lines = sql.split("\n");
  for (int i = 0; i < lines.length; i++) {
    String line = lines[i];
    sb.append(line).append("\n");
    if (i == (pos.getLineNum() - 1)) {
      for (int j = 0; j < pos.getColumnNum() - 1; j++) {
        sb.append(" ");
      }
      sb.append("^\n");
    }
  }
  return sb.toString();
}
 

import org.apache.calcite.sql.parser.SqlParserPos; //导入依赖的package包/类
@Test
public void testErrorFormating() {
  String sql = "Select * from Foo\nwhere tadadidada;\n";
  validateFormattedIs(sql, new SqlParserPos(1, 2),
      "Select * from Foo\n"
    + " ^\n"
    + "where tadadidada;\n");
  validateFormattedIs(sql, new SqlParserPos(2, 2),
      "Select * from Foo\n"
    + "where tadadidada;\n"
    + " ^\n" );
  validateFormattedIs(sql, new SqlParserPos(1, 10),
      "Select * from Foo\n"
    + "         ^\n"
    + "where tadadidada;\n");
  validateFormattedIs(sql, new SqlParserPos(-11, -10), sql);
  validateFormattedIs(sql, new SqlParserPos(0, 10), sql);
  validateFormattedIs(sql, new SqlParserPos(100, 10), sql);
}
 

import org.apache.calcite.sql.parser.SqlParserPos; //导入依赖的package包/类
public SqlCreateFunction(SqlParserPos pos, SqlIdentifier dbName,
                         SqlIdentifier funcName, SqlNode className, SqlNodeList jarList) {
  super(pos);
  this.dbName = dbName;
  this.funcName = funcName;
  this.className = className;
  this.jarList = jarList;
}
 

import org.apache.calcite.sql.parser.SqlParserPos; //导入依赖的package包/类
public RexNode makeOver(
		SqlAggFunction operator,
		List<RexNode> expressions,
		List<RexNode> partitionKeys
) {
	final Set<SqlKind> flags = EnumSet.noneOf(SqlKind.class);

	// TODO
	// This is a temporal fix to make HAWQ work with OVER + UNLIMITED BOUNDS
	// HAWQ requires ORDER BY if andy BOUNDS are set even unlimited upper and lower BOUNDS (which is equal to
	// the entire partition - e.g. not setting BOUNDs at all --
	// Note that the unnecessary ORDER BY have negative performance impact and has to be remove once either HAWQ
	// start supporting unbounded bounds without order by or Calcite can generate shorthand OVER PARTITION BY
	// syntax.
	List<RexFieldCollation> orderKeys = expressions.stream().map(
			rexNode -> new RexFieldCollation(rexNode, flags)).collect(Collectors.toList());

	return makeOver(
			operator,
			expressions,
			partitionKeys,
			ImmutableList.copyOf(orderKeys),
			RexWindowBound.create(SqlWindow.createUnboundedPreceding(SqlParserPos.ZERO), null),
			RexWindowBound.create(SqlWindow.createUnboundedFollowing(SqlParserPos.ZERO), null),
			true,
			true,
			false
	);
}
 

import org.apache.calcite.sql.parser.SqlParserPos; //导入依赖的package包/类
@Before
@SuppressWarnings("ResultOfMethodCallIgnored") // Mockito syntax
public void setupMocks() {
	relBuilder = Mockito.mock(JdbcRelBuilder.class);
	journalTable = Mockito.mock(JdbcTable.class);
	relOptTable = Mockito.mock(RelOptTable.class);
	context = Mockito.mock(RelOptTable.ToRelContext.class);

	JdbcRelBuilderFactory relBuilderFactory = Mockito.mock(JdbcRelBuilderFactory.class);
	RelOptCluster relOptCluster = Mockito.mock(RelOptCluster.class);
	JournalledJdbcSchema schema = Mockito.mock(JournalledJdbcSchema.class);
	RelOptSchema relOptSchema = Mockito.mock(RelOptSchema.class);
	RexInputRef versionField = Mockito.mock(RexInputRef.class);
	RexInputRef subsequentVersionField = Mockito.mock(RexInputRef.class);

	Mockito.doReturn(Schema.TableType.TABLE).when(journalTable).getJdbcTableType();
	table = new JournalledJdbcTable("theView", schema, journalTable, new String[] {"key1", "key2"});
	table.relBuilderFactory = relBuilderFactory;

	Mockito.doReturn("myV").when(schema).getVersionField();
	Mockito.doReturn("mySV").when(schema).getSubsequentVersionField();
	Mockito.doReturn(relOptCluster).when(context).getCluster();
	Mockito.doReturn(relBuilder).when(relBuilderFactory).create(Mockito.same(relOptCluster), Mockito.same(relOptSchema));
	Mockito.doReturn(Mockito.mock(RelOptPlanner.class)).when(relOptCluster).getPlanner();
	Mockito.doReturn(relOptSchema).when(relOptTable).getRelOptSchema();
	Mockito.doReturn(ImmutableList.of("theSchema", "theView")).when(relOptTable).getQualifiedName();
	Mockito.doReturn(new SqlIdentifier(
			ImmutableList.of("wrongSchema", "theJournal"),
			null,
			new SqlParserPos(0, 0),
			null
	)).when(journalTable).tableName();
	Mockito.doReturn(versionField).when(relBuilder).field(Mockito.eq("myV"));
	Mockito.doReturn(subsequentVersionField).when(relBuilder).field(Mockito.eq("mySV"));
}
 

import org.apache.calcite.sql.parser.SqlParserPos; //导入依赖的package包/类
public static SqlNode createCondition(SqlNode left, SqlOperator op, SqlNode right) {

    // if one of the operands is null, return the other
    if (left == null || right == null) {
      return left != null ? left : right;
    }

    List<Object> listCondition = Lists.newArrayList();
    listCondition.add(left);
    listCondition.add(new SqlParserUtil.ToTreeListItem(op, SqlParserPos.ZERO));
    listCondition.add(right);

    return SqlParserUtil.toTree(listCondition);
  }
 

import org.apache.calcite.sql.parser.SqlParserPos; //导入依赖的package包/类
public SqlCreateView(SqlParserPos pos, SqlIdentifier viewName, SqlNodeList fieldList,
                     SqlNode query, boolean replaceView) {
  super(pos);
  this.viewName = viewName;
  this.query = query;
  this.replaceView = replaceView;
  this.fieldList = fieldList;
}
 

import org.apache.calcite.sql.parser.SqlParserPos; //导入依赖的package包/类
@Override
public List<SqlNode> getOperandList() {
  List<SqlNode> ops = Lists.newArrayList();
  ops.add(viewName);
  ops.add(fieldList);
  ops.add(query);
  ops.add(SqlLiteral.createBoolean(replaceView, SqlParserPos.ZERO));
  return ops;
}
 

import org.apache.calcite.sql.parser.SqlParserPos; //导入依赖的package包/类
public SqlTrainModel(SqlParserPos pos, SqlIdentifier mdlName, SqlNodeList fieldList, SqlNodeList partitionColumns, SqlNode query) {
  super(pos);
  this.mdlName = mdlName;
  this.fieldList = fieldList;
  this.partitionColumns = partitionColumns;
  this.query = query;
}
 

import org.apache.calcite.sql.parser.SqlParserPos; //导入依赖的package包/类
public SqlNode getAsCompoundIdentifier(){
  List<String> names = Lists.newArrayListWithCapacity(ids.size());
  List<SqlParserPos> pos = Lists.newArrayListWithCapacity(ids.size());
  for(int i =0; i < ids.size(); i++){
    IdentifierHolder holder = ids.get(i);
    names.add(holder.value);
    pos.add(holder.parserPos);
  }
  return new SqlIdentifier(names, null, pos.get(0), pos);
}