@Override public DeleteBuilder deleteColumn(byte[] family, byte[] qualifier, long timestamp) { delete.deleteColumn(family, qualifier, timestamp); return this; }
d.deleteColumn(FAM, indexed_qualifer); primary.delete(d); IndexTestingUtils.verifyIndexTableAtTimestamp(index1, expected, ts, value1);
@Override public DeleteBuilder deleteColumn(byte[] family, byte[] qualifier) { delete.deleteColumn(family, qualifier); return this; }
d.deleteColumn(FAM2, indexed_qualifer, ts3); primary.delete(d);
@Override public DeleteBuilder deleteColumn(byte[] family, byte[] qualifier, long timestamp) { delete.deleteColumn(family, qualifier, timestamp); return this; }
d.deleteColumn(FAMILY, QUAL, 1); ensureNoUpdatesWhenCoveredByDelete(env, codec, kvs, d);
@Override public DeleteBuilder deleteColumn(byte[] family, byte[] qualifier) { delete.deleteColumn(family, qualifier); return this; }
/** * Delete the latest version of the specified column. * This is an expensive call in that on the server-side, it first does a * get to find the latest versions timestamp. Then it adds a delete using * the fetched cells timestamp. * @param family family name * @param qualifier column qualifier * @return this for invocation chaining */ public Delete deleteColumn(byte [] family, byte [] qualifier) { this.deleteColumn(family, qualifier, HConstants.LATEST_TIMESTAMP); return this; }
/** * Delete the latest version of the specified column. * This is an expensive call in that on the server-side, it first does a * get to find the latest versions timestamp. Then it adds a delete using * the fetched cells timestamp. * @param family family name * @param qualifier column qualifier * @return this for invocation chaining */ public Delete addColumn(final byte [] family, final byte [] qualifier) { this.deleteColumn(family, qualifier, this.ts); return this; }
d.deleteColumn(FAMILY, null); WALEdit withDelete = new WALEdit(); addMutation(withDelete, d, FAMILY);
public DeletedRowFamilyColumn<T, I> col(byte[] name) { if (currentFamily == null) { throw new RuntimeException("not implemented"); } else { delete.deleteColumn(currentFamily, name); } return this; }
d.deleteColumn(FAM, indexed_qualifer, ts1); d.deleteColumn(FAM2, regular_qualifer, ts3); primary.delete(d);
/** {@inheritDoc} */ @Override public void removeRecentTableLayoutVersions(String table, int numVersions) throws IOException { Preconditions.checkArgument(numVersions >= 1, "numVersions must be positive"); final Delete delete = new Delete(Bytes.toBytes(table)); for (int i = 0; i < numVersions; i++) { delete .deleteColumn(mFamilyBytes, QUALIFIER_UPDATE_BYTES) .deleteColumn(mFamilyBytes, QUALIFIER_LAYOUT_BYTES) .deleteColumn(mFamilyBytes, QUALIFIER_LAYOUT_ID_BYTES); } mTable.delete(delete); }
/** * Convert deletions to a Delete command. * * @param cfName The name of the ColumnFamily deletions belong to * @param key The row key * @param deletions The name of the columns to delete (a.k.a deletions) * @return Delete command or null if deletions were null or empty. */ private static Delete makeDeletionCommand(byte[] cfName, byte[] key, List<StaticBuffer> deletions) { Preconditions.checkArgument(!deletions.isEmpty()); Delete deleteCommand = new Delete(key); for (StaticBuffer del : deletions) { deleteCommand.deleteColumn(cfName, del.as(StaticBuffer.ARRAY_FACTORY)); } return deleteCommand; }
public void logInProfileInHBase(long userId, String ipAddress) throws IOException, Exception { HTableInterface profileTable = hTablePool.getTable(DataModelConsts.PROFILE_TABLE); ArrayList<Row> actions = new ArrayList<Row>(); byte[] profileRowKey = generateProfileRowKey(userId); Delete delete = new Delete(profileRowKey); delete.deleteColumn(DataModelConsts.PROFILE_COLUMN_FAMILY, DataModelConsts.CURRENT_LOG_IN_PURCHASES_VALUE_COL); delete.deleteColumn(DataModelConsts.PROFILE_COLUMN_FAMILY, DataModelConsts.CURRENT_LOG_IN_SELLS_VALUE_COL); actions.add(delete); Increment increment = new Increment(profileRowKey); increment.addColumn(DataModelConsts.PROFILE_COLUMN_FAMILY, DataModelConsts.LOG_IN_COUNT_COL, 1); actions.add(increment); Put put = new Put(profileRowKey); put.add(DataModelConsts.PROFILE_COLUMN_FAMILY, DataModelConsts.LAST_LOG_IN_COL, Bytes.toBytes(System.currentTimeMillis())); put.add(DataModelConsts.PROFILE_COLUMN_FAMILY, DataModelConsts.LOG_IN_IP_ADDERSSES, Bytes.toBytes(ipAddress)); actions.add(put); profileTable.batch(actions); }
/** {@inheritDoc} */ @Override public void deleteCell(EntityId entityId, String family, String qualifier, long timestamp) throws IOException { final State state = mState.get(); Preconditions.checkState(state == State.OPEN, "Cannot delete cell while FijiTableWriter %s is in state %s.", this, state); final HBaseColumnName hbaseColumnName = mWriterLayoutCapsule.getColumnNameTranslator() .toHBaseColumnName(FijiColumnName.create(family, qualifier)); final Delete delete = new Delete(entityId.getHBaseRowKey()) .deleteColumn(hbaseColumnName.getFamily(), hbaseColumnName.getQualifier(), timestamp); mHTable.delete(delete); }
/** {@inheritDoc} */ @Override public void deleteCell(EntityId entityId, String family, String qualifier, long timestamp) throws IOException { final HBaseColumnName hbaseColumnName = mTable.getColumnNameTranslator() .toHBaseColumnName(FijiColumnName.create(family, qualifier)); final Delete delete = new Delete(entityId.getHBaseRowKey()) .deleteColumn(hbaseColumnName.getFamily(), hbaseColumnName.getQualifier(), timestamp); updateBuffer(delete); }
@Override public void cleanup() { Set<HBaseCellId> writeSet = getWriteSet(); for (final HBaseCellId cell : writeSet) { Delete delete = new Delete(cell.getRow()); delete.deleteColumn(cell.getFamily(), cell.getQualifier(), getStartTimestamp()); try { cell.getTable().delete(delete); } catch (IOException e) { LOG.warn("Failed cleanup cell {} for Tx {}. This issue has been ignored", cell, getTransactionId(), e); } } try { flushTables(); } catch (IOException e) { LOG.warn("Failed flushing tables for Tx {}", getTransactionId(), e); } }
public byte[] doMutation(HRegion region, Integer lid) throws IOException { byte[] lockBytes = readLockBytes(region, row, lid, new Column(family, qualifier), prewriteTs, ThemisCpStatistics.getThemisCpStatistics().getLockAndEraseReadLatency); if (lockBytes == null) { return null; } Column lockColumn = ColumnUtil.getLockColumn(family, qualifier); Delete delete = new Delete(row); setLockFamilyDelete(delete); delete.deleteColumn(lockColumn.getFamily(), lockColumn.getQualifier(), prewriteTs); mutateToRegion(region, row, Lists.<Mutation> newArrayList(delete), ThemisCpStatistics.getThemisCpStatistics().getLockAndEraseReadLatency); return lockBytes; } }.run();
protected void eraseLock(ColumnCoordinate c, long ts) throws IOException { Column lc = ColumnUtil.getLockColumn(c); Delete delete = new Delete(c.getRow()).deleteColumn(lc.getFamily(), lc.getQualifier(), ts); getTable(c.getTableName()).delete(delete); }