Java Enumerable.enumerator方法代码示例

import org.apache.calcite.linq4j.Enumerable; //导入方法依赖的package包/类
@Test public void testList2() {
  final List<String> experience = Arrays.asList("jimi", "mitch", "noel");
  final Enumerator<String> enumerator = Linq4j.enumerator(experience);
  assertThat(enumerator.getClass().getName(), endsWith("ListEnumerator"));
  assertThat(count(enumerator), equalTo(3));

  final Enumerable<String> listEnumerable = Linq4j.asEnumerable(experience);
  final Enumerator<String> listEnumerator = listEnumerable.enumerator();
  assertThat(listEnumerator.getClass().getName(),
      endsWith("ListEnumerator"));
  assertThat(count(listEnumerator), equalTo(3));

  final Enumerable<String> linkedListEnumerable =
      Linq4j.asEnumerable(Lists.newLinkedList(experience));
  final Enumerator<String> iterableEnumerator =
      linkedListEnumerable.enumerator();
  assertThat(iterableEnumerator.getClass().getName(),
      endsWith("IterableEnumerator"));
  assertThat(count(iterableEnumerator), equalTo(3));
}
 

import org.apache.calcite.linq4j.Enumerable; //导入方法依赖的package包/类
@Test public void testDefaultIfEmpty() {
  final List<String> experience = Arrays.asList("jimi", "mitch", "noel");
  final Enumerable<String> notEmptyEnumerable = Linq4j.asEnumerable(experience).defaultIfEmpty();
  final Enumerator<String> notEmptyEnumerator = notEmptyEnumerable.enumerator();
  notEmptyEnumerator.moveNext();
  assertEquals("jimi", notEmptyEnumerator.current());
  notEmptyEnumerator.moveNext();
  assertEquals("mitch", notEmptyEnumerator.current());
  notEmptyEnumerator.moveNext();
  assertEquals("noel", notEmptyEnumerator.current());

  final Enumerable<String> emptyEnumerable =
      Linq4j.asEnumerable(Linq4j.<String>emptyEnumerable()).defaultIfEmpty();
  final Enumerator<String> emptyEnumerator = emptyEnumerable.enumerator();
  assertTrue(emptyEnumerator.moveNext());
  assertNull(emptyEnumerator.current());
  assertFalse(emptyEnumerator.moveNext());
}
 

import org.apache.calcite.linq4j.Enumerable; //导入方法依赖的package包/类
@Test public void testDefaultIfEmpty2() {
  final List<String> experience = Arrays.asList("jimi", "mitch", "noel");
  final Enumerable<String> notEmptyEnumerable =
      Linq4j.asEnumerable(experience).defaultIfEmpty("dummy");
  final Enumerator<String> notEmptyEnumerator = notEmptyEnumerable.enumerator();
  notEmptyEnumerator.moveNext();
  assertEquals("jimi", notEmptyEnumerator.current());
  notEmptyEnumerator.moveNext();
  assertEquals("mitch", notEmptyEnumerator.current());
  notEmptyEnumerator.moveNext();
  assertEquals("noel", notEmptyEnumerator.current());

  final Enumerable<String> emptyEnumerable =
      Linq4j.asEnumerable(Linq4j.<String>emptyEnumerable()).defaultIfEmpty("N/A");
  final Enumerator<String> emptyEnumerator = emptyEnumerable.enumerator();
  assertTrue(emptyEnumerator.moveNext());
  assertEquals("N/A", emptyEnumerator.current());
  assertFalse(emptyEnumerator.moveNext());
}
 

import org.apache.calcite.linq4j.Enumerable; //导入方法依赖的package包/类
public void testJoin(CorrelateJoinType joinType, Integer[][] expected) {
  Enumerable<Integer[]> join =
      Linq4j.asEnumerable(ImmutableList.of(1, 2, 3, 10, 20, 30))
          .correlateJoin(joinType,
              new Function1<Integer, Enumerable<Integer>>() {
                public Enumerable<Integer> apply(Integer a0) {
                  if (a0 == 1 || a0 == 10) {
                    return Linq4j.emptyEnumerable();
                  }
                  if (a0 == 2 || a0 == 20) {
                    return Linq4j.singletonEnumerable(a0 * 10);
                  }
                  if (a0 == 3 || a0 == 30) {
                    return Linq4j.asEnumerable(
                        ImmutableList.of(-a0 * 10, -a0 * 20));
                  }
                  throw new IllegalArgumentException(
                      "Unexpected input " + a0);
                }
              }, SELECT_BOTH);
  for (int i = 0; i < 2; i++) {
    Enumerator<Integer[]> e = join.enumerator();
    checkResults(e, expected);
    e.close();
  }
}
 

import org.apache.calcite.linq4j.Enumerable; //导入方法依赖的package包/类
public EnumerableDataScanner(
        long transactionId, String[] fieldNames, Column[] schema,
        Enumerable<DataAccessor> wrapped) {
    super(transactionId, fieldNames, schema);
    this.wrapped = wrapped.enumerator();
    fetchNext();
}
 

import org.apache.calcite.linq4j.Enumerable; //导入方法依赖的package包/类
public Enumerator<T> enumerator() {
    final JavaTypeFactory typeFactory =
            ((CalciteConnection) queryProvider).getTypeFactory();
    final SqlString sql = generateSql();
    //noinspection unchecked
    final Enumerable<T> enumerable = (Enumerable<T>) ResultSetEnumerable.of(
            dataSource.getDataSource(), sql.getSql(),
            JdbcUtils.ObjectArrayRowBuilder.factory(fieldClasses(typeFactory)));
    return enumerable.enumerator();
}
 

import org.apache.calcite.linq4j.Enumerable; //导入方法依赖的package包/类
@Test public void testEmptyEnumerable() {
  final Enumerable<Object> enumerable = Linq4j.emptyEnumerable();
  assertThat(enumerable.any(), is(false));
  assertThat(enumerable.longCount(), equalTo(0L));
  final Enumerator<Object> enumerator = enumerable.enumerator();
  assertThat(enumerator.moveNext(), is(false));
}
 

import org.apache.calcite.linq4j.Enumerable; //导入方法依赖的package包/类
@Test public void testSingletonEnumerable() {
  final Enumerable<String> enumerable = Linq4j.singletonEnumerable("foo");
  assertThat(enumerable.any(), is(true));
  assertThat(enumerable.longCount(), equalTo(1L));
  final Enumerator<String> enumerator = enumerable.enumerator();
  assertThat(enumerator.moveNext(), is(true));
  assertThat(enumerator.current(), equalTo("foo"));
  assertThat(enumerator.moveNext(), is(false));
}
 

import org.apache.calcite.linq4j.Enumerable; //导入方法依赖的package包/类
public Enumerator<T> enumerator() {
  final JavaTypeFactory typeFactory =
      ((CalciteConnection) queryProvider).getTypeFactory();
  final SqlString sql = generateSql();
  //noinspection unchecked
  final Enumerable<T> enumerable = (Enumerable<T>) ResultSetEnumerable.of(
      jdbcSchema.getDataSource(),
      sql.getSql(),
      JdbcUtils.ObjectArrayRowBuilder.factory(fieldClasses(typeFactory)));
  return enumerable.enumerator();
}
 

import org.apache.calcite.linq4j.Enumerable; //导入方法依赖的package包/类
public Node implement(final InterpreterImplementor implementor) {
  return new Node() {
    public void run() throws InterruptedException {
      final Sink sink =
          implementor.relSinks.get(EnumerableBindable.this).get(0);
      final Enumerable<Object[]> enumerable = bind(implementor.dataContext);
      final Enumerator<Object[]> enumerator = enumerable.enumerator();
      while (enumerator.moveNext()) {
        sink.send(Row.asCopy(enumerator.current()));
      }
    }
  };
}
 

import org.apache.calcite.linq4j.Enumerable; //导入方法依赖的package包/类
@SuppressWarnings("deprecation")
@Override public void setSourceEnumerable(Enumerable<Row> enumerable)
    throws InterruptedException {
  // just copy over the source into the local list
  final Enumerator<Row> enumerator = enumerable.enumerator();
  while (enumerator.moveNext()) {
    this.send(enumerator.current());
  }
  enumerator.close();
}
 

import org.apache.calcite.linq4j.Enumerable; //导入方法依赖的package包/类
@Override
public Enumerator<T> enumerator() {
    final Enumerable<T> enumerable =
            (Enumerable<T>) getTable().project();
    return enumerable.enumerator();
}
 

import org.apache.calcite.linq4j.Enumerable; //导入方法依赖的package包/类
public Enumerator<T> enumerator() {
  //noinspection unchecked
  final Enumerable<T> enumerable =
      (Enumerable<T>) getTable().query(getSession());
  return enumerable.enumerator();
}
 

import org.apache.calcite.linq4j.Enumerable; //导入方法依赖的package包/类
public Enumerator<T> enumerator() {
  //noinspection unchecked
  final Enumerable<T> enumerable =
      (Enumerable<T>) getTable().find(getMongoDb(), null, null, null);
  return enumerable.enumerator();
}