Java

GreptimeDB uses different client libraries for writing and querying data. You can choose the client library that best suits your needs.

Write data

GreptimeDB provides an ingester library to help you write data. It utilizes the gRPC protocol, which supports schemaless writing and eliminates the need to create tables before writing data. For more information, refer to Automatic Schema Generation.

The Java ingester SDK provided by GreptimeDB is a lightweight library with the following features:

  • SPI-based extensible network transport layer, which provides the default implementation using the gRPC framework.
  • Non-blocking, purely asynchronous API that is easy to use.
  • Automatic collection of various performance metrics by default. You can then configure and write them to local files.
  • Ability to take in-memory snapshots of critical objects, configure them, and write them to local files. This is helpful for troubleshooting complex issues.

Installation

  1. Install the Java Development Kit(JDK)

Make sure that your system has JDK 8 or later installed. For more information on how to check your version of Java and install the JDK, see the Oracle Overview of JDK Installation documentation

  1. Add GreptiemDB Java SDK as a Dependency

If you are using Maven, add the following to your pom.xml dependencies list:

xml

  1. <dependency>
  2.     <groupId>io.greptime</groupId>
  3.     <artifactId>ingester-all</artifactId>
  4.     <version>${latest_version}</version>
  5. </dependency>

The latest version can be viewed here.

After configuring your dependencies, make sure they are available to your project. This may require refreshing the project in your IDE or running the dependency manager.

Connect to database

Username and password are always required to connect to GreptimeDB. For how to set authentication to GreptimeDB, see Authentication. Here we set the username and password when using the library to connect to GreptimeDB.

The following code demonstrates how to connect to GreptimeDB with the simplest configuration. For customizing the connection options, please refer to API Documentation. Please pay attention to the accompanying comments for each option, as they provide detailed explanations of their respective roles.

java

  1. // GreptimeDB has a default database named "public" in the default catalog "greptime",
  2. // we can use it as the test database
  3. String database = "public";
  4. // By default, GreptimeDB listens on port 4001 using the gRPC protocol.
  5. // We can provide multiple endpoints that point to the same GreptimeDB cluster.
  6. // The client will make calls to these endpoints based on a load balancing strategy.
  7. String[] endpoints = {"127.0.0.1:4001"};
  8. // Sets authentication information.
  9. AuthInfo authInfo = new AuthInfo("username", "password");
  10. GreptimeOptions opts = GreptimeOptions.newBuilder(endpoints, database)
  11.         // If the database does not require authentication, we can use AuthInfo.noAuthorization() as the parameter.
  12.         .authInfo(authInfo)
  13.         // A good start ^_^
  14.         .build();
  16. GreptimeDB client = GreptimeDB.create(opts);

For customizing the connection options, please refer to API Documentation.

Row object

Each row item in a table consists of three types of columns: Tag, Timestamp, and Field. For more information, see Data Model. The types of column values could be String, Float, Int, Timestamp, etc. For more information, see Data Types.

The Java ingester SDK uses Table to denote multiple rows in a table. We can add row data items into the Table object, which are then written into GreptimeDB.

On the other hand, there is an alternative approach that allows us to use basic POJO objects for writing. This approach requires the use of Greptime’s own annotations, but they are easy to use.

Create rows

The following example shows how to create a row contains Tag, Timestamp, and Field columns. The Tag column is a String type, the Timestamp column is a Timestamp type, and the Field column is a Float type.

java

  1. // Creates schemas
  2. TableSchema cpuMetricSchema = TableSchema.newBuilder("cpu_metric") //
  3.         .addColumn("host", SemanticType.Tag, DataType.String) //
  4.         .addColumn("ts", SemanticType.Timestamp, DataType.TimestampMillisecond) //
  5.         .addColumn("cpu_user", SemanticType.Field, DataType.Float64) //
  6.         .addColumn("cpu_sys", SemanticType.Field, DataType.Float64) //
  7.         .build();
  8. Table cpuMetric = Table.from(cpuMetricSchema);
  10. String host = "127.0.0.1";
  11. long ts = System.currentTimeMillis();
  12. double cpuUser = 0.1;
  13. double cpuSys = 0.12;
  14. cpuMetric.addRow(host, ts, cpuUser, cpuSys);

To improve the efficiency of writing data, you can create multiple rows at once to write to GreptimeDB.

java

  1. // Creates schemas
  2. TableSchema cpuMetricSchema = TableSchema.newBuilder("cpu_metric") //
  3.         .addColumn("host", SemanticType.Tag, DataType.String) //
  4.         .addColumn("ts", SemanticType.Timestamp, DataType.TimestampMillisecond) //
  5.         .addColumn("cpu_user", SemanticType.Field, DataType.Float64) //
  6.         .addColumn("cpu_sys", SemanticType.Field, DataType.Float64) //
  7.         .build();
  9. TableSchema memMetricSchema = TableSchema.newBuilder("mem_metric") //
  10.         .addColumn("host", SemanticType.Tag, DataType.String) //
  11.         .addColumn("ts", SemanticType.Timestamp, DataType.TimestampMillisecond) //
  12.         .addColumn("mem_usage", SemanticType.Field, DataType.Float64) //
  13.         .build();
  15. Table cpuMetric = Table.from(cpuMetricSchema);
  16. Table memMetric = Table.from(memMetricSchema);
  18. // Adds row data items
  19. for (int i = 0; i < 10; i++) {
  20.     String host = "127.0.0." + i;
  21.     long ts = System.currentTimeMillis();
  22.     double cpuUser = i + 0.1;
  23.     double cpuSys = i + 0.12;
  24.     cpuMetric.addRow(host, ts, cpuUser, cpuSys);
  25. }
  27. for (int i = 0; i < 10; i++) {
  28.     String host = "127.0.0." + i;
  29.     long ts = System.currentTimeMillis();
  30.     double memUsage = i + 0.2;
  31.     memMetric.addRow(host, ts, memUsage);
  32. }

Or we can build data with POJO objects:

java

  1. @Metric(name = "cpu_metric")
  2. public class Cpu {
  3.     @Column(name = "host", tag = true, dataType = DataType.String)
  4.     private String host;
  6.     @Column(name = "ts", timestamp = true, dataType = DataType.TimestampMillisecond)
  7.     private long ts;
  9.     @Column(name = "cpu_user", dataType = DataType.Float64)
  10.     private double cpuUser;
  11.     @Column(name = "cpu_sys", dataType = DataType.Float64)
  12.     private double cpuSys;
  14.     // getters and setters
  15.     // ...
  16. }
  18. @Metric(name = "mem_metric")
  19. public class Memory {
  20.     @Column(name = "host", tag = true, dataType = DataType.String)
  21.     private String host;
  23.     @Column(name = "ts", timestamp = true, dataType = DataType.TimestampMillisecond)
  24.     private long ts;
  26.     @Column(name = "mem_usage", dataType = DataType.Float64)
  27.     private double memUsage;
  28.     // getters and setters
  29.     // ...
  30. }
  32. // Add rows
  33. List<Cpu> cpus = new ArrayList<>();
  34. for (int i = 0; i < 10; i++) {
  35.     Cpu c = new Cpu();
  36.     c.setHost("127.0.0." + i);
  37.     c.setTs(System.currentTimeMillis());
  38.     c.setCpuUser(i + 0.1);
  39.     c.setCpuSys(i + 0.12);
  40.     cpus.add(c);
  41. }
  43. List<Memory> memories = new ArrayList<>();
  44. for (int i = 0; i < 10; i++) {
  45.     Memory m = new Memory();
  46.     m.setHost("127.0.0." + i);
  47.     m.setTs(System.currentTimeMillis());
  48.     m.setMemUsage(i + 0.2);
  49.     memories.add(m);
  50. }

Save rows

The following example shows how to save rows to tables in GreptimeDB.

java

  1. // Saves data
  3. // For performance reasons, the SDK is designed to be purely asynchronous.
  4. // The return value is a future object. If you want to immediately obtain
  5. // the result, you can call `future.get()`.
  6. CompletableFuture<Result<WriteOk, Err>> future = greptimeDB.write(cpuMetric, memMetric);
  8. Result<WriteOk, Err> result = future.get();
  10. if (result.isOk()) {
  11.     LOG.info("Write result: {}", result.getOk());
  12. } else {
  13.     LOG.error("Failed to write: {}", result.getErr());
  14. }

We also can write with POJO objects:

java

  1. // Saves data
  3. CompletableFuture<Result<WriteOk, Err>> puts = greptimeDB.writePOJOs(cpus, memories);
  5. Result<WriteOk, Err> result = puts.get();
  7. if (result.isOk()) {
  8.     LOG.info("Write result: {}", result.getOk());
  9. } else {
  10.     LOG.error("Failed to write: {}", result.getErr());
  11. }

Update rows

Please refer to update data for the updating mechanism. The following example shows saving a row and then updating the row.

java

  1. Table cpuMetric = Table.from(myMetricCpuSchema);
  2. // save a row data
  3. long ts = 1703832681000L;
  4. cpuMetric.addRow("host1", ts, 0.23, 0.12);
  5. Result<WriteOk, Err> putResult = greptimeDB.write(cpuMetric).get();
  7. // update the row data
  8. Table newCpuMetric = Table.from(myMetricCpuSchema);
  9. // The same tag `host1`
  10. // The same time index `1703832681000`
  11. // The new value: cpu_user = `0.80`, cpu_sys = `0.81`
  12. long ts = 1703832681000L;
  13. myMetricCpuSchema.addRow("host1", ts, 0.80, 0.81);
  15. // overwrite the existing data
  16. Result<WriteOk, Err> updateResult = greptimeDB.write(myMetricCpuSchema).get();

Or we can update with POJO objects:

java

  1. Cpu cpu = new Cpu();
  2. cpu.setHost("host1");
  3. cpu.setTs(1703832681000L);
  4. cpu.setCpuUser(0.23);
  5. cpu.setCpuSys(0.12);
  7. // save a row data
  8. Result<WriteOk, Err> putResult = greptimeDB.writePOJOs(cpu).get();
  10. // update the row data
  11. Cpu newCpu = new Cpu();
  12. // The same tag `host1`
  13. newCpu.setHost("host1");
  14. // The same time index `1703832681000`
  15. newCpu.setTs(1703832681000L);
  16. // The new value: cpu_user = `0.80`, cpu_sys = `0.81`
  17. cpu.setCpuUser(0.80);
  18. cpu.setCpuSys(0.81);
  20. // overwrite the existing data
  21. Result<WriteOk, Err> updateResult = greptimeDB.writePOJOs(newCpu).get();

For the complete code of the demo, please refer to here.

Debug logs

The ingester SDK provides metrics and logs for debugging. Please refer to Metrics & Display and Magic Tools to learn how to enable or disable the logs.

More examples

For fully runnable code snippets and explanations for common methods, see the Examples.

Ingester library reference

Query data

GreptimeDB uses SQL as the main query language and is compatible with MySQL and PostgreSQL. Therefore, we recommend using mature SQL drivers to query data.

Java database connectivity (JDBC) is the JavaSoft specification of a standard application programming interface (API) that allows Java programs to access database management systems.

Many databases, such as MySQL or PostgreSQL, have implemented their own drivers based on the JDBC API. Since GreptimeDB supports mutiple protocols, we use MySQL as an example to demonstrate how to use JDBC. If you want to use other protocols, just replace the MySQL driver with the corresponding driver.

Installation

If you are using Maven, add the following to your pom.xml dependencies list:

xml

  1. <!-- MySQL usage dependency -->
  2. <dependency>
  3.     <groupId>mysql</groupId>
  4.     <artifactId>mysql-connector-java</artifactId>
  5.     <version>8.0.33</version>
  6. </dependency>

Connect to database

The following example shows how to connect to GreptimeDB:

Here we will use MySQL as an example to demonstrate how to connect to GreptimeDB.

java

  2. public static Connection getConnection() throws IOException, ClassNotFoundException, SQLException {
  3.     Properties prop = new Properties();
  4.     prop.load(QueryJDBC.class.getResourceAsStream("/db-connection.properties"));
  6.     String dbName = (String) prop.get("db.database-driver");
  8.     String dbConnUrl = (String) prop.get("db.url");
  9.     String dbUserName = (String) prop.get("db.username");
  10.     String dbPassword = (String) prop.get("db.password");
  12.     Class.forName(dbName);
  13.     Connection dbConn = DriverManager.getConnection(dbConnUrl, dbUserName, dbPassword);
  15.     return Objects.requireNonNull(dbConn, "Failed to make connection!");
  16. }

You need a properties file to store the DB connection information. Place it in the Resources directory and name it db-connection.properties. The file content is as follows:

txt

  1. # DataSource
  2. db.database-driver=com.mysql.cj.jdbc.Driver
  3. db.url=jdbc:mysql://localhost:4002/public
  4. db.username=
  5. db.password=

Or you can just get the file from here.

Raw SQL

We recommend you using raw SQL to experience the full features of GreptimeDB. The following example shows how to use raw SQL to query data:

java

  1. try (Connection conn = getConnection()) {
  2.     Statement statement = conn.createStatement();
  4.     // DESC table;
  5.     ResultSet rs = statement.executeQuery("DESC cpu_metric");
  6.     LOG.info("Column | Type | Key | Null | Default | Semantic Type ");
  7.     while (rs.next()) {
  8.         LOG.info("{} | {} | {} | {} | {} | {}", //
  9.                 rs.getString(1), //
  10.                 rs.getString(2), //
  11.                 rs.getString(3), //
  12.                 rs.getString(4), //
  13.                 rs.getString(5), //
  14.                 rs.getString(6));
  15.     }
  17.     // SELECT COUNT(*) FROM cpu_metric;
  18.     rs = statement.executeQuery("SELECT COUNT(*) FROM cpu_metric");
  19.     while (rs.next()) {
  20.         LOG.info("Count: {}", rs.getInt(1));
  21.     }
  23.     // SELECT * FROM cpu_metric ORDER BY ts DESC LIMIT 5;
  24.     rs = statement.executeQuery("SELECT * FROM cpu_metric ORDER BY ts DESC LIMIT 5");
  25.     LOG.info("host | ts | cpu_user | cpu_sys");
  26.     while (rs.next()) {
  27.         LOG.info("{} | {} | {} | {}", //
  28.                 rs.getString("host"), //
  29.                 rs.getTimestamp("ts"), //
  30.                 rs.getDouble("cpu_user"), //
  31.                 rs.getDouble("cpu_sys"));
  32.     }
  33. }

For the complete code of the demo, please refer to here.

Query library reference

For more information about how to use the query library, please see the documentation of the corresponding library: