DZone
Thanks for visiting DZone today,
Edit Profile
  • Manage Email Subscriptions
  • How to Post to DZone
  • Article Submission Guidelines
Sign Out View Profile
  • Post an Article
  • Manage My Drafts
Over 2 million developers have joined DZone.
Log In / Join
Refcards Trend Reports Events Over 2 million developers have joined DZone. Join Today! Thanks for visiting DZone today,
Edit Profile Manage Email Subscriptions Moderation Admin Console How to Post to DZone Article Submission Guidelines
View Profile
Sign Out
Refcards
Trend Reports
Events
Zones
Culture and Methodologies Agile Career Development Methodologies Team Management
Data Engineering AI/ML Big Data Data Databases IoT
Software Design and Architecture Cloud Architecture Containers Integration Microservices Performance Security
Coding Frameworks Java JavaScript Languages Tools
Testing, Deployment, and Maintenance Deployment DevOps and CI/CD Maintenance Monitoring and Observability Testing, Tools, and Frameworks
Culture and Methodologies
Agile Career Development Methodologies Team Management
Data Engineering
AI/ML Big Data Data Databases IoT
Software Design and Architecture
Cloud Architecture Containers Integration Microservices Performance Security
Coding
Frameworks Java JavaScript Languages Tools
Testing, Deployment, and Maintenance
Deployment DevOps and CI/CD Maintenance Monitoring and Observability Testing, Tools, and Frameworks
  1. DZone
  2. Data Engineering
  3. Databases
  4. Using Autonumber in Couchbase

Using Autonumber in Couchbase

NoSQL doesn't exactly lend itself to sequential ordering and incremental data, but using Couchbase's autonumber and counter document features, you can make it happen.

Laura Czajkowski user avatar by
Laura Czajkowski
·
Feb. 10, 17 · Tutorial
Like (1)
Save
Tweet
Share
8.43K Views

Join the DZone community and get the full member experience.

Join For Free

During the software development process, we often come across a situation where we need to generate a unique key (of an entity) in an orderly sequential fashion (either increasing or decreasing order). Common examples include:

  1. Storing entries of a log file with an auto-generated sequence number assigned to each row of data
  2. Storing business entities in a database and having a primary key generated from an incremental sequence number.

In the relational database world, this is achieved by making use of something known as “database sequence.” The sequence is a feature provided by most database products which simply creates unique number values in an orderly manner. It just increments a value and returns it. Without a database sequence, it is not very easy to generate unique numbers in a particular order. That’s why it is a popular choice when it comes to populating a primary key (or any unique key for that matter) with unique auto increasing values.

Other ways to generate randomly unique keys include using features such as GUID or UUID. However, there is no guarantee regarding the auto-increment nature that you get when using a database sequence generator.

No Sequence in NoSQL Databases

Unlike the relational database world, there is no straightforward built-in sequence generation feature available for most of the NoSQL databases on the market. One could argue that it’s not usual for a distributed system with free-form data to have a unique auto-incrementing number serve as a unique key on a document because of the conflicting numbers generated in the case of cross-replication of data among different nodes and shards. Instead, implementing a UUID seems a much more viable option to guarantee uniqueness. However, if you need a randomly generated unique ID in a sequence then you somehow need to have an auto incrementing sequence column in a NoSQL database, because the UUID solution would not preserve the sequencing nature of the generated numbers. The main question: How would you handle that using Couchbase? Well, Couchbase has you covered and that’s what this post will describe.

Set up a Couchbase Bucket to Save the Data

Let’s say we are storing items from a product catalog into Couchbase, and while storing the products in a Couchbase bucket we need to set a generated sequence in each of the product data JSON so that it can be used as a uniquely identifiable “key” of a document.

To do so, follow the steps below to create a bucket named “prodcat.”

  • First, log into the administrative console of Couchbase.
  • Type http://localhost:8091/ui/index.html in your browser.
  • Login with admin username and password.
  • Navigate to the Data Buckets tab and click on Create New Data Bucket.

  • Enter “prodcat” in the field Bucket Name and 512 in Per Node RAM Quota field.
    • Leave all the other fields as default and click on “Create.”
    • Once the bucket is created successfully it will be listed with 0 items. 

    Using Counter Documents

    Couchbase handles sequence generation by what is known as a “counter” document. Counter is a document that can be incremented or decremented sequentially. An important thing to note here is that the increment or decrement operation of the counter is atomic. When we insert a business entity (such as Product in our case) as a JSON document, we can use the counter document with a key pattern to generate a sequence.

    The following code snippet initializes a counter document with an initial value of 20.

    // create a connection to couchbase cluster and bucket
    Cluster cluster = CouchbaseCluster.create("127.0.0.1");
    Bucket bucket = cluster.openBucket(BUCKET_NAME);
    
    // Here, the BUCKET_NAME = “prodcat” (The one that was created using the Couchbase admin console)
    
    String key = "idGeneratorForProducts";
    try {
        bucket.remove(key);
    } catch (DocumentDoesNotExistException e) {
        
    }
    
    try {
        bucket.counter(key, 0, 20);
    } catch (DocumentDoesNotExistException e) {
        log.info("counter doesn't exist yet and no initial value was provided");
    }

     

    At this point, our counter document is initialized to a value of 20.

    We run the following code in a loop to insert product data in a sequential fashion:

    long nextIdNumber = bucket.counter(key, 1).content();
    log.info("nextIdNumber = "+ nextIdNumber);
    String id = "Prod::" + nextIdNumber;
    //you're now ready to save your document:
       Product product = ProductUtil.getProduct(nextIdNumber);
       JsonObject content = JsonObject.create()
              .put("type", Product.TYPE)
              .put("id", product.getId())
              .put("description", product.getDescription())
              .put("price", product.getPrice());
             
    bucket.insert(JsonDocument.create(id, content));

     

    Let's dive into the code above. The nextId is calculated by incrementing the counter by 1. We make use of the nextId to populate the “id” field of the product document. After completing the operation for three product documents, the prodcat bucket looks like this:

     

    “idGeneratorForProducts” is the counter document that holds the current value of the counter. Each product document has the “id” populated with the sequence:

    {
        "id": "Product 21",
        "price": "20",
        "type": "Product",
        "description": "This is a utility product"
    }

     

    It’s worth mentioning that we can implement the sequence in decreasing order as well. In that case, the only thing we need to do is:

    • Initialize the counter to the maximum value.
    • Decrement the counter by 1 to generate the nextId in sequence.
    • Use the nextId to insert a document in a bucket. 

    Conclusion

    The code used for this article is written in Java and makes use of the Spring Boot and Spring Data Couchbase dependencies. The same concepts can be applied to any Couchbase client SDK. 

    Source code for the application can be found at https://github.com/ratchakr/prodcat.

    Relational database Database Document Data (computing) Spring Framework

    Published at DZone with permission of Laura Czajkowski, DZone MVB. See the original article here.

    Opinions expressed by DZone contributors are their own.

    Popular on DZone

    • PostgreSQL: Bulk Loading Data With Node.js and Sequelize
    • Continuous Development: Building the Thing Right, to Build the Right Thing
    • AIOps Being Powered by Robotic Data Automation
    • Project Hygiene

    Comments

    Partner Resources

    X

    ABOUT US

    • About DZone
    • Send feedback
    • Careers
    • Sitemap

    ADVERTISE

    • Advertise with DZone

    CONTRIBUTE ON DZONE

    • Article Submission Guidelines
    • Become a Contributor
    • Visit the Writers' Zone

    LEGAL

    • Terms of Service
    • Privacy Policy

    CONTACT US

    • 600 Park Offices Drive
    • Suite 300
    • Durham, NC 27709
    • support@dzone.com
    • +1 (919) 678-0300

    Let's be friends: