/** * Parse a signature from a byte stream * * @param in input bytes to parse * @return the decoded signature data * @throws CtxException */ static ScalaSig parse(byte[] in) throws CtxException { ByteArrayInputStream bis = new ByteArrayInputStream(in); // Pull version info & check OK int major = Nat.read(bis); int minor = Nat.read(bis); if (major != 5 || minor != 0) { throw new CtxException("Unexpected signature version found: " + major + "." + minor); } // Pull table int tblEntries = Nat.read(bis); Table table = new Table(); for (int e = 0; e < tblEntries; e++) { int type = Nat.read(bis); int size = Nat.read(bis); byte[] raw = new byte[size]; if (bis.read(raw, 0, size) != size) { throw new CtxException("Unexpected EOF in signature data"); } table.addEntry(type, raw); } // The input stream should be consumed at this point but a 'feature' of the encoding is // that there may be a trailer 0 byte, just check all look good int trail = bis.read(); if (trail == 0) trail = bis.read(); if (trail != -1) throw new CtxException("Unexpected additional byte found at end of signature"); // All good so create signature return new ScalaSig(major, minor, table); }
private void addPartition( String databaseName, String tableName, CatalogProtos.PartitionDescProto partitionDescProto) { HiveCatalogStoreClientPool.HiveCatalogStoreClient client = null; try { client = clientPool.getClient(); Partition partition = new Partition(); partition.setDbName(databaseName); partition.setTableName(tableName); List<String> values = Lists.newArrayList(); for (CatalogProtos.PartitionKeyProto keyProto : partitionDescProto.getPartitionKeysList()) { values.add(keyProto.getPartitionValue()); } partition.setValues(values); Table table = client.getHiveClient().getTable(databaseName, tableName); StorageDescriptor sd = table.getSd(); sd.setLocation(partitionDescProto.getPath()); partition.setSd(sd); client.getHiveClient().add_partition(partition); } catch (Exception e) { throw new TajoInternalError(e); } finally { if (client != null) { client.release(); } } }
private boolean existColumn( final String databaseName, final String tableName, final String columnName) throws CatalogException { boolean exist = false; HiveCatalogStoreClientPool.HiveCatalogStoreClient client = null; try { client = clientPool.getClient(); Table table = client.getHiveClient().getTable(databaseName, tableName); List<FieldSchema> columns = table.getSd().getCols(); for (final FieldSchema currentColumn : columns) { if (currentColumn.getName().equalsIgnoreCase(columnName)) { exist = true; } } client.getHiveClient().alter_table(databaseName, tableName, table); } catch (NoSuchObjectException nsoe) { } catch (Exception e) { throw new TajoInternalError(e); } finally { if (client != null) { client.release(); } } return exist; }
private void renameColumn( String databaseName, String tableName, CatalogProtos.AlterColumnProto alterColumnProto) { HiveCatalogStoreClientPool.HiveCatalogStoreClient client = null; try { client = clientPool.getClient(); Table table = client.getHiveClient().getTable(databaseName, tableName); List<FieldSchema> columns = table.getSd().getCols(); for (final FieldSchema currentColumn : columns) { if (currentColumn.getName().equalsIgnoreCase(alterColumnProto.getOldColumnName())) { currentColumn.setName(alterColumnProto.getNewColumnName()); } } client.getHiveClient().alter_table(databaseName, tableName, table); } catch (NoSuchObjectException nsoe) { } catch (Exception e) { throw new TajoInternalError(e); } finally { if (client != null) { client.release(); } } }
public Edge getAssociationWeight(Vertex v1, Vertex v2) { Edge edge = graph.get(v1, v2); if (edge == null) { edge = graph.get(v2, v1); } return edge; }
@Override public void addColumn(IndexColumn indexColumn) { Table indexTable = indexColumn.getColumn().getTable(); Integer indexTableDepth = indexTable.getDepth(); assert indexTableDepth != null; super.addColumn(indexColumn); GroupIndexHelper.actOnGroupIndexTables(this, indexColumn, GroupIndexHelper.ADD); // Add the table into our navigable map if needed. Confirm it's within the branch ParticipatingTable participatingTable = tablesByDepth.get(indexTableDepth); if (participatingTable == null) { Map.Entry<Integer, ParticipatingTable> rootwardEntry = tablesByDepth.floorEntry(indexTableDepth); Map.Entry<Integer, ParticipatingTable> leafwardEntry = tablesByDepth.ceilingEntry(indexTableDepth); checkIndexTableInBranchNew(indexColumn, indexTable, indexTableDepth, rootwardEntry, true); checkIndexTableInBranchNew(indexColumn, indexTable, indexTableDepth, leafwardEntry, false); participatingTable = new ParticipatingTable(indexTable); tablesByDepth.put(indexTableDepth, participatingTable); } else if (participatingTable.table != indexTable) { throw new BranchingGroupIndexException( indexColumn.getIndex().getIndexName().getName(), indexTable.getName(), participatingTable.table.getName()); } participatingTable.markInvolvedInIndex(indexColumn.getColumn()); }
private Composite createAvailableList(Composite parent) { Composite container = new Composite(parent, SWT.NONE); GridLayout layout = new GridLayout(); layout.marginWidth = 0; layout.marginHeight = 0; container.setLayout(layout); container.setLayoutData(new GridData()); Label label = new Label(container, SWT.NONE); label.setText(PDEUIMessages.ImportWizard_DetailedPage_availableList); Table table = new Table(container, SWT.BORDER | SWT.MULTI | SWT.V_SCROLL); GridData gd = new GridData(GridData.FILL_BOTH); gd.heightHint = 200; gd.widthHint = 225; table.setLayoutData(gd); fAvailableListViewer = new TableViewer(table); fAvailableListViewer.setLabelProvider(new PluginImportLabelProvider()); fAvailableListViewer.setContentProvider(new ContentProvider()); fAvailableListViewer.setInput(PDECore.getDefault().getModelManager()); fAvailableListViewer.setComparator(ListUtil.PLUGIN_COMPARATOR); return container; }
@Test public void testGetRowSliceByRange() throws Throwable { String key = TEST_KEY + "slicerow"; Table table = Table.open("Keyspace1"); ColumnFamilyStore cfStore = table.getColumnFamilyStore("Standard1"); RowMutation rm = new RowMutation("Keyspace1", key); ColumnFamily cf = ColumnFamily.create("Keyspace1", "Standard1"); // First write "a", "b", "c" cf.addColumn(column("a", "val1", 1L)); cf.addColumn(column("b", "val2", 1L)); cf.addColumn(column("c", "val3", 1L)); rm.add(cf); rm.apply(); cf = cfStore.getColumnFamily( key, new QueryPath("Standard1"), "b".getBytes(), "c".getBytes(), false, 100); assertEquals(2, cf.getColumnCount()); cf = cfStore.getColumnFamily( key, new QueryPath("Standard1"), "b".getBytes(), "b".getBytes(), false, 100); assertEquals(1, cf.getColumnCount()); cf = cfStore.getColumnFamily( key, new QueryPath("Standard1"), "b".getBytes(), "c".getBytes(), false, 1); assertEquals(1, cf.getColumnCount()); cf = cfStore.getColumnFamily( key, new QueryPath("Standard1"), "c".getBytes(), "b".getBytes(), false, 1); assertNull(cf); }
@ManagedOperation( description = "Sends a STABLE message to all senders. This causes message purging and potential" + " retransmissions from senders") public void sendStableMessages() { for (Map.Entry<Address, ReceiverEntry> entry : recv_table.entrySet()) { Address dest = entry.getKey(); ReceiverEntry val = entry.getValue(); Table<Message> win = val != null ? val.received_msgs : null; if (win != null) { long[] tmp = win.getDigest(); long low = tmp[0], high = tmp[1]; if (val.last_highest == high) { if (val.num_stable_msgs >= max_stable_msgs) { continue; } else val.num_stable_msgs++; } else { val.last_highest = high; val.num_stable_msgs = 1; } sendStableMessage(dest, val.recv_conn_id, low, high); } } }
public RelOptTableImpl getTable(final String[] names) { List<Pair<String, Object>> pairs = new ArrayList<Pair<String, Object>>(); Schema schema2 = schema; for (int i = 0; i < names.length; i++) { final String name = names[i]; Schema subSchema = schema2.getSubSchema(name); if (subSchema != null) { pairs.add(Pair.<String, Object>of(name, subSchema)); schema2 = subSchema; continue; } final Table table = schema2.getTable(name); if (table != null) { pairs.add(Pair.<String, Object>of(name, table)); if (i != names.length - 1) { // not enough objects to match all names return null; } return new RelOptTableImpl( this, typeFactory.createType(table.getElementType()), names, table); } return null; } return null; }
public Optional<byte[]> get( Optional<String> table, Optional<String> family, Optional<String> qualifier, Optional<String> key) { if (!valid) { Logger.error("CANNOT GET! NO VALID CONNECTION"); return Optional.empty(); } if (table.isPresent() && family.isPresent() && qualifier.isPresent() && key.isPresent() && !key.get().isEmpty()) { try { final Table htable = connection.getTable(TableName.valueOf(table.get())); Result result = htable.get(new Get(key.get().getBytes("UTF8"))); return Optional.ofNullable( result.getValue(family.get().getBytes("UTF8"), qualifier.get().getBytes("UTF8"))); } catch (IOException e) { e.printStackTrace(); } } return Optional.empty(); }
protected void handleAckReceived(Address sender, long seqno, short conn_id) { if (log.isTraceEnabled()) log.trace( new StringBuilder() .append(local_addr) .append(" <-- ACK(") .append(sender) .append(": #") .append(seqno) .append(", conn-id=") .append(conn_id) .append(')')); SenderEntry entry = send_table.get(sender); if (entry != null && entry.send_conn_id != conn_id) { if (log.isTraceEnabled()) log.trace( local_addr + ": my conn_id (" + entry.send_conn_id + ") != received conn_id (" + conn_id + "); discarding ACK"); return; } Table<Message> win = entry != null ? entry.sent_msgs : null; if (win != null) { win.purge(seqno, true); // removes all messages <= seqno (forced purge) num_acks_received++; } }
public static String getEntityName(Class entity) { if (mappedName.get(entity) != null) { return mappedName.get(entity); } String name = null; Table table = (Table) entity.getAnnotation(Table.class); if (table != null && table.name() != null && !table.name().isEmpty()) { name = table.name(); } else { Entity entityAnnotation = (Entity) entity.getAnnotation(Entity.class); if (entityAnnotation != null && entityAnnotation.name() != null && !entityAnnotation.name().isEmpty()) { name = entityAnnotation.name(); } else { name = entity.getSimpleName(); } } mappedName.put(entity, name); return name; }
public Map<String, Long> getRegionSizes(String tableName) { Map<String, Long> regions = new HashMap<>(); try { final Table table = connection.getTable(TableName.valueOf(tableName)); RegionLocator regionLocator = connection.getRegionLocator(table.getName()); List<HRegionLocation> tableRegionInfos = regionLocator.getAllRegionLocations(); Set<byte[]> tableRegions = new TreeSet<byte[]>(Bytes.BYTES_COMPARATOR); for (HRegionLocation regionInfo : tableRegionInfos) { tableRegions.add(regionInfo.getRegionInfo().getRegionName()); } ClusterStatus clusterStatus = connection.getAdmin().getClusterStatus(); Collection<ServerName> servers = clusterStatus.getServers(); final long megaByte = 1024L * 1024L; for (ServerName serverName : servers) { ServerLoad serverLoad = clusterStatus.getLoad(serverName); for (RegionLoad regionLoad : serverLoad.getRegionsLoad().values()) { byte[] regionId = regionLoad.getName(); if (tableRegions.contains(regionId)) { long regionSizeBytes = regionLoad.getStorefileSizeMB() * megaByte; regions.put(regionLoad.getNameAsString(), regionSizeBytes); } } } } catch (IOException e) { e.printStackTrace(); } return regions; }
public Optional<Response> get(Optional<Request> request) { if (!valid) { Logger.error("CANNOT GET! NO VALID CONNECTION"); return Optional.empty(); } Response response = new Response(); if (request.isPresent()) { Request r = request.get(); response.key = r.key; response.table = r.table; try { final Table htable = connection.getTable(TableName.valueOf(r.table)); Result result = htable.get(new Get(r.key)); if (result == null || result.isEmpty()) { return Optional.empty(); } r.columns.forEach( c -> response.columns.add( new Request.Column( c.family, c.qualifier, result.getValue(c.family.getBytes(), c.qualifier.getBytes())))); } catch (IOException e) { e.printStackTrace(); } } return Optional.of(response); }
public void putBatch(Optional<List<Request>> putRequests, boolean optimize) { if (!valid) { Logger.error("CANNOT PUT! NO VALID CONNECTION"); return; } List<Put> puts = new ArrayList<>(); if (putRequests.isPresent() && !putRequests.get().isEmpty()) { String tableName = putRequests.get().get(0).table; putRequests .get() .forEach( pr -> pr.getPut() .ifPresent( p -> { if (optimize) { p.setDurability(Durability.SKIP_WAL); } puts.add(p); })); try { final Table table = connection.getTable(TableName.valueOf(tableName)); if (optimize && table instanceof HTable) { ((HTable) table).setAutoFlush(false, true); } table.put(puts); table.close(); } catch (IOException e) { e.printStackTrace(); } } }
@Test public void testGetRowSingleColumn() throws Throwable { final Table table = Table.open("Keyspace1"); final ColumnFamilyStore cfStore = table.getColumnFamilyStore("Standard1"); RowMutation rm = new RowMutation("Keyspace1", TEST_KEY); ColumnFamily cf = ColumnFamily.create("Keyspace1", "Standard1"); cf.addColumn(column("col1", "val1", 1L)); cf.addColumn(column("col2", "val2", 1L)); cf.addColumn(column("col3", "val3", 1L)); rm.add(cf); rm.apply(); Runnable verify = new WrappedRunnable() { public void runMayThrow() throws Exception { ColumnFamily cf; cf = cfStore.getColumnFamily( new NamesQueryFilter(TEST_KEY, new QueryPath("Standard1"), "col1".getBytes())); assertColumns(cf, "col1"); cf = cfStore.getColumnFamily( new NamesQueryFilter(TEST_KEY, new QueryPath("Standard1"), "col3".getBytes())); assertColumns(cf, "col3"); } }; reTest(table.getColumnFamilyStore("Standard1"), verify); }
@Override public List<Table> getTableList(UUID subscriptionId, String serviceName) throws AzureCmdException { String[] cmd = new String[] { "mobile", "table", "list", "--json", "-s", subscriptionId.toString(), serviceName }; String json = AzureCommandHelper.getInstance().consoleExec(cmd); CustomJsonSlurper slurper = new CustomJsonSlurper(); List<Map<String, String>> tempRes = (List<Map<String, String>>) slurper.parseText(json); List<Table> res = new ArrayList<Table>(); for (Map<String, String> item : tempRes) { Table t = new Table(); t.setName(item.get("name")); t.setSelfLink(item.get("selflink")); res.add(t); } return res; }
@Test public void testGetSliceFromSuperBasic() throws Throwable { // tests slicing against data from one row spread across two sstables final Table table = Table.open("Keyspace1"); final ColumnFamilyStore cfStore = table.getColumnFamilyStore("Super1"); final String ROW = "row2"; RowMutation rm = new RowMutation("Keyspace1", ROW); ColumnFamily cf = ColumnFamily.create("Keyspace1", "Super1"); SuperColumn sc = new SuperColumn("sc1".getBytes(), new LongType()); sc.addColumn(new Column(getBytes(1), "val1".getBytes(), 1L)); cf.addColumn(sc); rm.add(cf); rm.apply(); Runnable verify = new WrappedRunnable() { public void runMayThrow() throws Exception { ColumnFamily cf = cfStore.getColumnFamily( ROW, new QueryPath("Super1"), ArrayUtils.EMPTY_BYTE_ARRAY, ArrayUtils.EMPTY_BYTE_ARRAY, false, 10); assertColumns(cf, "sc1"); assertEquals( new String(cf.getColumn("sc1".getBytes()).getSubColumn(getBytes(1)).value()), "val1"); } }; reTest(table.getColumnFamilyStore("Standard1"), verify); }
@Test public void testGetSliceFromLarge() throws Throwable { // tests slicing against 1000 columns in an sstable Table table = Table.open("Keyspace1"); ColumnFamilyStore cfStore = table.getColumnFamilyStore("Standard1"); String key = "row3"; RowMutation rm = new RowMutation("Keyspace1", key); ColumnFamily cf = ColumnFamily.create("Keyspace1", "Standard1"); for (int i = 1000; i < 2000; i++) cf.addColumn(column("col" + i, ("v" + i), 1L)); rm.add(cf); rm.apply(); cfStore.forceBlockingFlush(); validateSliceLarge(cfStore); // compact so we have a big row with more than the minimum index count if (cfStore.getSSTables().size() > 1) { CompactionManager.instance.submitMajor(cfStore).get(); } SSTableReader sstable = cfStore.getSSTables().iterator().next(); DecoratedKey decKey = sstable.getPartitioner().decorateKey(key); SSTable.PositionSize info = sstable.getPosition(decKey); BufferedRandomAccessFile file = new BufferedRandomAccessFile(sstable.getFilename(), "r"); file.seek(info.position); assert file.readUTF().equals(key); file.readInt(); IndexHelper.skipBloomFilter(file); ArrayList<IndexHelper.IndexInfo> indexes = IndexHelper.deserializeIndex(file); assert indexes.size() > 2; validateSliceLarge(cfStore); }
/** * We need to resend our first message with our conn_id * * @param sender * @param seqno Resend the non null messages in the range [lowest .. seqno] */ protected void handleResendingOfFirstMessage(Address sender, long seqno) { if (log.isTraceEnabled()) log.trace(local_addr + " <-- SEND_FIRST_SEQNO(" + sender + "," + seqno + ")"); SenderEntry entry = send_table.get(sender); Table<Message> win = entry != null ? entry.sent_msgs : null; if (win == null) { if (log.isErrorEnabled()) log.error(local_addr + ": sender window for " + sender + " not found"); return; } boolean first_sent = false; for (long i = win.getLow() + 1; i <= seqno; i++) { Message rsp = win.get(i); if (rsp == null) continue; if (first_sent) { down_prot.down(new Event(Event.MSG, rsp)); } else { first_sent = true; // We need to copy the UnicastHeader and put it back into the message because Message.copy() // doesn't copy // the headers and therefore we'd modify the original message in the sender retransmission // window // (https://jira.jboss.org/jira/browse/JGRP-965) Message copy = rsp.copy(); Unicast2Header hdr = (Unicast2Header) copy.getHeader(this.id); Unicast2Header newhdr = hdr.copy(); newhdr.first = true; copy.putHeader(this.id, newhdr); down_prot.down(new Event(Event.MSG, copy)); } } }
@Override public List<GalenBasicTest> build(VarsContext context) { Table table = createTable(context); final VarsContext parameterizedContext = new VarsContext(new Properties(), context); final List<GalenBasicTest> tests = new LinkedList<GalenBasicTest>(); table.forEach( new RowVisitor() { @Override public void visit(Map<String, String> values) { parameterizedContext.addValuesFromMap(values); if (toParameterize instanceof ParameterizedNode) { ParameterizedNode parameterizedNode = (ParameterizedNode) toParameterize; tests.addAll( wrapTestsWithGroups(parameterizedNode.build(parameterizedContext), groups)); } else if (toParameterize instanceof TestNode) { TestNode suiteNode = (TestNode) toParameterize; tests.add(wrapTestWithGroups(suiteNode.build(parameterizedContext), groups)); } } }); return tests; }
public Table addColumn(String headerName, String attrs, List<Object> values) { Table t = new Table(); t.startHeaders().addCell(headerName, attrs).endHeaders(); for (Object val : values) { t.startRow().addCell(val).endRow(); } return this.addTable(t); }
public Table getTable(String name) { for (Table table : tables) { if (table.getName().equals(name)) { return table; } } return null; }
@Override public Collection<Integer> getAllTableIDs() { List<Integer> branchIDs = new ArrayList<>(tablesByDepth.size()); for (Table table = leafMostTable(); table != null; table = table.getParentTable()) { branchIDs.add(table.getTableId()); } return branchIDs; }
/** * @param request * @param tableCategoryId * @paqram includeAction if true, will load webactions also * @return elements are Table or WebAction */ public List getChildrenOfTableCategory( HttpServletRequest request, int tableCategoryId, boolean includeAction) { TableManager manager = TableManager.getInstance(); WebAction action; ArrayList cats = new ArrayList(); Connection conn = null; HashMap webActionEnv = null; Table table; UserWebImpl userWeb = ((UserWebImpl) WebUtils.getSessionContextManager(request.getSession()) .getActor(nds.util.WebKeys.USER)); TableCategory tc = manager.getTableCategory(tableCategoryId); List children = tc.children(); ArrayList catschild = new ArrayList(); try { if (includeAction) { conn = QueryEngine.getInstance().getConnection(); webActionEnv = new HashMap(); webActionEnv.put("connection", conn); webActionEnv.put("httpservletrequest", request); webActionEnv.put("userweb", userWeb); } for (int j = 0; j < children.size(); j++) { if (children.get(j) instanceof Table) { table = (Table) children.get(j); if (!table.isMenuObject()) { continue; } try { WebUtils.checkTableQueryPermission(table.getName(), request); } catch (NDSSecurityException e) { continue; } // table is ok for current user to list catschild.add(table); } else if (children.get(j) instanceof WebAction) { if (includeAction) { action = (WebAction) children.get(j); if (action.canDisplay(webActionEnv)) catschild.add(action); } } else { throw new NDSRuntimeException( "Unsupported element in TableCategory children:" + children.get(j).getClass()); } } } catch (Throwable t) { logger.error("Fail to load subsystem tree", t); } finally { try { if (conn != null) conn.close(); } catch (Throwable e) { } } return catschild; }
private boolean validateTables(TSelectSqlStatement stmt) { HashMap<String, Integer> present = new HashMap<String, Integer>(); if (!stmt.getResultColumnList().getResultColumn(0).toString().equals("*")) { int cols = stmt.getResultColumnList().size(); for (int a = 0; a < cols; a++) { present.put( stmt.getResultColumnList() .getResultColumn(a) .toString() .toLowerCase() .replace("(", "") .replace(")", ""), 0); } } TJoinList joins = stmt.joins; int j = joins.size(); int invalid = 1; for (int i = 0; i < j; i++) { Iterator<Table> it = DBSystem.tableList.iterator(); Table table = null; while (it.hasNext()) { table = it.next(); if (table.getName().equalsIgnoreCase(joins.getJoin(i).toString())) { invalid = 0; if (!stmt.getResultColumnList().getResultColumn(0).toString().equals("*")) { Iterator it1 = table.getColumnData().entrySet().iterator(); while (it1.hasNext()) { Map.Entry pairs = (Map.Entry) it1.next(); if (present.get(pairs.getKey().toString().toLowerCase()) != null && present.get(pairs.getKey().toString().toLowerCase()) == 0) { present.put(pairs.getKey().toString(), 1); } else if (present.get(pairs.getKey().toString().toLowerCase()) != null && present.get(pairs.getKey().toString().toLowerCase()) == 1) return false; } } } } if (invalid == 1) return false; else { invalid = 1; } } if (!stmt.getResultColumnList().getResultColumn(0).toString().equals("*")) { Iterator it2 = present.entrySet().iterator(); while (it2.hasNext()) { Map.Entry pairs = (Map.Entry) it2.next(); if ((Integer) pairs.getValue() == 0) { return false; } } } return true; }
private void putTableDeclaration(AnnotationInfo ai, Class<?> c) { Table table = c.getAnnotation(Table.class); if (table != null) { if (table.name() == null) throw new PersistenceException("You must specify a name= for @Table on " + c.getName()); ai.setDomainName(table.name()); } }
public void put(String tablename, Put p) { try { final Table table = connection.getTable(TableName.valueOf(tablename)); table.put(p); table.close(); } catch (IOException e) { e.printStackTrace(); } }
@Test public void simpleQueryWithRangeTombstoneTest() throws Exception { Table table = Table.open(KSNAME); ColumnFamilyStore cfs = table.getColumnFamilyStore(CFNAME); // Inserting data String key = "k1"; RowMutation rm; ColumnFamily cf; rm = new RowMutation(KSNAME, ByteBufferUtil.bytes(key)); for (int i = 0; i < 40; i += 2) add(rm, i, 0); rm.apply(); cfs.forceBlockingFlush(); rm = new RowMutation(KSNAME, ByteBufferUtil.bytes(key)); cf = rm.addOrGet(CFNAME); delete(cf, 10, 22, 1); rm.apply(); cfs.forceBlockingFlush(); rm = new RowMutation(KSNAME, ByteBufferUtil.bytes(key)); for (int i = 1; i < 40; i += 2) add(rm, i, 2); rm.apply(); cfs.forceBlockingFlush(); rm = new RowMutation(KSNAME, ByteBufferUtil.bytes(key)); cf = rm.addOrGet(CFNAME); delete(cf, 19, 27, 3); rm.apply(); // We don't flush to test with both a range tomsbtone in memtable and in sstable QueryPath path = new QueryPath(CFNAME); // Queries by name int[] live = new int[] {4, 9, 11, 17, 28}; int[] dead = new int[] {12, 19, 21, 24, 27}; SortedSet<ByteBuffer> columns = new TreeSet<ByteBuffer>(cfs.getComparator()); for (int i : live) columns.add(b(i)); for (int i : dead) columns.add(b(i)); cf = cfs.getColumnFamily(QueryFilter.getNamesFilter(dk(key), path, columns)); for (int i : live) assert isLive(cf, cf.getColumn(b(i))) : "Column " + i + " should be live"; for (int i : dead) assert !isLive(cf, cf.getColumn(b(i))) : "Column " + i + " shouldn't be live"; // Queries by slices cf = cfs.getColumnFamily( QueryFilter.getSliceFilter(dk(key), path, b(7), b(30), false, Integer.MAX_VALUE)); for (int i : new int[] {7, 8, 9, 11, 13, 15, 17, 28, 29, 30}) assert isLive(cf, cf.getColumn(b(i))) : "Column " + i + " should be live"; for (int i : new int[] {10, 12, 14, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}) assert !isLive(cf, cf.getColumn(b(i))) : "Column " + i + " shouldn't be live"; }