import net.hydromatic.linq4j.Enumerator; //导入依赖的package包/类
public Cursor cursor(Enumerator<T> enumerator) {
    // noinspection unchecked
    return new EnumeratorCursor<T>(enumerator) {
        protected Getter createGetter(final int ordinal) {
            return new Getter() {
                public Object getObject() {
                    return get(current(), ordinal);
                }

                public boolean wasNull() {
                    return getObject() == null;
                }
            };
        }
    };
}
 

import net.hydromatic.linq4j.Enumerator; //导入依赖的package包/类
/**
 * Returns the element type of a {@link Collection}, {@link Iterable}
 * (including {@link net.hydromatic.linq4j.Queryable Queryable} and
 * {@link net.hydromatic.linq4j.Enumerable Enumerable}), {@link Iterator},
 * {@link Enumerator}, or an array.
 *
 * <p>Returns null if the type is not one of these.</p>
 */
public static Type getElementType(Type type) {
  if (type instanceof ArrayType) {
    return ((ArrayType) type).getComponentType();
  }
  if (type instanceof GenericArrayType) {
    return ((GenericArrayType) type).getGenericComponentType();
  }
  Class clazz = toClass(type);
  if (clazz.isArray()) {
    return clazz.getComponentType();
  }
  if (Collection.class.isAssignableFrom(clazz)
      || Iterable.class.isAssignableFrom(clazz)
      || Iterator.class.isAssignableFrom(clazz)
      || Enumerator.class.isAssignableFrom(clazz)) {
    if (type instanceof ParameterizedType) {
      return ((ParameterizedType) type).getActualTypeArguments()[0];
    }
    return Object.class;
  }
  return null;
}
 

import net.hydromatic.linq4j.Enumerator; //导入依赖的package包/类
public Enumerator<Object[]> enumerator() {
    OLAPContext olapContext = OLAPContext.getThreadLocalContextById(contextId);
    switch (type) {
    case INDEX:
        return new CubeEnumerator(olapContext, optiqContext);
    case LOOKUP_TABLE:
        return new LookupTableEnumerator(olapContext);
    case HIVE:
        return new HiveEnumerator(olapContext);
    default:
        throw new IllegalArgumentException("Wrong type " + type + "!");
    }
}
 

import net.hydromatic.linq4j.Enumerator; //导入依赖的package包/类
@Override
public <T> Queryable<T> asQueryable(QueryProvider queryProvider, SchemaPlus schema, String tableName) {
    return new AbstractTableQueryable<T>(queryProvider, schema, this, tableName) {
        @SuppressWarnings("unchecked")
        public Enumerator<T> enumerator() {
            final OLAPQuery query = new OLAPQuery(EnumeratorTypeEnum.INDEX, 0);
            return (Enumerator<T>) query.enumerator();
        }
    };
}
 

import net.hydromatic.linq4j.Enumerator; //导入依赖的package包/类
public PrepareResult(String sql, List<AvaticaParameter> parameterList, Enumerator<Object[]> enumerator, ColumnMetaData.StructType structType) {
    super();
    this.sql = sql;
    this.parameterList = parameterList;
    this.enumerator = enumerator;
    this.structType = structType;
}
 

import net.hydromatic.linq4j.Enumerator; //导入依赖的package包/类
public AvaticaPrepareResult prepare(AvaticaStatement statement, String sql) {
    RemoteClient client = factory.newRemoteClient(conn);
    DataSet<Object[]> result = null;

    try {
        result = (DataSet<Object[]>) client.query(statement, sql);
    } catch (Exception e) {
        logger.error(e.getLocalizedMessage(), e);
        throw new RuntimeException("Failed to query kylin server with exception " + e.getLocalizedMessage());
    }

    return new KylinPrepare.PrepareResult(sql, null, (Enumerator<Object[]>) result.getEnumerator(), ColumnMetaData.struct(result.getMeta()));
}
 

import net.hydromatic.linq4j.Enumerator; //导入依赖的package包/类
@Override
public DataSet<Object[]> query(AvaticaStatement statement, String sql) {
    List<Object[]> data = new ArrayList<Object[]>();
    Object[] row = new Object[] { "foo", "bar", "tool" };
    data.add(row);
    Enumerator<Object[]> enumerator = new KylinEnumerator<Object[]>(data);
    List<ColumnMetaData> meta = new ArrayList<ColumnMetaData>();
    meta.add(ColumnMetaData.dummy(ColumnMetaData.scalar(Types.VARCHAR, "varchar", Rep.STRING), true));
    meta.add(ColumnMetaData.dummy(ColumnMetaData.scalar(Types.VARCHAR, "varchar", Rep.STRING), true));
    meta.add(ColumnMetaData.dummy(ColumnMetaData.scalar(Types.VARCHAR, "varchar", Rep.STRING), true));

    return new DataSet<Object[]>(meta, enumerator);
}
 

import net.hydromatic.linq4j.Enumerator; //导入依赖的package包/类
public static <K, V> MapStream<K, V> filter(final MapStream<K, V> s,
    final BiPredicate<? super K, ? super V> predicate) {
  return new AbstractMapStream<K, V>() {
    public Iterable<BiValue<K, V>> asIterable() {
      final Enumerator<BiValue<K, V>> enumerator =
          Linq4j.iterableEnumerator(s);
      final Enumerator<BiValue<K, V>> enumerator2 =
          new Enumerator<BiValue<K, V>>() {
            public BiValue<K, V> current() {
              return enumerator.current();
            }

            public boolean moveNext() {
              while (enumerator.moveNext()) {
                BiValue<K, V> o = enumerator.current();
                if (predicate.eval(o.getKey(), o.getValue())) {
                  return true;
                }
              }
              return false;
            }

            public void reset() {
              enumerator.reset();
            }

            public void close() {
              enumerator.close();
            }
          };
      return new Iterable<BiValue<K, V>>() {
        public Iterator<BiValue<K, V>> iterator() {
          return Linq4j.enumeratorIterator(enumerator2);
        }
      };
    }
  };
}
 

import net.hydromatic.linq4j.Enumerator; //导入依赖的package包/类
/**
 * @param meta
 * @param enumerator
 */
public DataSet(List<ColumnMetaData> meta, Enumerator<E> enumerator) {
    this.meta = meta;
    this.enumerator = enumerator;
}
 

import net.hydromatic.linq4j.Enumerator; //导入依赖的package包/类
public Enumerator<E> getEnumerator() {
    return enumerator;
}
 

import net.hydromatic.linq4j.Enumerator; //导入依赖的package包/类
@Override
public Enumerator<T> enumerator() {

	return Linq4j.enumerator(new ArrayList<T>());
}