@Override protected Collection<TableInSchema> initialTables() { final List<TableInSchema> list = new ArrayList<TableInSchema>(); final RelDataType mapType = typeFactory.createMapType( typeFactory.createSqlType(SqlTypeName.VARCHAR), typeFactory.createSqlType(SqlTypeName.ANY)); final RelDataType rowType = typeFactory.createStructType( new RelDataTypeFactory.FieldInfoBuilder().add("_MAP", mapType)); for (String collection : mongoDb.getCollectionNames()) { final MongoTable table = new MongoTable(this, collection, rowType); list.add( new TableInSchemaImpl(this, collection, TableType.TABLE, table)); } return list; } }
public RelDataType getRowType(RelDataTypeFactory typeFactory) { return ((JavaTypeFactory) typeFactory).createType(elementType); }
static Type javaClass( JavaTypeFactory typeFactory, RelDataType type) { final Type clazz = typeFactory.getJavaClass(type); return clazz instanceof Class ? clazz : Object[].class; }
public RelDataType nullifyType(RelDataType type, boolean nullable) { if (!nullable) { final Primitive primitive = javaPrimitive(type); if (primitive != null) { return typeFactory.createJavaType(primitive.primitiveClass); } } return typeFactory.createTypeWithNullability(type, nullable); }
/** Creates a RangeTable. */ public static RangeTable create( Schema schema, String tableName, String columnName, int start, int end) { final JavaTypeFactory typeFactory = schema.getTypeFactory(); final RelDataType integerType = typeFactory.createSqlType(SqlTypeName.INTEGER); final RelDataType rowType = typeFactory.createStructType( RelDataTypeFactory.FieldInfoBuilder .of(columnName, integerType)); return new RangeTable( schema, Object[].class, rowType, tableName, start, end); }
x = context.getTypeFactory().createType(elementType); preparedResult = preparingStmt.prepareQueryable(queryable, x); false, null, (Class) typeFactory.getJavaClass( x.isStruct() ? x.getFieldList().get(pair.i).getType()
private RelDataType getRelDataType( Connection connection, String catalogName, String schemaName, String tableName) throws SQLException { DatabaseMetaData metaData = connection.getMetaData(); final ResultSet resultSet = metaData.getColumns(catalogName, schemaName, tableName, null); final RelDataTypeFactory.FieldInfoBuilder fieldInfo = new RelDataTypeFactory.FieldInfoBuilder(); while (resultSet.next()) { final String columnName = resultSet.getString(4); final int dataType = resultSet.getInt(5); final int size = resultSet.getInt(7); final int scale = resultSet.getInt(9); RelDataType sqlType = zzz(dataType, size, scale); boolean nullable = resultSet.getBoolean(11); if (nullable) { sqlType = typeFactory.createTypeWithNullability(sqlType, true); } fieldInfo.add(columnName, sqlType); } resultSet.close(); return typeFactory.createStructType(fieldInfo); }
static PhysType of( final JavaTypeFactory typeFactory, Type javaRowClass) { final RelDataTypeFactory.FieldInfoBuilder builder = typeFactory.builder(); if (javaRowClass instanceof Types.RecordType) { final Types.RecordType recordType = (Types.RecordType) javaRowClass; for (Types.RecordField field : recordType.getRecordFields()) { builder.add(field.getName(), typeFactory.createType(field.getType())); } } RelDataType rowType = builder.build(); // Do not optimize if there are 0 or 1 fields. return new PhysTypeImpl( typeFactory, rowType, javaRowClass, JavaRowFormat.CUSTOM); }
public PhysType project(List<Integer> integers, JavaRowFormat format) { RelDataType projectedRowType = typeFactory.createStructType( Lists.transform(integers, new Function<Integer, RelDataTypeField>() { public RelDataTypeField apply(Integer index) { return rowType.getFieldList().get(index); } })); return of(typeFactory, projectedRowType, format.optimize(projectedRowType)); }
final RelDataType intType = typeFactory.createSqlType(SqlTypeName.INTEGER); final RelDataType rowType = typeFactory.builder() .add("a", intType) .add("b", intType)
private RelDataType zzz(int dataType, int precision, int scale) { SqlTypeName sqlTypeName = SqlTypeName.getNameForJdbcType(dataType); if (precision >= 0 && scale >= 0 && sqlTypeName.allowsPrecScale(true, true)) { return typeFactory.createSqlType(sqlTypeName, precision, scale); } else if (precision >= 0 && sqlTypeName.allowsPrecNoScale()) { return typeFactory.createSqlType(sqlTypeName, precision); } else { assert sqlTypeName.allowsNoPrecNoScale(); return typeFactory.createSqlType(sqlTypeName); } }
@Override protected RelDataType getLogicalSourceRowType( RelDataType sourceRowType, SqlInsert insert) { return ((JavaTypeFactory) typeFactory).toSql(sourceRowType); }
/** Quickly prepares a simple SQL statement, circumventing the usual * preparation process. */ private <T> PrepareResult<T> simplePrepare(Context context, String sql) { final JavaTypeFactory typeFactory = context.getTypeFactory(); final RelDataType x = typeFactory.builder().add("EXPR$0", SqlTypeName.INTEGER).build(); @SuppressWarnings("unchecked") final List<T> list = (List) ImmutableList.of(1); final List<String> origin = null; final List<List<String>> origins = Collections.nCopies(x.getFieldCount(), origin); return new PrepareResult<T>( sql, ImmutableList.<AvaticaParameter>of(), x, getColumnMetaDataList(typeFactory, x, x, origins), -1, new Bindable<T>() { public Enumerable<T> bind(DataContext dataContext) { return Linq4j.asEnumerable(list); } }, Integer.class); }
RelOptTableImpl.create( null, typeFactory.createJavaType( Types.toClass( Types.getElementType(call.targetExpression.getType()))), RelOptTableImpl.create( null, typeFactory.createJavaType((Class) ((ConstantExpression) call.expressions.get(1)).value), ImmutableList.<String>of(),
PhysTypeImpl.of( typeFactory, typeFactory.createSyntheticType(aggStateTypes));
public PhysType makeNullable(boolean nullable) { if (!nullable) { return this; } return new PhysTypeImpl(typeFactory, typeFactory.createTypeWithNullability(rowType, true), Primitive.box(javaRowClass), format); }
List<RelDataType> types = Arrays.asList( typeFactory.createSqlType(SqlTypeName.INTEGER), typeFactory.createSqlType(SqlTypeName.INTEGER)); List<String> names = Arrays.asList("x", "y"); RelDataType inputRowType = typeFactory.createStructType(types, names); final RexProgramBuilder builder = new RexProgramBuilder(inputRowType, rexBuilder);
public PhysType project( final List<Integer> integers, JavaRowFormat format) { RelDataType projectedRowType = typeFactory.createStructType( new AbstractList<Map.Entry<String, RelDataType>>() { public Map.Entry<String, RelDataType> get(int index) { return rowType.getFieldList().get(index); } public int size() { return integers.size(); } } ); return of(typeFactory, projectedRowType, format.optimize(projectedRowType)); }
public RelDataType nullifyType(RelDataType type, boolean nullable) { if (!nullable) { final Primitive primitive = javaPrimitive(type); if (primitive != null) { return typeFactory.createJavaType(primitive.primitiveClass); } } return typeFactory.createTypeWithNullability(type, nullable); }
@Override protected RelDataType getLogicalTargetRowType( RelDataType targetRowType, SqlInsert insert) { return ((JavaTypeFactory) typeFactory).toSql(targetRowType); } }