Java Linq4j.asEnumerable方法代码示例

import org.apache.calcite.linq4j.Linq4j; //导入方法依赖的package包/类
protected MetaResultSet createResultSet(
        Map<String, Object> internalParameters, List<ColumnMetaData> columns,
        CursorFactory cursorFactory, final Frame firstFrame) {
    try {
        final CalciteConnectionImpl connection = getConnection();
        final AvaticaStatement statement = connection.createStatement();
        final CalcitePrepare.CalciteSignature<Object> signature =
                new CalcitePrepare.CalciteSignature<Object>("",
                        ImmutableList.<AvaticaParameter>of(), internalParameters, null,
                        columns, cursorFactory, ImmutableList.<RelCollation>of(), -1,
                        null, Meta.StatementType.SELECT) {
                    @Override
                    public Enumerable<Object> enumerable(
                            DataContext dataContext) {
                        return Linq4j.asEnumerable(firstFrame.rows);
                    }
                };
        return MetaResultSet.create(connection.id, statement.getId(), true,
                signature, firstFrame);
    } catch (SQLException e) {
        throw new RuntimeException(e);
    }
}
 

import org.apache.calcite.linq4j.Linq4j; //导入方法依赖的package包/类
protected MetaResultSet createResultSet(
    Map<String, Object> internalParameters, List<ColumnMetaData> columns,
    CursorFactory cursorFactory, final Frame firstFrame) {
  try {
    final QuarkConnectionImpl connection = getConnection();
    final AvaticaStatement statement = connection.createStatement();
    final CalcitePrepare.CalciteSignature<Object> signature =
        new CalcitePrepare.CalciteSignature<Object>("",
            ImmutableList.<AvaticaParameter>of(), internalParameters, null,
            columns, cursorFactory, null, ImmutableList.<RelCollation>of(), -1,
            null, Meta.StatementType.SELECT) {
          @Override public Enumerable<Object> enumerable(
              DataContext dataContext) {
            return Linq4j.asEnumerable(firstFrame.rows);
          }
        };
    return MetaResultSet.create(connection.id, statement.getId(), true,
        signature, firstFrame);
  } catch (SQLException e) {
    throw new RuntimeException(e);
  }
}
 

import org.apache.calcite.linq4j.Linq4j; //导入方法依赖的package包/类
@Test public void testTakeWhileEnumerablePredicate() {
  final Enumerable<Department> enumerableDepts =
      Linq4j.asEnumerable(depts);
  final List<Department> deptList =
      EnumerableDefaults.takeWhile(
          enumerableDepts,
          new Predicate1<Department>() {
            public boolean apply(Department v1) {
              return v1.name.contains("e");
            }
          }).toList();

  // Only one department:
  // 0: Sales --> true
  // 1: HR --> false
  // 2: Marketing --> never get to it (we stop after false)
  assertEquals(1, deptList.size());
  assertEquals(depts[0], deptList.get(0));
}
 

import org.apache.calcite.linq4j.Linq4j; //导入方法依赖的package包/类
@Test public void testTakeWhileEnumerableFunction() {
  final Enumerable<Department> enumerableDepts =
      Linq4j.asEnumerable(depts);
  final List<Department> deptList =
      EnumerableDefaults.takeWhile(
          enumerableDepts,
          new Predicate2<Department, Integer>() {
            int index = 0;

            public boolean apply(Department v1, Integer v2) {
              // Make sure we're passed the correct indices
              assertEquals(
                  "Invalid index passed to function", index++, (int) v2);
              return 20 != v1.deptno;
            }
          }).toList();

  assertEquals(1, deptList.size());
  assertEquals(depts[0], deptList.get(0));
}
 

import org.apache.calcite.linq4j.Linq4j; //导入方法依赖的package包/类
@Test public void testZip() {
  final Enumerable<String> e1 = Linq4j.asEnumerable(Arrays.asList("a", "b", "c"));
  final Enumerable<String> e2 = Linq4j.asEnumerable(Arrays.asList("1", "2", "3"));

  final Enumerable<String> zipped = e1.zip(e2,
      new Function2<String, String, String>() {
        public String apply(String v0, String v1) {
          return v0 + v1;
        }
      });
  assertEquals(3, zipped.count());
  zipped.enumerator().reset();
  for (int i = 0; i < 3; i++) {
    assertEquals("" + (char) ('a' + i) + (char) ('1' + i), zipped.elementAt(i));
  }
}
 

import org.apache.calcite.linq4j.Linq4j; //导入方法依赖的package包/类
private static QueryableTable oneThreePlus(String s) {
  List<Integer> items;
  // Argument is null in case SQL contains function call with expression.
  // Then the engine calls a function with null arguments to get getRowType.
  if (s == null) {
    items = ImmutableList.of();
  } else {
    Integer latest = Integer.parseInt(s.substring(1, s.length() - 1));
    items = ImmutableList.of(1, 3, latest);
  }
  final Enumerable<Integer> enumerable = Linq4j.asEnumerable(items);
  return new AbstractQueryableTable(Integer.class) {
    public <E> Queryable<E> asQueryable(
        QueryProvider queryProvider, SchemaPlus schema, String tableName) {
      //noinspection unchecked
      return (Queryable<E>) enumerable.asQueryable();
    }

    public RelDataType getRowType(RelDataTypeFactory typeFactory) {
      return typeFactory.builder().add("c", SqlTypeName.INTEGER).build();
    }
  };
}
 

import org.apache.calcite.linq4j.Linq4j; //导入方法依赖的package包/类
@Override
public Enumerable<Object[]> scan(DataContext root, List<RexNode> filters) {
	SolrQuery solrQuery = null;
	try {
		solrQuery = buildSolrQuery(filters);
	} catch (SolrSqlException e) {
		logger.error(e);
	}
	return Linq4j.asEnumerable(new SolrQueryResults(solrClientFactory, solrQuery, pageSize));
}
 

import org.apache.calcite.linq4j.Linq4j; //导入方法依赖的package包/类
/** Quickly prepares a simple SQL statement, circumventing the usual
 * preparation process. */
private <T> CalciteSignature<T> simplePrepare(Context context, String sql) {
  final JavaTypeFactory typeFactory = context.getTypeFactory();
  final RelDataType x =
      typeFactory.builder()
          .add(SqlUtil.deriveAliasFromOrdinal(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);
  final List<ColumnMetaData> columns =
      getColumnMetaDataList(typeFactory, x, x, origins);
  final Meta.CursorFactory cursorFactory =
      Meta.CursorFactory.deduce(columns, null);
  return new CalciteSignature<>(
      sql,
      ImmutableList.<AvaticaParameter>of(),
      ImmutableMap.<String, Object>of(),
      x,
      columns,
      cursorFactory,
      context.getRootSchema(),
      ImmutableList.<RelCollation>of(),
      -1,
      new Bindable<T>() {
        public Enumerable<T> bind(DataContext dataContext) {
          return Linq4j.asEnumerable(list);
        }
      },
      Meta.StatementType.SELECT);
}
 

import org.apache.calcite.linq4j.Linq4j; //导入方法依赖的package包/类
@Test public void testTake() {
  final Enumerable<Department> enumerableDepts =
      Linq4j.asEnumerable(depts);
  final List<Department> enumerableDeptsResult =
      enumerableDepts.take(2).toList();
  assertEquals(2, enumerableDeptsResult.size());
  assertEquals(depts[0], enumerableDeptsResult.get(0));
  assertEquals(depts[1], enumerableDeptsResult.get(1));

  final List<Department> enumerableDeptsResult5 =
      enumerableDepts.take(5).toList();
  assertEquals(3, enumerableDeptsResult5.size());
}
 

import org.apache.calcite.linq4j.Linq4j; //导入方法依赖的package包/类
@Test public void testTakeEnumerable() {
  final Enumerable<Department> enumerableDepts =
      Linq4j.asEnumerable(depts);
  final List<Department> enumerableDeptsResult =
      EnumerableDefaults.take(enumerableDepts, 2).toList();
  assertEquals(2, enumerableDeptsResult.size());
  assertEquals(depts[0], enumerableDeptsResult.get(0));
  assertEquals(depts[1], enumerableDeptsResult.get(1));

  final List<Department> enumerableDeptsResult5 =
      EnumerableDefaults.take(enumerableDepts, 5).toList();
  assertEquals(3, enumerableDeptsResult5.size());
}
 

import org.apache.calcite.linq4j.Linq4j; //导入方法依赖的package包/类
@Test public void testTakeEnumerableGreaterThanLength() {
  final Enumerable<Department> enumerableDepts =
      Linq4j.asEnumerable(depts);
  final List<Department> depList =
      EnumerableDefaults.take(enumerableDepts, 5).toList();
  assertEquals(3, depList.size());
  assertEquals(depts[0], depList.get(0));
  assertEquals(depts[1], depList.get(1));
  assertEquals(depts[2], depList.get(2));
}
 

import org.apache.calcite.linq4j.Linq4j; //导入方法依赖的package包/类
@Test public void testTakeQueryableGreaterThanLength() {
  final Enumerable<Department> enumerableDepts =
      Linq4j.asEnumerable(depts);
  final List<Department> depList =
      EnumerableDefaults.take(enumerableDepts, 5).toList();
  assertEquals(3, depList.size());
  assertEquals(depts[0], depList.get(0));
  assertEquals(depts[1], depList.get(1));
  assertEquals(depts[2], depList.get(2));
}
 

import org.apache.calcite.linq4j.Linq4j; //导入方法依赖的package包/类
@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 =
      Linq4j.asEnumerable(
          Arrays.asList(
              new Object[]{100, 10, "Bill"},
              new Object[]{200, 20, "Eric"},
              new Object[]{150, 10, "Sebastian"},
              new Object[]{160, 10, "Theodore"}));
  final ColumnLoader<Object[]> loader =
      new ColumnLoader<Object[]>(typeFactory, enumerable,
          RelDataTypeImpl.proto(rowType), null);
  checkColumn(
      loader.representationValues.get(0),
      ArrayTable.RepresentationType.BIT_SLICED_PRIMITIVE_ARRAY,
      "Column(representation=BitSlicedPrimitiveArray(ordinal=0, bitCount=8, primitive=INT, signed=false), value=[100, 150, 160, 200, 0, 0, 0, 0])");
  checkColumn(
      loader.representationValues.get(1),
      ArrayTable.RepresentationType.BIT_SLICED_PRIMITIVE_ARRAY,
      "Column(representation=BitSlicedPrimitiveArray(ordinal=1, bitCount=5, primitive=INT, signed=false), value=[10, 10, 10, 20, 0, 0, 0, 0, 0, 0, 0, 0])");
  checkColumn(
      loader.representationValues.get(2),
      ArrayTable.RepresentationType.OBJECT_ARRAY,
      "Column(representation=ObjectArray(ordinal=2), value=[Bill, Sebastian, Theodore, Eric])");
}
 

import org.apache.calcite.linq4j.Linq4j; //导入方法依赖的package包/类
@Test public void testLast() {
  final Enumerable<String> enumerable = Linq4j.asEnumerable(Arrays.asList("jimi", "mitch"));
  assertEquals("mitch", enumerable.last());

  final Enumerable<?> emptyEnumerable = Linq4j.asEnumerable(Collections.EMPTY_LIST);
  try {
    emptyEnumerable.last();
    fail();
  } catch (Exception ignored) {
    // ok
  }
}
 

import org.apache.calcite.linq4j.Linq4j; //导入方法依赖的package包/类
private static Enumerable toEnumerable(final Object o) {
  if (o.getClass().isArray()) {
    if (o instanceof Object[]) {
      return Linq4j.asEnumerable((Object[]) o);
    } else {
      return Linq4j.asEnumerable(Primitive.asList(o));
    }
  }
  if (o instanceof Iterable) {
    return Linq4j.asEnumerable((Iterable) o);
  }
  throw new RuntimeException(
      "Cannot convert " + o.getClass() + " into a Enumerable");
}