You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@hbase.apache.org by "Andrew Purtell (JIRA)" <ji...@apache.org> on 2009/12/16 01:09:18 UTC
[jira] Created: (HBASE-2051) Use builder pattern to improve
usability of client API
Use builder pattern to improve usability of client API
------------------------------------------------------
Key: HBASE-2051
URL: https://issues.apache.org/jira/browse/HBASE-2051
Project: Hadoop HBase
Issue Type: Improvement
Reporter: Andrew Purtell
Fix For: 0.21.0
>From Paul Smith up on hbase-user@:
{quote}
I think a good collection of useful builders and utilities that handle the 80% case will help HBase gain much more traction. As an person starting with HBase, there are a lot of concepts to get, Bytes definitely get in the way of seeing the real underlying patterns. I'm a total believer in understanding the internals to get the best out of a product, but that often comes after experimentation, and these high-level libraries grease the wheels for faster 'grok'ing the concepts.
Thinking out loud here, but something like this may be useful:
{code}
PutBuilder builder = new PutBuilder(hTable);
// first Row
builder.withRowKey(1stRowKey).withColumnFamily("foo")
.put("columnA", valueA)
.put("columnB",valueB);
// secondRow
builder.withRowKey(2ndRowKey).withColumnFamily("eek")
.put("columnC", valueC)
.put("columnD",valueD);
..
builder.putAll();
{code}
{quote}
Perhaps we could use the Builder pattern to achieve simplification (e.g. HBASE-1990) and API support for multicalls (HBASE-1986, HBASE-1845) at the same time. Method variants should accept byte[] or String for keys or values, and lists.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (HBASE-2051) Use builder pattern to improve
usability of client API
Posted by "Paul Smith (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/HBASE-2051?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12792704#action_12792704 ]
Paul Smith commented on HBASE-2051:
-----------------------------------
:) Yeah comments could definitely be added, hopefully the code is self-documenting in most ways, but always good to add some more, obviously test cases would be essential.
Personally I think this sort of pattern has high value within HBase itself and would (hopefully) lend to more people being able to get up to speed quicker with Hbase. The critical issue is this project's current dependency set (Spring and Google Collections). While both ASL licensed, adding dependencies in a project can be controversial.
Ideally yes, Hadoop and Hbase final versions should be in the Maven repo, I'm really not sure why it's not published, that would really help, I can't imagine that's very hard ..?
I don't mind starting this of in Google Code (has advantage of quicker release cycle), but that may inhibit overall usage and development as well. happy to discuss further.
> Use builder pattern to improve usability of client API
> ------------------------------------------------------
>
> Key: HBASE-2051
> URL: https://issues.apache.org/jira/browse/HBASE-2051
> Project: Hadoop HBase
> Issue Type: Improvement
> Reporter: Andrew Purtell
> Fix For: 0.21.0
>
> Attachments: aconex-hbase-utils.zip
>
>
> From Paul Smith up on hbase-user@:
> {quote}
> I think a good collection of useful builders and utilities that handle the 80% case will help HBase gain much more traction. As an person starting with HBase, there are a lot of concepts to get, Bytes definitely get in the way of seeing the real underlying patterns. I'm a total believer in understanding the internals to get the best out of a product, but that often comes after experimentation, and these high-level libraries grease the wheels for faster 'grok'ing the concepts.
> Thinking out loud here, but something like this may be useful:
> {code}
> PutBuilder builder = new PutBuilder(hTable);
> // first Row
> builder.withRowKey(1stRowKey).withColumnFamily("foo")
> .put("columnA", valueA)
> .put("columnB",valueB);
> // secondRow
> builder.withRowKey(2ndRowKey).withColumnFamily("eek")
> .put("columnC", valueC)
> .put("columnD",valueD);
> ..
> builder.putAll();
> {code}
> {quote}
> Perhaps we could use the Builder pattern to achieve simplification (e.g. HBASE-1990) and API support for multicalls (HBASE-1986, HBASE-1845) at the same time. Method variants should accept byte[] or String for keys or values, and lists.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (HBASE-2051) Use builder pattern to improve
usability of client API
Posted by "Paul Smith (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/HBASE-2051?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12793837#action_12793837 ]
Paul Smith commented on HBASE-2051:
-----------------------------------
Thanks, I'll push this to Google Code and publish the details on hbase-dev.
> Use builder pattern to improve usability of client API
> ------------------------------------------------------
>
> Key: HBASE-2051
> URL: https://issues.apache.org/jira/browse/HBASE-2051
> Project: Hadoop HBase
> Issue Type: Improvement
> Reporter: Andrew Purtell
> Fix For: 0.21.0
>
> Attachments: aconex-hbase-utils.zip
>
>
> From Paul Smith up on hbase-user@:
> {quote}
> I think a good collection of useful builders and utilities that handle the 80% case will help HBase gain much more traction. As an person starting with HBase, there are a lot of concepts to get, Bytes definitely get in the way of seeing the real underlying patterns. I'm a total believer in understanding the internals to get the best out of a product, but that often comes after experimentation, and these high-level libraries grease the wheels for faster 'grok'ing the concepts.
> Thinking out loud here, but something like this may be useful:
> {code}
> PutBuilder builder = new PutBuilder(hTable);
> // first Row
> builder.withRowKey(1stRowKey).withColumnFamily("foo")
> .put("columnA", valueA)
> .put("columnB",valueB);
> // secondRow
> builder.withRowKey(2ndRowKey).withColumnFamily("eek")
> .put("columnC", valueC)
> .put("columnD",valueD);
> ..
> builder.putAll();
> {code}
> {quote}
> Perhaps we could use the Builder pattern to achieve simplification (e.g. HBASE-1990) and API support for multicalls (HBASE-1986, HBASE-1845) at the same time. Method variants should accept byte[] or String for keys or values, and lists.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (HBASE-2051) Use builder pattern to improve
usability of client API
Posted by "stack (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/HBASE-2051?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12793417#action_12793417 ]
stack commented on HBASE-2051:
------------------------------
In the code you have so far, the Spring dependency looks like it could be undone since only used in one place for minor benefit (least as I read it). In general, we've not prob. adding new jars when tit makes life easier(all additions are minor hiding in the shadow of the fat jruby complete jar).
Anything that makes hbase easier to use, we're game for.
We're a bit behind but its looking like hadoop jars wil be up in apache maven repo. before too long. HBase should follow suit.
I think the google code route a good way to go at first at least. I'd suggest you talk up your progress over in hbase-dev to keep your work in the spotlight -- it might help you get recruits whether users or co-devs.
Thanks.
> Use builder pattern to improve usability of client API
> ------------------------------------------------------
>
> Key: HBASE-2051
> URL: https://issues.apache.org/jira/browse/HBASE-2051
> Project: Hadoop HBase
> Issue Type: Improvement
> Reporter: Andrew Purtell
> Fix For: 0.21.0
>
> Attachments: aconex-hbase-utils.zip
>
>
> From Paul Smith up on hbase-user@:
> {quote}
> I think a good collection of useful builders and utilities that handle the 80% case will help HBase gain much more traction. As an person starting with HBase, there are a lot of concepts to get, Bytes definitely get in the way of seeing the real underlying patterns. I'm a total believer in understanding the internals to get the best out of a product, but that often comes after experimentation, and these high-level libraries grease the wheels for faster 'grok'ing the concepts.
> Thinking out loud here, but something like this may be useful:
> {code}
> PutBuilder builder = new PutBuilder(hTable);
> // first Row
> builder.withRowKey(1stRowKey).withColumnFamily("foo")
> .put("columnA", valueA)
> .put("columnB",valueB);
> // secondRow
> builder.withRowKey(2ndRowKey).withColumnFamily("eek")
> .put("columnC", valueC)
> .put("columnD",valueD);
> ..
> builder.putAll();
> {code}
> {quote}
> Perhaps we could use the Builder pattern to achieve simplification (e.g. HBASE-1990) and API support for multicalls (HBASE-1986, HBASE-1845) at the same time. Method variants should accept byte[] or String for keys or values, and lists.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (HBASE-2051) Use builder pattern to improve
usability of client API
Posted by "stack (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/HBASE-2051?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12791805#action_12791805 ]
stack commented on HBASE-2051:
------------------------------
Code looks good. Couple of comments wouldn't go amiss (smile). How you think this addition would be distributed Paul? You think the Builder pattern would be in hbase or a distinct project? I suppose life would be easier if hbase+hadoop were all up in a maven repo somewhere?
> Use builder pattern to improve usability of client API
> ------------------------------------------------------
>
> Key: HBASE-2051
> URL: https://issues.apache.org/jira/browse/HBASE-2051
> Project: Hadoop HBase
> Issue Type: Improvement
> Reporter: Andrew Purtell
> Fix For: 0.21.0
>
> Attachments: aconex-hbase-utils.zip
>
>
> From Paul Smith up on hbase-user@:
> {quote}
> I think a good collection of useful builders and utilities that handle the 80% case will help HBase gain much more traction. As an person starting with HBase, there are a lot of concepts to get, Bytes definitely get in the way of seeing the real underlying patterns. I'm a total believer in understanding the internals to get the best out of a product, but that often comes after experimentation, and these high-level libraries grease the wheels for faster 'grok'ing the concepts.
> Thinking out loud here, but something like this may be useful:
> {code}
> PutBuilder builder = new PutBuilder(hTable);
> // first Row
> builder.withRowKey(1stRowKey).withColumnFamily("foo")
> .put("columnA", valueA)
> .put("columnB",valueB);
> // secondRow
> builder.withRowKey(2ndRowKey).withColumnFamily("eek")
> .put("columnC", valueC)
> .put("columnD",valueD);
> ..
> builder.putAll();
> {code}
> {quote}
> Perhaps we could use the Builder pattern to achieve simplification (e.g. HBASE-1990) and API support for multicalls (HBASE-1986, HBASE-1845) at the same time. Method variants should accept byte[] or String for keys or values, and lists.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Updated: (HBASE-2051) Use builder pattern to improve
usability of client API
Posted by "Paul Smith (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/HBASE-2051?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Paul Smith updated HBASE-2051:
------------------------------
Attachment: aconex-hbase-utils.zip
I have attached a simple Maven project that we use here as a starting point for discussion. This won't compile anywhere else because it requires our internal Nexus repository, but someone with a little Maven experience could tweak this to remove the Parent POM definition and I think it should work. It currently depends only on Spring and Google Collections (both ASL 2 licensed).
No test cases as yet sorry, this project was put together as part of a week long hackathon project as I experimented with HBase. I'm already an Apache member (psmith@apache.org) so can potentially be used as a basis for a more formal contribution if need be, but I'm sure there's lots to discuss with those more intimately familiar with day 2 day HBase coding. I could well be naive here, but this works for me and I find the code much more readable when using this.
> Use builder pattern to improve usability of client API
> ------------------------------------------------------
>
> Key: HBASE-2051
> URL: https://issues.apache.org/jira/browse/HBASE-2051
> Project: Hadoop HBase
> Issue Type: Improvement
> Reporter: Andrew Purtell
> Fix For: 0.21.0
>
> Attachments: aconex-hbase-utils.zip
>
>
> From Paul Smith up on hbase-user@:
> {quote}
> I think a good collection of useful builders and utilities that handle the 80% case will help HBase gain much more traction. As an person starting with HBase, there are a lot of concepts to get, Bytes definitely get in the way of seeing the real underlying patterns. I'm a total believer in understanding the internals to get the best out of a product, but that often comes after experimentation, and these high-level libraries grease the wheels for faster 'grok'ing the concepts.
> Thinking out loud here, but something like this may be useful:
> {code}
> PutBuilder builder = new PutBuilder(hTable);
> // first Row
> builder.withRowKey(1stRowKey).withColumnFamily("foo")
> .put("columnA", valueA)
> .put("columnB",valueB);
> // secondRow
> builder.withRowKey(2ndRowKey).withColumnFamily("eek")
> .put("columnC", valueC)
> .put("columnD",valueD);
> ..
> builder.putAll();
> {code}
> {quote}
> Perhaps we could use the Builder pattern to achieve simplification (e.g. HBASE-1990) and API support for multicalls (HBASE-1986, HBASE-1845) at the same time. Method variants should accept byte[] or String for keys or values, and lists.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (HBASE-2051) Use builder pattern to improve
usability of client API
Posted by "Kay Kay (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/HBASE-2051?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12833342#action_12833342 ]
Kay Kay commented on HBASE-2051:
--------------------------------
| Thanks, I'll push this to Google Code and publish the details on hbase-dev.
If this is already here - may be - can you help with the url here. These utils definitely seems interesting, from an dev acceptance/ evangelism perspective.
If this is not already available yet - it might be worth to put up at some DVCS , like git or Hg . But that might be just me.
> Use builder pattern to improve usability of client API
> ------------------------------------------------------
>
> Key: HBASE-2051
> URL: https://issues.apache.org/jira/browse/HBASE-2051
> Project: Hadoop HBase
> Issue Type: Improvement
> Reporter: Andrew Purtell
> Fix For: 0.21.0
>
> Attachments: aconex-hbase-utils.zip
>
>
> From Paul Smith up on hbase-user@:
> {quote}
> I think a good collection of useful builders and utilities that handle the 80% case will help HBase gain much more traction. As an person starting with HBase, there are a lot of concepts to get, Bytes definitely get in the way of seeing the real underlying patterns. I'm a total believer in understanding the internals to get the best out of a product, but that often comes after experimentation, and these high-level libraries grease the wheels for faster 'grok'ing the concepts.
> Thinking out loud here, but something like this may be useful:
> {code}
> PutBuilder builder = new PutBuilder(hTable);
> // first Row
> builder.withRowKey(1stRowKey).withColumnFamily("foo")
> .put("columnA", valueA)
> .put("columnB",valueB);
> // secondRow
> builder.withRowKey(2ndRowKey).withColumnFamily("eek")
> .put("columnC", valueC)
> .put("columnD",valueD);
> ..
> builder.putAll();
> {code}
> {quote}
> Perhaps we could use the Builder pattern to achieve simplification (e.g. HBASE-1990) and API support for multicalls (HBASE-1986, HBASE-1845) at the same time. Method variants should accept byte[] or String for keys or values, and lists.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.