// implement RelDataType
public RelDataTypeField getField(String fieldName, boolean caseSensitive) {
for (RelDataTypeField field : fieldList) {
if (Util.match(caseSensitive, field.getName(), fieldName)) {
return field;
}
}
// Extra field
if (fieldList.size() > 0) {
final RelDataTypeField lastField = Iterables.getLast(fieldList);
if (lastField.getName().equals("_extra")) {
return new RelDataTypeFieldImpl(fieldName, -1, lastField.getType());
}
}
return null;
}
public static RelDataType createTypeFromProjection(
RelDataType type,
List<String> columnNameList,
RelDataTypeFactory typeFactory,
boolean caseSensitive) {
// If the names in columnNameList and type have case-sensitive differences,
// the resulting type will use those from type. These are presumably more
// canonical.
final List<RelDataTypeField> fields = new ArrayList<RelDataTypeField>(columnNameList.size());
for (String name : columnNameList) {
RelDataTypeField field = type.getField(name, caseSensitive);
fields.add(type.getFieldList().get(field.getIndex()));
}
return typeFactory.createStructType(fields);
}
/**
* Looks up a field with a given name, returning null if not found.
*
* @param rowType Row type
* @param columnName Field name
* @return Field, or null if not found
*/
public static RelDataTypeField lookupField(
boolean caseSensitive, final RelDataType rowType, String columnName) {
RelDataTypeField field = rowType.getField(columnName, caseSensitive);
if (field != null) {
return field;
}
// If record type is flagged as having "any field you ask for",
// return a type. (TODO: Better way to mark accommodating types.)
RelDataTypeField extra = RelDataTypeImpl.extra(rowType);
if (extra != null) {
return new RelDataTypeFieldImpl(columnName, -1, extra.getType());
}
return null;
}
private static List<RelCollation> deduceMonotonicity(Prepare.PreparingTable table) {
final List<RelCollation> collationList = new ArrayList<RelCollation>();
// Deduce which fields the table is sorted on.
int i = -1;
for (RelDataTypeField field : table.getRowType().getFieldList()) {
++i;
final SqlMonotonicity monotonicity = table.getMonotonicity(field.getName());
if (monotonicity != SqlMonotonicity.NotMonotonic) {
final RelFieldCollation.Direction direction =
monotonicity.isDecreasing()
? RelFieldCollation.Direction.Descending
: RelFieldCollation.Direction.Ascending;
collationList.add(
RelCollationImpl.of(
new RelFieldCollation(i, direction, RelFieldCollation.NullDirection.UNSPECIFIED)));
}
}
return collationList;
}
private List<RelCollation> deduceMonotonicity(SqlValidatorTable table) {
final RelDataType rowType = table.getRowType();
final List<RelCollation> collationList = new ArrayList<RelCollation>();
// Deduce which fields the table is sorted on.
int i = -1;
for (RelDataTypeField field : rowType.getFieldList()) {
++i;
final SqlMonotonicity monotonicity = table.getMonotonicity(field.getName());
if (monotonicity != SqlMonotonicity.NOT_MONOTONIC) {
final RelFieldCollation.Direction direction =
monotonicity.isDecreasing()
? RelFieldCollation.Direction.DESCENDING
: RelFieldCollation.Direction.ASCENDING;
collationList.add(
RelCollationImpl.of(
new RelFieldCollation(
i, direction, RelFieldCollation.NullDirection.UNSPECIFIED)));
}
}
return collationList;
}