Akshat-Jain commented on code in PR #17038: URL: https://github.com/apache/druid/pull/17038#discussion_r1793404447
########## 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)) { + RowsAndColumns gluedRAC = getConcatRacForFirstPartition(previousRac, limitedRAC); + ensureMaxRowsMaterializedConstraint(gluedRAC.numRows()); + previousRac = null; + currentIndex++; + return gluedRAC; + } else { + if (previousRac != null) { + RowsAndColumns temp = previousRac; + previousRac = null; + return temp; + } + } + } + + int start = boundaries[currentIndex]; + int end = boundaries[currentIndex + 1]; + currentIndex++; + return new LimitedRowsAndColumns(rac, start, end); + } + + /** + * Determines whether gluing is needed between the previous RowsAndColumns and the first partition + * of the current RowsAndColumns based on the partition columns. If the columns match, the two RACs + * will be glued together. + * + * @param previousRac The previous RowsAndColumns. + * @param firstPartitionOfCurrentRac The first partition of the current RowsAndColumns. + * @return true if gluing is needed, false otherwise. + */ + private boolean isGlueingNeeded(RowsAndColumns previousRac, RowsAndColumns firstPartitionOfCurrentRac) + { + if (previousRac == null) { + return false; + } + + final ConcatRowsAndColumns concatRac = getConcatRacForFirstPartition(previousRac, firstPartitionOfCurrentRac); + for (String column : partitionColumns) { + final Column theCol = concatRac.findColumn(column); + if (theCol == null) { + continue; + } + final ColumnAccessor accessor = theCol.toAccessor(); + // Compare 1st row of previousRac and firstPartitionOfCurrentRac in [previousRac, firstPartitionOfCurrentRac] form. + int comparison = accessor.compareRows(0, previousRac.numRows()); + if (comparison != 0) { + return false; + } + } + return true; + } + + private ConcatRowsAndColumns getConcatRacForFirstPartition(RowsAndColumns previousRac, RowsAndColumns firstPartitionOfCurrentRac) + { + return new ConcatRowsAndColumns(new ArrayList<>(Arrays.asList(previousRac, firstPartitionOfCurrentRac))); + } + } + + private void ensureMaxRowsMaterializedConstraint(int numRows) + { + if (maxRowsMaterialized != MAX_ROWS_MATERIALIZED_NO_LIMIT && numRows > maxRowsMaterialized) { + throw InvalidInput.exception( + "Too many rows to process (requested = %d, max = %d).", + numRows, + maxRowsMaterialized + ); + } + } + + @Override + protected Iterator<RowsAndColumns> getIteratorForRAC(RowsAndColumns rac) + { + return new GluedRACsIterator(rac); Review Comment: Right now, the GluedRACsIterator class encapsulates all the glueing logic. If we start doing the glueing outside, then it defeats the point of having an iterator class in my opinion. If we start doing the glueing in getIteratorForRAC(), then GluedRACsIterator would not have anything left to do - so we might as well not have any such class? Maybe I'm misinterpreting what you have in mind. Thoughts? -- 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]
