final DeleteRequest delete = new DeleteRequest( lastTableBytes, key.getBytes(), columnFamilyBytes); if (!durability) { delete.setDurable(false); delete.setBufferable(false); try { client.delete(delete).join(joinTimeout);
/** * Deletes the given cells from the data table. */ final Deferred<Object> delete(final byte[] key, final byte[][] qualifiers) { return client.delete(new DeleteRequest(table, key, FAMILY, qualifiers)); }
/** Serializes this request for HBase 0.94 and before. */ private ChannelBuffer serializeOld(final byte server_version) { final ChannelBuffer buf = newBuffer(server_version, predictSerializedSize()); buf.writeInt(2); // Number of parameters. // 1st param: byte array containing region name writeHBaseByteArray(buf, region.name()); // 2nd param: Delete object. buf.writeByte(CODE); // Code for a `Delete' parameter. buf.writeByte(CODE); // Code again (see HBASE-2877). buf.writeByte(1); // Delete#DELETE_VERSION. Stick to v1 here for now. writeByteArray(buf, key); buf.writeLong(timestamp); // Maximum timestamp. buf.writeLong(lockid); // Lock ID. // Families. if (family == WHOLE_ROW) { buf.writeInt(0); // Number of families that follow. return buf; } buf.writeInt(1); // Number of families that follow. // Each family is then written like so: writeByteArray(buf, family); // Column family name. buf.writeInt(qualifiers.length); // How many KeyValues for this family? serializePayload(buf); return buf; }
/** Serializes this request. */ ChannelBuffer serialize(final byte server_version) { if (server_version < RegionClient.SERVER_VERSION_095_OR_ABOVE) { return serializeOld(server_version); } final MutateRequest req = MutateRequest.newBuilder() .setRegion(region.toProtobuf()) .setMutation(toMutationProto()) .build(); return toChannelBuffer(MUTATE, req); }
@Override Object deserialize(final ChannelBuffer buf, int cell_size) { HBaseRpc.ensureNoCell(cell_size); final MutateResponse resp = readProtobuf(buf, MutateResponse.PARSER); return null; }
/** * Predicts a lower bound on the serialized size of this RPC. * This is to avoid using a dynamic buffer, to avoid re-sizing the buffer. * Since we use a static buffer, if the prediction is wrong and turns out * to be less than what we need, there will be an exception which will * prevent the RPC from being serialized. That'd be a severe bug. */ private int predictSerializedSize() { int size = 0; size += 4; // int: Number of parameters. size += 1; // byte: Type of the 1st parameter. size += 3; // vint: region name length (3 bytes => max length = 32768). size += region.name().length; // The region name. size += 1; // byte: Type of the 2nd parameter. size += 1; // byte: Type again (see HBASE-2877). size += 1; // byte: Version of Delete. size += 3; // vint: row key length (3 bytes => max length = 32768). size += key.length; // The row key. size += 8; // long: Timestamp. size += 8; // long: Lock ID. size += 4; // int: Number of families. size += 1; // vint: Family length (guaranteed on 1 byte). if (family == null) { return size; } size += family.length; // The column family. size += 4; // int: Number of KeyValues for this family. return size + payloadSize(); }
final DeleteRequest del = new DeleteRequest(table, key); client.delete(del);
final DeleteRequest old_forward_mapping = new DeleteRequest( table, toBytes(oldname), ID_FAMILY, kind); client.delete(old_forward_mapping).joinUninterruptibly();
this.client.delete(new DeleteRequest(this.river.getTable().getBytes(), keyEntry.getValue())).addErrback(this.cbLogger);