This tutorial describes how to create a sample Spring Boot application by using Spring Data JDBC for ScalarDB.


  • Java (OpenJDK 8 or higher)
  • Gradle
  • Docker, Docker Compose

In addition, you need access to the ScalarDB SQL GitHub repository and Packages in ScalarDB SQL repository. These repositories are available only to users with a commercial license and permission. To get a license and permission, please contact us.

You also need the gpr.user property for your GitHub username and the gpr.key property for your personal access token. You must either add these properties in ~/.gradle/ or specify the properties by using the -P option when running the ./gradlew command as follows:

$ ./gradlew run ... -Pgpr.user=<YOUR_GITHUB_USERNAME> -Pgpr.key=<YOUR_PERSONAL_ACCESS_TOKEN>

Or you can also use environment variables, USERNAME for your GitHub username and TOKEN for your personal access token.


For more details, see Install - ScalarDB SQL.

Sample application


This tutorial describes how to create a sample Spring Boot application for the same use case as ScalarDB Sample but by using Spring Data JDBC for ScalarDB. Please note that application-specific error handling, authentication processing, etc. are omitted in the sample application since this tutorial focuses on explaining how to use Spring Data JDBC for ScalarDB. For details, please see Guide of Spring Data JDBC for ScalarDB.


The schema is as follows:



CREATE TABLE IF NOT EXISTS sample.customers (
  customer_id INT PRIMARY KEY,
  name TEXT,
  credit_limit INT,
  credit_total INT

  customer_id INT,
  timestamp BIGINT,
  order_id TEXT,
  PRIMARY KEY (customer_id, timestamp)

CREATE INDEX IF NOT EXISTS ON sample.orders (order_id);

CREATE TABLE IF NOT EXISTS sample.statements (
  order_id TEXT,
  item_id INT,
  count INT,
  PRIMARY KEY (order_id, item_id)

  item_id INT PRIMARY KEY,
  name TEXT,
  price INT

All the tables are created in the sample namespace.

  • sample.customers: a table that manages customers’ information
    • credit_limit: the maximum amount of money a lender will allow each customer to spend when using a credit card
    • credit_total: the amount of money that each customer has already spent by using the credit card
  • sample.orders: a table that manages order information
  • sample.statements: a table that manages order statement information
  • sample.items: a table that manages information of items to be ordered

The Entity Relationship Diagram for the schema is as follows:



The following five transactions are implemented in this sample application:

  1. Getting customer information
  2. Placing an order by credit card (checks if the cost of the order is below the credit limit, then records order history and updates the credit_total if the check passes)
  3. Getting order information by order ID
  4. Getting order information by customer ID
  5. Repayment (reduces the amount in the credit_total)


Configurations for the sample Spring Boot application are as follows:


Since this sample application uses Cassandra, as shown above, you need to configure your settings for Cassandra in this configuration.


Clone the ScalarDB samples repository

Open Terminal, then clone the ScalarDB samples repository by running the following command:

$ git clone

Then, go to the directory with this sample by running the following command:

$ cd scalardb-samples/spring-data-sample

Start Cassandra

To start Cassandra, you need to run the following docker-compose command:

$ docker-compose up -d

Please note that starting the containers may take more than one minute.

Load schema

You then need to apply the schema with the following command. To download the CLI tool, scalardb-sql-cli-<VERSION>-all.jar, see the Releases of ScalarDB SQL and download the version that you want to use.

$ java -jar scalardb-sql-cli-<VERSION>-all.jar --config --file schema.sql

Load initial data

After the containers have started, you need to load the initial data by running the following command:

$ ./gradlew run --args="LoadInitialData"

After the initial data has loaded, the following records should be stored in the tables:

  • For the sample.customers table:
customer_id name credit_limit credit_total
1 Yamada Taro 10000 0
2 Yamada Hanako 10000 0
3 Suzuki Ichiro 10000 0
  • For the sample.items table:
item_id name price
1 Apple 1000
2 Orange 2000
3 Grape 2500
4 Mango 5000
5 Melon 3000

Run the sample application

Let’s start with getting information about the customer whose ID is 1:

$ ./gradlew run --args="GetCustomerInfo 1"
{"customer_id":1,"name":"Yamada Taro","credit_limit":10000,"credit_total":0}

Then, place an order for three apples and two oranges by using customer ID 1. Note that the order format is <Item ID>:<Count>,<Item ID>:<Count>,...:

$ ./gradlew run --args="PlaceOrder 1 1:3,2:2"

You can see that running this command shows the order ID.

Let’s check the details of the order by using the order ID:

$ ./gradlew run --args="GetOrder 2358ab35-5819-4f8f-acb1-12e73d97d34e"
{"order_id":"2358ab35-5819-4f8f-acb1-12e73d97d34e","timestamp":1677478005400,"customer_id":1,"customer_name":"Yamada Taro","statements":[{"item_id":1,"item_name":"Apple","price":1000,"count":3,"total":3000},{"item_id":2,"item_name":"Orange","price":2000,"count":2,"total":4000}],"total":7000}

Then, let’s place another order and get the order history of customer ID 1:

$ ./gradlew run --args="PlaceOrder 1 5:1"
$ ./gradlew run --args="GetOrders 1"
[{"order_id":"46062b16-b71b-46f9-a9ff-dc6b0991259b","timestamp":1677478201428,"customer_id":1,"customer_name":"Yamada Taro","statements":[{"item_id":5,"item_name":"Melon","price":3000,"count":1,"total":3000}],"total":3000},{"order_id":"2358ab35-5819-4f8f-acb1-12e73d97d34e","timestamp":1677478005400,"customer_id":1,"customer_name":"Yamada Taro","statements":[{"item_id":1,"item_name":"Apple","price":1000,"count":3,"total":3000},{"item_id":2,"item_name":"Orange","price":2000,"count":2,"total":4000}],"total":7000}]

This order history is shown in descending order by timestamp.

The customer’s current credit_total is 10000. Since the customer has now reached their credit_limit, which was shown when retrieving their information, they cannot place anymore orders.

$ ./gradlew run --args="GetCustomerInfo 1"
{"id": 1, "name": "Yamada Taro", "credit_limit": 10000, "credit_total": 10000}
$ ./gradlew run --args="PlaceOrder 1 3:1,4:1"
java.lang.RuntimeException: Credit limit exceeded. limit:10000, total:17500
        at sample.SampleService.placeOrder(
        at sample.SampleService$$FastClassBySpringCGLIB$$1123c447.invoke(<generated>)
        at org.springframework.cglib.proxy.MethodProxy.invoke(
        at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(
        at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(
        at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.proceed(
        at org.springframework.transaction.interceptor.TransactionInterceptor$1.proceedWithInvocation(
        at org.springframework.transaction.interceptor.TransactionAspectSupport.invokeWithinTransaction(
        at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(
        at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(
        at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.proceed(
        at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(
        at sample.SampleService$$EnhancerBySpringCGLIB$$a94e1d9.placeOrder(<generated>)
        at picocli.CommandLine.executeUserObject(
        at picocli.CommandLine.access$1500(
        at picocli.CommandLine$RunLast.executeUserObjectOfLastSubcommandWithSameParent(
        at picocli.CommandLine$RunLast.handle(
        at picocli.CommandLine$RunLast.handle(
        at picocli.CommandLine$AbstractParseResultHandler.execute(
        at picocli.CommandLine$RunLast.execute(
        at picocli.CommandLine.execute(
        at org.springframework.boot.SpringApplication.callRunner(
        at org.springframework.boot.SpringApplication.callRunners(
        at sample.SampleApp.main(

After making a payment, the customer will be able to place orders again.

$ ./gradlew run --args="Repayment 1 8000"
$ ./gradlew run --args="GetCustomerInfo 1"
{"customer_id":1,"name":"Yamada Taro","credit_limit":10000,"credit_total":2000}
$ ./gradlew run --args="PlaceOrder 1 3:1,4:1"


To stop Cassandra, run the following command:

$ docker-compose down