@Override public int getValueOffset() { return this.kv.getValueOffset(); }
protected static String getValueString(final KeyValue kv) { return Bytes.toStringBinary(kv.getValueArray(), kv.getValueOffset(), kv.getValueLength()); }
@Test public void testBasic() throws Exception { Configuration hconf = HadoopUtil.getCurrentConfiguration(); Context context = MockupMapContext.create(hconf, cubeName, outKV); CubeHFileMapper mapper = new CubeHFileMapper(); mapper.doSetup(context); Text key = new Text("not important"); Text value = new Text(new byte[] { 2, 2, 51, -79, 1 }); mapper.map(key, value, context); KeyValue outValue = (KeyValue) outKV[1]; assertTrue(Bytes.compareTo(value.getBytes(), 0, value.getLength(), outValue.getValueArray(), outValue.getValueOffset(), outValue.getValueLength()) == 0); }
KeyValue kv1 = kvs.get(i); Assert.assertTrue(kv.equals(kv1)); Assert.assertTrue(Bytes.equals(kv.getValueArray(), kv.getValueOffset(), kv.getValueLength(), kv1.getValueArray(), kv1.getValueOffset(), kv1.getValueLength())); Assert.assertTrue(Bytes.equals(kv.getTagsArray(), kv.getTagsOffset(), kv.getTagsLength(), kv1.getTagsArray(), kv1.getTagsOffset(),
KeyValue kv = KeyValueUtil.ensureKeyValue(result.getColumnLatestCell(f, q)); List<Tag> tags = TestCoprocessorForTags.tags; assertEquals(3L, Bytes.toLong(kv.getValueArray(), kv.getValueOffset(), kv.getValueLength())); assertEquals(1, tags.size()); assertEquals("tag1", Bytes.toString(Tag.cloneValue(tags.get(0)))); kv = KeyValueUtil.ensureKeyValue(result.getColumnLatestCell(f, q)); tags = TestCoprocessorForTags.tags; assertEquals(5L, Bytes.toLong(kv.getValueArray(), kv.getValueOffset(), kv.getValueLength())); assertEquals(2, tags.size()); kv = KeyValueUtil.ensureKeyValue(result.getColumnLatestCell(f, q)); tags = TestCoprocessorForTags.tags; assertEquals(4L, Bytes.toLong(kv.getValueArray(), kv.getValueOffset(), kv.getValueLength())); assertEquals(1, tags.size()); assertEquals("tag2", Bytes.toString(Tag.cloneValue(tags.get(0))));
@Test public void testCreateKeyOnly() throws Exception { long ts = 1; byte [] value = Bytes.toBytes("a real value"); byte [] evalue = new byte[0]; // empty value for (byte[] val : new byte[][]{value, evalue}) { for (boolean useLen : new boolean[]{false,true}) { KeyValue kv1 = new KeyValue(rowA, family, qualA, ts, val); KeyValue kv1ko = kv1.createKeyOnly(useLen); // keys are still the same assertTrue(kv1.equals(kv1ko)); // but values are not assertTrue(kv1ko.getValueLength() == (useLen?Bytes.SIZEOF_INT:0)); if (useLen) { assertEquals(kv1.getValueLength(), Bytes.toInt(kv1ko.getValueArray(), kv1ko.getValueOffset(), kv1ko.getValueLength())); } } } }
public void testAdd() throws Exception { byte[] bytes = Bytes.toBytes(getName()); KeyValue kv = new KeyValue(bytes, bytes, bytes, bytes); this.csls.add(kv); assertTrue(this.csls.contains(kv)); assertEquals(1, this.csls.getDelegatee().size()); Cell first = this.csls.first(); assertTrue(kv.equals(first)); assertTrue(Bytes.equals(kv.getValueArray(), kv.getValueOffset(), kv.getValueLength(), first.getValueArray(), first.getValueOffset(), first.getValueLength())); // Now try overwritting byte[] overwriteValue = Bytes.toBytes("overwrite"); KeyValue overwrite = new KeyValue(bytes, bytes, bytes, overwriteValue); this.csls.add(overwrite); assertEquals(1, this.csls.getDelegatee().size()); first = this.csls.first(); assertTrue(Bytes.equals(overwrite.getValueArray(), overwrite.getValueOffset(), overwrite.getValueLength(), first.getValueArray(), first.getValueOffset(), first.getValueLength())); assertFalse(Bytes.equals(CellUtil.cloneValue(overwrite), CellUtil.cloneValue(kv))); }
final KeyValue transformedQual2 = KeyValueUtil.ensureKeyValue(flist.transformCell(kvQual2)); assertEquals("value", Bytes.toString(transformedQual2.getValueArray(), transformedQual2.getValueOffset(), transformedQual2.getValueLength()));
kv1.getFamilyOffset() - KeyValue.ROW_OFFSET, kv1.getFamilyLength(), kv1.getQualifierOffset() - KeyValue.ROW_OFFSET, kv1.getQualifierLength(), kv1.getTimestamp(), kv1.getTypeByte(), kv1.getValueArray(), kv1.getValueOffset(), kv1.getValueLength(), kv1.getSequenceId(), kv1.getTagsArray(), kv1.getTagsOffset(), kv1.getTagsLength()); kv2.getFamilyOffset() - KeyValue.ROW_OFFSET, kv2.getFamilyLength(), kv2.getQualifierOffset() - KeyValue.ROW_OFFSET, kv2.getQualifierLength(), kv2.getTimestamp(), kv2.getTypeByte(), kv2.getValueArray(), kv2.getValueOffset(), kv2.getValueLength(), kv2.getSequenceId(), kv2.getTagsArray(), kv2.getTagsOffset(), kv2.getTagsLength()); kv2.getQualifierOffset() - KeyValue.ROW_OFFSET, kv2.getQualifierLength(), kv2.getTimestamp(), kv2.getTypeByte(), ByteBuffer.wrap(kv2.getValueArray()), kv2.getValueOffset(), kv2.getValueLength(), kv2.getSequenceId(), ByteBuffer.wrap(kv2.getTagsArray()), kv2.getTagsOffset(), kv2.getTagsLength()); ByteArrayOutputStream os = new ByteArrayOutputStream();
assertTrue(Bytes.equals(kv.getQualifierArray(), kv.getQualifierOffset(), kv.getQualifierLength(), q, 0, q.length)); assertTrue(Bytes.equals(kv.getValueArray(), kv.getValueOffset(), kv.getValueLength(), value, 0, value.length)); List<Tag> tags = PrivateCellUtil.getTags(kv);
static void writeCell(PositionedByteRange pbr, KeyValue kv) throws Exception { pbr.putInt(kv.getKeyLength()); pbr.putInt(kv.getValueLength()); pbr.put(kv.getBuffer(), kv.getKeyOffset(), kv.getKeyLength()); pbr.put(kv.getBuffer(), kv.getValueOffset(), kv.getValueLength()); int tagsLen = kv.getTagsLength(); pbr.put((byte) (tagsLen >> 8 & 0xff)); pbr.put((byte) (tagsLen & 0xff)); pbr.put(kv.getTagsArray(), kv.getTagsOffset(), tagsLen); pbr.putVLong(kv.getSequenceId()); }
assertTrue(Bytes.compareTo(value, 0, value.length, kv.getValueArray(), kv.getValueOffset(), kv.getValueLength()) == 0); if (useTags) {
@Override public boolean getValue(byte[] family, byte[] qualifier, ImmutableBytesWritable ptr) { if (keyValue == null) return false; ptr.set(keyValue.getBuffer(), keyValue.getValueOffset(), keyValue.getValueLength()); return true; } }
@Override public MetaDataMutationResult updateIndexState(List<Mutation> tableMetadata, String parentTableName) throws SQLException { byte[][] rowKeyMetadata = new byte[3][]; SchemaUtil.getVarChars(tableMetadata.get(0).getRow(), rowKeyMetadata); KeyValue newKV = tableMetadata.get(0).getFamilyMap().get(TABLE_FAMILY_BYTES).get(0); PIndexState newState = PIndexState.fromSerializedValue(newKV.getBuffer()[newKV.getValueOffset()]); String schemaName = Bytes.toString(rowKeyMetadata[PhoenixDatabaseMetaData.SCHEMA_NAME_INDEX]); String indexName = Bytes.toString(rowKeyMetadata[PhoenixDatabaseMetaData.TABLE_NAME_INDEX]); String indexTableName = SchemaUtil.getTableName(schemaName, indexName); PTable index = metaData.getTable(indexTableName); index = PTableImpl.makePTable(index,newState == PIndexState.USABLE ? PIndexState.ACTIVE : newState == PIndexState.UNUSABLE ? PIndexState.INACTIVE : newState); return new MetaDataMutationResult(MutationCode.TABLE_ALREADY_EXISTS, 0, index); }
@Override public boolean getValue(byte[] family, byte[] qualifier, ImmutableBytesWritable ptr) { KeyValue kv = getValue(family, qualifier); if (kv == null) return false; ptr.set(kv.getValueArray(), kv.getValueOffset(), kv.getValueLength()); return true; }
@Override public boolean getValue(byte[] family, byte[] qualifier, ImmutableBytesWritable ptr) { KeyValue kv = getValue(family, qualifier); if (kv == null) return false; ptr.set(kv.getBuffer(), kv.getValueOffset(), kv.getValueLength()); return true; } }
@Override public boolean getValue(byte[] family, byte[] qualifier, ImmutableBytesWritable ptr) { KeyValue kv = getValue(family, qualifier); if (kv == null) return false; ptr.set(kv.getBuffer(), kv.getValueOffset(), kv.getValueLength()); return true; } }
@Override public boolean getValue(byte[] family, byte[] qualifier, ImmutableBytesWritable ptr) { KeyValue kv = getValue(family, qualifier); if (kv == null) return false; ptr.set(kv.getBuffer(), kv.getValueOffset(), kv.getValueLength()); return true; } }
public SequenceValue(Result r) { KeyValue currentValueKV = getCurrentValueKV(r); KeyValue incrementByKV = getIncrementByKV(r); KeyValue cacheSizeKV = getCacheSizeKV(r); timestamp = currentValueKV.getTimestamp(); nextValue = PDataType.LONG.getCodec().decodeLong(currentValueKV.getBuffer(), currentValueKV.getValueOffset(), null); incrementBy = PDataType.LONG.getCodec().decodeLong(incrementByKV.getBuffer(), incrementByKV.getValueOffset(), null); cacheSize = PDataType.INTEGER.getCodec().decodeInt(cacheSizeKV.getBuffer(), cacheSizeKV.getValueOffset(), null); currentValue = nextValue - incrementBy * cacheSize; } }
public static long getSequenceNumber(Mutation tableMutation) { List<KeyValue> kvs = tableMutation.getFamilyMap().get(PhoenixDatabaseMetaData.TABLE_FAMILY_BYTES); if (kvs != null) { for (KeyValue kv : kvs) { // list is not ordered, so search. TODO: we could potentially assume the position if (Bytes.compareTo(kv.getBuffer(), kv.getQualifierOffset(), kv.getQualifierLength(), PhoenixDatabaseMetaData.TABLE_SEQ_NUM_BYTES, 0, PhoenixDatabaseMetaData.TABLE_SEQ_NUM_BYTES.length) == 0) { return PDataType.LONG.getCodec().decodeLong(kv.getBuffer(), kv.getValueOffset(), null); } } } throw new IllegalStateException(); }