当前位置：源码 > Java源码 >

Java源码示例：org.apache.calcite.linq4j.AbstractEnumerable

示例1

@Override
public Enumerable<Object[]> scan(DataContext root, List<RexNode> filters, int[] projects) {
    String backendTaskSQL = CalciteUtls.getBackendTaskSQL(filters,
            logicTable().getColumns(),
            CalciteUtls.getColumnList(logicTable(), projects), backendTableInfo);

    MycatCalciteDataContext root1 = (MycatCalciteDataContext) root;
    MycatConnection connection = root1.getUponDBContext().getConnection(backendTableInfo.getTargetName());
    RowBaseIterator rowBaseIterator = connection.executeQuery(null, backendTaskSQL);
    return new AbstractEnumerable<Object[]>() {
        @Override
        @SneakyThrows
        public Enumerator<Object[]> enumerator() {
            return new MyCatResultSetEnumerator(root1.getCancelFlag(), rowBaseIterator);
        }
    };

}

示例2

@Override
public Enumerable<Object[]> scan(DataContext root, List<RexNode> filters, int[] projects) {
	List<Object> list = REGISTRY.getIfPresent(this.operatorIdentifier).objects;

	final int[] actualProjects = resolveProjects(projects);

	Enumerator<Object[]> enumerator =  Linq4j.enumerator(list.stream()
			.filter(o -> referenceInterface.isAssignableFrom(o.getClass()))
			.map(
			m -> {
				Object[] res = new Object[actualProjects.length];
				for (int i = 0; i < actualProjects.length; i++) {
					res[i] = methodsForFields.get(actualProjects[i]).apply(m);
				}
				return res;
			}
	).collect(Collectors.toList()));

	return new AbstractEnumerable<Object[]>() {
		@Override
		public Enumerator<Object[]> enumerator() {
			return enumerator;
		}
	};
}

示例3

public Enumerable<Object[]> scan(DataContext root) {
  final Random random = seed >= 0 ? new Random(seed) : new Random();
  final Maze maze = new Maze(width, height);
  final PrintWriter pw = Util.printWriter(System.out);
  maze.layout(random, pw);
  if (Maze.DEBUG) {
    maze.print(pw, true);
  }
  return new AbstractEnumerable<Object[]>() {
    public Enumerator<Object[]> enumerator() {
      final Set<Integer> solutionSet;
      if (solution) {
        solutionSet = maze.solve(0, 0);
      } else {
        solutionSet = null;
      }
      return Linq4j.transform(maze.enumerator(solutionSet),
          s -> new Object[] {s});
    }
  };
}

示例4

private Enumerable<String> myEnumerable(final int[] closes, final int size) {
  return new AbstractEnumerable<String>() {
    public Enumerator<String> enumerator() {
      return new Enumerator<String>() {
        int i = 0;

        public String current() {
          return "x";
        }

        public boolean moveNext() {
          return i++ < size;
        }

        public void reset() {
        }

        public void close() {
          ++closes[0];
        }
      };
    }
  };
}

示例5

/** Executes an "aggregate" operation on the underlying collection.
 *
 * <p>For example:
 * <code>zipsTable.aggregate(
 * "{$filter: {state: 'OR'}",
 * "{$group: {_id: '$city', c: {$sum: 1}, p: {$sum: '$pop'}}}")
 * </code></p>
 *
 * @param mongoDb MongoDB connection
 * @param fields List of fields to project; or null to return map
 * @param operations One or more JSON strings
 * @return Enumerator of results
 */
private Enumerable<Object> aggregate(final MongoDatabase mongoDb,
    final List<Map.Entry<String, Class>> fields,
    final List<String> operations) {
  final List<Bson> list = new ArrayList<>();
  for (String operation : operations) {
    list.add(BsonDocument.parse(operation));
  }
  final Function1<Document, Object> getter =
      MongoEnumerator.getter(fields);
  return new AbstractEnumerable<Object>() {
    public Enumerator<Object> enumerator() {
      final Iterator<Document> resultIterator;
      try {
        resultIterator = mongoDb.getCollection(collectionName)
            .aggregate(list).iterator();
      } catch (Exception e) {
        throw new RuntimeException("While running MongoDB query "
            + Util.toString(operations, "[", ",\n", "]"), e);
      }
      return new MongoEnumerator(resultIterator, getter);
    }
  };
}

示例6

public Enumerable<Object[]> scan(DataContext root, List<RexNode> filters) {
    CollectionWrapper rows = (CollectionWrapper) getModifiableCollection();
    for (RexNode filter : filters) {
        rows = scanFilterForKeyFields(root, filter, rows);
    }
    final Collection coll = rows;
    final AtomicBoolean cancelFlag = DataContext.Variable.CANCEL_FLAG.get(root);
    return new AbstractEnumerable<Object[]>() {
        @SuppressWarnings("unchecked")
        public Enumerator<Object[]> enumerator() {
            return new TableEnumerator<>(Iterators.<Object, Object[]>transform(
                coll.iterator(), Table::toArray), cancelFlag, true);
        }
    };
}

示例7

public Enumerable<Object[]> scan(DataContext root) {
	final List<String> types = new ArrayList<String>(sourceTable.columns.size());
	for (JSqlMapData.Column column : sourceTable.columns) {
		types.add(column.type);
	}
	final int[] fields = identityList(this.dataType.getFieldCount());
	return new AbstractEnumerable<Object[]>() {
		public Enumerator<Object[]> enumerator() {
			return new JSqlEnumerator<Object[]>(fields, types, sourceTable.data);
		}
	};
}

示例8

private Enumerable<DataAccessor> createEnumerable(boolean rewindOnClose) {
    return new AbstractEnumerable<DataAccessor>() {
        @Override
        public Enumerator<DataAccessor> enumerator() {
            return asEnumerator(rewindOnClose);
        }
    };
}

示例9

public static Enumerable<Object[]> scan() {
    return new AbstractEnumerable<Object[]>() {
        public Enumerator<Object[]> enumerator() {
            return new GremlinEnumerator(rows);
        }
    };
}

示例10

public Enumerable<Object[]> scan(DataContext root) {
  return new AbstractEnumerable<Object[]>() {
    public Enumerator<Object[]> enumerator() {
      return null;
    }
  };
}

示例11

/**
 * Returns an enumerable over a given projection of the fields.
 *
 * Called from generated code.
 */
public Enumerable<Object> project(final int[] fields) {
  return new AbstractEnumerable<Object>() {
    public org.apache.calcite.linq4j.Enumerator enumerator() {
      return new QuarkEnumerator();
    }
  };
}

示例12

@Override
public Enumerable<Object[]> scan(DataContext dataContext) {
    return new AbstractEnumerable<Object[]>() {
        @Override
        public Enumerator<Object[]> enumerator() {
            return new StackFramesEnumerator(snapshot, getThreadStacks());
        }
    };
}

示例13

public Enumerable<Object[]> scan(DataContext root) {
  final List<CsvFieldType> fieldTypes = getFieldTypes(root.getTypeFactory());
  final int[] fields = CsvEnumerator.identityList(fieldTypes.size());
  final AtomicBoolean cancelFlag = DataContext.Variable.CANCEL_FLAG.get(root);
  return new AbstractEnumerable<Object[]>() {
    public Enumerator<Object[]> enumerator() {
      return new CsvEnumerator<>(source, cancelFlag, true, null,
          new CsvEnumerator.ArrayRowConverter(fieldTypes, fields, true));
    }
  };
}

示例14

public Enumerable<Object[]> scan(DataContext root) {
  final List<CsvFieldType> fieldTypes = getFieldTypes(root.getTypeFactory());
  final int[] fields = CsvEnumerator.identityList(fieldTypes.size());
  final AtomicBoolean cancelFlag = DataContext.Variable.CANCEL_FLAG.get(root);
  return new AbstractEnumerable<Object[]>() {
    public Enumerator<Object[]> enumerator() {
      return new CsvEnumerator<>(source, cancelFlag, false, null,
          new CsvEnumerator.ArrayRowConverter(fieldTypes, fields));
    }
  };
}

示例15

/** Returns an enumerable over a given projection of the fields.
 *
 * <p>Called from generated code. */
public Enumerable<Object> project(final DataContext root,
    final int[] fields) {
  final AtomicBoolean cancelFlag = DataContext.Variable.CANCEL_FLAG.get(root);
  return new AbstractEnumerable<Object>() {
    public Enumerator<Object> enumerator() {
      return new CsvEnumerator<>(
          source,
          cancelFlag,
          getFieldTypes(root.getTypeFactory()),
          fields);
    }
  };
}

示例16

public Enumerable<Object[]> scan(DataContext root) {
  return new AbstractEnumerable<Object[]>() {
    public Enumerator<Object[]> enumerator() {
      return new JsonEnumerator(getDataList(root.getTypeFactory()));
    }
  };
}

示例17

public Enumerable<Object[]> scan(DataContext root, List<RexNode> filters) {
  final List<CsvFieldType> fieldTypes = getFieldTypes(root.getTypeFactory());
  final String[] filterValues = new String[fieldTypes.size()];
  filters.removeIf(filter -> addFilter(filter, filterValues));
  final int[] fields = CsvEnumerator.identityList(fieldTypes.size());
  final AtomicBoolean cancelFlag = DataContext.Variable.CANCEL_FLAG.get(root);
  return new AbstractEnumerable<Object[]>() {
    public Enumerator<Object[]> enumerator() {
      return new CsvEnumerator<>(source, cancelFlag, false, filterValues,
          new CsvEnumerator.ArrayRowConverter(fieldTypes, fields));
    }
  };
}

示例18

@Override public Enumerable<Object[]> scan(DataContext root) {
  return new AbstractEnumerable<Object[]>() {
    public Enumerator<Object[]> enumerator() {
      return new RedisEnumerator(redisConfig, schema, tableName);
    }
  };
}

示例19

@Override public Enumerable<Object[]> scan(DataContext root) {
  return new AbstractEnumerable<Object[]>() {
    public Enumerator<Object[]> enumerator() {
      return new GeodeSimpleEnumerator<Object[]>(clientCache, regionName) {
        @Override public Object[] convert(Object obj) {
          Object values = convertToRowValues(relDataType.getFieldList(), obj);
          if (values instanceof Object[]) {
            return (Object[]) values;
          }
          return new Object[]{values};
        }
      };
    }
  };
}

示例20

/** Returns an enumerable over a given projection of the fields. */
public Enumerable<Object> project(final int[] fields) {
  return new AbstractEnumerable<Object>() {
    public Enumerator<Object> enumerator() {
      try {
        return new FileEnumerator(reader.iterator(), converter, fields);
      } catch (Exception e) {
        throw new RuntimeException(e);
      }
    }
  };
}

示例21

/** Executes a "find" operation on the underlying collection.
 *
 * <p>For example,
 * <code>zipsTable.find("{state: 'OR'}", "{city: 1, zipcode: 1}")</code></p>
 *
 * @param mongoDb MongoDB connection
 * @param filterJson Filter JSON string, or null
 * @param projectJson Project JSON string, or null
 * @param fields List of fields to project; or null to return map
 * @return Enumerator of results
 */
private Enumerable<Object> find(MongoDatabase mongoDb, String filterJson,
    String projectJson, List<Map.Entry<String, Class>> fields) {
  final MongoCollection collection =
      mongoDb.getCollection(collectionName);
  final Bson filter =
      filterJson == null ? null : BsonDocument.parse(filterJson);
  final Bson project =
      projectJson == null ? null : BsonDocument.parse(projectJson);
  final Function1<Document, Object> getter = MongoEnumerator.getter(fields);
  return new AbstractEnumerable<Object>() {
    public Enumerator<Object> enumerator() {
      @SuppressWarnings("unchecked") final FindIterable<Document> cursor =
          collection.find(filter).projection(project);
      return new MongoEnumerator(cursor.iterator(), getter);
    }
  };
}

示例22

public Enumerable<Object[]> scan(DataContext root) {
  return new AbstractEnumerable<Object[]>() {
    public Enumerator<Object[]> enumerator() {
      final Content content = supplier.get();
      return content.arrayEnumerator();
    }
  };
}

示例23

/**
 * Creates enumerable implementation that applies sessionization to elements from the input
 * enumerator based on a specified key. Elements are windowed into sessions separated by
 * periods with no input for at least the duration specified by gap parameter.
 */
public static Enumerable<Object[]> sessionize(Enumerator<Object[]> inputEnumerator,
    int indexOfWatermarkedColumn, int indexOfKeyColumn, long gap) {
  return new AbstractEnumerable<Object[]>() {
    @Override public Enumerator<Object[]> enumerator() {
      return new SessionizationEnumerator(inputEnumerator,
          indexOfWatermarkedColumn, indexOfKeyColumn, gap);
    }
  };
}

示例24

/**
 * Create enumerable implementation that applies hopping on each element from the input
 * enumerator and produces at least one element for each input element.
 */
public static Enumerable<Object[]> hopping(Enumerator<Object[]> inputEnumerator,
    int indexOfWatermarkedColumn, long emitFrequency, long intervalSize) {
  return new AbstractEnumerable<Object[]>() {
    @Override public Enumerator<Object[]> enumerator() {
      return new HopEnumerator(inputEnumerator,
          indexOfWatermarkedColumn, emitFrequency, intervalSize);
    }
  };
}

示例25

/**
 * Apply tumbling per row from the enumerable input.
 */
public static <TSource, TResult> Enumerable<TResult> tumbling(
    Enumerable<TSource> inputEnumerable,
    Function1<TSource, TResult> outSelector) {
  return new AbstractEnumerable<TResult>() {
    // Applies tumbling on each element from the input enumerator and produces
    // exactly one element for each input element.
    @Override public Enumerator<TResult> enumerator() {
      return new Enumerator<TResult>() {
        Enumerator<TSource> inputs = inputEnumerable.enumerator();

        public TResult current() {
          return outSelector.apply(inputs.current());
        }

        public boolean moveNext() {
          return inputs.moveNext();
        }

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

        public void close() {
        }
      };
    }
  };
}

示例26

/**
 * Function that, given a certain List containing single-item structs (i.e. arrays / lists with
 * a single item), builds an Enumerable that returns those single items inside the structs.
 */
public static Function1<Object, Enumerable<Comparable>> flatList() {
  return inputObject -> {
    final List list = (List) inputObject;
    final Enumerator<List<Object>> enumerator = Linq4j.enumerator(list);
    return new AbstractEnumerable<Comparable>() {
      public Enumerator<Comparable> enumerator() {
        return new Enumerator<Comparable>() {

          @Override public boolean moveNext() {
            return enumerator.moveNext();
          }

          @Override public Comparable current() {
            final Object element = enumerator.current();
            final Comparable comparable;
            if (element.getClass().isArray()) {
              comparable = (Comparable) ((Object[]) element)[0];
            } else {
              comparable = (Comparable) ((List) element).get(0);
            }
            return comparable;
          }

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

          @Override public void close() {
            enumerator.close();
          }
        };
      }
    };
  };
}

示例27

/** Similar to {@link Linq4j#product(Iterable)} but each resulting list
 * implements {@link FlatLists.ComparableList}. */
public static <E extends Comparable> Enumerable<FlatLists.ComparableList<E>> product(
    final List<Enumerator<List<E>>> enumerators, final int fieldCount,
    final boolean withOrdinality) {
  return new AbstractEnumerable<FlatLists.ComparableList<E>>() {
    public Enumerator<FlatLists.ComparableList<E>> enumerator() {
      return new ProductComparableListEnumerator<>(enumerators, fieldCount,
          withOrdinality);
    }
  };
}

示例28

private Enumerable<List<Comparable>> getRows(final PreparedStatement s) {
  return new AbstractEnumerable<List<Comparable>>() {
    public Enumerator<List<Comparable>> enumerator() {
      try {
        final ResultSet r = s.executeQuery();
        return getListEnumerator(r, r.getMetaData().getColumnCount());
      } catch (SQLException e) {
        throw TestUtil.rethrow(e);
      }
    }
  };
}

示例29

public Enumerable<Object[]> scan(DataContext root) {
  return new AbstractEnumerable<Object[]>() {
    public Enumerator<Object[]> enumerator() {
      return nestedRecordsEnumerator();
    }
  };
}

示例30

public Enumerable<Object[]> scan(DataContext root) {
  return new AbstractEnumerable<Object[]>() {
    public Enumerator<Object[]> enumerator() {
      return nestedRecordsEnumerator();
    }
  };
}

Java源码示例：org.apache.calcite.linq4j.AbstractEnumerable

微信关注