All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.apache.cassandra.db.MultiCBuilder Maven / Gradle / Ivy

There is a newer version: 3.11.12.3
Show newest version
/*
 * 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.cassandra.db;

import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.NavigableSet;

import org.apache.cassandra.config.ColumnDefinition;
import org.apache.cassandra.utils.ByteBufferUtil;
import org.apache.cassandra.utils.btree.BTreeSet;

/**
 * Builder that allow to build multiple Clustering/ClusteringBound at the same time.
 */
public abstract class MultiCBuilder
{
    /**
     * The table comparator.
     */
    protected final ClusteringComparator comparator;

    /**
     * The number of clustering elements that have been added.
     */
    protected int size;

    /**
     * true if the clusterings have been build, false otherwise.
     */
    protected boolean built;

    /**
     * true if the clusterings contains some null elements.
     */
    protected boolean containsNull;

    /**
     * true if the composites contains some unset elements.
     */
    protected boolean containsUnset;

    /**
     * true if some empty collection have been added.
     */
    protected boolean hasMissingElements;

    protected MultiCBuilder(ClusteringComparator comparator)
    {
        this.comparator = comparator;
    }

    /**
     * Creates a new empty {@code MultiCBuilder}.
     */
    public static MultiCBuilder create(ClusteringComparator comparator, boolean forMultipleValues)
    {
        return forMultipleValues
             ? new MultiClusteringBuilder(comparator)
             : new OneClusteringBuilder(comparator);
    }

    /**
     * Adds the specified element to all the clusterings.
     * 

* If this builder contains 2 clustering: A-B and A-C a call to this method to add D will result in the clusterings: * A-B-D and A-C-D. *

* * @param value the value of the next element * @return this MulitCBuilder */ public abstract MultiCBuilder addElementToAll(ByteBuffer value); /** * Adds individually each of the specified elements to the end of all of the existing clusterings. *

* If this builder contains 2 clusterings: A-B and A-C a call to this method to add D and E will result in the 4 * clusterings: A-B-D, A-B-E, A-C-D and A-C-E. *

* * @param values the elements to add * @return this CompositeBuilder */ public abstract MultiCBuilder addEachElementToAll(List values); /** * Adds individually each of the specified list of elements to the end of all of the existing composites. *

* If this builder contains 2 composites: A-B and A-C a call to this method to add [[D, E], [F, G]] will result in the 4 * composites: A-B-D-E, A-B-F-G, A-C-D-E and A-C-F-G. *

* * @param values the elements to add * @return this CompositeBuilder */ public abstract MultiCBuilder addAllElementsToAll(List> values); protected void checkUpdateable() { if (!hasRemaining() || built) throw new IllegalStateException("this builder cannot be updated anymore"); } /** * Returns the number of elements that can be added to the clusterings. * * @return the number of elements that can be added to the clusterings. */ public int remainingCount() { return comparator.size() - size; } /** * Checks if the clusterings contains null elements. * * @return true if the clusterings contains null elements, false otherwise. */ public boolean containsNull() { return containsNull; } /** * Checks if the clusterings contains unset elements. * * @return true if the clusterings contains unset elements, false otherwise. */ public boolean containsUnset() { return containsUnset; } /** * Checks if some empty list of values have been added * @return true if the clusterings have some missing elements, false otherwise. */ public boolean hasMissingElements() { return hasMissingElements; } /** * Builds the clusterings. * * @return the clusterings */ public abstract NavigableSet build(); /** * Builds the ClusteringBounds for slice restrictions. * * @param isStart specify if the bound is a start one * @param isInclusive specify if the bound is inclusive or not * @param isOtherBoundInclusive specify if the other bound is inclusive or not * @param columnDefs the columns of the slice restriction * @return the ClusteringBounds */ public abstract NavigableSet buildBoundForSlice(boolean isStart, boolean isInclusive, boolean isOtherBoundInclusive, List columnDefs); /** * Builds the ClusteringBounds * * @param isStart specify if the bound is a start one * @param isInclusive specify if the bound is inclusive or not * @return the ClusteringBounds */ public abstract NavigableSet buildBound(boolean isStart, boolean isInclusive); /** * Checks if some elements can still be added to the clusterings. * * @return true if it is possible to add more elements to the clusterings, false otherwise. */ public boolean hasRemaining() { return remainingCount() > 0; } /** * Specialization of MultiCBuilder when we know only one clustering/bound is created. */ private static class OneClusteringBuilder extends MultiCBuilder { /** * The elements of the clusterings */ private final ByteBuffer[] elements; public OneClusteringBuilder(ClusteringComparator comparator) { super(comparator); this.elements = new ByteBuffer[comparator.size()]; } public MultiCBuilder addElementToAll(ByteBuffer value) { checkUpdateable(); if (value == null) containsNull = true; if (value == ByteBufferUtil.UNSET_BYTE_BUFFER) containsUnset = true; elements[size++] = value; return this; } public MultiCBuilder addEachElementToAll(List values) { if (values.isEmpty()) { hasMissingElements = true; return this; } assert values.size() == 1; return addElementToAll(values.get(0)); } public MultiCBuilder addAllElementsToAll(List> values) { if (values.isEmpty()) { hasMissingElements = true; return this; } assert values.size() == 1; return addEachElementToAll(values.get(0)); } public NavigableSet build() { built = true; if (hasMissingElements) return BTreeSet.empty(comparator); return BTreeSet.of(comparator, size == 0 ? Clustering.EMPTY : Clustering.make(elements)); } @Override public NavigableSet buildBoundForSlice(boolean isStart, boolean isInclusive, boolean isOtherBoundInclusive, List columnDefs) { return buildBound(isStart, columnDefs.get(0).isReversedType() ? isOtherBoundInclusive : isInclusive); } public NavigableSet buildBound(boolean isStart, boolean isInclusive) { built = true; if (hasMissingElements) return BTreeSet.empty(comparator); if (size == 0) return BTreeSet.of(comparator, isStart ? ClusteringBound.BOTTOM : ClusteringBound.TOP); ByteBuffer[] newValues = size == elements.length ? elements : Arrays.copyOf(elements, size); return BTreeSet.of(comparator, ClusteringBound.create(ClusteringBound.boundKind(isStart, isInclusive), newValues)); } } /** * MultiCBuilder implementation actually supporting the creation of multiple clustering/bound. */ private static class MultiClusteringBuilder extends MultiCBuilder { /** * The elements of the clusterings */ private final List> elementsList = new ArrayList<>(); public MultiClusteringBuilder(ClusteringComparator comparator) { super(comparator); } public MultiCBuilder addElementToAll(ByteBuffer value) { checkUpdateable(); if (elementsList.isEmpty()) elementsList.add(new ArrayList()); if (value == null) containsNull = true; else if (value == ByteBufferUtil.UNSET_BYTE_BUFFER) containsUnset = true; for (int i = 0, m = elementsList.size(); i < m; i++) elementsList.get(i).add(value); size++; return this; } public MultiCBuilder addEachElementToAll(List values) { checkUpdateable(); if (elementsList.isEmpty()) elementsList.add(new ArrayList()); if (values.isEmpty()) { hasMissingElements = true; } else { for (int i = 0, m = elementsList.size(); i < m; i++) { List oldComposite = elementsList.remove(0); for (int j = 0, n = values.size(); j < n; j++) { List newComposite = new ArrayList<>(oldComposite); elementsList.add(newComposite); ByteBuffer value = values.get(j); if (value == null) containsNull = true; if (value == ByteBufferUtil.UNSET_BYTE_BUFFER) containsUnset = true; newComposite.add(values.get(j)); } } } size++; return this; } public MultiCBuilder addAllElementsToAll(List> values) { checkUpdateable(); if (elementsList.isEmpty()) elementsList.add(new ArrayList()); if (values.isEmpty()) { hasMissingElements = true; } else { for (int i = 0, m = elementsList.size(); i < m; i++) { List oldComposite = elementsList.remove(0); for (int j = 0, n = values.size(); j < n; j++) { List newComposite = new ArrayList<>(oldComposite); elementsList.add(newComposite); List value = values.get(j); if (value.contains(null)) containsNull = true; if (value.contains(ByteBufferUtil.UNSET_BYTE_BUFFER)) containsUnset = true; newComposite.addAll(value); } } size += values.get(0).size(); } return this; } public NavigableSet build() { built = true; if (hasMissingElements) return BTreeSet.empty(comparator); CBuilder builder = CBuilder.create(comparator); if (elementsList.isEmpty()) return BTreeSet.of(builder.comparator(), builder.build()); BTreeSet.Builder set = BTreeSet.builder(builder.comparator()); for (int i = 0, m = elementsList.size(); i < m; i++) { List elements = elementsList.get(i); set.add(builder.buildWith(elements)); } return set.build(); } public NavigableSet buildBoundForSlice(boolean isStart, boolean isInclusive, boolean isOtherBoundInclusive, List columnDefs) { built = true; if (hasMissingElements) return BTreeSet.empty(comparator); CBuilder builder = CBuilder.create(comparator); if (elementsList.isEmpty()) return BTreeSet.of(comparator, builder.buildBound(isStart, isInclusive)); // Use a TreeSet to sort and eliminate duplicates BTreeSet.Builder set = BTreeSet.builder(comparator); // The first column of the slice might not be the first clustering column (e.g. clustering_0 = ? AND (clustering_1, clustering_2) >= (?, ?) int offset = columnDefs.get(0).position(); for (int i = 0, m = elementsList.size(); i < m; i++) { List elements = elementsList.get(i); // Handle the no bound case if (elements.size() == offset) { set.add(builder.buildBoundWith(elements, isStart, true)); continue; } // In the case of mixed order columns, we will have some extra slices where the columns change directions. // For example: if we have clustering_0 DESC and clustering_1 ASC a slice like (clustering_0, clustering_1) > (1, 2) // will produce 2 slices: [BOTTOM, 1) and (1.2, 1] // So, the END bound will return 2 bounds with the same values 1 ColumnDefinition lastColumn = columnDefs.get(columnDefs.size() - 1); if (elements.size() <= lastColumn.position() && i < m - 1 && elements.equals(elementsList.get(i + 1))) { set.add(builder.buildBoundWith(elements, isStart, false)); set.add(builder.buildBoundWith(elementsList.get(i++), isStart, true)); continue; } // Handle the normal bounds ColumnDefinition column = columnDefs.get(elements.size() - 1 - offset); set.add(builder.buildBoundWith(elements, isStart, column.isReversedType() ? isOtherBoundInclusive : isInclusive)); } return set.build(); } public NavigableSet buildBound(boolean isStart, boolean isInclusive) { built = true; if (hasMissingElements) return BTreeSet.empty(comparator); CBuilder builder = CBuilder.create(comparator); if (elementsList.isEmpty()) return BTreeSet.of(comparator, builder.buildBound(isStart, isInclusive)); // Use a TreeSet to sort and eliminate duplicates BTreeSet.Builder set = BTreeSet.builder(comparator); for (int i = 0, m = elementsList.size(); i < m; i++) { List elements = elementsList.get(i); set.add(builder.buildBoundWith(elements, isStart, isInclusive)); } return set.build(); } } }




© 2015 - 2024 Weber Informatics LLC | Privacy Policy