org.apache.calcite.schema.ColumnStrategy Java Examples

@Override public ColumnStrategy generationStrategy(RelOptTable table,
    int iColumn) {
  final ModifiableViewTable viewTable =
      table.unwrap(ModifiableViewTable.class);
  assert iColumn < viewTable.columnMapping.size();

  // Use the view constraint to generate the default value if the column is
  // constrained.
  final int mappedOrdinal = viewTable.columnMapping.get(iColumn);
  final RexNode viewConstraint = projectMap.get(mappedOrdinal);
  if (viewConstraint != null) {
    return ColumnStrategy.DEFAULT;
  }

  // Otherwise use the default value of the underlying table.
  final Table schemaTable = viewTable.getTable();
  if (schemaTable instanceof Wrapper) {
    final InitializerExpressionFactory initializerExpressionFactory =
        ((Wrapper) schemaTable).unwrap(InitializerExpressionFactory.class);
    if (initializerExpressionFactory != null) {
      return initializerExpressionFactory.generationStrategy(table,
          iColumn);
    }
  }
  return super.generationStrategy(table, iColumn);
}
 

private void addStrategy(List<io.kareldb.schema.ColumnStrategy> strategies, ColumnStrategy strategy, SqlNode expression) {
    switch (strategy) {
        case NULLABLE:
            strategies.add(io.kareldb.schema.ColumnStrategy.NULL_STRATEGY);
            break;
        case NOT_NULLABLE:
            strategies.add(io.kareldb.schema.ColumnStrategy.NOT_NULL_STRATEGY);
            break;
        case DEFAULT:
            if (expression instanceof SqlLiteral) {
                strategies.add(new DefaultStrategy(((SqlLiteral) expression).getValue()));
            } else {
                strategies.add(io.kareldb.schema.ColumnStrategy.NOT_NULL_STRATEGY);
            }
            break;
        default:
            strategies.add(io.kareldb.schema.ColumnStrategy.NOT_NULL_STRATEGY);
            break;
    }
}
 

@Override public ColumnStrategy generationStrategy(RelOptTable table,
    int iColumn) {
  final ModifiableViewTable viewTable =
      table.unwrap(ModifiableViewTable.class);
  assert iColumn < viewTable.columnMapping.size();

  // Use the view constraint to generate the default value if the column is
  // constrained.
  final int mappedOrdinal = viewTable.columnMapping.get(iColumn);
  final RexNode viewConstraint = projectMap.get(mappedOrdinal);
  if (viewConstraint != null) {
    return ColumnStrategy.DEFAULT;
  }

  // Otherwise use the default value of the underlying table.
  final Table schemaTable = viewTable.getTable();
  if (schemaTable instanceof Wrapper) {
    final InitializerExpressionFactory initializerExpressionFactory =
        ((Wrapper) schemaTable).unwrap(InitializerExpressionFactory.class);
    if (initializerExpressionFactory != null) {
      return initializerExpressionFactory.generationStrategy(table,
          iColumn);
    }
  }
  return super.generationStrategy(table, iColumn);
}
 

private void addStrategy(List<io.kareldb.schema.ColumnStrategy> strategies, ColumnStrategy strategy, SqlNode expression) {
    switch (strategy) {
        case NULLABLE:
            strategies.add(io.kareldb.schema.ColumnStrategy.NULL_STRATEGY);
            break;
        case NOT_NULLABLE:
            strategies.add(io.kareldb.schema.ColumnStrategy.NOT_NULL_STRATEGY);
            break;
        case DEFAULT:
            if (expression instanceof SqlLiteral) {
                strategies.add(new DefaultStrategy(((SqlLiteral) expression).getValue()));
            } else {
                strategies.add(io.kareldb.schema.ColumnStrategy.NOT_NULL_STRATEGY);
            }
            break;
        default:
            strategies.add(io.kareldb.schema.ColumnStrategy.NOT_NULL_STRATEGY);
            break;
    }
}
 

/** Returns the row type of a table after any {@link ColumnStrategy#VIRTUAL}
 * columns have been removed. This is the type of the records that are
 * actually stored. */
public static RelDataType realRowType(RelOptTable table) {
  final RelDataType rowType = table.getRowType();
  final List<ColumnStrategy> strategies = columnStrategies(table);
  if (!strategies.contains(ColumnStrategy.VIRTUAL)) {
    return rowType;
  }
  final RelDataTypeFactory.Builder builder =
      table.getRelOptSchema().getTypeFactory().builder();
  for (RelDataTypeField field : rowType.getFieldList()) {
    if (strategies.get(field.getIndex()) != ColumnStrategy.VIRTUAL) {
      builder.add(field);
    }
  }
  return builder.build();
}
 

/** Helper for {@link #getColumnStrategies()}. */
public static List<ColumnStrategy> columnStrategies(final RelOptTable table) {
  final int fieldCount = table.getRowType().getFieldCount();
  final InitializerExpressionFactory ief =
      Util.first(table.unwrap(InitializerExpressionFactory.class),
          NullInitializerExpressionFactory.INSTANCE);
  return new AbstractList<ColumnStrategy>() {
    public int size() {
      return fieldCount;
    }

    public ColumnStrategy get(int index) {
      return ief.generationStrategy(table, index);
    }
  };
}
 

private ColumnDef(SqlNode expr, RelDataType type,
    ColumnStrategy strategy) {
  this.expr = expr;
  this.type = type;
  this.strategy = Objects.requireNonNull(strategy);
  Preconditions.checkArgument(
      strategy == ColumnStrategy.NULLABLE
          || strategy == ColumnStrategy.NOT_NULLABLE
          || expr != null);
}
 

@Override public ColumnStrategy generationStrategy(RelOptTable table,
    int iColumn) {
  switch (iColumn) {
  case 0:
  case 1:
  case 5:
    return ColumnStrategy.DEFAULT;
  default:
    return super.generationStrategy(table, iColumn);
  }
}
 

@Override public ColumnStrategy generationStrategy(RelOptTable table, int iColumn) {
  switch (iColumn) {
  case 3:
    return ColumnStrategy.STORED;
  case 4:
    return ColumnStrategy.VIRTUAL;
  default:
    return super.generationStrategy(table, iColumn);
  }
}
 

@Override public ColumnStrategy generationStrategy(RelOptTable table,
    int iColumn) {
  final RelDataTypeField field =
      table.getRowType().getFieldList().get(iColumn);
  if (defaultColumns.contains(field.getName())) {
    return ColumnStrategy.DEFAULT;
  }
  return super.generationStrategy(table, iColumn);
}
 

/** Creates a SqlColumnDeclaration; use {@link SqlDdlNodes#column}. */
SqlColumnDeclaration(SqlParserPos pos, SqlIdentifier name,
    SqlDataTypeSpec dataType, SqlNode expression,
    ColumnStrategy strategy) {
  super(pos);
  this.name = name;
  this.dataType = dataType;
  this.expression = expression;
  this.strategy = strategy;
}
 

/** Converts the ordinal of a field into the ordinal of a stored field.
 * That is, it subtracts the number of virtual fields that come before it. */
public static int realOrdinal(final RelOptTable table, int i) {
  List<ColumnStrategy> strategies = table.getColumnStrategies();
  int n = 0;
  for (int j = 0; j < i; j++) {
    switch (strategies.get(j)) {
    case VIRTUAL:
      ++n;
    }
  }
  return i - n;
}
 

/**
 * Creates a SqlColumnDeclaration.
 */
public SqlColumnDeclaration(SqlParserPos pos, SqlIdentifier name,
                            SqlDataTypeSpec dataType, SqlNode expression) {
  super(pos);
  this.name = name;
  this.dataType = dataType;
  this.expression = expression;
  this.strategy = ColumnStrategy.NULLABLE;
}
 

private ColumnDef(SqlNode expr, RelDataType type,
                  ColumnStrategy strategy) {
    this.expr = expr;
    this.type = type;
    this.strategy = Objects.requireNonNull(strategy);
    Preconditions.checkArgument(
        strategy == ColumnStrategy.NULLABLE
            || strategy == ColumnStrategy.NOT_NULLABLE
            || expr != null);
}
 

private ColumnDef(SqlNode expr, RelDataType type,
                  ColumnStrategy strategy) {
    this.expr = expr;
    this.type = type;
    this.strategy = Objects.requireNonNull(strategy);
    Preconditions.checkArgument(
        strategy == ColumnStrategy.NULLABLE
            || strategy == ColumnStrategy.NOT_NULLABLE
            || expr != null);
}
 

public ColumnStrategy generationStrategy(RelOptTable table, int iColumn) {
  return table.getRowType().getFieldList().get(iColumn).getType().isNullable()
      ? ColumnStrategy.NULLABLE
      : ColumnStrategy.NOT_NULLABLE;
}
 

public ColumnStrategy generationStrategy(RelOptTable table, int iColumn) {
  return table.getRowType().getFieldList().get(iColumn).getType().isNullable()
      ? ColumnStrategy.NULLABLE
      : ColumnStrategy.NOT_NULLABLE;
}
 

public List<ColumnStrategy> getColumnStrategies() {
  return RelOptTableImpl.columnStrategies(this);
}
 

public List<ColumnStrategy> getColumnStrategies() {
  return parent.getColumnStrategies();
}
 

public List<ColumnStrategy> getColumnStrategies() {
  throw new UnsupportedOperationException();
}
 

public List<ColumnStrategy> getColumnStrategies() {
  return RelOptTableImpl.columnStrategies(this);
}
 

/** Creates a column declaration. */
public static SqlNode column(SqlParserPos pos, SqlIdentifier name,
    SqlDataTypeSpec dataType, SqlNode expression, ColumnStrategy strategy) {
  return new SqlColumnDeclaration(pos, name, dataType, expression, strategy);
}
 

static ColumnDef of(SqlNode expr, RelDataType type,
                    ColumnStrategy strategy) {
    return new ColumnDef(expr, type, strategy);
}
 

@Override
public List<ColumnStrategy> getColumnStrategies() {
  return relOptTable.getColumnStrategies();
}
 

public List<ColumnStrategy> getColumnStrategies() {
  return RelOptTableImpl.columnStrategies(AbstractPreparingTable.this);
}
 

static ColumnDef of(SqlNode expr, RelDataType type,
                    ColumnStrategy strategy) {
    return new ColumnDef(expr, type, strategy);
}
 

@Override
public List<ColumnStrategy> getColumnStrategies() {
  return ImmutableList.of();
}
 

static ColumnDef of(SqlNode expr, RelDataType type,
    ColumnStrategy strategy) {
  return new ColumnDef(expr, type, strategy);
}
 

@Override
public List<ColumnStrategy> getColumnStrategies() {
  return ImmutableList.of();
}
 

@Override
public List<ColumnStrategy> getColumnStrategies() {
  return ImmutableList.of();
}