The OBKV-Table Java client supports single-row and batch data updates. You can choose the appropriate interface based on your requirements.
Supported update interfaces
The following interfaces of ObTableClient support data updates:
API |
Description |
Considerations |
|---|---|---|
update(String tableName) |
Updates a row of data. You can set update conditions. | |
insertOrUpdate(String tableName) |
Inserts or updates a row of data. | |
replace(String tableName) |
Replaces a row of data (using delete-then-insert logic). | |
put(String tableName) |
Overwrites a row of data. |
|
increment(String tableName) |
Atomically increments the value of an integer column. | If the old row does not exist, the specified delta value is written to a new row. |
append(String tableName) |
Atomically appends a string to a string column. | If the old row does not exist, the specified delta value is written to a new row. |
checkAndInsUp(String tableName, ObTableFilter filter, InsertOrUpdate insUp, boolean checkExists, boolean rollbackWhenCheckFailed) |
Updates or inserts a row if the conditions are met. |
|
Update examples
Prerequisites
- Your ObTableClient has been initialized.
- You have created a relational table in your database. The following example uses this table:
CREATE TABLE IF NOT EXISTS `employees` ( `employeeId` int NOT NULL, `name` varchar(100) NOT NULL, `department` varchar(50), `position` varchar(50), `workYear` int, `comment` varchar(100), PRIMARY KEY (`employeeId`) ) PARTITION BY KEY(`employeeId`) PARTITIONS 97;
Single-row update
update
The sample code updates the workYear of the record whose primary key employeeId is 1001 to 11.
// Assume the following data already exists in the database:
/*
+------------+----------+------------+----------+----------+---------+
| employeeId | name | department | position | workYear | comment |
+------------+----------+------------+----------+----------+---------+
| 1001 | zhangsan | R&D | dev | 10 | NULL |
+------------+----------+------------+----------+----------+---------+
*/
private static void updateRow(ObTableClient obkvHandle) throws Exception {
Row rowKey = row().add(colVal("employeeId", 1001));
Row properties = row().add(colVal("workYear", 11));
obkvHandle.update("employees")
.setRowKey(rowKey)
.addMutateRow(properties)
.execute();
}
The sample code updates the workYear of the record whose primary key employeeId is 1001 to 11 if the current value is greater than or equal to 3.
// Assume the following data already exists in the database:
/*
+------------+----------+------------+----------+----------+---------+
| employeeId | name | department | position | workYear | comment |
+------------+----------+------------+----------+----------+---------+
| 1001 | zhangsan | R&D | dev | 10 | NULL |
+------------+----------+------------+----------+----------+---------+
*/
private static void updateRowWithFilter(ObTableClient obkvHandle) throws Exception {
Row rowKey = row().add(colVal("employeeId", 1001));
Row properties = row().add(colVal("workYear", 11));
ObTableValueFilter filter = compareVal(ObCompareOp.GE, "workYear", 3);
obkvHandle.update("employees")
.setRowKey(rowKey)
.addMutateRow(properties)
.setFilter(filter)
.execute();
}
insertOrUpdate
The sample code updates the workYear of the record whose primary key employeeId is 1001 to 11.
// Assume the following data already exists in the database:
/*
+------------+----------+------------+----------+----------+---------+
| employeeId | name | department | position | workYear | comment |
+------------+----------+------------+----------+----------+---------+
| 1001 | zhangsan | R&D | dev | 10 | NULL |
+------------+----------+------------+----------+----------+---------+
*/
private static void insertOrUpdateRow(ObTableClient obkvHandle) throws Exception {
Row rowKey = row().add(colVal("employeeId", 1001));
Row properties = row().add(colVal("workYear", 11));
obkvHandle.insertOrUpdate("employees")
.setRowKey(rowKey)
.addMutateRow(properties)
.execute();
}
replace
The sample code updates the workYear of the record whose primary key employeeId is 1001 to 11.
// Assume the following data already exists in the database:
/*
+------------+----------+------------+----------+----------+---------+
| employeeId | name | department | position | workYear | comment |
+------------+----------+------------+----------+----------+---------+
| 1001 | zhangsan | R&D | dev | 10 | NULL |
+------------+----------+------------+----------+----------+---------+
*/
private static void replaceRow(ObTableClient obkvHandle) throws Exception {
Row rowKey = row().add(colVal("employeeId", 1001));
Row properties = row().add(colVal("name", "zhangsan"))
.add(colVal("department", "R&D"))
.add(colVal("position", "dev"))
.add(colVal("workYear", 11));
obkvHandle.replace("employees")
.setRowKey(rowKey)
.addMutateRow(properties)
.execute();
}
put
The sample code overwrites the row whose primary key employeeId is 1001, setting workYear to 11.
// Assume the following data already exists in the database:
/*
+------------+----------+------------+----------+-----------+--------------+
| employeeId | name | department | position | workYear | comment |
+------------+----------+------------+----------+-----------+--------------+
| 1001 | zhangsan | R&D | dev | 10 | new employee |
+------------+----------+------------+----------+-----------+--------------+
*/
private static void putRow(ObTableClient obkvHandle) throws Exception {
Row rowKey = row().add(colVal("employeeId", 1001));
Row properties = row().add(colVal("name", "zhangsan"))
.add(colVal("department", "R&D"))
.add(colVal("position", "dev"))
.add(colVal("workYear", 1))
.add(colVal("comment", "new employee"));
obkvHandle.put("employees")
.setRowKey(rowKey)
.addMutateRow(properties)
.execute();
}
increment
The sample code atomically increments the workYear of the record whose primary key employeeId is 1001 by 1. The result is 11.
// Assume the following data already exists in the database:
/*
+------------+----------+------------+----------+----------+---------+
| employeeId | name | department | position | workYear | comment |
+------------+----------+------------+----------+----------+---------+
| 1001 | zhangsan | R&D | dev | 10 | NULL |
+------------+----------+------------+----------+----------+---------+
*/
private static void incrementRow(ObTableClient obkvHandle) throws Exception {
Row rowKey = row().add(colVal("employeeId", 1001));
Row properties = row().add(colVal("workYear", 1));
obkvHandle.increment("employees")
.setRowKey(rowKey)
.addMutateRow(properties)
.execute();
}
append
The sample code appends the string dev to the position column of the record whose primary key employeeId is 1001. The result is java dev.
// Assume the following data already exists in the database:
/*
+------------+----------+------------+----------+----------+---------+
| employeeId | name | department | position | workYear | comment |
+------------+----------+------------+----------+----------+---------+
| 1001 | zhangsan | R&D | java | 10 | NULL |
+------------+----------+------------+----------+----------+---------+
*/
private static void appendRow(ObTableClient obkvHandle) throws Exception {
Row rowKey = row().add(colVal("employeeId", 1001));
Row properties = row().add(colVal("position", "dev"));
obkvHandle.append("employees")
.setRowKey(rowKey)
.addMutateRow(properties)
.execute();
}
checkAndInsUp
The sample code checks whether the workYear of the record whose primary key employeeId is 1001 is greater than or equal to 3. If so, it executes insertUpOp to update comment to good.
// Assume the following data already exists in the database:
/*
+------------+----------+------------+----------+----------+---------+
| employeeId | name | department | position | workYear | comment |
+------------+----------+------------+----------+----------+---------+
| 1001 | zhangsan | R&D | dev | 10 | NULL |
+------------+----------+------------+----------+----------+---------+
*/
private static void checkAndInsUpRow(ObTableClient obkvHandle) throws Exception {
Row rowKey = row().add(colVal("employeeId", 1001));
Row properties = row().add(colVal("name", "zhangsan"))
.add(colVal("department", "R&D"))
.add(colVal("position", "dev"))
.add(colVal("workYear", 10))
.add(colVal("comment", "good"));
InsertOrUpdate insertUpOp = insertOrUpdate().setRowKey(rowKey).addMutateRow(properties);
ObTableValueFilter filter = compareVal(ObCompareOp.GE, "workYear", 3);
MutationResult result = obkvHandle.checkAndInsUp("employees", filter, insertUpOp, true)
.execute();
System.out.println(result.getAffectedRows());
}
Batch updates
batchUpdate
The sample code updates two rows in a batch, setting workYear to 11 for the records whose employeeId is 1001 and 1002.
// Assume the following data already exists in the database:
/*
+------------+----------+------------+----------+----------+---------+
| employeeId | name | department | position | workYear | comment |
+------------+----------+------------+----------+----------+---------+
| 1001 | zhangsan | R&D | dev | 10 | NULL |
| 1002 | lisi | R&D | dev | 10 | NULL |
+------------+----------+------------+----------+----------+---------+
*/
private static void batchUpdateRow(ObTableClient obkvHandle) throws Exception {
Row rowKey1 = row().add(colVal("employeeId", 1001));
Row rowKey2 = row().add(colVal("employeeId", 1002));
Row properties1 = row().add(colVal("workYear", 11));
Row properties2 = row().add(colVal("workYear", 11));
Update updateOp1 = update().setRowKey(rowKey1).addMutateRow(properties1);
Update updateOp2 = update().setRowKey(rowKey2).addMutateRow(properties2);
BatchOperationResult res = obkvHandle.batchOperation("employees")
.addOperation(updateOp1,updateOp2)
.execute();
System.out.println(res.hasError());
}
batchInsertOrUpdate
The sample code updates two rows in a batch, setting workYear to 11 for the records whose employeeId is 1001 and 1002.
// Assume the following data already exists in the database:
/*
+------------+----------+------------+----------+----------+---------+
| employeeId | name | department | position | workYear | comment |
+------------+----------+------------+----------+----------+---------+
| 1001 | zhangsan | R&D | dev | 10 | NULL |
| 1002 | lisi | R&D | dev | 10 | NULL |
+------------+----------+------------+----------+----------+---------+
*/
private static void batchInsertOrUpdateRow(ObTableClient obkvHandle) throws Exception {
Row rowKey1 = row().add(colVal("employeeId", 1001));
Row rowKey2 = row().add(colVal("employeeId", 1002));
Row properties1 = row().add(colVal("workYear", 11));
Row properties2 = row().add(colVal("workYear", 11));
InsertOrUpdate insertUpOp1 = insertOrUpdate().setRowKey(rowKey1).addMutateRow(properties1);
InsertOrUpdate insertUpOp2 = insertOrUpdate().setRowKey(rowKey2).addMutateRow(properties2);
BatchOperationResult res = obkvHandle.batchOperation("employees")
.addOperation(insertUpOp1,insertUpOp2)
.execute();
System.out.println(res.hasError());
}
batchReplace
The sample code updates two rows in a batch, setting workYear to 11 for the records whose employeeId is 1001 and 1002.
// Assume the following data already exists in the database:
/*
+------------+----------+------------+----------+----------+---------+
| employeeId | name | department | position | workYear | comment |
+------------+----------+------------+----------+----------+---------+
| 1001 | zhangsan | R&D | dev | 10 | NULL |
| 1002 | lisi | R&D | dev | 10 | NULL |
+------------+----------+------------+----------+----------+---------+
*/
private static void batchReplaceRow(ObTableClient obkvHandle) throws Exception {
Row rowKey1 = row().add(colVal("employeeId", 1001));
Row rowKey2 = row().add(colVal("employeeId", 1002));
Row properties1 = row().add(colVal("name", "zhangsan"))
.add(colVal("department", "R&D"))
.add(colVal("position", "dev"))
.add(colVal("workYear", 11));
Row properties2 = row().add(colVal("name", "lisi"))
.add(colVal("department", "R&D"))
.add(colVal("position", "dev"))
.add(colVal("workYear", 11));
Replace replaceOp1 = replace().setRowKey(rowKey1).addMutateRow(properties1);
Replace replaceOp2 = replace().setRowKey(rowKey2).addMutateRow(properties2);
BatchOperationResult res = obkvHandle.batchOperation("employees")
.addOperation(replaceOp1,replaceOp2)
.execute();
System.out.println(res.hasError());
}
batchPut
The sample code updates two rows in a batch, setting workYear to 11 for the records whose employeeId is 1001 and 1002.
// Assume the following data already exists in the database:
/*
+------------+----------+------------+----------+-----------+--------------+
| employeeId | name | department | position | workYear | comment |
+------------+----------+------------+----------+-----------+--------------+
| 1001 | zhangsan | R&D | dev | 10 | new employee |
| 1002 | lisi | R&D | dev | 10 | new employee |
+------------+----------+------------+----------+-----------+--------------+
*/
private static void batchPutRow(ObTableClient obkvHandle) throws Exception {
Row rowKey1 = row().add(colVal("employeeId", 1001));
Row rowKey2 = row().add(colVal("employeeId", 1002));
Row properties1 = row().add(colVal("name", "zhangsan"))
.add(colVal("department", "R&D"))
.add(colVal("position", "dev"))
.add(colVal("workYear", 11))
.add(colVal("comment", "new employee"));
Row properties2 = row().add(colVal("name", "lisi"))
.add(colVal("department", "R&D"))
.add(colVal("position", "dev"))
.add(colVal("workYear", 11))
.add(colVal("comment", "new employee"));
Put putOp1 = put().setRowKey(rowKey1).addMutateRow(properties1);
Put putOp2 = put().setRowKey(rowKey2).addMutateRow(properties2);
BatchOperationResult res = obkvHandle.batchOperation("employees")
.addOperation(putOp1,putOp2)
.execute();
System.out.println(res.hasError());
}
batchIncrement
The sample code increments the workYear of two rows in a batch by 1 for the records whose employeeId is 1001 and 1002. The result is 11.
// Assume the following data already exists in the database:
/*
+------------+----------+------------+----------+----------+---------+
| employeeId | name | department | position | workYear | comment |
+------------+----------+------------+----------+----------+---------+
| 1001 | zhangsan | R&D | dev | 10 | NULL |
| 1002 | lisi | R&D | dev | 10 | NULL |
+------------+----------+------------+----------+----------+---------+
*/
private static void batchIncrementRow(ObTableClient obkvHandle) throws Exception {
Row rowKey1 = row().add(colVal("employeeId", 1001));
Row rowKey2 = row().add(colVal("employeeId", 1002));
Row properties1 = row().add(colVal("workYear", 1));
Row properties2 = row().add(colVal("workYear", 1));
Increment incrementOp1 = increment().setRowKey(rowKey1).addMutateRow(properties1);
Increment incrementOp2 = increment().setRowKey(rowKey2).addMutateRow(properties2);
BatchOperationResult res = obkvHandle.batchOperation("employees")
.addOperation(incrementOp1,incrementOp2)
.execute();
System.out.println(res.hasError());
}
batchAppend
The sample code appends the string dev to the position column in a batch for the records whose employeeId is 1001 and 1002. The result is java dev.
// Assume the following data already exists in the database:
/*
+------------+----------+------------+----------+----------+---------+
| employeeId | name | department | position | workYear | comment |
+------------+----------+------------+----------+----------+---------+
| 1001 | zhangsan | R&D | java | 10 | NULL |
| 1002 | lisi | R&D | java | 10 | NULL |
+------------+----------+------------+----------+----------+---------+
*/
private static void batchAppendRow(ObTableClient obkvHandle) throws Exception {
Row rowKey1 = row().add(colVal("employeeId", 1001));
Row rowKey2 = row().add(colVal("employeeId", 1002));
Row properties1 = row().add(colVal("position", " dev"));
Row properties2 = row().add(colVal("position", " dev"));
Append appendOp1 = append().setRowKey(rowKey1).addMutateRow(properties1);
Append appendOp2 = append().setRowKey(rowKey2).addMutateRow(properties2);
BatchOperationResult res = obkvHandle.batchOperation("employees")
.addOperation(appendOp1,appendOp2)
.execute();
System.out.println(res.hasError());
}
batchCheckAndInsUp
The sample code checks whether the workYear of the rows whose employeeId is 1001 or 1002 is greater than or equal to 3. If so, it updates comment to good.
// Assume the following data already exists in the database:
/*
+------------+----------+------------+----------+----------+---------+
| employeeId | name | department | position | workYear | comment |
+------------+----------+------------+----------+----------+---------+
| 1001 | zhangsan | R&D | dev | 10 | NULL |
| 1002 | lisi | R&D | dev | 10 | NULL |
+------------+----------+------------+----------+----------+---------+
*/
Row rowKey1 = row().add(colVal("employeeId", 1001));
Row rowKey2 = row().add(colVal("employeeId", 1002));
Row properties1 = row().add(colVal("name", "zhangsan"))
.add(colVal("department", "R&D"))
.add(colVal("position", "dev"))
.add(colVal("workYear", 10))
.add(colVal("comment", "good"));
Row properties2 = row().add(colVal("name", "lisi"))
.add(colVal("department", "R&D"))
.add(colVal("position", "dev"))
.add(colVal("workYear", 10))
.add(colVal("comment", "good"));
InsertOrUpdate insertUpOp1 = insertOrUpdate().setRowKey(rowKey1).addMutateRow(properties1);
InsertOrUpdate insertUpOp2 = insertOrUpdate().setRowKey(rowKey2).addMutateRow(properties2);
ObTableValueFilter filter = compareVal(ObCompareOp.GE, "workYear", 3);
CheckAndInsUp ckOp1 = new CheckAndInsUp(filter, insertUpOp1, true);
CheckAndInsUp ckOp2 = new CheckAndInsUp(filter, insertUpOp2, true);
BatchOperationResult res = obkvHandle.batchOperation("employees")
.addOperation(ckOp1,ckOp2)
.execute();
System.out.println(res.hasError());
}