public List<Edge<Node>> getAdjacent(AdjacencyList<V>.Node source) { return adjacencies.get(source); }
void addEdge(Node source, Node target, int weight) { adjacencies.put(source, new Edge<Node>(source, target, weight)); allNodes.add(source); allNodes.add(target); }
void clearVisited() { for (Edge<Node> e : adjacencies.values()) { e.from.visited = false; e.to.visited = false; } }
String functionSignature = String.format(functionSignaturePattern, functionName, functionInput); if (allFuncWithSignatures.get(functionName).contains(functionSignature)) { throw new FunctionValidationException(String.format("Found duplicated function in %s: %s", registryHolder.getJarNameByFunctionSignature(functionName, functionSignature), functionSignature)); } else { functions.add(functionSignature); allFuncWithSignatures.put(functionName, functionSignature);
protected List<RowGroupReadEntry> getReadEntries(int minorFragmentId) { assert minorFragmentId < mappings.size() : String .format("Mappings length [%d] should be longer than minor fragment id [%d] but it isn't.", mappings.size(), minorFragmentId); List<RowGroupInfo> rowGroupsForMinor = mappings.get(minorFragmentId); Preconditions.checkArgument(!rowGroupsForMinor.isEmpty(), String.format("MinorFragmentId %d has no read entries assigned", minorFragmentId)); List<RowGroupReadEntry> entries = new ArrayList<>(); for (RowGroupInfo rgi : rowGroupsForMinor) { RowGroupReadEntry entry = new RowGroupReadEntry(rgi.getPath(), rgi.getStart(), rgi.getLength(), rgi.getRowGroupIndex(), rgi.getNumRecordsToRead()); entries.add(entry); } return entries; }
/** * Returns {@link ListMultimap#asMap multimap.asMap()}, with its type * corrected from {@code Map<K, Collection<V>>} to {@code Map<K, List<V>>}. * * @since 15.0 */ @Beta @SuppressWarnings("unchecked") // safe by specification of ListMultimap.asMap() public static <K, V> Map<K, List<V>> asMap(ListMultimap<K, V> multimap) { return (Map<K, List<V>>) (Map<K, ?>) multimap.asMap(); }
public Set<Node> getNodeSet() { return adjacencies.keySet(); }
/** * Returns list of functions with list of function signatures for each functions. * Uses guava {@link ListMultimap} structure to return data. * If no functions present, will return empty {@link ListMultimap}. * This is read operation, so several users can perform this operation at the same time. * * @return all functions which their signatures */ public ListMultimap<String, String> getAllFunctionsWithSignatures() { try (@SuppressWarnings("unused") Closeable lock = readLock.open()) { ListMultimap<String, String> functionsWithSignatures = ArrayListMultimap.create(); for (Map.Entry<String, Map<String, DrillFuncHolder>> function : functions.entrySet()) { functionsWithSignatures.putAll(function.getKey(), new ArrayList<>(function.getValue().keySet())); } return functionsWithSignatures; } }
@Override public EasySubScan getSpecificScan(int minorFragmentId) { if (mappings == null) { createMappings(this.endpointAffinities); } assert minorFragmentId < mappings.size() : String.format( "Mappings length [%d] should be longer than minor fragment id [%d] but it isn't.", mappings.size(), minorFragmentId); List<CompleteFileWork> filesForMinor = mappings.get(minorFragmentId); Preconditions.checkArgument(!filesForMinor.isEmpty(), String.format("MinorFragmentId %d has no read entries assigned", minorFragmentId)); EasySubScan subScan = new EasySubScan(getUserName(), convert(filesForMinor), formatPlugin, columns, selectionRoot); subScan.setOperatorId(this.getOperatorId()); return subScan; }
/** * Registers all functions present in {@link DrillOperatorTable}, * also sets sync registry version used at the moment of function registration. * * @param operatorTable drill operator table */ public void register(DrillOperatorTable operatorTable) { AtomicInteger versionHolder = new AtomicInteger(); final Map<String, Collection<DrillFuncHolder>> registeredFunctions = registryHolder.getAllFunctionsWithHolders(versionHolder).asMap(); operatorTable.setFunctionRegistryVersion(versionHolder.get()); registerOperatorsWithInference(operatorTable, registeredFunctions); registerOperatorsWithoutInference(operatorTable, registeredFunctions); }
public Set<Node> getNodeSet() { return adjacencies.keySet(); }
/** * Returns list of functions with list of function holders for each functions. * Uses guava {@link ListMultimap} structure to return data. * If no functions present, will return empty {@link ListMultimap}. * If version holder is not null, updates it with current registry version number. * This is read operation, so several users can perform this operation at the same time. * * @param version version holder * @return all functions which their holders */ public ListMultimap<String, DrillFuncHolder> getAllFunctionsWithHolders(AtomicInteger version) { try (@SuppressWarnings("unused") Closeable lock = readLock.open()) { if (version != null) { version.set(this.version); } ListMultimap<String, DrillFuncHolder> functionsWithHolders = ArrayListMultimap.create(); for (Map.Entry<String, Map<String, DrillFuncHolder>> function : functions.entrySet()) { functionsWithHolders.putAll(function.getKey(), new ArrayList<>(function.getValue().values())); } return functionsWithHolders; } }
@Override public KafkaSubScan getSpecificScan(int minorFragmentId) { List<PartitionScanWork> workList = assignments.get(minorFragmentId); List<KafkaPartitionScanSpec> scanSpecList = Lists.newArrayList(); for (PartitionScanWork work : workList) { scanSpecList.add(work.partitionScanSpec); } return new KafkaSubScan(getUserName(), kafkaStoragePlugin, columns, scanSpecList); }
public Collection<Edge<Node>> getAllEdges() { return adjacencies.values(); }
void addEdge(Node source, Node target, int weight) { adjacencies.put(source, new Edge<Node>(source, target, weight)); allNodes.add(source); allNodes.add(target); }
@Override public KuduSubScan getSpecificScan(int minorFragmentId) { List<KuduWork> workList = assignments.get(minorFragmentId); List<KuduSubScanSpec> scanSpecList = Lists.newArrayList(); for (KuduWork work : workList) { scanSpecList.add(new KuduSubScanSpec(getTableName(), work.getPartitionKeyStart(), work.getPartitionKeyEnd())); } return new KuduSubScan(kuduStoragePlugin, scanSpecList, this.columns); }
public void printEdges() { for (Edge<Node> e : adjacencies.values()) { System.out.println(e.from.index + " -> " + e.to.index); } }
public List<Edge<Node>> getAdjacent(AdjacencyList<V>.Node source) { return adjacencies.get(source); }
Collection<Node> getInternalRootNodes() { Set<Node> nodes = new HashSet<Node>(getNodeSet()); for (Edge<Node> e : adjacencies.values()) { nodes.remove(e.to); } return nodes; }
@Override public List<V> get(K key) { synchronized (mutex) { return list(delegate().get(key), mutex); } }