private static Optional<List<Symbol>> translateSymbols(Iterable<Symbol> partitioning, Function<Symbol, Optional<Symbol>> translator) { ImmutableList.Builder<Symbol> newPartitioningColumns = ImmutableList.builder(); for (Symbol partitioningColumn : partitioning) { Optional<Symbol> translated = translator.apply(partitioningColumn); if (!translated.isPresent()) { return Optional.empty(); } newPartitioningColumns.add(translated.get()); } return Optional.of(newPartitioningColumns.build()); }
public long getTotalPartitionsCount(String keyspace, String table, Optional<Long> sessionSplitsPerNode) { if (sessionSplitsPerNode.isPresent()) { return sessionSplitsPerNode.get(); } else if (configSplitsPerNode.isPresent()) { return configSplitsPerNode.get(); } List<SizeEstimate> estimates = session.getSizeEstimates(keyspace, table); return estimates.stream() .mapToLong(SizeEstimate::getPartitionsCount) .sum(); }
private ConnectorBucketNodeMap(int bucketCount, Optional<List<Node>> bucketToNode) { if (bucketCount <= 0) { throw new IllegalArgumentException("bucketCount must be positive"); } if (bucketToNode.isPresent() && bucketToNode.get().size() != bucketCount) { throw new IllegalArgumentException(format("Mismatched bucket count in bucketToNode (%s) and bucketCount (%s)", bucketToNode.get().size(), bucketCount)); } this.bucketCount = bucketCount; this.bucketToNode = bucketToNode.map(ArrayList::new).map(Collections::unmodifiableList); }
public List<Symbol> getOriginalNonDistinctAggregateArgs() { return aggregations.values().stream() .filter(aggregation -> !aggregation.getMask().isPresent()) .map(Aggregation::getCall) .flatMap(function -> function.getArguments().stream()) .distinct() .map(Symbol::from) .collect(Collectors.toList()); }
private static Optional<Domain> getDomain(OptionalInt timestampOrdinalPosition, TupleDomain<LocalFileColumnHandle> predicate) { Optional<Map<LocalFileColumnHandle, Domain>> domains = predicate.getDomains(); Domain domain = null; if (domains.isPresent() && timestampOrdinalPosition.isPresent()) { Map<LocalFileColumnHandle, Domain> domainMap = domains.get(); Set<Domain> timestampDomain = domainMap.entrySet().stream() .filter(entry -> entry.getKey().getOrdinalPosition() == timestampOrdinalPosition.getAsInt()) .map(Map.Entry::getValue) .collect(toSet()); if (!timestampDomain.isEmpty()) { domain = Iterables.getOnlyElement(timestampDomain); } } return Optional.ofNullable(domain); }
@Override public Boolean process(Node node, @Nullable Void context) { if (expressions.stream().anyMatch(node::equals) && (!orderByScope.isPresent() || !hasOrderByReferencesToOutputColumns(node)) && !hasFreeReferencesToLambdaArgument(node, analysis)) { return true; } return super.process(node, context); } }
@Test @SuppressWarnings("rawtypes") public void missingOptionalParamList() throws Exception { ConfigurableWebBindingInitializer initializer = new ConfigurableWebBindingInitializer(); initializer.setConversionService(new DefaultConversionService()); WebDataBinderFactory binderFactory = new DefaultDataBinderFactory(initializer); MethodParameter param = this.testMethod.annotPresent(RequestParam.class).arg(Optional.class, List.class); Object result = resolver.resolveArgument(param, null, webRequest, binderFactory); assertEquals(Optional.empty(), result); result = resolver.resolveArgument(param, null, webRequest, binderFactory); assertEquals(Optional.class, result.getClass()); assertFalse(((Optional) result).isPresent()); }
@Test public void resolveOptionalParamValue() { ServerWebExchange exchange = MockServerWebExchange.from(MockServerHttpRequest.get("/")); MethodParameter param = this.testMethod.arg(forClassWithGenerics(Optional.class, Integer.class)); Object result = resolve(param, exchange); assertEquals(Optional.empty(), result); exchange = MockServerWebExchange.from(MockServerHttpRequest.get("/path?name=123")); result = resolve(param, exchange); assertEquals(Optional.class, result.getClass()); Optional<?> value = (Optional<?>) result; assertTrue(value.isPresent()); assertEquals(123, value.get()); }
private void checkLeftOutputSymbolsBeforeRight(List<Symbol> leftSymbols, List<Symbol> outputSymbols) { int leftMaxPosition = -1; Optional<Integer> rightMinPosition = Optional.empty(); Set<Symbol> leftSymbolsSet = new HashSet<>(leftSymbols); for (int i = 0; i < outputSymbols.size(); i++) { Symbol symbol = outputSymbols.get(i); if (leftSymbolsSet.contains(symbol)) { leftMaxPosition = i; } else if (!rightMinPosition.isPresent()) { rightMinPosition = Optional.of(i); } } checkState(!rightMinPosition.isPresent() || rightMinPosition.get() > leftMaxPosition, "Not all left output symbols are before right output symbols"); }
private ConnectorBucketNodeMap(int bucketCount, Optional<List<Node>> bucketToNode) { if (bucketCount <= 0) { throw new IllegalArgumentException("bucketCount must be positive"); } if (bucketToNode.isPresent() && bucketToNode.get().size() != bucketCount) { throw new IllegalArgumentException(format("Mismatched bucket count in bucketToNode (%s) and bucketCount (%s)", bucketToNode.get().size(), bucketCount)); } this.bucketCount = bucketCount; this.bucketToNode = bucketToNode.map(ArrayList::new).map(Collections::unmodifiableList); }
@JsonCreator // Available for Jackson deserialization only! public static <T> TupleDomain<T> fromColumnDomains(@JsonProperty("columnDomains") Optional<List<ColumnDomain<T>>> columnDomains) { if (!columnDomains.isPresent()) { return none(); } return withColumnDomains(columnDomains.get().stream() .collect(toMap(ColumnDomain::getColumn, ColumnDomain::getDomain))); }
/** * If a value is present in {@code optional}, returns a stream containing only that element, * otherwise returns an empty stream. * * <p><b>Java 9 users:</b> use {@code optional.stream()} instead. */ public static <T> Stream<T> stream(java.util.Optional<T> optional) { return optional.isPresent() ? Stream.of(optional.get()) : Stream.of(); }
private Set<NullableValue> filterValues(Set<NullableValue> nullableValues, TpchColumn<?> column, Constraint<ColumnHandle> constraint) { return nullableValues.stream() .filter(convertToPredicate(constraint.getSummary(), toColumnHandle(column))) .filter(value -> !constraint.predicate().isPresent() || constraint.predicate().get().test(ImmutableMap.of(toColumnHandle(column), value))) .collect(toSet()); }
@Test @SuppressWarnings("rawtypes") public void missingOptionalParamValue() throws Exception { ConfigurableWebBindingInitializer initializer = new ConfigurableWebBindingInitializer(); initializer.setConversionService(new DefaultConversionService()); WebDataBinderFactory binderFactory = new DefaultDataBinderFactory(initializer); MethodParameter param = this.testMethod.annotPresent(RequestParam.class).arg(Optional.class, Integer.class); Object result = resolver.resolveArgument(param, null, webRequest, binderFactory); assertEquals(Optional.empty(), result); result = resolver.resolveArgument(param, null, webRequest, binderFactory); assertEquals(Optional.class, result.getClass()); assertFalse(((Optional) result).isPresent()); }
@Override protected String visitParameter(Parameter node, Void context) { if (parameters.isPresent()) { checkArgument(node.getPosition() < parameters.get().size(), "Invalid parameter number %s. Max value is %s", node.getPosition(), parameters.get().size() - 1); return process(parameters.get().get(node.getPosition()), context); } return "?"; }