public List<SuperColumn> get_slice_super(
String table,
String key,
String column_family,
byte[] start,
byte[] finish,
boolean is_ascending,
int count,
int consistency_level)
throws InvalidRequestException {
if (logger.isDebugEnabled()) logger.debug("get_slice_super");
if (!DatabaseDescriptor.getColumnFamilyType(table, column_family).equals("Super"))
throw new InvalidRequestException("get_slice_super requires a super CF name");
if (count <= 0) throw new InvalidRequestException("get_slice_super requires positive count");
ColumnFamily cfamily =
readColumnFamily(
new SliceFromReadCommand(
table, key, new QueryPath(column_family), start, finish, is_ascending, count),
consistency_level);
if (cfamily == null) {
return EMPTY_SUPERCOLUMNS;
}
Collection<IColumn> columns = cfamily.getSortedColumns();
return thriftifySuperColumns(columns, !is_ascending);
}
public SuperColumn get_super_column(
String table, String key, SuperColumnPath super_column_path, int consistency_level)
throws InvalidRequestException, NotFoundException {
if (logger.isDebugEnabled()) logger.debug("get_superColumn");
ThriftValidation.validateSuperColumnPath(table, super_column_path);
ColumnFamily cfamily =
readColumnFamily(
new SliceByNamesReadCommand(
table,
key,
new QueryPath(super_column_path.column_family),
Arrays.asList(super_column_path.super_column)),
consistency_level);
if (cfamily == null) {
throw new NotFoundException();
}
Collection<IColumn> columns = cfamily.getSortedColumns();
if (columns == null || columns.size() == 0) {
throw new NotFoundException();
}
assert columns.size() == 1;
IColumn column = columns.iterator().next();
if (column.getSubColumns().size() == 0) {
throw new NotFoundException();
}
return new SuperColumn(column.name(), thriftifyColumns(column.getSubColumns()));
}
public Column get_column(String table, String key, ColumnPath column_path, int consistency_level)
throws InvalidRequestException, NotFoundException {
if (logger.isDebugEnabled()) logger.debug("get_column");
ThriftValidation.validateColumnPath(table, column_path);
QueryPath path = new QueryPath(column_path.column_family, column_path.super_column);
ColumnFamily cfamily =
readColumnFamily(
new SliceByNamesReadCommand(table, key, path, Arrays.asList(column_path.column)),
consistency_level);
// TODO can we leverage getSlice here and just check that it returns one column?
if (cfamily == null) {
throw new NotFoundException();
}
Collection<IColumn> columns = null;
if (column_path.super_column != null) {
IColumn column = cfamily.getColumn(column_path.super_column);
if (column != null) {
columns = column.getSubColumns();
}
} else {
columns = cfamily.getSortedColumns();
}
if (columns == null || columns.size() == 0) {
throw new NotFoundException();
}
assert columns.size() == 1;
IColumn column = columns.iterator().next();
if (column.isMarkedForDelete()) {
throw new NotFoundException();
}
return new Column(column.name(), column.value(), column.timestamp());
}
public static void assertColumns(ColumnFamily cf, String... columnNames) {
Collection<IColumn> columns = cf == null ? new TreeSet<IColumn>() : cf.getSortedColumns();
List<String> L = new ArrayList<String>();
for (IColumn column : columns) {
L.add(new String(column.name()));
}
assert Arrays.equals(L.toArray(new String[columns.size()]), columnNames)
: "Columns ["
+ ((cf == null) ? "" : cf.getComparator().getColumnsString(columns))
+ "]"
+ " is not expected ["
+ StringUtils.join(columnNames, ",")
+ "]";
}
/** for resultsets of standard columns */
private List<Column> getSlice(ReadCommand command, int consistency_level)
throws InvalidRequestException {
ColumnFamily cfamily = readColumnFamily(command, consistency_level);
boolean reverseOrder = false;
if (command instanceof SliceFromReadCommand)
reverseOrder = !((SliceFromReadCommand) command).isAscending;
if (cfamily == null || cfamily.getColumnsMap().size() == 0) {
return EMPTY_COLUMNS;
}
if (cfamily.isSuper()) {
IColumn column = cfamily.getColumnsMap().values().iterator().next();
return thriftifyColumns(column.getSubColumns(), reverseOrder);
}
return thriftifyColumns(cfamily.getSortedColumns(), reverseOrder);
}
public int get_column_count(
String table, String key, ColumnParent column_parent, int consistency_level)
throws InvalidRequestException {
if (logger.isDebugEnabled()) logger.debug("get_column_count");
// validateColumnParent assumes we require simple columns; g_c_c is the only
// one of the columnParent-taking apis that can also work at the SC level.
// so we roll a one-off validator here.
String cfType = ThriftValidation.validateColumnFamily(table, column_parent.column_family);
if (cfType.equals("Standard") && column_parent.super_column != null) {
throw new InvalidRequestException(
"columnfamily alone is required for standard CF " + column_parent.column_family);
}
ColumnFamily cfamily;
cfamily =
readColumnFamily(
new SliceFromReadCommand(
table,
key,
column_parent,
ArrayUtils.EMPTY_BYTE_ARRAY,
ArrayUtils.EMPTY_BYTE_ARRAY,
true,
Integer.MAX_VALUE),
consistency_level);
if (cfamily == null) {
return 0;
}
Collection<IColumn> columns = null;
if (column_parent.super_column != null) {
IColumn column = cfamily.getColumn(column_parent.super_column);
if (column != null) {
columns = column.getSubColumns();
}
} else {
columns = cfamily.getSortedColumns();
}
if (columns == null || columns.size() == 0) {
return 0;
}
return columns.size();
}
public List<SuperColumn> get_slice_super_by_names(
String table,
String key,
String column_family,
List<byte[]> super_column_names,
int consistency_level)
throws InvalidRequestException {
if (logger.isDebugEnabled()) logger.debug("get_slice_super_by_names");
ThriftValidation.validateColumnFamily(table, column_family);
ColumnFamily cfamily =
readColumnFamily(
new SliceByNamesReadCommand(
table, key, new QueryPath(column_family), super_column_names),
consistency_level);
if (cfamily == null) {
return EMPTY_SUPERCOLUMNS;
}
return thriftifySuperColumns(cfamily.getSortedColumns());
}
public void trim(ColumnFamily cf, int trimTo, long now) {
// each cell can increment the count by at most one, so if we have fewer cells than trimTo, we
// can skip trimming
if (cf.getColumnCount() < trimTo) return;
ColumnCounter counter = columnCounter(cf.getComparator(), now);
Collection<Cell> cells = reversed ? cf.getReverseSortedColumns() : cf.getSortedColumns();
DeletionInfo.InOrderTester tester = cf.deletionInfo().inOrderTester(reversed);
for (Iterator<Cell> iter = cells.iterator(); iter.hasNext(); ) {
Cell cell = iter.next();
counter.count(cell, tester);
if (counter.live() > trimTo) {
iter.remove();
while (iter.hasNext()) {
iter.next();
iter.remove();
}
}
}
}
private void validateSliceLarge(ColumnFamilyStore cfStore) throws IOException {
String key = "row3";
ColumnFamily cf;
cf =
cfStore.getColumnFamily(
key,
new QueryPath("Standard1"),
"col1000".getBytes(),
ArrayUtils.EMPTY_BYTE_ARRAY,
false,
3);
assertColumns(cf, "col1000", "col1001", "col1002");
assertEquals(new String(cf.getColumn("col1000".getBytes()).value()), "v1000");
assertEquals(new String(cf.getColumn("col1001".getBytes()).value()), "v1001");
assertEquals(new String(cf.getColumn("col1002".getBytes()).value()), "v1002");
cf =
cfStore.getColumnFamily(
key,
new QueryPath("Standard1"),
"col1195".getBytes(),
ArrayUtils.EMPTY_BYTE_ARRAY,
false,
3);
assertColumns(cf, "col1195", "col1196", "col1197");
assertEquals(new String(cf.getColumn("col1195".getBytes()).value()), "v1195");
assertEquals(new String(cf.getColumn("col1196".getBytes()).value()), "v1196");
assertEquals(new String(cf.getColumn("col1197".getBytes()).value()), "v1197");
cf =
cfStore.getColumnFamily(
key,
new QueryPath("Standard1"),
"col1996".getBytes(),
ArrayUtils.EMPTY_BYTE_ARRAY,
true,
1000);
IColumn[] columns = cf.getSortedColumns().toArray(new IColumn[0]);
for (int i = 1000; i < 1996; i++) {
String expectedName = "col" + i;
IColumn column = columns[i - 1000];
assert Arrays.equals(column.name(), expectedName.getBytes())
: cfStore.getComparator().getString(column.name()) + " is not " + expectedName;
assert Arrays.equals(column.value(), ("v" + i).getBytes());
}
cf =
cfStore.getColumnFamily(
key,
new QueryPath("Standard1"),
"col1990".getBytes(),
ArrayUtils.EMPTY_BYTE_ARRAY,
false,
3);
assertColumns(cf, "col1990", "col1991", "col1992");
assertEquals(new String(cf.getColumn("col1990".getBytes()).value()), "v1990");
assertEquals(new String(cf.getColumn("col1991".getBytes()).value()), "v1991");
assertEquals(new String(cf.getColumn("col1992".getBytes()).value()), "v1992");
cf =
cfStore.getColumnFamily(
key,
new QueryPath("Standard1"),
ArrayUtils.EMPTY_BYTE_ARRAY,
ArrayUtils.EMPTY_BYTE_ARRAY,
true,
3);
assertColumns(cf, "col1997", "col1998", "col1999");
assertEquals(new String(cf.getColumn("col1999".getBytes()).value()), "v1999");
assertEquals(new String(cf.getColumn("col1998".getBytes()).value()), "v1998");
assertEquals(new String(cf.getColumn("col1997".getBytes()).value()), "v1997");
cf =
cfStore.getColumnFamily(
key,
new QueryPath("Standard1"),
"col9000".getBytes(),
ArrayUtils.EMPTY_BYTE_ARRAY,
true,
3);
assertColumns(cf, "col1997", "col1998", "col1999");
cf =
cfStore.getColumnFamily(
key,
new QueryPath("Standard1"),
"col9000".getBytes(),
ArrayUtils.EMPTY_BYTE_ARRAY,
false,
3);
assertColumns(cf);
}
