Java FlatLists类代码示例

import org.apache.calcite.runtime.FlatLists; //导入依赖的package包/类
Enumerable<MetaSchema> schemas(String catalog) {
    return Linq4j.asEnumerable(
            getConnection().getCalciteRootSchema().getSubSchemaMap().values())
            .select(
                    new Function1<CalciteSchema, MetaSchema>() {
                        public MetaSchema apply(CalciteSchema calciteSchema) {
                            return new CalciteMetaSchema(
                                    calciteSchema,
                                    connection.getCatalog(),
                                    calciteSchema.getName());
                        }
                    })
            .orderBy(
                    new Function1<MetaSchema, Comparable>() {
                        public Comparable apply(MetaSchema metaSchema) {
                            return (Comparable) FlatLists.of(
                                    Util.first(metaSchema.tableCatalog, ""),
                                    metaSchema.tableSchem);
                        }
                    });
}
 

import org.apache.calcite.runtime.FlatLists; //导入依赖的package包/类
Enumerable<MetaSchema> schemas(String catalog) {
  return Linq4j.asEnumerable(
      getConnection().rootSchema.getSubSchemaMap().values())
      .select(
          new Function1<CalciteSchema, MetaSchema>() {
            public MetaSchema apply(CalciteSchema calciteSchema) {
              return new CalciteMetaSchema(
                  calciteSchema,
                  connection.getCatalog(),
                  calciteSchema.getName());
            }
          })
      .orderBy(
          new Function1<MetaSchema, Comparable>() {
            public Comparable apply(MetaSchema metaSchema) {
              return (Comparable) FlatLists.of(
                  Util.first(metaSchema.tableCatalog, ""),
                  metaSchema.tableSchem);
            }
          });
}
 

import org.apache.calcite.runtime.FlatLists; //导入依赖的package包/类
@Test public void testFlatListProduct() {
  final List<Enumerator<List<String>>> list = new ArrayList<>();
  list.add(Linq4j.enumerator(l2(l1("a"), l1("b"))));
  list.add(Linq4j.enumerator(l3(l2("x", "p"), l2("y", "q"), l2("z", "r"))));
  final Enumerable<FlatLists.ComparableList<String>> product =
      SqlFunctions.product(list, 3, false);
  int n = 0;
  FlatLists.ComparableList<String> previous = FlatLists.of();
  for (FlatLists.ComparableList<String> strings : product) {
    if (n++ == 1) {
      assertThat(strings.size(), is(3));
      assertThat(strings.get(0), is("a"));
      assertThat(strings.get(1), is("y"));
      assertThat(strings.get(2), is("q"));
    }
    if (previous != null) {
      assertTrue(previous.compareTo(strings) < 0);
    }
    previous = strings;
  }
  assertThat(n, is(6));
}
 

import org.apache.calcite.runtime.FlatLists; //导入依赖的package包/类
@Test public void testUnnestItemsInMapWithNoAliasAndAdditionalArgument()
    throws SQLException {
  Connection connection = DriverManager.getConnection("jdbc:calcite:");
  final String sql =
      "select * from unnest(MAP['a', 1, 'b', 2], array[5, 6, 7])";
  ResultSet resultSet = connection.createStatement().executeQuery(sql);

  List<String> map = FlatLists.of("KEY=a; VALUE=1", "KEY=b; VALUE=2");
  List<String> array = FlatLists.of(" EXPR$1=5", " EXPR$1=6", " EXPR$1=7");

  final StringBuilder b = new StringBuilder();
  for (List<String> row : Linq4j.product(FlatLists.of(map, array))) {
    b.append(row.get(0)).append(";").append(row.get(1)).append("\n");
  }
  final String expected = b.toString();

  assertThat(CalciteAssert.toString(resultSet), is(expected));
  connection.close();
}
 

import org.apache.calcite.runtime.FlatLists; //导入依赖的package包/类
public Schema create(
    SchemaPlus parentSchema,
    String name,
    final Map<String, Object> operand) {
  final boolean mutable =
      SqlFunctions.isNotFalse((Boolean) operand.get("mutable"));
  return new ReflectiveSchema(new HrSchema()) {
    @Override protected Map<String, Table> getTableMap() {
      // Mine the EMPS table and add it under another name e.g. ELVIS
      final Map<String, Table> tableMap = super.getTableMap();
      final Table table = tableMap.get("emps");
      final String tableName = (String) operand.get("tableName");
      return FlatLists.append(tableMap, tableName, table);
    }

    @Override public boolean isMutable() {
      return mutable;
    }
  };
}
 

import org.apache.calcite.runtime.FlatLists; //导入依赖的package包/类
public static void register(final Kryo kryo) {
  // register list
  ImmutableListSerializer.register(kryo);
  // register set
  ImmutableSetSerializer.register(kryo);
  // register set
  ImmutableMapSerializer.register(kryo);
  // others
  kryo.addDefaultSerializer(FlatLists.AbstractFlatList.class, FieldSerializer.class);
  kryo.addDefaultSerializer(ImmutableNullableList.class, ImmutableNullableListSerializer.class);
}
 

import org.apache.calcite.runtime.FlatLists; //导入依赖的package包/类
Sql optimize(final RuleSet ruleSet, final RelOptPlanner relOptPlanner) {
  return new Sql(schemaSpec, sql, dialect, config,
      FlatLists.append(transforms, new Function<RelNode, RelNode>() {
        public RelNode apply(RelNode r) {
          Program program = Programs.of(ruleSet);
          return program.run(relOptPlanner, r, r.getTraitSet(),
              ImmutableList.<RelOptMaterialization>of(),
              ImmutableList.<RelOptLattice>of());
        }
      }));
}
 

import org.apache.calcite.runtime.FlatLists; //导入依赖的package包/类
protected void explain_(
    RelNode rel,
    List<Pair<String, Object>> values) {
  List<RelNode> inputs = rel.getInputs();
  if (rel instanceof HashJoinPrel && ((HashJoinPrel) rel).isSwapped()) {
    HashJoinPrel joinPrel = (HashJoinPrel) rel;
    inputs = FlatLists.of(joinPrel.getRight(), joinPrel.getLeft());
  }

  if (!RelMetadataQuery.isVisibleInExplain(
      rel,
      detailLevel)) {
    // render children in place of this, at same level
    explainInputs(inputs);
    return;
  }

  StringBuilder s = new StringBuilder();
  OpId id = ids.get(rel);
  if (id != null) {
    s.append(String.format("%02d-%02d", id.fragmentId, id.opId));
  }else{
    s.append("     ");
  }
  s.append("  ");

  if (id != null && id.opId == 0) {
    for(int i =0; i < spacer.get(); i++){ s.append('-');}
  }else{
    spacer.spaces(s);
  }

  s.append("  ");

  s.append(rel.getRelTypeName().replace("Prel", ""));
  if (detailLevel != SqlExplainLevel.NO_ATTRIBUTES) {
    int j = 0;
    for (Pair<String, Object> value : values) {
      if (value.right instanceof RelNode) {
        continue;
      }
      if (j++ == 0) {
        s.append("(");
      } else {
        s.append(", ");
      }
      s.append(value.left)
          .append("=[")
          .append(value.right)
          .append("]");
    }
    if (j > 0) {
      s.append(")");
    }
  }
  if (detailLevel == SqlExplainLevel.ALL_ATTRIBUTES) {
    s.append(" : rowType = " + rel.getRowType().toString());
    s.append(": rowcount = ")
        .append(RelMetadataQuery.getRowCount(rel))
        .append(", cumulative cost = ")
        .append(RelMetadataQuery.getCumulativeCost(rel));
     s.append(", id = ").append(rel.getId());
  }
  pw.println(s);
  spacer.add(2);
  explainInputs(inputs);
  spacer.subtract(2);
}
 

import org.apache.calcite.runtime.FlatLists; //导入依赖的package包/类
protected void explain_(
    RelNode rel,
    List<Pair<String, Object>> values) {
  List<RelNode> inputs = rel.getInputs();
  RelMetadataQuery mq = RelMetadataQuery.instance(DefaultRelMetadataProvider.INSTANCE);
  if (rel instanceof HashJoinPrel && ((HashJoinPrel) rel).isSwapped()) {
    HashJoinPrel joinPrel = (HashJoinPrel) rel;
    inputs = FlatLists.of(joinPrel.getRight(), joinPrel.getLeft());
  }

  if (!mq.isVisibleInExplain(rel, detailLevel)) {
    // render children in place of this, at same level
    explainInputs(inputs);
    return;
  }

  StringBuilder s = new StringBuilder();
  OpId id = ids.get(rel);
  if (id != null) {
    s.append(String.format("%02d-%02d", id.fragmentId, id.opId));
  }else{
    s.append("     ");
  }
  s.append("  ");

  if (id != null && id.opId == 0) {
    for(int i =0; i < spacer.get(); i++){ s.append('-');}
  }else{
    spacer.spaces(s);
  }

  s.append("  ");

  s.append(rel.getRelTypeName().replace("Prel", ""));
  if (detailLevel != SqlExplainLevel.NO_ATTRIBUTES) {
    int j = 0;
    for (Pair<String, Object> value : values) {
      if (value.right instanceof RelNode) {
        continue;
      }
      if (j++ == 0) {
        s.append("(");
      } else {
        s.append(", ");
      }
      s.append(value.left)
          .append("=[")
          .append(value.right)
          .append("]");
    }
    if (j > 0) {
      s.append(")");
    }
  }
  if (detailLevel == SqlExplainLevel.ALL_ATTRIBUTES) {
    s.append(" : rowType = " + rel.getRowType().toString());
    s.append(": rowcount = ")
        .append(mq.getRowCount(rel))
        .append(", cumulative cost = ")
        .append(mq.getCumulativeCost(rel));
     s.append(", id = ").append(rel.getId());
  }
  pw.println(s);
  spacer.add(2);
  explainInputs(inputs);
  spacer.subtract(2);
}
 

import org.apache.calcite.runtime.FlatLists; //导入依赖的package包/类
protected void explain_(
    RelNode rel,
    List<Pair<String, Object>> values) {
  List<RelNode> inputs = rel.getInputs();
  if (rel instanceof HashJoinPrel && ((HashJoinPrel) rel).isSwapped()) {
    HashJoinPrel joinPrel = (HashJoinPrel) rel;
    inputs = FlatLists.of(joinPrel.getRight(), joinPrel.getLeft());
  }

  RelMetadataQuery mq = RelMetadataQuery.instance();
  if (!mq.isVisibleInExplain(rel, detailLevel)) {
    // render children in place of this, at same level
    explainInputs(inputs);
    return;
  }

  StringBuilder s = new StringBuilder();
  OpId id = ids.get(rel);
  if (id != null) {
    s.append(String.format("%02d-%02d", id.fragmentId, id.opId));
  }else{
    s.append("     ");
  }
  s.append("  ");

  if (id != null && id.opId == 0) {
    for(int i =0; i < spacer.get(); i++){ s.append('-');}
  }else{
    spacer.spaces(s);
  }

  s.append("  ");

  s.append(rel.getRelTypeName().replace("Prel", ""));
  if (detailLevel != SqlExplainLevel.NO_ATTRIBUTES) {
    int j = 0;
    for (Pair<String, Object> value : values) {
      if (value.right instanceof RelNode) {
        continue;
      }
      if (j++ == 0) {
        s.append("(");
      } else {
        s.append(", ");
      }
      s.append(value.left)
          .append("=[")
          .append(value.right)
          .append("]");
    }
    if (j > 0) {
      s.append(")");
    }
  }
  if (detailLevel == SqlExplainLevel.ALL_ATTRIBUTES) {
    s.append(" : rowType = ")
      .append(rel.getRowType())
      .append(": rowcount = ")
      .append(mq.getRowCount(rel))
      .append(", cumulative cost = ")
      .append(mq.getCumulativeCost(rel))
      .append(", id = ")
      .append(rel.getId());
  }
  pw.println(s);
  spacer.add(2);
  explainInputs(inputs);
  spacer.subtract(2);
}
 

import org.apache.calcite.runtime.FlatLists; //导入依赖的package包/类
public List<RelNode> getInputs() {
  return FlatLists.of(left, right);
}
 

import org.apache.calcite.runtime.FlatLists; //导入依赖的package包/类
public List<ImmutableIntList> keys() {
  return FlatLists.of(leftKeys, rightKeys);
}
 

import org.apache.calcite.runtime.FlatLists; //导入依赖的package包/类
/**
 * Tests that flat lists behave like regular lists in terms of equals
 * and hashCode.
 */
@Test public void testFlatList() {
  final List<String> emp = FlatLists.of();
  final List<String> emp0 = Collections.emptyList();
  assertEquals(emp, emp0);
  assertEquals(emp.hashCode(), emp0.hashCode());

  final List<String> ab = FlatLists.of("A", "B");
  final List<String> ab0 = Arrays.asList("A", "B");
  assertEquals(ab, ab0);
  assertEquals(ab.hashCode(), ab0.hashCode());

  final List<String> abc = FlatLists.of("A", "B", "C");
  final List<String> abc0 = Arrays.asList("A", "B", "C");
  assertEquals(abc, abc0);
  assertEquals(abc.hashCode(), abc0.hashCode());

  final List<Object> abc1 = FlatLists.of((Object) "A", "B", "C");
  assertEquals(abc1, abc0);
  assertEquals(abc, abc0);
  assertEquals(abc1.hashCode(), abc0.hashCode());

  final List<String> an = FlatLists.of("A", null);
  final List<String> an0 = Arrays.asList("A", null);
  assertEquals(an, an0);
  assertEquals(an.hashCode(), an0.hashCode());

  final List<String> anb = FlatLists.of("A", null, "B");
  final List<String> anb0 = Arrays.asList("A", null, "B");
  assertEquals(anb, anb0);
  assertEquals(anb.hashCode(), anb0.hashCode());

  // Comparisons
  assertThat(emp, instanceOf(Comparable.class));
  assertThat(ab, instanceOf(Comparable.class));
  @SuppressWarnings("unchecked")
  final Comparable<List> cemp = (Comparable) emp;
  @SuppressWarnings("unchecked")
  final Comparable<List> cab = (Comparable) ab;
  assertThat(cemp.compareTo(emp), is(0));
  assertThat(cemp.compareTo(ab) < 0, is(true));
  assertThat(cab.compareTo(ab), is(0));
  assertThat(cab.compareTo(emp) > 0, is(true));
  assertThat(cab.compareTo(anb) > 0, is(true));
}
 

import org.apache.calcite.runtime.FlatLists; //导入依赖的package包/类
/** Adds a transform that will be applied to {@link #tester}
 * just before running the query. */
private Sql withTransform(Function<Tester, Tester> transform) {
  return new Sql(sql, preProgram, hepPlanner, hooks,
      FlatLists.append(transforms, transform));
}
 

import org.apache.calcite.runtime.FlatLists; //导入依赖的package包/类
/** Adds a hook and a handler for that hook. Calcite will create a thread
 * hook (by calling {@link Hook#addThread(com.google.common.base.Function)})
 * just before running the query, and remove the hook afterwards. */
public <T> Sql withHook(Hook hook, Function<T, Void> handler) {
  return new Sql(sql, preProgram, hepPlanner,
      FlatLists.append(hooks, hook, handler), transforms);
}