@Override public StreamProperties visitTableScan(TableScanNode node, List<StreamProperties> inputProperties) { checkArgument(node.getLayout().isPresent(), "table layout has not yet been chosen"); TableLayout layout = metadata.getLayout(session, node.getLayout().get()); Map<ColumnHandle, Symbol> assignments = ImmutableBiMap.copyOf(node.getAssignments()).inverse(); // Globally constant assignments Set<ColumnHandle> constants = new HashSet<>(); extractFixedValues(node.getCurrentConstraint()).orElse(ImmutableMap.of()) .entrySet().stream() .filter(entry -> !entry.getValue().isNull()) // TODO consider allowing nulls .forEach(entry -> constants.add(entry.getKey())); Optional<Set<Symbol>> streamPartitionSymbols = layout.getStreamPartitioningColumns() .flatMap(columns -> getNonConstantSymbols(columns, assignments, constants)); // if we are partitioned on empty set, we must say multiple of unknown partitioning, because // the connector does not guarantee a single split in this case (since it might not understand // that the value is a constant). if (streamPartitionSymbols.isPresent() && streamPartitionSymbols.get().isEmpty()) { return new StreamProperties(MULTIPLE, Optional.empty(), false); } return new StreamProperties(MULTIPLE, streamPartitionSymbols, false); }
@GwtIncompatible // SerializableTester public void testInverseSerialization() { ImmutableBiMap<String, Integer> bimap = ImmutableBiMap.copyOf(ImmutableMap.of(1, "one", 2, "two")).inverse(); ImmutableBiMap<String, Integer> copy = SerializableTester.reserializeAndAssert(bimap); assertEquals(Integer.valueOf(1), copy.get("one")); assertEquals("one", copy.inverse().get(1)); assertSame(copy, copy.inverse().inverse()); } }
public void testConstantNameMatchesString() throws Exception { // Special case some of the weird HTTP Header names... ImmutableBiMap<String, String> specialCases = ImmutableBiMap.of( "ETAG", "ETag", "X_WEBKIT_CSP", "X-WebKit-CSP", "X_WEBKIT_CSP_REPORT_ONLY", "X-WebKit-CSP-Report-Only"); ImmutableSet<String> uppercaseAcronyms = ImmutableSet.of( "ID", "DNT", "DNS", "HTTP2", "IP", "MD5", "P3P", "TE", "UID", "URL", "WWW", "XSS"); assertConstantNameMatchesString(HttpHeaders.class, specialCases, uppercaseAcronyms); }
public static int getLog2mFromHllFieldSize(int hllFieldSize) { Preconditions.checkArgument(LOG2M_TO_SIZE_IN_BYTES.containsValue(hllFieldSize), "HllFieldSize: " + hllFieldSize + " is not in valid range."); return LOG2M_TO_SIZE_IN_BYTES.inverse().get(hllFieldSize); } }
public static int getHllFieldSizeFromLog2m(int log2m) { Preconditions .checkArgument(LOG2M_TO_SIZE_IN_BYTES.containsKey(log2m), "Log2m: " + log2m + " is not in valid range."); return LOG2M_TO_SIZE_IN_BYTES.get(log2m); }
@Override public ActualProperties visitTableScan(TableScanNode node, List<ActualProperties> inputProperties) { checkArgument(node.getLayout().isPresent(), "table layout has not yet been chosen"); TableLayout layout = metadata.getLayout(session, node.getLayout().get()); Map<ColumnHandle, Symbol> assignments = ImmutableBiMap.copyOf(node.getAssignments()).inverse(); ActualProperties.Builder properties = ActualProperties.builder(); // Globally constant assignments Map<ColumnHandle, NullableValue> globalConstants = new HashMap<>(); extractFixedValues(node.getCurrentConstraint()).orElse(ImmutableMap.of()) .entrySet().stream() .filter(entry -> !entry.getValue().isNull()) .forEach(entry -> globalConstants.put(entry.getKey(), entry.getValue())); Map<Symbol, NullableValue> symbolConstants = globalConstants.entrySet().stream() .filter(entry -> assignments.containsKey(entry.getKey())) .collect(toMap(entry -> assignments.get(entry.getKey()), Map.Entry::getValue)); properties.constants(symbolConstants); // Partitioning properties properties.global(deriveGlobalProperties(layout, assignments, globalConstants)); // Append the global constants onto the local properties to maximize their translation potential List<LocalProperty<ColumnHandle>> constantAppendedLocalProperties = ImmutableList.<LocalProperty<ColumnHandle>>builder() .addAll(globalConstants.keySet().stream().map(ConstantProperty::new).iterator()) .addAll(layout.getLocalProperties()) .build(); properties.local(LocalProperties.translate(constantAppendedLocalProperties, column -> Optional.ofNullable(assignments.get(column)))); return properties.build(); }
.transform(node.getAssignments()::get) .intersect(node.getCurrentConstraint()); List<TableLayoutResult> layouts = metadata.getLayouts( session, node.getTable(), new Constraint<>(simplifiedConstraint, bindings -> true), Optional.of(ImmutableSet.copyOf(node.getAssignments().values()))); node.getOutputSymbols(), node.getAssignments(), Optional.of(layout.getLayout().getHandle()), simplifiedConstraint.intersect(layout.getLayout().getPredicate()), Optional.ofNullable(node.getOriginalConstraint()).orElse(predicate)); Map<ColumnHandle, Symbol> assignments = ImmutableBiMap.copyOf(node.getAssignments()).inverse(); Expression resultingPredicate = combineConjuncts( decomposedPredicate.getRemainingExpression(),
@Override public Optional<NewTableLayout> getInsertLayout(Session session, TableHandle target) { List<TableLayout> layouts = getLayouts(session, target, new Constraint<>(TupleDomain.all(), map -> true), Optional.empty()) .stream() .map(TableLayoutResult::getLayout) .filter(layout -> layout.getNodePartitioning().isPresent()) .collect(toImmutableList()); if (layouts.isEmpty()) { return Optional.empty(); } if (layouts.size() > 1) { throw new PrestoException(NOT_SUPPORTED, "Tables with multiple layouts can not be written"); } TableLayout layout = Iterables.getOnlyElement(layouts); ConnectorPartitioningHandle partitioningHandle = layout.getNodePartitioning().get().getPartitioningHandle().getConnectorHandle(); Map<ColumnHandle, String> columnNamesByHandle = ImmutableBiMap.copyOf(getColumnHandles(session, target)).inverse(); List<String> partitionColumns = layout.getNodePartitioning().get().getPartitioningColumns().stream() .map(columnNamesByHandle::get) .collect(toImmutableList()); return Optional.of(new NewTableLayout( layout.getConnectorId(), lookupConnectorFor(target).getTransactionHandle(session), new ConnectorNewTableLayout(partitioningHandle, partitionColumns))); }
Optional<TableHandle> tableHandle = metadata.getTableHandle(session, tableName); if (!tableHandle.isPresent()) { throw new TableNotFoundException(tableName.asSchemaTableName()); List<TableLayoutResult> layouts = metadata.getLayouts(session, tableHandle.get(), Constraint.<ColumnHandle>alwaysTrue(), Optional.empty()); Map<ColumnHandle, String> columnHandles = ImmutableBiMap.copyOf(metadata.getColumnHandles(session, tableHandle.get())).inverse(); Map<ColumnHandle, MethodHandle> methodHandles = new HashMap<>(); for (ColumnHandle columnHandle : columnHandles.keySet()) { int partitionNumber = 1; for (TupleDomain<ColumnHandle> domain : predicates.getPredicates()) { for (Entry<ColumnHandle, NullableValue> entry : TupleDomain.extractFixedValues(domain).get().entrySet()) { ColumnHandle columnHandle = entry.getKey(); String columnName = columnHandles.get(columnHandle);
.transform(node.getAssignments()::get) .intersect(node.getEnforcedConstraint()); .collect(toImmutableSet()); Set<ColumnHandle> outputColumns = node.getOutputSymbols().stream().map(node.getAssignments()::get).collect(toImmutableSet()); Optional<ResolvedIndex> optionalResolvedIndex = metadata.resolveIndex(session, node.getTable(), lookupColumns, outputColumns, simplifiedConstraint); if (!optionalResolvedIndex.isPresent()) { ResolvedIndex resolvedIndex = optionalResolvedIndex.get(); Map<ColumnHandle, Symbol> inverseAssignments = ImmutableBiMap.copyOf(node.getAssignments()).inverse(); domainTranslator.toPredicate(resolvedIndex.getUnresolvedTupleDomain().transform(inverseAssignments::get)), decomposedPredicate.getRemainingExpression());
/** * Create a prefix {@link Converter} for {@link XPathExpressionException} defined in a particular YANG * {@link Module} .Instantiation requires establishing how a module's imports are mapped to actual modules * and their namespaces. This information is cached and used for improved lookups. * * @param ctx A SchemaContext * @param module Module in which the XPath is defined * @return A new Converter */ public static @Nonnull Converter<String, QNameModule> create(final SchemaContext ctx, final Module module) { // Always check for null ctx requireNonNull(ctx, "Schema context may not be null"); // Use immutable map builder for detection of duplicates (which should never occur) final Builder<String, QNameModule> b = ImmutableBiMap.builder(); b.put(module.getPrefix(), module.getQNameModule()); for (ModuleImport i : module.getImports()) { final Optional<Module> mod = ctx.findModule(i.getModuleName(), i.getRevision()); checkArgument(mod.isPresent(), "Unsatisfied import of %s by module %s", i, module); b.put(i.getPrefix(), mod.get().getQNameModule()); } return Maps.asConverter(b.build()); } }
public Optional<Flags.Flag> asSystemFlag() { return Optional.ofNullable(IMAP_SYSTEM_FLAGS.inverse() .get(this)); }
static Optional<String> mutableToImmutable(String fullyQualifiedClassName) { return Optional.ofNullable(MUTABLE_TO_IMMUTABLE_CLASS_NAME_MAP.get(fullyQualifiedClassName)); }
.transform(node.getAssignments()::get) .intersect(node.getEnforcedConstraint()); Map<ColumnHandle, Symbol> assignments = ImmutableBiMap.copyOf(node.getAssignments()).inverse(); domainTranslator.toPredicate(newDomain.simplify().transform(assignments::get)))); constraint = new Constraint<>(newDomain, evaluator::isCandidate); List<TableLayoutResult> layouts = metadata.getLayouts( session, node.getTable(), constraint, Optional.of(node.getOutputSymbols().stream() .map(node.getAssignments()::get) .collect(toImmutableSet()))); node.getOutputSymbols(), node.getAssignments(), Optional.of(layout.getLayout().getHandle()), layout.getLayout().getPredicate(), computeEnforced(newDomain, layout.getUnenforcedConstraint()));
public void testGet_collections() { assertEquals(ImmutableSet.of().iterator(), ArbitraryInstances.get(Iterator.class)); assertFalse(ArbitraryInstances.get(PeekingIterator.class).hasNext()); assertFalse(ArbitraryInstances.get(ListIterator.class).hasNext()); assertEquals(ImmutableSet.of(), ArbitraryInstances.get(Iterable.class)); assertEquals(ImmutableSet.of(), ArbitraryInstances.get(Set.class)); assertEquals(ImmutableSet.of(), ArbitraryInstances.get(ImmutableSet.class)); assertEquals(ImmutableList.of(), ArbitraryInstances.get(List.class)); assertEquals(ImmutableList.of(), ArbitraryInstances.get(ImmutableList.class)); assertEquals(ImmutableMap.of(), ArbitraryInstances.get(Map.class)); assertEquals(ImmutableMap.of(), ArbitraryInstances.get(ImmutableMap.class)); assertEquals(ImmutableSortedMap.of(), ArbitraryInstances.get(SortedMap.class)); assertEquals(ImmutableSortedMap.of(), ArbitraryInstances.get(ImmutableSortedMap.class)); assertEquals(ImmutableTable.of(), ArbitraryInstances.get(ImmutableTable.class)); assertTrue(ArbitraryInstances.get(RowSortedTable.class).isEmpty()); assertEquals(ImmutableBiMap.of(), ArbitraryInstances.get(BiMap.class)); assertEquals(ImmutableBiMap.of(), ArbitraryInstances.get(ImmutableBiMap.class)); assertTrue(ArbitraryInstances.get(ImmutableClassToInstanceMap.class).isEmpty()); assertTrue(ArbitraryInstances.get(ClassToInstanceMap.class).isEmpty());
getAllChecks().values().stream() .filter(c -> c.defaultSeverity() == SeverityLevel.ERROR && c.disableable()) .forEach(c -> severities.put(c.canonicalName(), SeverityLevel.WARNING)); getAllChecks().values().stream() .filter(c -> c.disableable()) .forEach(c -> disabled.add(c.canonicalName())); BugCheckerInfo check = getAllChecks().get(checkName); if (check == null) { if (errorProneOptions.ignoreUnknownChecks()) { case WARN: if (!disabled().contains(check.canonicalName()) && !check.disableable() && check.defaultSeverity() == SeverityLevel.ERROR) { ImmutableMap.copyOf(severities), ImmutableSet.copyOf(disabled), ErrorProneFlags.fromMap(flagsMap));
public void testFromHashMap() { Map<String, Integer> hashMap = Maps.newLinkedHashMap(); hashMap.put("one", 1); hashMap.put("two", 2); ImmutableBiMap<String, Integer> bimap = ImmutableBiMap.copyOf(ImmutableMap.of("one", 1, "two", 2)); assertMapEquals(bimap, "one", 1, "two", 2); assertMapEquals(bimap.inverse(), 1, "one", 2, "two"); }
public void testKeySet() { ImmutableBiMap<String, Integer> bimap = ImmutableBiMap.copyOf(ImmutableMap.of("one", 1, "two", 2, "three", 3, "four", 4)); Set<String> keys = bimap.keySet(); assertEquals(Sets.newHashSet("one", "two", "three", "four"), keys); assertThat(keys).containsExactly("one", "two", "three", "four").inOrder(); }
/** * Finalize internal data structure after all the states and transitions have been added. */ public void finishDefinition(){ sequencer = null; states = ImmutableBiMap.copyOf(states); Map<S, Set<T>> validTransitionsCopied = new HashMap<S, Set<T>>(); for (Map.Entry<S, Set<T>> entry: validTransitions.entrySet()){ validTransitionsCopied.put(entry.getKey(), ImmutableSet.copyOf(entry.getValue())); } validTransitions = ImmutableMap.copyOf(validTransitions); }