hbase-user mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Mike Spreitzer <mspre...@us.ibm.com>
Subject Re: Why only check1-and-putMany and check1-and-deleteMany?
Date Fri, 30 Nov 2012 02:55:28 GMT
Yes.  What I have been asking about is an operation that atomically checks 
multiple columns for equality with given values and, if they all match, 
applies multiple Mutations --- all in one row.

Silly me.  What I should be asking to compare is not values but 
timestamps.  The test should be, for each of several columns, does the 
latest timestamp equal a given stamp?


From:   lars hofhansl <lhofhansl@yahoo.com>
To:     "user@hbase.apache.org" <user@hbase.apache.org>
Date:   11/29/2012 08:49 PM
Subject:        Re: Why only check1-and-putMany and check1-and-deleteMany?

So just to understand for the usecase you have in mind you want both:
1. checking multiple columns of the row
2. apply multiple operations to the row

As Jon said, right?

I do not think that would too hard to add. For #2 we already have 
RowMutations (HBASE-3584, HBASE-5203).
We just have to add multiple predicates.

-- Lars
From: Mike Spreitzer <mspreitz@us.ibm.com>
To: user@hbase.apache.org 
Sent: Thursday, November 29, 2012 11:59 AM
Subject: Re: Why only check1-and-putMany and check1-and-deleteMany?

I would not suggest that a single composite operation should be able to 
access multiple rows.  What I expect would be easy is an arbitrary set of 
accesses to one row.

The use case is optimistic concurrency control.  In scenarios where 
conflicts are rare, you can get reasonably efficient serializable 
transactions (where one transaction can do arbitrary pointwise accesses to 

a single row) by using a general test-and-set operation.  There is some 
non-trivial stuff the client has to do, but a general single-row 
test-and-set is the only missing piece of HTable functionality.


From:   Michel Segel <michael_segel@hotmail.com>
To:     "user@hbase.apache.org" <user@hbase.apache.org>
Cc:     "user@hbase.apache.org" <user@hbase.apache.org>
Date:   11/29/2012 02:46 PM
Subject:        Re: Why only check1-and-putMany and check1-and-deleteMany?

Silly question...

I mean while it is technically feasible to do, can you come up with a use 
case and then show how it is better than the alternatives?

Sent from a remote device. Please excuse any typos...

Mike Segel

On Nov 29, 2012, at 12:44 PM, Jonathan Hsieh <jon@cloudera.com> wrote:

> Actually, I think we'd want to have repeated Conditions in to have 
> check predicates, and would want to add repeated Conditions to multi
> requests.
> This would let us have arbitrary number of checks and arbitrary number 
> puts and deletes from an API point of view.
> Jon.
> On Mon, Nov 19, 2012 at 10:55 AM, Ted Yu <yuzhihong@gmail.com> wrote:
>> Looking at hbase-server/src/main/protobuf/Client.proto in trunk, I 
>> the following formation to see if we can pass more than one qualifier:
>> Index: hbase-server/src/main/protobuf/Client.proto
>> ===================================================================
>> --- hbase-server/src/main/protobuf/Client.proto    (revision 1411337)
>> +++ hbase-server/src/main/protobuf/Client.proto    (working copy)
>> @@ -97,7 +97,7 @@
>> message Condition {
>>   required bytes row = 1;
>>   required bytes family = 2;
>> -  required bytes qualifier = 3;
>> +  repeated bytes qualifier = 3;
>>   required CompareType compareType = 4;
>>   required Comparator comparator = 5;
>> }
>> protoc is able to compile the above code.
>> This means we can potentially compare more than one qualifier in the 
>> step.
>> More discussion is needed to figure out the proper API which would be a
>> superset of what we have today:
>>  public boolean checkAndPut(final byte [] row,
>>      final byte [] family, final byte [] qualifier, final byte [] 
>>      final Put put)
>> Cheers
>> On Sat, Nov 17, 2012 at 10:28 PM, Mike Spreitzer <mspreitz@us.ibm.com
>>> wrote:
>>> I am not looking at the trunk.  I am just a user looking at the 
>>> documented on the web site and wondering why the atomic composite
>>> functionality is so limited.  It is not hard to imagine an expanded
>>> interface that allows checking an arbitrary set of columns and, if 
>>> has a value specified for it, doing an arbitrary set of Mutations.
>>> Thanks,
>>> Mike
>>> From:   Ted Yu <yuzhihong@gmail.com>
>>> To:    user@hbase.apache.org
>>> Date:   11/17/2012 11:44 PM
>>> Subject:        Re: Why only check1-and-putMany and
>> check1-and-deleteMany?
>>> Are you looking at trunk code ?
>>> In trunk, take a look at HRegion.checkAndMutate() where you can 
>>> ByteArrayComparable which does the comparison (matching).
>>> There is still the limit of single value:
>>>        } else if (result.size() == 1 && !valueIsNull) {
>>>          KeyValue kv = result.get(0);
>>> For the moment, only Put and Delete are supported:
>>>    if (!isPut && !(w instanceof Delete))
>>>      throw new DoNotRetryIOException("Action must be Put or Delete");
>>> If you have suggestion on how the check part can be more general, 
>>> comment.
>>> Thanks
>>> On Sat, Nov 17, 2012 at 7:30 PM, Mike Spreitzer <mspreitz@us.ibm.com>
>>> wrote:
>>>> If I understand correctly, an HTable has two composite atomic
>>> operations,
>>>> checkAndPut and checkAndDelete.  The check part checks just a single
>>>> column's value.  Why not allow checking more than one column?
>>>> Why no checkAndAppend?
>>>> The checkAndPut operation can put to multiple columns, right?  And 
>>>> checkAndDelete operation can delete multiple columns, right?  Why not
>>> let
>>>> them be mixed?  Why not checkAndMutate?
>>>> Thanks!
>>>> Mike
> -- 
> // Jonathan Hsieh (shay)
> // Software Engineer, Cloudera
> // jon@cloudera.com

  • Unnamed multipart/alternative (inline, None, 0 bytes)
View raw message