Refine search
@Test public void testCBOMaxNumToCNF1() { // OR(=($0, 1), AND(=($0, 0), =($1, 8))) // transformation creates 7 nodes AND(OR(=($0, 1), =($0, 0)), OR(=($0, 1), =($1, 8))) // thus, it is triggered final RelDataTypeFactory typeFactory = new JavaTypeFactoryImpl(); final RexBuilder rexBuilder = new RexBuilder(typeFactory); final RexNode cond = rexBuilder.makeCall(SqlStdOperatorTable.OR, rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, rexBuilder.makeInputRef(typeFactory.createSqlType(SqlTypeName.INTEGER), 0), rexBuilder.makeLiteral(1, typeFactory.createSqlType(SqlTypeName.INTEGER), false)), rexBuilder.makeCall(SqlStdOperatorTable.AND, rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, rexBuilder.makeInputRef(typeFactory.createSqlType(SqlTypeName.INTEGER), 0), rexBuilder.makeLiteral(0, typeFactory.createSqlType(SqlTypeName.INTEGER), false)), rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, rexBuilder.makeInputRef(typeFactory.createSqlType(SqlTypeName.INTEGER), 1), rexBuilder.makeLiteral(8, typeFactory.createSqlType(SqlTypeName.INTEGER), false)))); final RexNode newCond = RexUtil.toCnf(rexBuilder, maxNumNodesCNF, cond); assertEquals(newCond.toString(), "AND(OR(=($0, 1), =($0, 0)), OR(=($0, 1), =($1, 8)))"); }
@Override public RelDataType toSql(RelDataType type) { if (type instanceof JavaType) { JavaType javaType = (JavaType) type; SqlTypeName sqlTypeName = JavaToSqlTypeConversionRules.instance().lookup(javaType.getJavaClass()); if (sqlTypeName == null) { sqlTypeName = SqlTypeName.ANY; } return createTypeWithNullability(createSqlType(sqlTypeName), type.isNullable()); } return super.toSql(type); } }
@Before public void before() { HepProgramBuilder programBuilder = new HepProgramBuilder(); programBuilder.addRuleInstance(new HivePointLookupOptimizerRule.FilterCondition(2)); planner = new HepPlanner(programBuilder.build()); JavaTypeFactoryImpl typeFactory = new JavaTypeFactoryImpl(); RexBuilder rexBuilder = new RexBuilder(typeFactory); final RelOptCluster optCluster = RelOptCluster.create(planner, rexBuilder); RelDataType rowTypeMock = typeFactory.createStructType(MyRecord.class); Mockito.doReturn(rowTypeMock).when(tableMock).getRowType(); Mockito.doReturn(tableMock).when(schemaMock).getTableForMember(Matchers.any()); Mockito.doReturn(hiveTableMDMock).when(tableMock).getHiveTableMD(); builder = HiveRelFactories.HIVE_BUILDER.create(optCluster, schemaMock); }
checkSatisfiable(rexBuilder.makeLiteral(true), "true"); checkNotSatisfiable(rexBuilder.makeLiteral(false)); rexBuilder.makeCall( SqlStdOperatorTable.EQUALS, rexBuilder.makeInputRef( typeFactory.createType(int.class), 0), rexBuilder.makeExactLiteral(BigDecimal.ZERO)); SqlStdOperatorTable.EQUALS, rexBuilder.makeInputRef( typeFactory.createType(int.class), 1), rexBuilder.makeExactLiteral(BigDecimal.ONE)); rexBuilder.makeInputRef( typeFactory.createType(boolean.class), 2); rexBuilder.makeInputRef( typeFactory.createType(boolean.class), 3); rexBuilder.makeInputRef( typeFactory.createType(boolean.class), 4);
final BlockBuilder builder = new BlockBuilder(); final JavaTypeFactoryImpl javaTypeFactory = new JavaTypeFactoryImpl(rexBuilder.getTypeFactory().getTypeSystem());
final JavaTypeFactoryImpl typeFactory = new JavaTypeFactoryImpl(TYPE_SYSTEM);
public void setUp() { typeFactory = new JavaTypeFactoryImpl(RelDataTypeSystem.DEFAULT); rexBuilder = new RexBuilder(typeFactory); executor = new RexExecutorImpl(new DummyTestDataContext()); simplify = new RexSimplify(rexBuilder, RelOptPredicateList.EMPTY, executor) .withParanoid(true); trueLiteral = rexBuilder.makeLiteral(true); falseLiteral = rexBuilder.makeLiteral(false); nonNullableInt = typeFactory.createSqlType(SqlTypeName.INTEGER); nullableInt = typeFactory.createTypeWithNullability(nonNullableInt, true); nullInt = rexBuilder.makeNullLiteral(nullableInt); nonNullableBool = typeFactory.createSqlType(SqlTypeName.BOOLEAN); nullableBool = typeFactory.createTypeWithNullability(nonNullableBool, true); nullBool = rexBuilder.makeNullLiteral(nullableBool); nonNullableVarchar = typeFactory.createSqlType(SqlTypeName.VARCHAR); nullableVarchar = typeFactory.createTypeWithNullability(nonNullableVarchar, true); nullVarchar = rexBuilder.makeNullLiteral(nullableVarchar); }
private static RelNode createTableScan(Table viewTable) { final RexBuilder rexBuilder = new RexBuilder(new JavaTypeFactoryImpl()); final RelOptCluster cluster = RelOptCluster.create(planner, rexBuilder);
@Test public void testProjectPermutation() { final RelDataTypeFactory typeFactory = new JavaTypeFactoryImpl(); final RexBuilder builder = new RexBuilder(typeFactory); final RelDataType doubleType = typeFactory.createSqlType(SqlTypeName.DOUBLE); // A project with [1, 1] is not a permutation, so should return null final Permutation perm = Project.getPermutation(2, ImmutableList.of(builder.makeInputRef(doubleType, 1), builder.makeInputRef(doubleType, 1))); assertThat(perm, nullValue()); // A project with [0, 1, 0] is not a permutation, so should return null final Permutation perm1 = Project.getPermutation(2, ImmutableList.of(builder.makeInputRef(doubleType, 0), builder.makeInputRef(doubleType, 1), builder.makeInputRef(doubleType, 0))); assertThat(perm1, nullValue()); // A project of [1, 0] is a valid permutation! final Permutation perm2 = Project.getPermutation(2, ImmutableList.of(builder.makeInputRef(doubleType, 1), builder.makeInputRef(doubleType, 0))); assertThat(perm2, is(new Permutation(new int[]{1, 0}))); } }
@Before public void setUp() { typeFactory = new JavaTypeFactoryImpl(RelDataTypeSystem.DEFAULT); rexBuilder = new RexBuilder(typeFactory); boolRelDataType = typeFactory.createSqlType(SqlTypeName.BOOLEAN); x = new RexInputRef( 0, typeFactory.createTypeWithNullability(boolRelDataType, true)); y = new RexInputRef( 1, typeFactory.createTypeWithNullability(boolRelDataType, true)); z = new RexInputRef( 2, typeFactory.createTypeWithNullability(boolRelDataType, true)); trueRex = rexBuilder.makeLiteral(true); falseRex = rexBuilder.makeLiteral(false); }
@Test public void testBetweenFilterStringCase() throws IOException { final Fixture f = new Fixture(); final List<RexNode> listRexNodes = ImmutableList.of(f.rexBuilder.makeLiteral(false), f.rexBuilder.makeInputRef(f.varcharRowType, 0), f.rexBuilder.makeLiteral("lower-bound"), f.rexBuilder.makeLiteral("upper-bound")); RelDataType relDataType = f.typeFactory.createSqlType(SqlTypeName.BOOLEAN); RexNode betweenRexNode = f.rexBuilder.makeCall(relDataType, SqlStdOperatorTable.BETWEEN, listRexNodes); DruidJsonFilter returnValue = DruidJsonFilter .toDruidFilters(betweenRexNode, f.varcharRowType, druidQuery); Assert.assertNotNull("Filter is null", returnValue); JsonFactory jsonFactory = new JsonFactory(); final StringWriter sw = new StringWriter(); JsonGenerator jsonGenerator = jsonFactory.createGenerator(sw); returnValue.write(jsonGenerator); jsonGenerator.close(); Assert.assertThat(sw.toString(), is("{\"type\":\"bound\",\"dimension\":\"dimensionName\",\"lower\":\"lower-bound\"," + "\"lowerStrict\":false,\"upper\":\"upper-bound\",\"upperStrict\":false," + "\"ordering\":\"lexicographic\"}")); }
private static RelNode createMaterializedViewScan(HiveConf conf, Table viewTable) { final RexBuilder rexBuilder = new RexBuilder( new JavaTypeFactoryImpl( new HiveTypeSystemImpl())); final RelOptCluster cluster = RelOptCluster.create(planner, rexBuilder); RelDataTypeFactory dtFactory = cluster.getRexBuilder().getTypeFactory(); for (RelDataTypeField field : rowType.getFieldList()) { if (DruidTable.DEFAULT_TIMESTAMP_COLUMN.equals(field.getName())) {
@Test public void testLoadSorted() { final JavaTypeFactoryImpl typeFactory = new JavaTypeFactoryImpl(RelDataTypeSystem.DEFAULT); final RelDataType rowType = typeFactory.builder() .add("empid", typeFactory.createType(int.class)) .add("deptno", typeFactory.createType(int.class)) .add("name", typeFactory.createType(String.class)) .build(); final Enumerable<Object[]> enumerable =
final Types.ArrayType arrayType = (Types.ArrayType) type; final RelDataType componentRelType = createType(arrayType.getComponentType()); return createArrayType( createTypeWithNullability(componentRelType, arrayType.componentIsNullable()), arrayType.maximumCardinality()); final RelDataType keyRelType = createType(mapType.getKeyType()); final RelDataType valueRelType = createType(mapType.getValueType()); return createMapType( createTypeWithNullability(keyRelType, mapType.keyIsNullable()), createTypeWithNullability(valueRelType, mapType.valueIsNullable())); switch (Primitive.flavor(clazz)) { case PRIMITIVE: return createJavaType(clazz); case BOX: return createJavaType(Primitive.ofBox(clazz).boxClass); return createJavaType(clazz); } else if (clazz.isArray()) { return createMultisetType( createType(clazz.getComponentType()), -1); } else if (List.class.isAssignableFrom(clazz)) { return createArrayType( createTypeWithNullability(createSqlType(SqlTypeName.ANY), true), -1); } else if (Map.class.isAssignableFrom(clazz)) { return createMapType( createTypeWithNullability(createSqlType(SqlTypeName.ANY), true),
JavaTypeFactoryImpl javaTypeFactory = new JavaTypeFactoryImpl(); for (JsonColumn column : columns) { String[] array = column.name.split(":", -1); names.add(array[0]); types.add(javaTypeFactory.getDataType(relDataTypeFactory, array[1]));
public RelDataType createStructType(Class type) { final List<RelDataTypeField> list = new ArrayList<>(); for (Field field : type.getFields()) { if (!Modifier.isStatic(field.getModifiers())) { // FIXME: watch out for recursion final Type fieldType = fieldType(field); list.add( new RelDataTypeFieldImpl( field.getName(), list.size(), createType(fieldType))); } } return canonize(new JavaRecordType(list, type)); }
@Override public RelDataType createSqlType(SqlTypeName typeName, int precision) { switch (typeName) { case TIME: case TIMESTAMP: return super.createSqlType(typeName, RelDataTypeSystemImpl.SUPPORTED_DATETIME_PRECISION); default: return super.createSqlType(typeName, precision); } }
checkSatisfiable(rexBuilder.makeLiteral(true), "true"); checkNotSatisfiable(rexBuilder.makeLiteral(false)); rexBuilder.makeCall( SqlStdOperatorTable.EQUALS, rexBuilder.makeInputRef( typeFactory.createType(int.class), 0), rexBuilder.makeExactLiteral(BigDecimal.ZERO)); SqlStdOperatorTable.EQUALS, rexBuilder.makeInputRef( typeFactory.createType(int.class), 1), rexBuilder.makeExactLiteral(BigDecimal.ONE)); rexBuilder.makeInputRef( typeFactory.createType(boolean.class), 2); rexBuilder.makeInputRef( typeFactory.createType(boolean.class), 3); rexBuilder.makeInputRef( typeFactory.createType(boolean.class), 4);
/** * Creates an {@link RexExecutable} that allows to apply the * generated code during query processing (filter, projection). * * @param rexBuilder Rex builder * @param exps Expressions * @param rowType describes the structure of the input row. */ public RexExecutable getExecutable(RexBuilder rexBuilder, List<RexNode> exps, RelDataType rowType) { final JavaTypeFactoryImpl typeFactory = new JavaTypeFactoryImpl(rexBuilder.getTypeFactory().getTypeSystem()); final InputGetter getter = new DataContextInputGetter(rowType, typeFactory); final String code = compile(rexBuilder, exps, getter, rowType); return new RexExecutable(code, "generated Rex code"); }
/** * Translate a field access, possibly through a projection, to an underlying Druid dataSource. * * @param rowSignature row signature of underlying Druid dataSource * @param project projection, or null * @param fieldNumber number of the field to access * * @return row expression */ public static RexNode fromFieldAccess( final RowSignature rowSignature, final Project project, final int fieldNumber ) { if (project == null) { // I don't think the factory impl matters here. return RexInputRef.of(fieldNumber, rowSignature.getRelDataType(new JavaTypeFactoryImpl())); } else { return project.getChildExps().get(fieldNumber); } }