JDBC mit einer GoogleSQL-Dialekt-Datenbank verbinden

Hinweis: Auf dieser Seite wird der Spanner-JDBC-Treiber beschrieben, der von Google empfohlen und erstellt wird.

Auf dieser Seite wird beschrieben, wie Sie grundlegende Vorgänge in Spanner mit dem Spanner-JDBC-Treiber ausführen.

JDBC-Treiber installieren

Führen Sie die Schritte unter Spanner-Clientbibliotheken aus, um die Authentifizierung einzurichten, und fügen Sie dann der Datei pom.xml die Spanner-JDBC-Treiberabhängigkeiten hinzu, die im folgenden Snippet gezeigt werden.

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>com.google.cloud</groupId>
      <artifactId>libraries-bom</artifactId>
      <version>26.37.0</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

<dependencies>
  <dependency>
    <groupId>com.google.cloud</groupId>
    <artifactId>google-cloud-spanner-jdbc</artifactId>
  </dependency>

Wenn Sie ein Framework verwenden, das den Java-Klassennamen erfordert, um den JDBC-Treiber zu laden, ist es com.google.cloud.spanner.jdbc.JdbcDriver. Informationen zum Einrichten einer Verbindung finden Sie in der API-Dokumentation für JdbcDriver.

Mit einer Spanner-Datenbank verbinden

Die Klassenbeschreibung JdbcDriver zeigt die Syntax des Verbindungsstrings und enthält Beispielcode zum Erstellen einer Verbindung und zum Ausführen einer Abfrage.

Der Treiber erkennt automatisch den SQL-Dialekt (GoogleSQL oder PostgreSQL) der angegebenen Datenbank. Ein Dialektparameter ist nicht erforderlich oder zulässig.

Mit dem Emulator verbinden

Hinweis zur PostgreSQL-Schnittstelle: Die PostgreSQL-Schnittstelle unterstützt den Emulator derzeit nicht.

Wenn Sie eine Verbindung zum Emulator herstellen möchten, legen Sie die Umgebungsvariable SPANNER_EMULATOR_HOST fest. Beispiel:

Linux/macOS

export SPANNER_EMULATOR_HOST=localhost:9010

Windows

set SPANNER_EMULATOR_HOST=localhost:9010

Dadurch wird der Spanner-JDBC-Treibertreiber angewiesen, eine Verbindung zum Emulator herzustellen, der auf dem localhost ausgeführt wird, statt mit dem Standard-Produktionsdienst.

Hinweis: Obwohl dies weniger üblich ist, können Sie den Host im Verbindungsstring angeben, z. B. jdbc:cloudspanner://localhost:9010/projects/test-project/instances/test-instance/databases/test-db;usePlainText=true. Der Host im Verbindungsstring hat immer Vorrang, unabhängig davon, ob SPANNER_EMULATOR_HOST festgelegt ist. Außerdem müssen Sie usePlainText=true im Verbindungsstring angeben, da der Emulator SSL/TLS nicht unterstützt.

Beispiele

Die folgenden Codebeispiele decken einige gängige Anwendungsfälle ab.

Schemaaktualisierung ausführen

Im folgenden Codebeispiel wird die Tabelle Singers der Datenbank hinzugefügt. Dazu wird zuerst eine JDBC-Verbindung und dann die Tabelle erstellt:

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;

class CreateTableExample {

  static void createTable() throws SQLException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project";
    String instanceId = "my-instance";
    String databaseId = "my-database";
    createTable(projectId, instanceId, databaseId);
  }

  static void createTable(String projectId, String instanceId, String databaseId)
      throws SQLException {
    String connectionUrl =
        String.format(
            "jdbc:cloudspanner:/projects/%s/instances/%s/databases/%s",
            projectId, instanceId, databaseId);
    try (Connection connection = DriverManager.getConnection(connectionUrl)) {
      try (Statement statement = connection.createStatement()) {
        statement.execute(
            "CREATE TABLE Singers (\n"
                + "  SingerId   INT64 NOT NULL,\n"
                + "  FirstName  STRING(1024),\n"
                + "  LastName   STRING(1024),\n"
                + "  SingerInfo BYTES(MAX),\n"
                + "  Revenues   NUMERIC,\n"
                + ") PRIMARY KEY (SingerId)\n");
      }
    }
    System.out.println("Created table [Singers]");
  }
}

Zeilen mit einer Transaktion im automatischen Commit-Modus hinzuzufügen

Wenn Sie nicht mehrere Vorgänge als Gruppe ausführen müssen, können Sie eine Transaktion im Autocommit-Modus verwenden. Dies ist das Standardverhalten. Im folgenden Codebeispiel wird eine Transaktion im Autocommit-Modus verwendet, um der Tabelle Singers Zeilen hinzuzufügen:

import java.math.BigDecimal;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Types;
import java.util.Arrays;
import java.util.List;

class InsertDataExample {
  // Class to contain singer sample data.
  static class Singer {
    final long singerId;
    final String firstName;
    final String lastName;
    final BigDecimal revenues;

    Singer(long singerId, String firstName, String lastName, BigDecimal revenues) {
      this.singerId = singerId;
      this.firstName = firstName;
      this.lastName = lastName;
      this.revenues = revenues;
    }
  }

  static final List<Singer> SINGERS =
      Arrays.asList(
          new Singer(10, "Marc", "Richards", new BigDecimal("104100.00")),
          new Singer(20, "Catalina", "Smith", new BigDecimal("9880.99")),
          new Singer(30, "Alice", "Trentor", new BigDecimal("300183")),
          new Singer(40, "Lea", "Martin", new BigDecimal("20118.12")),
          new Singer(50, "David", "Lomond", new BigDecimal("311399.26")));

  static void insertData() throws SQLException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project";
    String instanceId = "my-instance";
    String databaseId = "my-database";
    insertData(projectId, instanceId, databaseId);
  }

  static void insertData(String projectId, String instanceId, String databaseId)
      throws SQLException {
    String connectionUrl =
        String.format(
            "jdbc:cloudspanner:/projects/%s/instances/%s/databases/%s",
            projectId, instanceId, databaseId);
    try (Connection connection = DriverManager.getConnection(connectionUrl)) {
      try (PreparedStatement ps =
          connection.prepareStatement(
              "INSERT INTO Singers\n"
                  + "(SingerId, FirstName, LastName, SingerInfo, Revenues)\n"
                  + "VALUES\n"
                  + "(?, ?, ?, ?, ?)")) {
        for (Singer singer : SINGERS) {
          ps.setLong(1, singer.singerId);
          ps.setString(2, singer.firstName);
          ps.setString(3, singer.lastName);
          ps.setNull(4, Types.BINARY);
          ps.setBigDecimal(5, singer.revenues);
          ps.addBatch();
        }
        int[] updateCounts = ps.executeBatch();
        System.out.printf("Insert counts: %s%n", Arrays.toString(updateCounts));
      }
    }
  }
}

Steuern, wie mehrere Vorgänge als Gruppe durchgeführt werden

Wenn Sie festlegen möchten, ob Spanner mehrere Vorgänge zusammen als Gruppe mit Commits festschreibt, können Sie den Autocommit-Modus deaktivieren. Im folgenden Codebeispiel werden connection.setAutoCommit(false) und connection.commit() zum Hinzufügen von Zeilen zur Tabelle Singers verwendet.

import com.google.common.collect.ImmutableList;
import java.math.BigDecimal;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.Arrays;

class BatchDmlExample {
  static class Singer {
    final long singerId;
    final String firstName;
    final String lastName;
    final BigDecimal revenues;

    Singer(long singerId, String firstName, String lastName, BigDecimal revenues) {
      this.singerId = singerId;
      this.firstName = firstName;
      this.lastName = lastName;
      this.revenues = revenues;
    }
  }

  static void batchDml() throws SQLException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project";
    String instanceId = "my-instance";
    String databaseId = "my-database";
    batchDml(projectId, instanceId, databaseId);
  }

  // This example shows how to execute a batch of DML statements with the JDBC driver.
  static void batchDml(String projectId, String instanceId, String databaseId) throws SQLException {
    String connectionUrl =
        String.format(
            "jdbc:cloudspanner:/projects/%s/instances/%s/databases/%s",
            projectId, instanceId, databaseId);

    ImmutableList<Singer> singers = ImmutableList.of(
        new Singer(10, "Marc", "Richards", BigDecimal.valueOf(10000)),
        new Singer(11, "Amirah", "Finney", BigDecimal.valueOf(195944.10d)),
        new Singer(12, "Reece", "Dunn", BigDecimal.valueOf(10449.90))
    );

    try (Connection connection = DriverManager.getConnection(connectionUrl)) {
      connection.setAutoCommit(false);
      // Use prepared statements for the lowest possible latency when executing the same SQL string
      // multiple times.
      try (PreparedStatement statement = connection.prepareStatement(
          "INSERT INTO Singers (SingerId, FirstName, LastName, Revenues)\n"
              + "VALUES (?, ?, ?, ?)")) {
        for (Singer singer : singers) {
          statement.setLong(1, singer.singerId);
          statement.setString(2, singer.firstName);
          statement.setString(3, singer.lastName);
          statement.setBigDecimal(4, singer.revenues);
          // Add the current parameter values to the batch.
          statement.addBatch();
        }
        // Execute the batched statements.
        int[] updateCounts = statement.executeBatch();
        connection.commit();
        System.out.printf("Batch insert counts: %s%n", Arrays.toString(updateCounts));
      }
    }
  }
}

SQL-Abfrage ausführen

Im folgenden Codebeispiel werden alle Zeilen in der Tabelle Singers zurückgegeben, sortiert nach dem Nachnamen des Sängers:

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class SingleUseReadOnlyExample {

  static void singleUseReadOnly() throws SQLException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project";
    String instanceId = "my-instance";
    String databaseId = "my-database";
    singleUseReadOnly(projectId, instanceId, databaseId);
  }

  static void singleUseReadOnly(String projectId, String instanceId, String databaseId)
      throws SQLException {
    String connectionUrl =
        String.format(
            "jdbc:cloudspanner:/projects/%s/instances/%s/databases/%s",
            projectId, instanceId, databaseId);
    try (Connection connection = DriverManager.getConnection(connectionUrl);
        Statement statement = connection.createStatement()) {
      // When the connection is in autocommit mode, any query that is executed will automatically
      // be executed using a single-use read-only transaction, even if the connection itself is in
      // read/write mode.
      try (ResultSet rs =
          statement.executeQuery(
              "SELECT SingerId, FirstName, LastName, Revenues FROM Singers ORDER BY LastName")) {
        while (rs.next()) {
          System.out.printf(
              "%d %s %s %s%n",
              rs.getLong(1), rs.getString(2), rs.getString(3), rs.getBigDecimal(4));
        }
      }
    }
  }
}

Nächste Schritte

• Häufig gestellte Fragen zum Spanner-JDBC-Treiber
• Befehle zur Sitzungsverwaltung für Spanner-JDBC-Treiber