本文整理汇总了Java中org.apache.calcite.adapter.enumerable.EnumerableConvention类的典型用法代码示例。如果您正苦于以下问题:Java EnumerableConvention类的具体用法?Java EnumerableConvention怎么用?Java EnumerableConvention使用的例子?那么恭喜您, 这里精选的类代码示例或许可以为您提供帮助。
EnumerableConvention类属于org.apache.calcite.adapter.enumerable包,在下文中一共展示了EnumerableConvention类的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Java代码示例。
示例1: create
import org.apache.calcite.adapter.enumerable.EnumerableConvention; //导入依赖的package包/类
/** Creates an DirPrunedEnumerableTableScan. */
public static EnumerableTableScan create(RelOptCluster cluster,
RelOptTable relOptTable, String digestFromSelection) {
final Table table = relOptTable.unwrap(Table.class);
Class elementType = EnumerableTableScan.deduceElementType(table);
final RelTraitSet traitSet =
cluster.traitSetOf(EnumerableConvention.INSTANCE)
.replaceIfs(RelCollationTraitDef.INSTANCE,
new Supplier<List<RelCollation>>() {
public List<RelCollation> get() {
if (table != null) {
return table.getStatistic().getCollations();
}
return ImmutableList.of();
}
});
return new DirPrunedEnumerableTableScan(cluster, traitSet, relOptTable, elementType, digestFromSelection);
}
示例2: plan
import org.apache.calcite.adapter.enumerable.EnumerableConvention; //导入依赖的package包/类
public RelNode plan(String sql) {
try {
// hack to capitalize group by columns...not sure why the parser complains if the group by columns
// are not capitalized
final int groupByIndex = sql.toLowerCase().indexOf("group by");
if(groupByIndex > -1) {
final String firstPart = sql.substring(0, groupByIndex + "group by".length());
final String groupPart = sql.substring(groupByIndex + "group by".length(), sql.length());
sql = firstPart + groupPart.toUpperCase();
// from index
final int fromIndex = sql.toLowerCase().indexOf("from");
sql = sql.substring(0, fromIndex).toUpperCase() + sql.substring(fromIndex, sql.length());
}
final SqlNode parse = planner.parse(sql);
final SqlNode validate = planner.validate(parse);
final RelNode convert = planner.convert(validate);
final RelTraitSet traitSet = planner.getEmptyTraitSet()
.replace(EnumerableConvention.INSTANCE);
final RelNode transform = planner.transform(0, traitSet, convert);
return transform;
} catch (Exception e) {
throw new ParseException("Error parsing: " + sql, e);
}
}
示例3: runProjectQueryWithLex
import org.apache.calcite.adapter.enumerable.EnumerableConvention; //导入依赖的package包/类
private static void runProjectQueryWithLex(Lex lex, String sql)
throws SqlParseException, ValidationException, RelConversionException {
Config javaLex = SqlParser.configBuilder().setLex(lex).build();
Planner planner = getPlanner(null, javaLex, Programs.ofRules(Programs.RULE_SET));
SqlNode parse = planner.parse(sql);
SqlNode validate = planner.validate(parse);
RelNode convert = planner.rel(validate).rel;
RelTraitSet traitSet =
planner.getEmptyTraitSet().replace(EnumerableConvention.INSTANCE);
RelNode transform = planner.transform(0, traitSet, convert);
assertThat(transform, instanceOf(EnumerableProject.class));
List<String> fieldNames = transform.getRowType().getFieldNames();
assertThat(fieldNames.size(), is(2));
if (lex.caseSensitive) {
assertThat(fieldNames.get(0), is("EMPID"));
assertThat(fieldNames.get(1), is("empid"));
} else {
assertThat(fieldNames.get(0) + "-" + fieldNames.get(1),
anyOf(is("EMPID-empid0"), is("EMPID0-empid")));
}
}
示例4: testPlan
import org.apache.calcite.adapter.enumerable.EnumerableConvention; //导入依赖的package包/类
/** Unit test that parses, validates, converts and plans. */
@Test public void testPlan() throws Exception {
Program program =
Programs.ofRules(
FilterMergeRule.INSTANCE,
EnumerableRules.ENUMERABLE_FILTER_RULE,
EnumerableRules.ENUMERABLE_PROJECT_RULE);
Planner planner = getPlanner(null, program);
SqlNode parse = planner.parse("select * from \"emps\"");
SqlNode validate = planner.validate(parse);
RelNode convert = planner.rel(validate).project();
RelTraitSet traitSet = planner.getEmptyTraitSet()
.replace(EnumerableConvention.INSTANCE);
RelNode transform = planner.transform(0, traitSet, convert);
assertThat(toString(transform),
equalTo(
"EnumerableProject(empid=[$0], deptno=[$1], name=[$2], salary=[$3], commission=[$4])\n"
+ " EnumerableTableScan(table=[[hr, emps]])\n"));
}
示例5: testSortPlan
import org.apache.calcite.adapter.enumerable.EnumerableConvention; //导入依赖的package包/类
/** Unit test that parses, validates, converts and
* plans for query using order by */
@Test public void testSortPlan() throws Exception {
RuleSet ruleSet =
RuleSets.ofList(
SortRemoveRule.INSTANCE,
EnumerableRules.ENUMERABLE_PROJECT_RULE,
EnumerableRules.ENUMERABLE_SORT_RULE);
Planner planner = getPlanner(null, Programs.of(ruleSet));
SqlNode parse = planner.parse(
"select * from \"emps\" "
+ "order by \"emps\".\"deptno\"");
SqlNode validate = planner.validate(parse);
RelNode convert = planner.rel(validate).project();
RelTraitSet traitSet = convert.getTraitSet()
.replace(EnumerableConvention.INSTANCE);
RelNode transform = planner.transform(0, traitSet, convert);
assertThat(toString(transform),
equalTo("EnumerableSort(sort0=[$1], dir0=[ASC])\n"
+ " EnumerableProject(empid=[$0], deptno=[$1], name=[$2], salary=[$3], commission=[$4])\n"
+ " EnumerableTableScan(table=[[hr, emps]])\n"));
}
示例6: runDuplicateSortCheck
import org.apache.calcite.adapter.enumerable.EnumerableConvention; //导入依赖的package包/类
private void runDuplicateSortCheck(String sql, String plan) throws Exception {
RuleSet ruleSet =
RuleSets.ofList(
SortRemoveRule.INSTANCE,
EnumerableRules.ENUMERABLE_PROJECT_RULE,
EnumerableRules.ENUMERABLE_WINDOW_RULE,
EnumerableRules.ENUMERABLE_SORT_RULE,
ProjectToWindowRule.PROJECT);
Planner planner = getPlanner(null,
SqlParser.configBuilder().setLex(Lex.JAVA).build(),
Programs.of(ruleSet));
SqlNode parse = planner.parse(sql);
SqlNode validate = planner.validate(parse);
RelNode convert = planner.rel(validate).rel;
RelTraitSet traitSet = planner.getEmptyTraitSet()
.replace(EnumerableConvention.INSTANCE);
if (traitSet.getTrait(RelCollationTraitDef.INSTANCE) == null) {
// SortRemoveRule can only work if collation trait is enabled.
return;
}
RelNode transform = planner.transform(0, traitSet, convert);
assertThat(toString(transform), equalTo(plan));
}
示例7: testDuplicateSortPlanWORemoveSortRule
import org.apache.calcite.adapter.enumerable.EnumerableConvention; //导入依赖的package包/类
/** Unit test that parses, validates, converts and
* plans for query using two duplicate order by.*/
@Test public void testDuplicateSortPlanWORemoveSortRule() throws Exception {
RuleSet ruleSet =
RuleSets.ofList(
EnumerableRules.ENUMERABLE_PROJECT_RULE,
EnumerableRules.ENUMERABLE_SORT_RULE);
Planner planner = getPlanner(null, Programs.of(ruleSet));
SqlNode parse = planner.parse(
"select \"empid\" from ( "
+ "select * "
+ "from \"emps\" "
+ "order by \"emps\".\"deptno\") "
+ "order by \"deptno\"");
SqlNode validate = planner.validate(parse);
RelNode convert = planner.rel(validate).rel;
RelTraitSet traitSet = planner.getEmptyTraitSet()
.replace(EnumerableConvention.INSTANCE);
RelNode transform = planner.transform(0, traitSet, convert);
assertThat(toString(transform),
equalTo("EnumerableSort(sort0=[$1], dir0=[ASC])\n"
+ " EnumerableProject(empid=[$0], deptno=[$1])\n"
+ " EnumerableSort(sort0=[$1], dir0=[ASC])\n"
+ " EnumerableProject(empid=[$0], deptno=[$1], name=[$2], salary=[$3], commission=[$4])\n"
+ " EnumerableTableScan(table=[[hr, emps]])\n"));
}
示例8: testPlanWithExplicitTraitDefs
import org.apache.calcite.adapter.enumerable.EnumerableConvention; //导入依赖的package包/类
/** Unit test that parses, validates, converts and plans. Planner is
* provided with a list of RelTraitDefs to register. */
@Test public void testPlanWithExplicitTraitDefs() throws Exception {
RuleSet ruleSet =
RuleSets.ofList(
FilterMergeRule.INSTANCE,
EnumerableRules.ENUMERABLE_FILTER_RULE,
EnumerableRules.ENUMERABLE_PROJECT_RULE);
final List<RelTraitDef> traitDefs = new ArrayList<>();
traitDefs.add(ConventionTraitDef.INSTANCE);
traitDefs.add(RelCollationTraitDef.INSTANCE);
Planner planner = getPlanner(traitDefs, Programs.of(ruleSet));
SqlNode parse = planner.parse("select * from \"emps\"");
SqlNode validate = planner.validate(parse);
RelNode convert = planner.rel(validate).project();
RelTraitSet traitSet = planner.getEmptyTraitSet()
.replace(EnumerableConvention.INSTANCE);
RelNode transform = planner.transform(0, traitSet, convert);
assertThat(toString(transform),
equalTo(
"EnumerableProject(empid=[$0], deptno=[$1], name=[$2], salary=[$3], commission=[$4])\n"
+ " EnumerableTableScan(table=[[hr, emps]])\n"));
}
示例9: testPlanTransformTwice
import org.apache.calcite.adapter.enumerable.EnumerableConvention; //导入依赖的package包/类
/** Unit test that calls {@link Planner#transform} twice. */
@Test public void testPlanTransformTwice() throws Exception {
RuleSet ruleSet =
RuleSets.ofList(
FilterMergeRule.INSTANCE,
EnumerableRules.ENUMERABLE_FILTER_RULE,
EnumerableRules.ENUMERABLE_PROJECT_RULE);
Planner planner = getPlanner(null, Programs.of(ruleSet));
SqlNode parse = planner.parse("select * from \"emps\"");
SqlNode validate = planner.validate(parse);
RelNode convert = planner.rel(validate).project();
RelTraitSet traitSet = planner.getEmptyTraitSet()
.replace(EnumerableConvention.INSTANCE);
RelNode transform = planner.transform(0, traitSet, convert);
RelNode transform2 = planner.transform(0, traitSet, transform);
assertThat(toString(transform2),
equalTo(
"EnumerableProject(empid=[$0], deptno=[$1], name=[$2], salary=[$3], commission=[$4])\n"
+ " EnumerableTableScan(table=[[hr, emps]])\n"));
}
示例10: checkJoinNWay
import org.apache.calcite.adapter.enumerable.EnumerableConvention; //导入依赖的package包/类
private void checkJoinNWay(int n) throws Exception {
final StringBuilder buf = new StringBuilder();
buf.append("select *");
for (int i = 0; i < n; i++) {
buf.append(i == 0 ? "\nfrom " : ",\n ")
.append("\"depts\" as d").append(i);
}
for (int i = 1; i < n; i++) {
buf.append(i == 1 ? "\nwhere" : "\nand").append(" d")
.append(i).append(".\"deptno\" = d")
.append(i - 1).append(".\"deptno\"");
}
Planner planner = getPlanner(null,
Programs.heuristicJoinOrder(Programs.RULE_SET, false, 6));
SqlNode parse = planner.parse(buf.toString());
SqlNode validate = planner.validate(parse);
RelNode convert = planner.rel(validate).project();
RelTraitSet traitSet = planner.getEmptyTraitSet()
.replace(EnumerableConvention.INSTANCE);
RelNode transform = planner.transform(0, traitSet, convert);
assertThat(toString(transform),
containsString(
"EnumerableJoin(condition=[=($0, $5)], joinType=[inner])"));
}
示例11: checkBushy
import org.apache.calcite.adapter.enumerable.EnumerableConvention; //导入依赖的package包/类
/** Checks that a query returns a particular plan, using a planner with
* MultiJoinOptimizeBushyRule enabled. */
private void checkBushy(String sql, String expected) throws Exception {
final SchemaPlus rootSchema = Frameworks.createRootSchema(true);
final FrameworkConfig config = Frameworks.newConfigBuilder()
.parserConfig(SqlParser.Config.DEFAULT)
.defaultSchema(
CalciteAssert.addSchema(rootSchema,
CalciteAssert.SchemaSpec.CLONE_FOODMART))
.traitDefs((List<RelTraitDef>) null)
.programs(Programs.heuristicJoinOrder(Programs.RULE_SET, true, 2))
.build();
Planner planner = Frameworks.getPlanner(config);
SqlNode parse = planner.parse(sql);
SqlNode validate = planner.validate(parse);
RelNode convert = planner.rel(validate).project();
RelTraitSet traitSet = planner.getEmptyTraitSet()
.replace(EnumerableConvention.INSTANCE);
RelNode transform = planner.transform(0, traitSet, convert);
assertThat(toString(transform), containsString(expected));
}
示例12: register
import org.apache.calcite.adapter.enumerable.EnumerableConvention; //导入依赖的package包/类
public static void register(final Kryo kryo) {
final EnumSerializer enumSerializer = new EnumSerializer();
kryo.addDefaultSerializer(BindableConvention.class, enumSerializer);
kryo.addDefaultSerializer(EnumerableConvention.class, enumSerializer);
kryo.addDefaultSerializer(InterpretableConvention.class, enumSerializer);
kryo.addDefaultSerializer(Convention.Impl.class, ConventionSerializer.class);
kryo.addDefaultSerializer(RelDistributions.SINGLETON.getClass(), RelDistributionSerializer.class);
kryo.addDefaultSerializer(DistributionTrait.class, DistributionTraitSerializer.class);
kryo.addDefaultSerializer(RelCollation.class, RelCollationSerializer.class);
kryo.addDefaultSerializer(RelTraitSet.class, RelTraitSetSerializer.class);
}
示例13: implementEnumerable
import org.apache.calcite.adapter.enumerable.EnumerableConvention; //导入依赖的package包/类
@Override
public EnumerableRel implementEnumerable(List<EnumerableRel> inputs) {
// keep it for having clause
RexBuilder rexBuilder = getCluster().getRexBuilder();
RelDataType inputRowType = getInput().getRowType();
RexProgramBuilder programBuilder = new RexProgramBuilder(inputRowType, rexBuilder);
programBuilder.addIdentity();
programBuilder.addCondition(this.condition);
RexProgram program = programBuilder.getProgram();
return new EnumerableCalc(getCluster(), getCluster().traitSetOf(EnumerableConvention.INSTANCE), //
sole(inputs), program);
}
示例14: implementEnumerable
import org.apache.calcite.adapter.enumerable.EnumerableConvention; //导入依赖的package包/类
@Override
public EnumerableRel implementEnumerable(List<EnumerableRel> inputs) {
ArrayList<RelNode> relInputs = new ArrayList<>(inputs.size());
for (EnumerableRel input : inputs) {
if (input instanceof OLAPRel) {
((OLAPRel) input).replaceTraitSet(EnumerableConvention.INSTANCE);
}
relInputs.add(input);
}
return new EnumerableUnion(getCluster(), traitSet, relInputs, localAll);
}
示例15: implementEnumerable
import org.apache.calcite.adapter.enumerable.EnumerableConvention; //导入依赖的package包/类
@Override
public EnumerableRel implementEnumerable(List<EnumerableRel> inputs) {
for (EnumerableRel input : inputs) {
if (input instanceof OLAPRel) {
((OLAPRel) input).replaceTraitSet(EnumerableConvention.INSTANCE);
}
}
return EnumerableWindowBridge.createEnumerableWindow(getCluster(), traitSet, inputs.get(0), constants, rowType,
groups);
}