public static TIncrement incrementFromHBase(Increment in) throws IOException { TIncrement out = new TIncrement(); out.setRow(in.getRow()); out.setDurability(durabilityFromHBase(in.getDurability())); columnValue.setAmount( Bytes.toLong(cell.getValueArray(), cell.getValueOffset(), cell.getValueLength())); out.addToColumns(columnValue); out.putToAttributes(ByteBuffer.wrap(Bytes.toBytes(attribute.getKey())), ByteBuffer.wrap(attribute.getValue())); TCellVisibility tCellVisibility = new TCellVisibility(); tCellVisibility.setExpression(cellVisibility.getExpression()); out.setCellVisibility(tCellVisibility); out.setReturnResults(in.isReturnResults()); return out;
case ROW: if (value == null) { unsetRow(); } else { if (value instanceof byte[]) { setRow((byte[])value); } else { setRow((java.nio.ByteBuffer)value); unsetColumns(); } else { setColumns((java.util.List<TColumnIncrement>)value); unsetAttributes(); } else { setAttributes((java.util.Map<java.nio.ByteBuffer,java.nio.ByteBuffer>)value); unsetDurability(); } else { setDurability((TDurability)value); unsetCellVisibility(); } else { setCellVisibility((TCellVisibility)value); unsetReturnResults(); } else { setReturnResults((java.lang.Boolean)value);
@Override public boolean equals(java.lang.Object that) { if (that == null) return false; if (that instanceof TIncrement) return this.equals((TIncrement)that); return false; }
/** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new java.lang.IllegalArgumentException(); } switch (field) { case ROW: return isSetRow(); case COLUMNS: return isSetColumns(); case ATTRIBUTES: return isSetAttributes(); case DURABILITY: return isSetDurability(); case CELL_VISIBILITY: return isSetCellVisibility(); case RETURN_RESULTS: return isSetReturnResults(); } throw new java.lang.IllegalStateException(); }
@org.apache.thrift.annotation.Nullable public java.lang.Object getFieldValue(_Fields field) { switch (field) { case ROW: return getRow(); case COLUMNS: return getColumns(); case ATTRIBUTES: return getAttributes(); case DURABILITY: return getDurability(); case CELL_VISIBILITY: return getCellVisibility(); case RETURN_RESULTS: return isReturnResults(); } throw new java.lang.IllegalStateException(); }
public static Increment incrementFromThrift(TIncrement in) throws IOException { Increment out = new Increment(in.getRow()); for (TColumnIncrement column : in.getColumns()) { out.addColumn(column.getFamily(), column.getQualifier(), column.getAmount()); } if (in.isSetAttributes()) { addAttributes(out,in.getAttributes()); } if (in.isSetDurability()) { out.setDurability(durabilityFromThrift(in.getDurability())); } if(in.getCellVisibility() != null) { out.setCellVisibility(new CellVisibility(in.getCellVisibility().getExpression())); } if (in.isSetReturnResults()) { out.setReturnResults(in.isReturnResults()); } return out; }
public static Increment incrementFromThrift(TIncrement in) throws IOException { Increment out = new Increment(in.getRow()); for (TColumnIncrement column : in.getColumns()) { out.addColumn(column.getFamily(), column.getQualifier(), column.getAmount()); } if (in.isSetAttributes()) { addAttributes(out,in.getAttributes()); } if (in.isSetDurability()) { out.setDurability(durabilityFromThrift(in.getDurability())); } if(in.getCellVisibility() != null) { out.setCellVisibility(new CellVisibility(in.getCellVisibility().getExpression())); } return out; }
@Override public void read(org.apache.thrift.protocol.TProtocol prot, increment_args struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; struct.table = iprot.readBinary(); struct.setTableIsSet(true); struct.increment = new TIncrement(); struct.increment.read(iprot); struct.setIncrementIsSet(true); } }
@Test public void testIncrementWithTagsWithNotMatchLabels() throws Exception { ThriftHBaseServiceHandler handler = createHandler(); byte[] rowName = Bytes.toBytes("testIncrementWithTagsWithNotMatchLabels"); ByteBuffer table = wrap(tableAname); List<TColumnValue> columnValues = new ArrayList<>(1); columnValues.add(new TColumnValue(wrap(familyAname), wrap(qualifierAname), wrap(Bytes.toBytes(1L)))); TPut put = new TPut(wrap(rowName), columnValues); put.setColumnValues(columnValues); put.setCellVisibility(new TCellVisibility().setExpression(PRIVATE)); handler.put(table, put); List<TColumnIncrement> incrementColumns = new ArrayList<>(1); incrementColumns.add(new TColumnIncrement(wrap(familyAname), wrap(qualifierAname))); TIncrement increment = new TIncrement(wrap(rowName), incrementColumns); increment.setCellVisibility(new TCellVisibility().setExpression(SECRET)); handler.increment(table, increment); TGet get = new TGet(wrap(rowName)); TAuthorization tauth = new TAuthorization(); List<String> labels = new ArrayList<>(1); labels.add(PUBLIC); tauth.setLabels(labels); get.setAuthorizations(tauth); TResult result = handler.get(table, get); assertNull(result.getRow()); }
public TIncrement deepCopy() { return new TIncrement(this); }
TIncrement tIncrement = new TIncrement(wrap(rowName), incrementColumns); tIncrement.setAttributes(attributes); Increment increment = incrementFromThrift(tIncrement); assertArrayEquals(increment.getAttribute("attribute1"), attributeValue);
assertEquals(Durability.FSYNC_WAL, put.getDurability()); TIncrement tIncrement = new TIncrement(wrap(rowName), incrementColumns); tIncrement.setDurability(TDurability.SKIP_WAL); Increment increment = incrementFromThrift(tIncrement); assertEquals(Durability.SKIP_WAL, increment.getDurability()); tIncrement.setDurability(TDurability.ASYNC_WAL); increment = incrementFromThrift(tIncrement); assertEquals(Durability.ASYNC_WAL, increment.getDurability()); tIncrement.setDurability(TDurability.SYNC_WAL); increment = incrementFromThrift(tIncrement); assertEquals(Durability.SYNC_WAL, increment.getDurability()); tIncrement.setDurability(TDurability.FSYNC_WAL); increment = incrementFromThrift(tIncrement); assertEquals(Durability.FSYNC_WAL, increment.getDurability());
/** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); } switch (field) { case ROW: return isSetRow(); case COLUMNS: return isSetColumns(); case WRITE_TO_WAL: return isSetWriteToWal(); } throw new IllegalStateException(); }
public Object getFieldValue(_Fields field) { switch (field) { case ROW: return getRow(); case COLUMNS: return getColumns(); case WRITE_TO_WAL: return Boolean.valueOf(isWriteToWal()); } throw new IllegalStateException(); }
private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException { try { // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor. __isset_bitfield = 0; read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); } catch (org.apache.thrift.TException te) { throw new java.io.IOException(te); } }
/** * Performs a deep copy on <i>other</i>. */ public TIncrement(TIncrement other) { __isset_bit_vector.clear(); __isset_bit_vector.or(other.__isset_bit_vector); if (other.isSetRow()) { this.row = org.apache.thrift.TBaseHelper.copyBinary(other.row); ; } if (other.isSetColumns()) { List<TColumnIncrement> __this__columns = new ArrayList<TColumnIncrement>(); for (TColumnIncrement other_element : other.columns) { __this__columns.add(new TColumnIncrement(other_element)); } this.columns = __this__columns; } this.writeToWal = other.writeToWal; }
@Override public int hashCode() { int hashCode = 1; hashCode = hashCode * 8191 + ((isSetRow()) ? 131071 : 524287); if (isSetRow()) hashCode = hashCode * 8191 + row.hashCode(); hashCode = hashCode * 8191 + ((isSetColumns()) ? 131071 : 524287); if (isSetColumns()) hashCode = hashCode * 8191 + columns.hashCode(); hashCode = hashCode * 8191 + ((isSetAttributes()) ? 131071 : 524287); if (isSetAttributes()) hashCode = hashCode * 8191 + attributes.hashCode(); hashCode = hashCode * 8191 + ((isSetDurability()) ? 131071 : 524287); if (isSetDurability()) hashCode = hashCode * 8191 + durability.getValue(); hashCode = hashCode * 8191 + ((isSetCellVisibility()) ? 131071 : 524287); if (isSetCellVisibility()) hashCode = hashCode * 8191 + cellVisibility.hashCode(); hashCode = hashCode * 8191 + ((isSetReturnResults()) ? 131071 : 524287); if (isSetReturnResults()) hashCode = hashCode * 8191 + ((returnResults) ? 131071 : 524287); return hashCode; }
public Object getFieldValue(_Fields field) { switch (field) { case ROW: return getRow(); case COLUMNS: return getColumns(); case ATTRIBUTES: return getAttributes(); case DURABILITY: return getDurability(); case CELL_VISIBILITY: return getCellVisibility(); } throw new IllegalStateException(); }
public static Increment incrementFromThrift(TIncrement in) throws IOException { Increment out = new Increment(in.getRow()); for (TColumnIncrement column : in.getColumns()) { out.addColumn(column.getFamily(), column.getQualifier(), column.getAmount()); } if (in.isSetAttributes()) { addAttributes(out,in.getAttributes()); } if (in.isSetDurability()) { out.setDurability(durabilityFromThrift(in.getDurability())); } if(in.getCellVisibility() != null) { out.setCellVisibility(new CellVisibility(in.getCellVisibility().getExpression())); } return out; }
@Override public void read(org.apache.thrift.protocol.TProtocol prot, increment_args struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; struct.table = iprot.readBinary(); struct.setTableIsSet(true); struct.increment = new TIncrement(); struct.increment.read(iprot); struct.setIncrementIsSet(true); } }