@Override public Enumerable<Object[]> scan(final DataContext root) { final FluentIterable<Object[]> results = FluentIterable .from(rootSchema.getSubSchemaNames()) .transform( new Function<String, Object[]>() { @Override public Object[] apply(final String schemaName) { final SchemaPlus subSchema = rootSchema.getSubSchema(schemaName); return new Object[]{ CATALOG_NAME, // CATALOG_NAME subSchema.getName(), // SCHEMA_NAME null, // SCHEMA_OWNER null, // DEFAULT_CHARACTER_SET_CATALOG null, // DEFAULT_CHARACTER_SET_SCHEMA null, // DEFAULT_CHARACTER_SET_NAME null // SQL_PATH }; } } ); return Linq4j.asEnumerable(results); }
RexNode compose(RexBuilder rexBuilder, Iterable<RexNode> exprs) { exprs = Linq4j.asEnumerable(exprs).where(new Predicate1<RexNode>() { public boolean apply(RexNode expr) { return expr != null; } }); return RexUtil.composeConjunction(rexBuilder, exprs, false); }
RexNode compose(RexBuilder rexBuilder, Iterable<RexNode> exprs) { exprs = Linq4j.asEnumerable(exprs).where(new Predicate1<RexNode>() { public boolean apply(RexNode expr) { return expr != null; } }); return RexUtil.composeConjunction(rexBuilder, exprs, false); }
@Override public Enumerable<Object[]> scan(DataContext root) { final List<Object[]> rows = new ArrayList<>(); final List<ImmutableDruidServer> druidServers = serverView.getDruidServers(); final int serverSegmentsTableSize = SERVER_SEGMENTS_SIGNATURE.getRowOrder().size(); for (ImmutableDruidServer druidServer : druidServers) { for (DataSegment segment : druidServer.getSegments()) { Object[] row = new Object[serverSegmentsTableSize]; row[0] = druidServer.getHost(); row[1] = segment.getId(); rows.add(row); } } return Linq4j.asEnumerable(rows); } }
return Linq4j.asEnumerable(results);
return Linq4j.asEnumerable(results);
); return Linq4j.asEnumerable(allSegments).where(Objects::nonNull);
@Override public Enumerable<Object[]> scan(DataContext root) { final List<ImmutableDruidServer> druidServers = serverView.getDruidServers(); final AuthenticationResult authenticationResult = (AuthenticationResult) root.get(PlannerContext.DATA_CTX_AUTHENTICATION_RESULT); final Access access = AuthorizationUtils.authorizeAllResourceActions( authenticationResult, Collections.singletonList(new ResourceAction(new Resource("STATE", ResourceType.STATE), Action.READ)), authorizerMapper ); if (!access.isAllowed()) { throw new ForbiddenException("Insufficient permission to view servers :" + access); } final FluentIterable<Object[]> results = FluentIterable .from(druidServers) .transform(val -> new Object[]{ val.getHost(), extractHost(val.getHost()), (long) extractPort(val.getHostAndPort()), (long) extractPort(val.getHostAndTlsPort()), toStringOrNull(val.getType()), val.getTier(), val.getCurrSize(), val.getMaxSize() }); return Linq4j.asEnumerable(results); } }
public Enumerable<Object[]> scan(DataContext root) { Object[][] rows = {{"abcde"}, {"xyz"}, {content}}; return Linq4j.asEnumerable(rows); } }
public Enumerable<Object[]> scan(DataContext root) { Object[][] rows = {{"abcde"}, {"xyz"}, {content}}; return Linq4j.asEnumerable(rows); } }
Enumerable<MetaCatalog> catalogs() { final String catalog; try { catalog = connection.getCatalog(); } catch (SQLException e) { throw new RuntimeException(e); } return Linq4j.asEnumerable( ImmutableList.of(new MetaCatalog(catalog))); }
Enumerable<MetaTableType> tableTypes() { return Linq4j.asEnumerable( ImmutableList.of( new MetaTableType("TABLE"), new MetaTableType("VIEW"))); }
/** * Produces the set union of two sequences by using * the default equality comparer. */ public static <TSource> Enumerable<TSource> union(Enumerable<TSource> source0, Enumerable<TSource> source1) { Set<TSource> set = new HashSet<>(); source0.into(set); source1.into(set); return Linq4j.asEnumerable(set); }
Enumerable<MetaTableType> tableTypes() { return Linq4j.asEnumerable( ImmutableList.of( new MetaTableType("TABLE"), new MetaTableType("VIEW"))); }
CatalogScope(SqlValidatorScope parent, List<String> names) { super(parent); this.names = ImmutableList.copyOf(names); this.schemaNames = Linq4j.asEnumerable( validator.getCatalogReader() .getAllSchemaObjectNames(ImmutableList.of())) .where(input -> input.getType() == SqlMonikerType.SCHEMA) .select(SqlMoniker::getFullyQualifiedNames) .into(new HashSet<>()); }
public void sortAndAccumulate(Iterable<TSource> sourceIterable, TAccumulate accumulator) { List<TSource> sorted = Linq4j.asEnumerable(sourceIterable) .orderBy(keySelector, comparator) .toList(); TAccumulate accumulator1 = accumulator; for (TSource source : sorted) { accumulator1 = accumulatorAdder.apply(accumulator1, source); } } }
private static <T extends Comparable<T>> Enumerable<T> intersect( List<T> list0, List<T> list1) { return EnumerableDefaults.mergeJoin( Linq4j.asEnumerable(list0), Linq4j.asEnumerable(list1), Functions.identitySelector(), Functions.identitySelector(), (v0, v1) -> v0, false, false); }
private static <T extends Comparable<T>> Enumerable<T> intersect( List<T> list0, List<T> list1) { return EnumerableDefaults.mergeJoin( Linq4j.asEnumerable(list0), Linq4j.asEnumerable(list1), Functions.identitySelector(), Functions.identitySelector(), (v0, v1) -> v0, false, false); }
Enumerable<MetaSchema> schemas(final String catalog) { return Linq4j.asEnumerable( getConnection().rootSchema.getSubSchemaMap().values()) .select((Function1<CalciteSchema, MetaSchema>) calciteSchema -> new CalciteMetaSchema(calciteSchema, catalog, calciteSchema.getName())) .orderBy((Function1<MetaSchema, Comparable>) metaSchema -> (Comparable) FlatLists.of(Util.first(metaSchema.tableCatalog, ""), metaSchema.tableSchem)); }
Enumerable<MetaSchema> schemas(final String catalog) { return Linq4j.asEnumerable( getConnection().rootSchema.getSubSchemaMap().values()) .select((Function1<CalciteSchema, MetaSchema>) calciteSchema -> new CalciteMetaSchema(calciteSchema, catalog, calciteSchema.getName())) .orderBy((Function1<MetaSchema, Comparable>) metaSchema -> (Comparable) FlatLists.of(Util.first(metaSchema.tableCatalog, ""), metaSchema.tableSchem)); }