Hologres:Bonnes pratiques pour les requêtes ponctuelles rapides

-- Create a row-oriented table optimized for point queries.
-- The key column is the primary key, clustering key, and distribution key.
-- Queries on key= go directly to the matching shard and return in one seek.
BEGIN;
CREATE TABLE test_kv_table (
  key   TEXT PRIMARY KEY,
  value TEXT
);
CALL set_table_property('test_kv_table', 'orientation',      'row');
CALL set_table_property('test_kv_table', 'clustering_key',   'key');
CALL set_table_property('test_kv_table', 'distribution_key', 'key');
COMMIT;

Importance de chaque propriété

L'omission de orientation = 'row' constitue l'erreur de performance la plus courante. Une table utilisant le stockage en colonnes nécessite une entrée/sortie par colonne pour chaque requête ponctuelle, ce qui peut ajouter des dizaines de millisecondes de latence sur les tables larges.

Requêtes SQL

Pour des recherches rapides ou des tests ad hoc, utilisez directement SQL :

-- Single key
SELECT * FROM test_kv_table WHERE key = '1';

-- Multiple keys in one round trip
SELECT * FROM test_kv_table WHERE key IN ('1', '2', '3');

Java avec des instructions préparées

Utilisez une instruction préparée et réutilisez-la pour plusieurs requêtes. La réutilisation d'une instruction préparée permet à Hologres d'éviter la planification de la requête à chaque appel, ce qui élimine une source significative de latence à haut débit QPS.

Connectez-vous toujours via le point de terminaison VPC. Les points de terminaison publics ajoutent du temps d'aller-retour réseau et sont soumis à des limitations de débit.

// Query multiple keys using a reused prepared statement.
// The prepared statement is created once and reused for every query in the loop.
private static void testKV(Connection conn) throws Exception {
    String sql = "SELECT * FROM test_kv_table WHERE key = ?";
    try (PreparedStatement stmt = conn.prepareStatement(sql)) {
        for (int i = 0; i < 100; ++i) {
            stmt.setString(1, Integer.toString(i));
            long begin = System.currentTimeMillis();
            try (ResultSet rs = stmt.executeQuery()) {
                long cost = System.currentTimeMillis() - begin;
                while (rs.next()) {
                    System.out.println(
                        "data => " + rs.getObject(1) + " " + rs.getObject(2)
                        + " latency => [" + cost + "]ms"
                    );
                }
            }
        }
    }
}

HoloClient (recommandé pour les charges de travail à haut QPS)

HoloClient est un SDK Java natif pour Hologres qui regroupe automatiquement les appels Get concurrents en une seule instruction SQL. Cette approche réduit les allers-retours réseau et constitue la méthode recommandée lorsque le QPS est la contrainte principale.

Ajoutez la dépendance via Maven :

<dependency>
  <groupId>com.alibaba.hologres</groupId>
  <artifactId>holo-client</artifactId>
  <version>{1.2.16.5}</version>
</dependency>

Configurez et utilisez le client :

// The JDBC URL format is jdbc:postgresql://host:port/db.
// Use your VPC endpoint as the host.
HoloConfig config = new HoloConfig();
config.setJdbcUrl(url);
config.setUsername(username);
config.setPassword(password);
config.setReadThreadCount(10); // Maintain up to 10 concurrent JDBC connections

try (HoloClient client = new HoloClient(config)) {
    TableSchema schema0 = client.getTableSchema("t0");

    // Submit two Gets asynchronously. HoloClient batches them into one SQL call.
    Get get  = Get.newBuilder(schema0).setPrimaryKey("id", 0).build(); // WHERE id = 0
    Get get1 = Get.newBuilder(schema0).setPrimaryKey("id", 1).build(); // WHERE id = 1

    client.get(get).thenAcceptAsync(record  -> { /* handle result */ });
    client.get(get1).thenAcceptAsync(record -> { /* handle result */ });
} catch (HoloClientException e) {
    // handle exception
}

package test;

import org.postgresql.jdbc.PgConnection;
import java.sql.*;

public class TestPointQuery {

    // Create a row-oriented table and populate it with test data.
    private static void init(Connection conn) throws Exception {
        try (Statement stmt = conn.createStatement()) {
            stmt.execute("DROP TABLE IF EXISTS test_kv_table;");
            stmt.execute("BEGIN;");
            stmt.execute(
                "CREATE TABLE IF NOT EXISTS test_kv_table(" +
                "  key   TEXT PRIMARY KEY," +
                "  value TEXT" +
                ");"
            );
            stmt.execute("CALL set_table_property('test_kv_table', 'orientation', 'row');");
            stmt.execute("CALL set_table_property('test_kv_table', 'shard_count',  '20');");
            stmt.execute("END;");
            stmt.execute(
                "INSERT INTO test_kv_table SELECT i, i FROM generate_series(1, 10000) i"
            );
        }
    }

    // Query 100 keys using a reused prepared statement.
    private static void testKV(Connection conn) throws Exception {
        String sql = "SELECT * FROM test_kv_table WHERE key = ?";
        try (PreparedStatement stmt = conn.prepareStatement(sql)) {
            for (int i = 0; i < 100; ++i) {
                stmt.setString(1, Integer.toString(i));
                long begin = System.currentTimeMillis();
                try (ResultSet rs = stmt.executeQuery()) {
                    long cost = System.currentTimeMillis() - begin;
                    while (rs.next()) {
                        System.out.println(
                            "data => " + rs.getObject(1) + " " + rs.getObject(2)
                            + " latency => [" + cost + "]ms"
                        );
                    }
                }
            }
        }
    }

    public static void main(String[] args) throws Exception {
        Class.forName("org.postgresql.Driver").newInstance();

        // Replace these placeholders with your actual values.
        String host     = "<vpc-endpoint>";  // VPC endpoint from the Hologres console
        String db       = "<database-name>";
        String user     = "<access-key-id>";      // AccessKey ID
        String password = "<access-key-secret>";  // AccessKey secret
        String url      = "jdbc:postgresql://" + host + "/" + db;

        try (PgConnection conn = (PgConnection) DriverManager.getConnection(url, user, password)) {
            System.out.println("Initializing test_kv_table...");
            init(conn);
            System.out.println("Running point query test...");
            testKV(conn);
        }
    }
}