Akshat-Jain commented on code in PR #17038: URL: https://github.com/apache/druid/pull/17038#discussion_r1793843435
########## processing/src/main/java/org/apache/druid/query/operator/GlueingPartitioningOperator.java: ########## @@ -0,0 +1,279 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.druid.query.operator; + +import org.apache.druid.error.InvalidInput; +import org.apache.druid.query.rowsandcols.ConcatRowsAndColumns; +import org.apache.druid.query.rowsandcols.LimitedRowsAndColumns; +import org.apache.druid.query.rowsandcols.RowsAndColumns; +import org.apache.druid.query.rowsandcols.column.Column; +import org.apache.druid.query.rowsandcols.column.ColumnAccessor; +import org.apache.druid.query.rowsandcols.semantic.ClusteredGroupPartitioner; +import org.apache.druid.query.rowsandcols.semantic.DefaultClusteredGroupPartitioner; + +import java.io.Closeable; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Iterator; +import java.util.List; +import java.util.NoSuchElementException; +import java.util.concurrent.atomic.AtomicReference; + +/** + * This glueing partitioning operator is supposed to continuously receive data, and output batches of partitioned RACs. + * It maintains a last-partitioning-boundary of the last-pushed-RAC, and attempts to glue it with the next RAC it receives, + * ensuring that partitions are handled correctly, even across multiple RACs. + * <p> + * Additionally, this assumes that data has been pre-sorted according to the partitioning columns. + */ +public class GlueingPartitioningOperator extends AbstractPartitioningOperator +{ + private final int maxRowsMaterialized; + private RowsAndColumns previousRac; + + private static final int MAX_ROWS_MATERIALIZED_NO_LIMIT = -1; + + public GlueingPartitioningOperator( + Operator child, + List<String> partitionColumns + ) + { + this(child, partitionColumns, MAX_ROWS_MATERIALIZED_NO_LIMIT); + } + + public GlueingPartitioningOperator( + Operator child, + List<String> partitionColumns, + int maxRowsMaterialized + ) + { + super(partitionColumns, child); + this.maxRowsMaterialized = maxRowsMaterialized; + } + + @Override + public Closeable goOrContinue(Closeable continuation, Receiver receiver) + { + if (continuation != null) { + Continuation cont = (Continuation) continuation; + + if (cont.iter != null) { + while (cont.iter.hasNext()) { + RowsAndColumns next = cont.iter.next(); + + if (!cont.iter.hasNext()) { + // We are at the last RAC. Process it only if subContinuation is null, otherwise save it in previousRac. + if (cont.subContinuation == null) { + receiver.push(next); + receiver.completed(); + return null; + } else { + previousRac = next; + break; + } + } + + final Signal signal = receiver.push(next); + if (signal != Signal.GO) { + return handleNonGoCases(signal, cont.iter, receiver, cont); + } + } + + if (cont.subContinuation == null) { + receiver.completed(); + return null; + } + } + + continuation = cont.subContinuation; + } + + AtomicReference<Iterator<RowsAndColumns>> iterHolder = new AtomicReference<>(); + + final Closeable retVal = child.goOrContinue( + continuation, + new Receiver() + { + @Override + public Signal push(RowsAndColumns rac) + { + ensureMaxRowsMaterializedConstraint(rac.numRows()); + return handlePush(rac, receiver, iterHolder); + } + + @Override + public void completed() + { + if (previousRac != null) { + receiver.push(previousRac); + previousRac = null; + } + if (iterHolder.get() == null) { + receiver.completed(); + } + } + } + ); + + if (iterHolder.get() != null || retVal != null) { + return new Continuation( + iterHolder.get(), + retVal + ); + } else { + return null; + } + } + + /** + * Iterator implementation for gluing partitioned RowsAndColumns. + * It handles the boundaries of partitions within a single RAC and potentially glues + * the first partition of the current RAC with the previous RAC if needed. + */ + private class GluedRACsIterator implements Iterator<RowsAndColumns> + { + private final RowsAndColumns rac; + private final int[] boundaries; + private int currentIndex = 0; + private boolean firstPartitionHandled = false; + + public GluedRACsIterator(RowsAndColumns rac) + { + this.rac = rac; + ClusteredGroupPartitioner groupPartitioner = rac.as(ClusteredGroupPartitioner.class); + if (groupPartitioner == null) { + groupPartitioner = new DefaultClusteredGroupPartitioner(rac); + } + this.boundaries = groupPartitioner.computeBoundaries(partitionColumns); + } + + @Override + public boolean hasNext() + { + return currentIndex < boundaries.length - 1; + } + + /** + * Retrieves the next partition in the RowsAndColumns. If the first partition has not been handled yet, + * it may be glued with the previous RowsAndColumns if the partition columns match. + * + * @return The next RowsAndColumns partition, potentially glued with the previous one. + * @throws NoSuchElementException if there are no more partitions. + */ + @Override + public RowsAndColumns next() + { + if (!hasNext()) { + throw new NoSuchElementException(); + } + + if (!firstPartitionHandled) { + firstPartitionHandled = true; + int start = boundaries[currentIndex]; + int end = boundaries[currentIndex + 1]; + LimitedRowsAndColumns limitedRAC = new LimitedRowsAndColumns(rac, start, end); + + if (isGlueingNeeded(previousRac, limitedRAC)) { Review Comment: I went with that to keep `isGlueingNeeded` more understandable. Have made the change to build the concat RAC only once, but had to change the method signature to `isGlueingNeeded(ConcatRowsAndColumns rac, int index1, int index2)` to achieve it. Hope that works. -- This is an automated message from the Apache Git Service. To respond to the message, please log on to GitHub and use the URL above to go to the specific comment. To unsubscribe, e-mail: [email protected] For queries about this service, please contact Infrastructure at: [email protected] --------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
