/*
* 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.io.sstable;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.apache.cassandra.db.marshal.AbstractType;
import org.apache.cassandra.db.marshal.ColumnToCollectionType;
import org.apache.cassandra.db.marshal.CompositeType;
import static org.apache.cassandra.utils.ByteBufferUtil.minimalBufferFor;
public class ColumnNameHelper
{
/**
* finds the max column name(s)
*
* if comparator is of CompositeType, candidate will be split into its components, and each
* component is compared to the component on the same place in maxSeen, and then returning the list
* with the max columns.
*
* will collect at most the number of types in the comparator.
*
* if comparator is not CompositeType, maxSeen is assumed to be of size 1 and the item there is
* compared to the candidate.
*
* @param maxSeen the max columns seen so far
* @param candidate the candidate column(s)
* @param comparator the comparator to use
* @return a list with the max column(s)
*/
public static List<ByteBuffer> maxComponents(List<ByteBuffer> maxSeen, ByteBuffer candidate, AbstractType<?> comparator)
{
if (comparator instanceof CompositeType)
{
CompositeType ct = (CompositeType)comparator;
if (maxSeen.isEmpty())
return Arrays.asList(ct.split(candidate));
int typeCount = getTypeCount(ct);
List<ByteBuffer> components = Arrays.asList(ct.split(candidate));
List<ByteBuffer> biggest = maxSeen.size() > components.size() ? maxSeen : components;
// if typecount is less than both the components and maxseen, we only keep typecount columns.
int minSize = Math.min(typeCount, Math.min(components.size(), maxSeen.size()));
int maxSize = Math.min(typeCount, biggest.size());
List<ByteBuffer> retList = new ArrayList<ByteBuffer>(maxSize);
for (int i = 0; i < minSize; i++)
retList.add(ColumnNameHelper.max(maxSeen.get(i), components.get(i), ct.types.get(i)));
for (int i = minSize; i < maxSize; i++)
retList.add(biggest.get(i));
return retList;
}
else
{
if (maxSeen.size() == 0)
return Collections.singletonList(candidate);
return Collections.singletonList(ColumnNameHelper.max(maxSeen.get(0), candidate, comparator));
}
}
/**
* finds the min column name(s)
*
* if comparator is of CompositeType, candidate will be split into its components, and each
* component is compared to the component on the same place in minSeen, and then returning the list
* with the min columns.
*
* if comparator is not CompositeType, maxSeen is assumed to be of size 1 and the item there is
* compared to the candidate.
*
* @param minSeen the max columns seen so far
* @param candidate the candidate column(s)
* @param comparator the comparator to use
* @return a list with the min column(s)
*/
public static List<ByteBuffer> minComponents(List<ByteBuffer> minSeen, ByteBuffer candidate, AbstractType<?> comparator)
{
if (comparator instanceof CompositeType)
{
CompositeType ct = (CompositeType)comparator;
if (minSeen.isEmpty())
return Arrays.asList(ct.split(candidate));
int typeCount = getTypeCount(ct);
List<ByteBuffer> components = Arrays.asList(ct.split(candidate));
List<ByteBuffer> biggest = minSeen.size() > components.size() ? minSeen : components;
// if typecount is less than both the components and maxseen, we only collect typecount columns.
int minSize = Math.min(typeCount, Math.min(components.size(), minSeen.size()));
int maxSize = Math.min(typeCount, biggest.size());
List<ByteBuffer> retList = new ArrayList<ByteBuffer>(maxSize);
for (int i = 0; i < minSize; i++)
retList.add(ColumnNameHelper.min(minSeen.get(i), components.get(i), ct.types.get(i)));
for (int i = minSize; i < maxSize; i++)
retList.add(biggest.get(i));
return retList;
}
else
{
if (minSeen.size() == 0)
return Collections.singletonList(candidate);
return Collections.singletonList(ColumnNameHelper.min(minSeen.get(0), candidate, comparator));
}
}
/**
* return the min column
*
* note that comparator should not be of CompositeType!
*
* @param b1 lhs
* @param b2 rhs
* @param comparator the comparator to use
* @return the smallest column according to comparator
*/
private static ByteBuffer min(ByteBuffer b1, ByteBuffer b2, AbstractType<?> comparator)
{
if (comparator.compare(b1, b2) >= 0)
return b2;
return b1;
}
/**
* return the max column
*
* note that comparator should not be of CompositeType!
*
* @param b1 lhs
* @param b2 rhs
* @param comparator the comparator to use
* @return the biggest column according to comparator
*/
private static ByteBuffer max(ByteBuffer b1, ByteBuffer b2, AbstractType<?> comparator)
{
if (comparator.compare(b1, b2) >= 0)
return b1;
return b2;
}
/**
* if columnNameComparator is CompositeType the columns are compared by components using the subcomparator
* on the same position.
*
* if comparator is not CompositeType, the lists are assumed to be of max size 1 and compared using the comparator
* directly.
*
* @param minColumnNames lhs
* @param candidates rhs
* @param columnNameComparator comparator to use
* @return a list with smallest column names according to (sub)comparator
*/
public static List<ByteBuffer> mergeMin(List<ByteBuffer> minColumnNames, List<ByteBuffer> candidates, AbstractType<?> columnNameComparator)
{
if (minColumnNames.isEmpty())
return minimalBuffersFor(candidates);
if (candidates.isEmpty())
return minColumnNames;
if (columnNameComparator instanceof CompositeType)
{
CompositeType ct = (CompositeType)columnNameComparator;
List<ByteBuffer> biggest = minColumnNames.size() > candidates.size() ? minColumnNames : candidates;
int typeCount = getTypeCount(ct);
int minSize = Math.min(typeCount, Math.min(minColumnNames.size(), candidates.size()));
int maxSize = Math.min(typeCount, biggest.size());
List<ByteBuffer> retList = new ArrayList<ByteBuffer>(maxSize);
for (int i = 0; i < minSize; i++)
retList.add(minimalBufferFor(min(minColumnNames.get(i), candidates.get(i), ct.types.get(i))));
for (int i = minSize; i < maxSize; i++)
retList.add(minimalBufferFor(biggest.get(i)));
return retList;
}
else
{
return Collections.singletonList(minimalBufferFor(min(minColumnNames.get(0), candidates.get(0), columnNameComparator)));
}
}
private static List<ByteBuffer> minimalBuffersFor(List<ByteBuffer> candidates)
{
List<ByteBuffer> minimalBuffers = new ArrayList<ByteBuffer>(candidates.size());
for (ByteBuffer byteBuffer : candidates)
minimalBuffers.add(minimalBufferFor(byteBuffer));
return minimalBuffers;
}
/**
* if columnNameComparator is CompositeType the columns are compared by components using the subcomparator
* on the same position.
*
* if comparator is not CompositeType, the lists are assumed to be of max size 1 and compared using the comparator
* directly.
*
* @param maxColumnNames lhs
* @param candidates rhs
* @param columnNameComparator comparator to use
* @return a list with biggest column names according to (sub)comparator
*/
public static List<ByteBuffer> mergeMax(List<ByteBuffer> maxColumnNames, List<ByteBuffer> candidates, AbstractType<?> columnNameComparator)
{
if (maxColumnNames.isEmpty())
return minimalBuffersFor(candidates);
if (candidates.isEmpty())
return maxColumnNames;
if (columnNameComparator instanceof CompositeType)
{
CompositeType ct = (CompositeType)columnNameComparator;
List<ByteBuffer> biggest = maxColumnNames.size() > candidates.size() ? maxColumnNames : candidates;
int typeCount = getTypeCount(ct);
int minSize = Math.min(typeCount, Math.min(maxColumnNames.size(), candidates.size()));
int maxSize = Math.min(typeCount, biggest.size());
List<ByteBuffer> retList = new ArrayList<ByteBuffer>(maxSize);
for (int i = 0; i < minSize; i++)
retList.add(minimalBufferFor(max(maxColumnNames.get(i), candidates.get(i), ct.types.get(i))));
for (int i = minSize; i < maxSize; i++)
retList.add(minimalBufferFor(biggest.get(i)));
return retList;
}
else
{
return Collections.singletonList(minimalBufferFor(max(maxColumnNames.get(0), candidates.get(0), columnNameComparator)));
}
}
private static int getTypeCount(CompositeType ct)
{
return ct.types.get(ct.types.size() - 1) instanceof ColumnToCollectionType ? ct.types.size() - 1 : ct.types.size();
}
}