Java Code Examples for org.apache.hadoop.hbase.client.HTableInterface#put()

@Override
public void updateUser(UserDetails user) {
    HTableInterface htable = null;
    try {
        byte[] userAuthorities = serialize(user.getAuthorities());
        htable = HBaseConnection.get(hbaseUrl).getTable(userTableName);
        Put put = new Put(Bytes.toBytes(user.getUsername()));
        put.add(Bytes.toBytes(USER_AUTHORITY_FAMILY), Bytes.toBytes(USER_AUTHORITY_COLUMN), userAuthorities);

        htable.put(put);
        htable.flushCommits();
    } catch (IOException e) {
        throw new RuntimeException(e.getMessage(), e);
    } finally {
        IOUtils.closeQuietly(htable);
    }
}
 

protected boolean add(KVSerializable item, String tableName) {
    long size = 1L;

    Put put = new Put(item.getKey());
    HTableInterface table = getHTableInterface(tableName);

    //put.setWriteToWAL(false);
    put.add(CF, V_DATA, item.getValue());
    try {
        table.put(put);
        table.flushCommits();
        succCounter.update(size);
        hbaseSendTps.update(size);
    } catch (Throwable ex) {
        logger.error("Error", ex);
        failedCounter.update(size);
        return false;
    } finally {
        closeTable(table);
    }
    return true;
}
 

@Override
protected void putResourceImpl(String resPath, InputStream content, long ts) throws IOException {
    ByteArrayOutputStream bout = new ByteArrayOutputStream();
    IOUtils.copy(content, bout);
    bout.close();

    HTableInterface table = getConnection().getTable(getAllInOneTableName());
    try {
        byte[] row = Bytes.toBytes(resPath);
        Put put = buildPut(resPath, ts, row, bout.toByteArray(), table);

        table.put(put);
        table.flushCommits();
    } finally {
        IOUtils.closeQuietly(table);
    }
}
 

protected boolean batchAdd(Collection<KVSerializable> items, String tableName) {
    int size = items.size();
    List<Put> batch = new ArrayList<>(size);
    HTableInterface table = getHTableInterface(tableName);
    for (KVSerializable v : items) {
        byte[] rowKey = v.getKey();
        Put put = new Put(rowKey);
        put.add(CF, V_DATA, v.getValue());
        batch.add(put);
    }
    try {
        table.put(batch);
        table.flushCommits();
        succCounter.update(size);
        hbaseSendTps.update(size);
    } catch (Throwable ex) {
        logger.error("Error", ex);
        failedCounter.update(size);
        return false;
    } finally {
        closeTable(table);
    }
    return true;
}
 

public void saveQuery(final String creator, final Query query) throws IOException {
    List<Query> queries = getQueries(creator);
    queries.add(query);
    Query[] queryArray = new Query[queries.size()];

    byte[] bytes = querySerializer.serialize(queries.toArray(queryArray));
    HTableInterface htable = null;
    try {
        htable = HBaseConnection.get(hbaseUrl).getTable(userTableName);
        Put put = new Put(Bytes.toBytes(creator));
        put.add(Bytes.toBytes(USER_QUERY_FAMILY), Bytes.toBytes(USER_QUERY_COLUMN), bytes);

        htable.put(put);
        htable.flushCommits();
    } finally {
        IOUtils.closeQuietly(htable);
    }
}
 

public void removeQuery(final String creator, final String id) throws IOException {
    List<Query> queries = getQueries(creator);
    Iterator<Query> queryIter = queries.iterator();

    boolean changed = false;
    while (queryIter.hasNext()) {
        Query temp = queryIter.next();
        if (temp.getId().equals(id)) {
            queryIter.remove();
            changed = true;
            break;
        }
    }

    if (!changed) {
        return;
    }

    Query[] queryArray = new Query[queries.size()];
    byte[] bytes = querySerializer.serialize(queries.toArray(queryArray));
    HTableInterface htable = null;
    try {
        htable = HBaseConnection.get(hbaseUrl).getTable(userTableName);
        Put put = new Put(Bytes.toBytes(creator));
        put.add(Bytes.toBytes(USER_QUERY_FAMILY), Bytes.toBytes(USER_QUERY_COLUMN), bytes);

        htable.put(put);
        htable.flushCommits();
    } finally {
        IOUtils.closeQuietly(htable);
    }
}
 

public static void populateValidationRules(HConnection connection, ValidationRules rules) throws Exception {
  HTableInterface table = connection.getTable(HBaseTableMetaModel.profileCacheTableName);

  try {
    Put put = new Put(HBaseTableMetaModel.validationRulesRowKey);
    put.add(HBaseTableMetaModel.profileCacheColumnFamily, HBaseTableMetaModel.validationRulesRowKey, Bytes.toBytes(rules.getJSONObject().toString()));
    table.put(put);
  } finally {
    table.close();
  }
}
 

public static void populateUserProfile(HConnection connection, UserProfile userProfile) throws Exception {
  HTableInterface table = connection.getTable(HBaseTableMetaModel.profileCacheTableName);

  try {
    Put put = new Put(convertKeyToRowKey(HBaseTableMetaModel.profileCacheTableName, userProfile.userId));
    put.add(HBaseTableMetaModel.profileCacheColumnFamily, HBaseTableMetaModel.profileCacheJsonColumn, Bytes.toBytes(userProfile.getJSONObject().toString()));
    put.add(HBaseTableMetaModel.profileCacheColumnFamily, HBaseTableMetaModel.profileCacheTsColumn, Bytes.toBytes(System.currentTimeMillis()));
    table.put(put);
  } finally {
    table.close();
  }
}
 

public final void put(List<E> entityList) {
	HTableInterface hTableInterface = getHTableInterface();
	try {
		List<Put> puts = buildPutList(entityList);
		hTableInterface.put(puts);
	} catch (Exception cause) {
		throw new RuntimeException(cause);
	} finally {
		closeHTableInterface(hTableInterface);
	}
}
 

public void setStatusForTransaction(final long transactionId, final TransactionStatus status) {
    Put update = new Put(getRow(transactionId));
    update.add(INFO_FAMILY, STATUS_QUALIFIER, HConstants.LATEST_TIMESTAMP, Bytes.toBytes(status.name()));

    HTableInterface table = getTable();
    try {
        table.put(update);
    } catch (IOException e) {
        throw new RuntimeException(e);
    } finally {
        putTable(table);
    }
}
 

private void updateIndex(final IndexSpecification indexSpec, final Put put,
    final NavigableMap<byte[], byte[]> newColumnValues,
    final SortedMap<byte[], byte[]> oldColumnValues) throws IOException {
  Delete indexDelete = makeDeleteToRemoveOldIndexEntry(indexSpec,
      put.getRow(), oldColumnValues);
  Put indexPut = makeIndexUpdate(indexSpec, put.getRow(), newColumnValues);

  HTableInterface indexTable = getIndexTable(indexSpec);
  try {
    if (indexDelete != null
        && !Bytes.equals(indexDelete.getRow(), indexPut.getRow())) {
      // Only do the delete if the row changed. This way we save the put after
      // delete issues in HBASE-2256
      LOG.debug("Deleting old index row ["
          + Bytes.toString(indexDelete.getRow()) + "]. New row is ["
          + Bytes.toString(indexPut.getRow()) + "].");
      indexTable.delete(indexDelete);
    } else if (indexDelete != null) {
      LOG.debug("Skipping deleting index row ["
          + Bytes.toString(indexDelete.getRow())
          + "] because it has not changed.");
    }
    indexTable.put(indexPut);
  } finally {
    putTable(indexTable);
  }
}
 

@Test
public void testPut() throws IOException {
	Configuration configuration = HBaseConfiguration.create();
	HConnection connection = HConnectionManager.createConnection(configuration);
	 HTableInterface table = connection.getTable("page");
	 // use the table as needed, for a single operation and a single thread
	 Put put = new Put("2".getBytes());
	 put.add("content".getBytes(), null, "我吃包子".getBytes());
	 put.add("title".getBytes(), null, "吃包子".getBytes());
	 put.add("url".getBytes(), null, "http://www.sina.com.cn".getBytes());
	 table.put(put);
	 table.close();
	 connection.close();
}
 

private void putData(HTableInterface table, byte[] rowkey) throws IOException {
    Put put = new Put(rowkey);
    put.add(TEST_TABLE_CF.getBytes(), "c1".getBytes(), rowkey);
    table.put(put);
}
 

private void putData2(HTableInterface table, byte[] rowkey) throws IOException {
    Put put = new Put(rowkey);
    put.addColumn(TEST_TABLE_CF.getBytes(), "c1".getBytes(), rowkey);
    put.addColumn(TEST_TABLE_CF2.getBytes(), "c1".getBytes(), rowkey);
    table.put(put);
}
 

private void putData(HTableInterface table, byte[] rowkey) throws IOException {
    Put put = new Put(rowkey);
    put.addColumn(TEST_TABLE_CF.getBytes(), "c1".getBytes(), rowkey);
    table.put(put);
}
 

private void putData2(HTableInterface table, byte[] rowkey) throws IOException {
    Put put = new Put(rowkey);
    put.add(TEST_TABLE_CF.getBytes(), "c1".getBytes(), rowkey);
    put.add(TEST_TABLE_CF2.getBytes(), "c1".getBytes(), rowkey);
    table.put(put);
}
 

private void putData(HTableInterface table, byte[] rowkey) throws IOException {
    Put put = new Put(rowkey);
    put.add(TEST_TABLE_CF.getBytes(), "c1".getBytes(), rowkey);
    table.put(put);
}
 

private static void prepareData(HConnection conn) throws IOException {
    HTableInterface table = conn.getTable(TEST_TABLE);

    try {
        // check how many rows existing
        int nRows = 0;
        Scan scan = new Scan();
        scan.setFilter(new KeyOnlyFilter());
        ResultScanner scanner = table.getScanner(scan);
        for (Result r : scanner) {
            r.getRow(); // nothing to do
            nRows++;
        }

        if (nRows > 0) {
            System.out.println(nRows + " existing rows");
            if (nRows != N_ROWS)
                throw new IOException("Expect " + N_ROWS + " rows but it is not");
            return;
        }

        // insert rows into empty table
        System.out.println("Writing " + N_ROWS + " rows to " + TEST_TABLE);
        long nBytes = 0;
        for (int i = 0; i < N_ROWS; i++) {
            byte[] rowkey = Bytes.toBytes(i);
            Put put = new Put(rowkey);
            byte[] cell = randomBytes();
            put.add(CF, QN, cell);
            table.put(put);
            nBytes += cell.length;
            dot(i, N_ROWS);
        }
        System.out.println();
        System.out.println("Written " + N_ROWS + " rows, " + nBytes + " bytes");

    } finally {
        IOUtils.closeQuietly(table);
    }

}
 

private void putData2(HTableInterface table, byte[] rowkey) throws IOException {
    Put put = new Put(rowkey);
    put.addColumn(TEST_TABLE_CF.getBytes(), "c1".getBytes(), rowkey);
    put.addColumn(TEST_TABLE_CF2.getBytes(), "c1".getBytes(), rowkey);
    table.put(put);
}
 

@VisibleForTesting
void saveRegionCountForTime(HTableInterface stateTable, byte[] timeBytes, int count) throws IOException {
  Put put = new Put(makeTimeRegionCountKey(timeBytes));
  put.add(FAMILY, REGION_TIME_COL, Bytes.toBytes(count));
  stateTable.put(put);
}