HBase协处理器是否跨表提供原子性？

我正在试验HBase协处理器来创建辅助索引。它似乎起作用了。我想知道这种方法是否提供了某种程度的原子性

下面是一些示例代码。它观察

将

放在

表A

上，并在

表B

中创建一个倒排索引：

public class MyObserver extends BaseRegionObserver {                                                                                                                                     

    public static final TableName TABLE_A = TableName.valueOf("tableA");                                                                                                            
    public static final TableName TABLE_B = TableName.valueOf("tableB");

    public static final byte[] family = Bytes.toBytes("f");                                                                                                                       
    public static final byte[] qualA = Bytes.toBytes("qualA");                                                                                                       
    public static final byte[] qualB = Bytes.toBytes("qualB");                                                                                                                 

    private Connection connection;                                                                                                                                                                                                                                                                                                                       

    @Override                                                                                                                                                                     
    public void start(CoprocessorEnvironment env) throws IOException {                                                                                                            
        Configuration config = env.getConfiguration();                                                                                                                            
        connection = ConnectionFactory.createConnection(config);                                                                                                                  
    }                                                                                                                                                                             

    @Override                                                                                                                                                                     
    public void stop(CoprocessorEnvironment env) throws IOException {                                                                                                             
        connection.close();                                                                                                                                                       
    }                                                                                                                                                                             

    @Override                                                                                                                                                                     
    public void prePut(ObserverContext<RegionCoprocessorEnvironment> env, Put put, WALEdit edit, Durability durability) throws IOException {                                      
        TableName tableName = env.getEnvironment().getRegionInfo().getTable();                                                                                                                                                                          

        if (!tableName.equals(TABLE_A)) {                                                                                                                          
            return;                                                                                                                                                               
        }                                                                                                                                                                         

        byte[] key = put.getRow();                                                                                                                                             
        byte[] value = CellUtil.cloneValue(put.get(family, qualA).get(0));                                                                                             

        Put putB = new Put(value);                                                                                                                                          
        putB.addColumn(family, qualB, key);                                                                                                                         

        try (Table tableB = connection.getTable(TABLE_B)) {                                                                                                                        
            tableB.put(putB);                                                                                                                                               
        }                                                                                                                                                                         
        catch (IOException e) {                                                                                                                                                   
            logger.info("Error: {}", e);                                                                                                                                          
        }
    }                                                        
}

公共类MyObserver扩展BaseRegionObserver{
公共静态最终表名TABLE_A=TableName.valueOf（“tableA”）；
公共静态最终表名TABLE_B=TableName.valueOf（“tableB”）；
公共静态最终字节[]系列=字节.toBytes（“f”）；
公共静态最终字节[]qualA=Bytes.toBytes（“qualA”）；
公共静态最终字节[]qualB=字节.toBytes（“qualB”）；
专用连接；
@凌驾
public void start（协处理器环境环境）引发IOException{
Configuration config=env.getConfiguration（）；
connection=ConnectionFactory.createConnection（配置）；
}                                                                                                                                                                             
@凌驾
公共无效停止（协处理器环境环境）引发IOException{
connection.close（）；
}                                                                                                                                                                             
@凌驾
public void prePut（ObserverContext env、Put Put、WALEdit edit、耐久性）抛出IOException{
TableName TableName=env.getEnvironment（）.getRegionInfo（）.getTable（）；
如果（！tableName.equals（TABLE_A））{
返回；
}                                                                                                                                                                         
byte[]key=put.getRow（）；
byte[]value=CellUtil.cloneValue（put.get（family，qualA.get（0））；
Put putB=新的Put（值）；
putB.addColumn（family、qualB、key）；
try（Table tableB=connection.getTable（Table_B））{
表B.put（putB）；
}                                                                                                                                                                         
捕获（IOE）{
info（“错误：{}”，e）；
}
}