package org.apache.cassandra.config;
import java.nio.ByteBuffer;
import java.util.*;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Function;
import com.google.common.base.MoreObjects;
import com.google.common.base.Objects;
import com.google.common.collect.Collections2;
import org.apache.cassandra.cql3.*;
import org.apache.cassandra.cql3.selection.Selectable;
import org.apache.cassandra.cql3.selection.Selector;
import org.apache.cassandra.cql3.selection.SimpleSelector;
import org.apache.cassandra.db.rows.*;
import org.apache.cassandra.db.marshal.*;
import org.apache.cassandra.exceptions.InvalidRequestException;
import org.apache.cassandra.serializers.MarshalException;
import org.apache.cassandra.utils.ByteBufferUtil;
import org.github.jamm.Unmetered;
@Unmetered
public class ColumnDefinition extends ColumnSpecification implements Selectable, Comparable<ColumnDefinition>
{
public static final Comparator<Object> asymmetricColumnDataComparator =
(a, b) -> ((ColumnData) a).column().compareTo((ColumnDefinition) b);
public static final int NO_POSITION = -1;
public enum ClusteringOrder
{
ASC, DESC, NONE
}
public enum Kind
{
PARTITION_KEY,
CLUSTERING,
REGULAR,
STATIC;
public boolean isPrimaryKeyKind()
{
return this == PARTITION_KEY || this == CLUSTERING;
}
}
public final Kind kind;
private final int position;
private final Comparator<CellPath> cellPathComparator;
private final Comparator<Object> asymmetricCellPathComparator;
private final Comparator<? super Cell> cellComparator;
private int hash;
private final long comparisonOrder;
private static long comparisonOrder(Kind kind, boolean isComplex, long position, ColumnIdentifier name)
{
assert position >= 0 && position < 1 << 12;
return (((long) kind.ordinal()) << 61)
| (isComplex ? 1L << 60 : 0)
| (position << 48)
| (name.prefixComparison >>> 16);
}
public static ColumnDefinition partitionKeyDef(CFMetaData cfm, ByteBuffer name, AbstractType<?> type, int position)
{
return new ColumnDefinition(cfm, name, type, position, Kind.PARTITION_KEY);
}
public static ColumnDefinition partitionKeyDef(String ksName, String cfName, String name, AbstractType<?> type, int position)
{
return new ColumnDefinition(ksName, cfName, ColumnIdentifier.getInterned(name, true), type, position, Kind.PARTITION_KEY);
}
public static ColumnDefinition clusteringDef(CFMetaData cfm, ByteBuffer name, AbstractType<?> type, int position)
{
return new ColumnDefinition(cfm, name, type, position, Kind.CLUSTERING);
}
public static ColumnDefinition clusteringDef(String ksName, String cfName, String name, AbstractType<?> type, int position)
{
return new ColumnDefinition(ksName, cfName, ColumnIdentifier.getInterned(name, true), type, position, Kind.CLUSTERING);
}
public static ColumnDefinition regularDef(CFMetaData cfm, ByteBuffer name, AbstractType<?> type)
{
return new ColumnDefinition(cfm, name, type, NO_POSITION, Kind.REGULAR);
}
public static ColumnDefinition regularDef(String ksName, String cfName, String name, AbstractType<?> type)
{
return new ColumnDefinition(ksName, cfName, ColumnIdentifier.getInterned(name, true), type, NO_POSITION, Kind.REGULAR);
}
public static ColumnDefinition staticDef(CFMetaData cfm, ByteBuffer name, AbstractType<?> type)
{
return new ColumnDefinition(cfm, name, type, NO_POSITION, Kind.STATIC);
}
public ColumnDefinition(CFMetaData cfm, ByteBuffer name, AbstractType<?> type, int position, Kind kind)
{
this(cfm.ksName,
cfm.cfName,
ColumnIdentifier.getInterned(name, cfm.getColumnDefinitionNameComparator(kind)),
type,
position,
kind);
}
@VisibleForTesting
public ColumnDefinition(String ksName,
String cfName,
ColumnIdentifier name,
AbstractType<?> type,
int position,
Kind kind)
{
super(ksName, cfName, name, type);
assert name != null && type != null && kind != null;
assert (position == NO_POSITION) == !kind.isPrimaryKeyKind();
this.kind = kind;
this.position = position;
this.cellPathComparator = makeCellPathComparator(kind, type);
this.cellComparator = cellPathComparator == null ? ColumnData.comparator : (a, b) -> cellPathComparator.compare(a.path(), b.path());
this.asymmetricCellPathComparator = cellPathComparator == null ? null : (a, b) -> cellPathComparator.compare(((Cell)a).path(), (CellPath) b);
this.comparisonOrder = comparisonOrder(kind, isComplex(), Math.max(0, position), name);
}
private static Comparator<CellPath> makeCellPathComparator(Kind kind, AbstractType<?> type)
{
if (kind.isPrimaryKeyKind() || !type.isMultiCell())
return null;
AbstractType<?> nameComparator = type.isCollection()
? ((CollectionType) type).nameComparator()
: ((UserType) type).nameComparator();
return new Comparator<CellPath>()
{
public int compare(CellPath path1, CellPath path2)
{
if (path1.size() == 0 || path2.size() == 0)
{
if (path1 == CellPath.BOTTOM)
return path2 == CellPath.BOTTOM ? 0 : -1;
if (path1 == CellPath.TOP)
return path2 == CellPath.TOP ? 0 : 1;
return path2 == CellPath.BOTTOM ? 1 : -1;
}
assert path1.size() == 1 && path2.size() == 1;
return nameComparator.compare(path1.get(0), path2.get(0));
}
};
}
public ColumnDefinition copy()
{
return new ColumnDefinition(ksName, cfName, name, type, position, kind);
}
public ColumnDefinition withNewName(ColumnIdentifier newName)
{
return new ColumnDefinition(ksName, cfName, newName, type, position, kind);
}
public ColumnDefinition withNewType(AbstractType<?> newType)
{
return new ColumnDefinition(ksName, cfName, name, newType, position, kind);
}
public boolean isPartitionKey()
{
return kind == Kind.PARTITION_KEY;
}
public boolean isClusteringColumn()
{
return kind == Kind.CLUSTERING;
}
public boolean isStatic()
{
return kind == Kind.STATIC;
}
public boolean isRegular()
{
return kind == Kind.REGULAR;
}
public ClusteringOrder clusteringOrder()
{
if (!isClusteringColumn())
return ClusteringOrder.NONE;
return type.isReversed() ? ClusteringOrder.DESC : ClusteringOrder.ASC;
}
public int position()
{
return position;
}
@Override
public boolean equals(Object o)
{
if (this == o)
return true;
if (!(o instanceof ColumnDefinition))
return false;
ColumnDefinition cd = (ColumnDefinition) o;
return Objects.equal(ksName, cd.ksName)
&& Objects.equal(cfName, cd.cfName)
&& Objects.equal(name, cd.name)
&& Objects.equal(type, cd.type)
&& Objects.equal(kind, cd.kind)
&& Objects.equal(position, cd.position);
}
@Override
public int hashCode()
{
int result = hash;
if(result == 0)
{
result = 31 + (ksName == null ? 0 : ksName.hashCode());
result = 31 * result + (cfName == null ? 0 : cfName.hashCode());
result = 31 * result + (name == null ? 0 : name.hashCode());
result = 31 * result + (type == null ? 0 : type.hashCode());
result = 31 * result + (kind == null ? 0 : kind.hashCode());
result = 31 * result + position;
hash = result;
}
return result;
}
@Override
public String toString()
{
return name.toString();
}
public String debugString()
{
return MoreObjects.toStringHelper(this)
.add("name", name)
.add("type", type)
.add("kind", kind)
.add("position", position)
.toString();
}
public boolean isPrimaryKeyColumn()
{
return kind.isPrimaryKeyKind();
}
public boolean isPartOfCellName(boolean isCQL3Table, boolean isSuper)
{
if (isCQL3Table)
return kind == Kind.REGULAR || kind == Kind.STATIC;
else if (isSuper)
return kind == Kind.REGULAR;
else
return kind == Kind.STATIC;
}
public static Collection<ColumnIdentifier> toIdentifiers(Collection<ColumnDefinition> definitions)
{
return Collections2.transform(definitions, new Function<ColumnDefinition, ColumnIdentifier>()
{
@Override
public ColumnIdentifier apply(ColumnDefinition columnDef)
{
return columnDef.name;
}
});
}
public int compareTo(ColumnDefinition other)
{
if (this == other)
return 0;
if (comparisonOrder != other.comparisonOrder)
return Long.compare(comparisonOrder, other.comparisonOrder);
return this.name.compareTo(other.name);
}
public Comparator<CellPath> cellPathComparator()
{
return cellPathComparator;
}
public Comparator<Object> asymmetricCellPathComparator()
{
return asymmetricCellPathComparator;
}
public Comparator<? super Cell> cellComparator()
{
return cellComparator;
}
public boolean isComplex()
{
return cellPathComparator != null;
}
public boolean isSimple()
{
return !isComplex();
}
public CellPath.Serializer cellPathSerializer()
{
return CollectionType.cellPathSerializer;
}
public void validateCell(Cell cell)
{
if (cell.isTombstone())
{
if (cell.value().hasRemaining())
throw new MarshalException("A tombstone should not have a value");
if (cell.path() != null)
validateCellPath(cell.path());
}
else if(type.isUDT())
{
((UserType)type).validateCell(cell);
}
else
{
type.validateCellValue(cell.value());
if (cell.path() != null)
validateCellPath(cell.path());
}
}
private void validateCellPath(CellPath path)
{
if (!isComplex())
throw new MarshalException("Only complex cells should have a cell path");
assert type.isMultiCell();
if (type.isCollection())
((CollectionType)type).nameComparator().validate(path.get(0));
else
((UserType)type).nameComparator().validate(path.get(0));
}
public static String toCQLString(Iterable<ColumnDefinition> defs)
{
return toCQLString(defs.iterator());
}
public static String toCQLString(Iterator<ColumnDefinition> defs)
{
if (!defs.hasNext())
return "";
StringBuilder sb = new StringBuilder();
sb.append(defs.next().name);
while (defs.hasNext())
sb.append(", ").append(defs.next().name);
return sb.toString();
}
public AbstractType<?> cellValueType()
{
assert !(type instanceof UserType && type.isMultiCell());
return type instanceof CollectionType && type.isMultiCell()
? ((CollectionType)type).valueComparator()
: type;
}
public boolean isCounterColumn()
{
if (type instanceof CollectionType)
return ((CollectionType) type).valueComparator().isCounter();
return type.isCounter();
}
public Selector.Factory newSelectorFactory(CFMetaData cfm, AbstractType<?> expectedType, List<ColumnDefinition> defs, VariableSpecifications boundNames) throws InvalidRequestException
{
return SimpleSelector.newFactory(this, addAndGetIndex(this, defs));
}
public AbstractType<?> getExactTypeIfKnown(String keyspace)
{
return type;
}
public static abstract class Raw extends Selectable.Raw
{
public static Raw forUnquoted(String text)
{
return new Literal(text, false);
}
public static Raw forQuoted(String text)
{
return new Literal(text, true);
}
public static Raw forColumn(ColumnDefinition column)
{
return new ForColumn(column);
}
public abstract ColumnIdentifier getIdentifier(CFMetaData cfm);
public abstract String rawText();
@Override
public abstract ColumnDefinition prepare(CFMetaData cfm);
@Override
public boolean processesSelection()
{
return false;
}
@Override
public final int hashCode()
{
return toString().hashCode();
}
@Override
public final boolean equals(Object o)
{
if(!(o instanceof Raw))
return false;
Raw that = (Raw)o;
return this.toString().equals(that.toString());
}
private static class Literal extends Raw
{
private final String text;
public Literal(String rawText, boolean keepCase)
{
this.text = keepCase ? rawText : rawText.toLowerCase(Locale.US);
}
public ColumnIdentifier getIdentifier(CFMetaData cfm)
{
if (!cfm.isStaticCompactTable())
return ColumnIdentifier.getInterned(text, true);
AbstractType<?> thriftColumnNameType = cfm.thriftColumnNameType();
if (thriftColumnNameType instanceof UTF8Type)
return ColumnIdentifier.getInterned(text, true);
ByteBuffer bufferName = ByteBufferUtil.bytes(text);
for (ColumnDefinition def : cfm.allColumns())
{
if (def.name.bytes.equals(bufferName))
return def.name;
}
return ColumnIdentifier.getInterned(thriftColumnNameType, thriftColumnNameType.fromString(text), text);
}
public ColumnDefinition prepare(CFMetaData cfm)
{
if (!cfm.isStaticCompactTable())
return find(cfm);
AbstractType<?> thriftColumnNameType = cfm.thriftColumnNameType();
if (thriftColumnNameType instanceof UTF8Type)
return find(cfm);
ByteBuffer bufferName = ByteBufferUtil.bytes(text);
for (ColumnDefinition def : cfm.allColumns())
{
if (def.name.bytes.equals(bufferName))
return def;
}
return find(thriftColumnNameType.fromString(text), cfm);
}
private ColumnDefinition find(CFMetaData cfm)
{
return find(ByteBufferUtil.bytes(text), cfm);
}
private ColumnDefinition find(ByteBuffer id, CFMetaData cfm)
{
ColumnDefinition def = cfm.getColumnDefinition(id);
if (def == null)
throw new InvalidRequestException(String.format("Undefined column name %s", toString()));
return def;
}
public String rawText()
{
return text;
}
@Override
public String toString()
{
return ColumnIdentifier.maybeQuote(text);
}
}
private static class ForColumn extends Raw
{
private final ColumnDefinition column;
private ForColumn(ColumnDefinition column)
{
this.column = column;
}
public ColumnIdentifier getIdentifier(CFMetaData cfm)
{
return column.name;
}
public ColumnDefinition prepare(CFMetaData cfm)
{
assert cfm.getColumnDefinition(column.name) != null;
return column;
}
public String rawText()
{
return column.name.toString();
}
@Override
public String toString()
{
return column.name.toCQLString();
}
}
}
}