com.google.cloud.spanner.SpannerOptions Java Examples

private DatabaseClient configureDb() {
  final SpannerOptions options = SpannerOptions.newBuilder().build();
  spanner = options.getService();
  final DatabaseId db = DatabaseId.of(PROJECT_ID, instanceName, dbName);
  final String clientProject = spanner.getOptions().getProjectId();

  if (!db.getInstanceId().getProject().equals(clientProject)) {
    log.error(
        "Invalid project specified. Project in the database id should match"
            + "the project name set in the environment variable GCLOUD_PROJECT. Expected: "
            + clientProject);

    stop();
    System.exit(1);
  }

  final DatabaseClient dbClient = spanner.getDatabaseClient(db);

  return dbClient;
}
 

DatabaseClient get() throws Throwable {
  if (!initialized) {
    synchronized (lock) {
      if (!initialized) {
        try {
          DatabaseId db =
              DatabaseId.of(
                  SpannerOptions.getDefaultProjectId(),
                  SPANNER_INSTANCE_ID,
                  SPANNER_DATABASE_ID);
          client = createSpanner().getDatabaseClient(db);
        } catch (Throwable t) {
          error = t;
        }
        initialized = true;
      }
    }
  }
  if (error != null) {
    throw error;
  }
  return client;
}
 

static void clientWithQueryOptions(DatabaseId db) {
  SpannerOptions options =
      SpannerOptions.newBuilder()
          .setDefaultQueryOptions(
              db, QueryOptions.newBuilder().setOptimizerVersion("1").build())
          .build();
  Spanner spanner = options.getService();
  DatabaseClient dbClient = spanner.getDatabaseClient(db);
  try (ResultSet resultSet =
      dbClient
          .singleUse()
          .executeQuery(Statement.of("SELECT SingerId, AlbumId, AlbumTitle FROM Albums"))) {
    while (resultSet.next()) {
      System.out.printf(
          "%d %d %s\n", resultSet.getLong(0), resultSet.getLong(1), resultSet.getString(2));
    }
  }
}
 

@Bean
@ConditionalOnMissingBean
public SpannerOptions spannerOptions(SessionPoolOptions sessionPoolOptions) {
	Builder builder = SpannerOptions.newBuilder()
			.setProjectId(this.projectId)
			.setHeaderProvider(new UserAgentHeaderProvider(this.getClass()))
			.setCredentials(this.credentials);
	if (this.numRpcChannels >= 0) {
		builder.setNumChannels(this.numRpcChannels);
	}
	if (this.prefetchChunks >= 0) {
		builder.setPrefetchChunks(this.prefetchChunks);
	}
	builder.setSessionPoolOption(sessionPoolOptions);
	return builder.build();
}
 

public static void main(String[] args) throws Exception {
  if (!(args.length == 3 || args.length == 4)) {
    printUsageAndExit();
  }
  SpannerOptions options = SpannerOptions.newBuilder().build();
  Spanner spanner = options.getService();
  try {
    String command = args[0];
    DatabaseId db = DatabaseId.of(options.getProjectId(), args[1], args[2]);
    DatabaseClient dbClient = spanner.getDatabaseClient(db);
    DatabaseAdminClient dbAdminClient = spanner.getDatabaseAdminClient();
    switch (command) {
      case "create":
        create(dbAdminClient, db);
        break;
      default:
        printUsageAndExit();
    }
  } finally {
    spanner.close();
  }
  System.out.println("Closed client");
}
 

@Test
public void testEuropeWestSingleNodeConfig() {
  String credentialsPath = "cloudspanner-emulator-key.json";
  String projectId = "test-project";
  GoogleCredentials credentials = null;
  try {
    credentials = CloudSpannerConnection.getCredentialsFromFile(credentialsPath);
  } catch (IOException e) {
    throw new RuntimeException("Could not read key file " + credentialsPath, e);
  }
  Builder builder = SpannerOptions.newBuilder();
  builder.setProjectId(projectId);
  builder.setCredentials(credentials);
  builder.setHost(CloudSpannerIT.getHost());

  SpannerOptions options = builder.build();
  Spanner spanner = options.getService();

  InstanceAdminClient instanceAdminClient = spanner.getInstanceAdminClient();
  InstanceConfig config = instanceAdminClient.getInstanceConfig("regional-europe-west1");
  assertEquals("regional-europe-west1", config.getId().getInstanceConfig());
  spanner.close();
}
 

public CloudSpannerIT() {
  // generate a unique instance id for this test run
  Random rnd = new Random();
  this.instanceId = "test-instance-" + rnd.nextInt(1000000);
  this.credentialsPath = getKeyFile();
  GoogleCredentials credentials = null;
  try {
    credentials = CloudSpannerConnection.getCredentialsFromFile(credentialsPath);
  } catch (IOException e) {
    throw new RuntimeException("Could not read key file " + credentialsPath, e);
  }
  Builder builder = SpannerOptions.newBuilder();
  builder.setProjectId(getProject());
  builder.setCredentials(credentials);
  builder.setHost(getHost());

  SpannerOptions options = builder.build();
  spanner = options.getService();
}
 

@BeforeClass
public static void createTestDatabase() throws Exception {
  SpannerOptions options = SpannerOptions.newBuilder().build();
  Spanner spanner = options.getService();
  dbClient = spanner.getDatabaseAdminClient();
  if (instanceId == null) {
    Iterator<Instance> iterator =
        spanner.getInstanceAdminClient().listInstances().iterateAll().iterator();
    if (iterator.hasNext()) {
      instanceId = iterator.next().getId().getInstance();
    }
  }
  dbId = DatabaseId.of(options.getProjectId(), instanceId, databaseId);
  dbClient.dropDatabase(dbId.getInstanceId().getInstance(), dbId.getDatabase());
  dbClient.createDatabase(instanceId, databaseId, Collections.emptyList()).get();
  CreateTableExample.createTable(options.getProjectId(), instanceId, databaseId);
}
 

public static void main(String[] args) {
  SpannerOptions options = SpannerOptions.newBuilder().build();
  Spanner spanner = options.getService();

  try {

    DatabaseId db = DatabaseId.of(options.getProjectId(), args[0], args[1]);
    // [END init_client]
    // This will return the default project id based on the environment.
    String clientProject = spanner.getOptions().getProjectId();
    if (!db.getInstanceId().getProject().equals(clientProject)) {
      System.err.println("Invalid project specified. Project in the database id should match"
          + "the project name set in the environment variable GCLOUD_PROJECT. Expected: "
          + clientProject);
    }
    // [START init_client]
    DatabaseClient dbClient = spanner.getDatabaseClient(db);
    DatabaseAdminClient dbAdminClient = spanner.getDatabaseAdminClient();
    createDatabase(dbAdminClient, db);
  } finally {
    spanner.close();
  }
  
}
 

public SpannerBenchWrapperImpl() {
  SpannerOptions options = SpannerOptions.newBuilder().setProjectId("test-project-id").build();
  spanner = options.getService();

  dbClient =
      spanner.getDatabaseClient(
          DatabaseId.of(options.getProjectId(), "test-instance", "test-db"));
}
 

@Before
public void setUp() throws Exception {
  PipelineOptionsFactory.register(SpannerTestPipelineOptions.class);
  options = TestPipeline.testingPipelineOptions().as(SpannerTestPipelineOptions.class);

  project = options.getInstanceProjectId();
  if (project == null) {
    project = options.as(GcpOptions.class).getProject();
  }

  spanner = SpannerOptions.newBuilder().setProjectId(project).build().getService();

  databaseName = generateDatabaseName();

  databaseAdminClient = spanner.getDatabaseAdminClient();

  // Delete database if exists.
  databaseAdminClient.dropDatabase(options.getInstanceId(), databaseName);

  OperationFuture<Database, CreateDatabaseMetadata> op =
      databaseAdminClient.createDatabase(
          options.getInstanceId(),
          databaseName,
          Collections.singleton(
              "CREATE TABLE "
                  + options.getTable()
                  + " ("
                  + "  Key           INT64,"
                  + "  Value         STRING(MAX),"
                  + ") PRIMARY KEY (Key)"));
  op.get();
  makeTestData();
}
 

@Before
public void setUp() throws Exception {
  PipelineOptionsFactory.register(SpannerTestPipelineOptions.class);
  options = TestPipeline.testingPipelineOptions().as(SpannerTestPipelineOptions.class);

  project = options.getInstanceProjectId();
  if (project == null) {
    project = options.as(GcpOptions.class).getProject();
  }

  spanner = SpannerOptions.newBuilder().setProjectId(project).build().getService();

  databaseName = generateDatabaseName();

  databaseAdminClient = spanner.getDatabaseAdminClient();

  // Delete database if exists.
  databaseAdminClient.dropDatabase(options.getInstanceId(), databaseName);

  OperationFuture<Database, CreateDatabaseMetadata> op =
      databaseAdminClient.createDatabase(
          options.getInstanceId(),
          databaseName,
          Collections.singleton(
              "CREATE TABLE "
                  + options.getTable()
                  + " ("
                  + "  Key           INT64,"
                  + "  Value         STRING(MAX) NOT NULL,"
                  + ") PRIMARY KEY (Key)"));
  op.get();
}
 

private static void connect() throws IOException {
  if (INSTANCE_ID == null) {
    if (sc != null) {
      sc.log("environment variable SPANNER_INSTANCE need to be defined.");
    }
    return;
  }
  SpannerOptions options = SpannerOptions.newBuilder().build();
  PROJECT_ID = options.getProjectId();
  spanner = options.getService();
  databaseAdminClient = spanner.getDatabaseAdminClient();
}
 

private static void connect() throws IOException {
  if (INSTANCE_ID == null) {
    if (sc != null) {
      sc.log("environment variable SPANNER_INSTANCE need to be defined.");
    }
    return;
  }
  SpannerOptions options = SpannerOptions.newBuilder().build();
  PROJECT_ID = options.getProjectId();
  spanner = options.getService();
  databaseAdminClient = spanner.getDatabaseAdminClient();
}
 

/**
 * Constructs the {@link ClientLibraryOperations} object.
 */
public ClientLibraryOperations() {
  SpannerOptions spannerOptions = SpannerOptions.newBuilder().setProjectId(PROJECT_ID).build();
  this.spanner = spannerOptions.getService();

  this.databaseAdminClient = this.spanner.getDatabaseAdminClient();
  this.databaseClient = this.spanner.getDatabaseClient(
        DatabaseId.of(PROJECT_ID, INSTANCE_NAME, DATABASE_NAME));
}
 

public static void main(String[] args) throws Exception {
  if (args.length != 3) {
    printUsageAndExit();
  }
  // [START init_client]
  SpannerOptions options = SpannerOptions.newBuilder().build();
  Spanner spanner = options.getService();
  try {
    String command = args[0];
    DatabaseId db = DatabaseId.of(options.getProjectId(), args[1], args[2]);
    // [END init_client]
    // This will return the default project id based on the environment.
    String clientProject = spanner.getOptions().getProjectId();
    if (!db.getInstanceId().getProject().equals(clientProject)) {
      System.err.println(
          "Invalid project specified. Project in the database id should match the"
              + "project name set in the environment variable GOOGLE_CLOUD_PROJECT. Expected: "
              + clientProject);
      printUsageAndExit();
    }
    // Generate a backup id for the sample database.
    String backupName =
        String.format(
            "%s_%02d",
            db.getDatabase(), LocalDate.now().get(ChronoField.ALIGNED_WEEK_OF_YEAR));
    BackupId backup = BackupId.of(db.getInstanceId(), backupName);

    // [START init_client]
    DatabaseClient dbClient = spanner.getDatabaseClient(db);
    DatabaseAdminClient dbAdminClient = spanner.getDatabaseAdminClient();
    InstanceAdminClient instanceAdminClient = spanner.getInstanceAdminClient();
    // Use client here...
    // [END init_client]
    run(dbClient, dbAdminClient, instanceAdminClient, command, db, backup);
  } finally {
    spanner.close();
  }
  // [END init_client]
  System.out.println("Closed client");
}
 

public static void main(String... args) throws Exception {

    if (args.length != 2) {
      System.err.println("Usage: QuickStartSample <instance_id> <database_id>");
      return;
    }
    // Instantiates a client
    SpannerOptions options = SpannerOptions.newBuilder().build();
    Spanner spanner = options.getService();

    // Name of your instance & database.
    String instanceId = args[0];
    String databaseId = args[1];
    try {
      // Creates a database client
      DatabaseClient dbClient =
          spanner.getDatabaseClient(DatabaseId.of(options.getProjectId(), instanceId, databaseId));
      // Queries the database
      ResultSet resultSet = dbClient.singleUse().executeQuery(Statement.of("SELECT 1"));

      System.out.println("\n\nResults:");
      // Prints the results
      while (resultSet.next()) {
        System.out.printf("%d\n\n", resultSet.getLong(0));
      }
    } finally {
      // Closes the client which will free up the resources used
      spanner.close();
    }
  }
 

public static void main(String... args) throws Exception {

    if (args.length != 2) {
      System.err.println("Usage: QuickStartSample <instance_id> <database_id>");
      return;
    }
    // Instantiates a client
    SpannerOptions options = SpannerOptions.newBuilder().build();
    Spanner spanner = options.getService();

    // Name of your instance & database.
    String instanceId = args[0];
    String databaseId = args[1];
    try {
      // Creates a database client
      DatabaseClient dbClient =
          spanner.getDatabaseClient(DatabaseId.of(options.getProjectId(), instanceId, databaseId));
      // Queries the database
      try (ResultSet resultSet = dbClient.singleUse().executeQuery(Statement.of("SELECT 1"))) {
        System.out.println("\n\nResults:");
        // Prints the results
        while (resultSet.next()) {
          System.out.printf("%d\n\n", resultSet.getLong(0));
        }
      }
    } finally {
      // Closes the client which will free up the resources used
      spanner.close();
    }
  }
 

@BeforeClass
public static void setUp() throws Exception {
  SpannerOptions options = SpannerOptions.newBuilder().build();
  spanner = options.getService();
  dbClient = spanner.getDatabaseAdminClient();
  dbId = DatabaseId.of(options.getProjectId(), instanceId, databaseId);
  dbClient.dropDatabase(dbId.getInstanceId().getInstance(), dbId.getDatabase());
  dbClient.dropDatabase(
      dbId.getInstanceId().getInstance(), SpannerSample.createRestoredSampleDbId(dbId));
}
 

@Before
public void setUp() throws Exception {
  SpannerOptions options = SpannerOptions.newBuilder().build();
  Spanner spanner = options.getService();
  dbClient = spanner.getDatabaseAdminClient();
  dbId = DatabaseId.of(options.getProjectId(), instanceId, databaseId);
  dbClient.dropDatabase(dbId.getInstanceId().getInstance(), dbId.getDatabase());
}
 

BatchClient getBatchClient() {
  // [START get_batch_client]
  SpannerOptions options = SpannerOptions.newBuilder().build();
  Spanner spanner = options.getService();
  final String project = "test-project";
  final String instance = "test-instance";
  final String database = "example-db";
  DatabaseId db = DatabaseId.of(project, instance, database);
  BatchClient batchClient = spanner.getBatchClient(db);
  // [END get_batch_client]

  return batchClient;
}
 

InstanceAdminClient getInstanceAdminClient() {
  // [START get_instance_admin_client]
  SpannerOptions options = SpannerOptions.newBuilder().build();
  Spanner spanner = options.getService();
  InstanceAdminClient instanceAdminClient = spanner.getInstanceAdminClient();
  // [END get_instance_admin_client]

  return instanceAdminClient;
}
 

DatabaseClient getDatabaseClient() {
  // [START get_db_client]
  SpannerOptions options = SpannerOptions.newBuilder().build();
  Spanner spanner = options.getService();
  final String project = "test-project";
  final String instance = "test-instance";
  final String database = "example-db";
  DatabaseId db = DatabaseId.of(project, instance, database);
  DatabaseClient dbClient = spanner.getDatabaseClient(db);
  // [END get_db_client]

  return dbClient;
}
 

public static void main(String[] args) throws Exception {
  if (!(args.length == 3 || args.length == 4)) {
    printUsageAndExit();
  }
  SpannerOptions options = SpannerOptions.newBuilder().build();
  Spanner spanner = options.getService();
  try {
    String command = args[0];
    DatabaseId db = DatabaseId.of(options.getProjectId(), args[1], args[2]);
    DatabaseClient dbClient = spanner.getDatabaseClient(db);
    DatabaseAdminClient dbAdminClient = spanner.getDatabaseAdminClient();
    switch (command) {
      case "create":
        create(dbAdminClient, db);
        break;
      case "insert":
        String insertType;
        try {
          insertType = args[3];
        } catch (ArrayIndexOutOfBoundsException exception) {
          insertType = "";
        }
        insert(dbClient, insertType);
        break;
      default:
        printUsageAndExit();
    }
  } finally {
    spanner.close();
  }
  System.out.println("Closed client");
}
 

DatabaseAdminClient getDatabaseAdminClient() {
  // [START get_dbadmin_client]
  SpannerOptions options = SpannerOptions.newBuilder().build();
  Spanner spanner = options.getService();
  DatabaseAdminClient dbAdminClient = spanner.getDatabaseAdminClient();
  // [END get_dbadmin_client]

  return dbAdminClient;
}
 

@Test
public void testEmulatorAutoConfigurationDisabled() {
	this.contextRunner
			.run(context -> {
				SpannerOptions spannerOptions = context.getBean(SpannerOptions.class);
				assertThat(spannerOptions.getEndpoint()).isEqualTo("spanner.googleapis.com:443");
			});
}
 

@Bean
@ConditionalOnMissingBean
public SpannerOptions spannerOptions() {
	Assert.notNull(this.properties.getEmulatorHost(), "`spring.cloud.gcp.spanner.emulator-host` must be set.");
	return SpannerOptions.newBuilder()
			.setProjectId(this.properties.getProjectId())
			.setCredentials(NoCredentials.getInstance())
			.setEmulatorHost(this.properties.getEmulatorHost()).build();
}
 

@Test
public void testEmulatorAutoConfigurationEnabled() {
	this.contextRunner.withPropertyValues("spring.cloud.gcp.spanner.emulator.enabled=true")
			.run(context -> {
				SpannerOptions spannerOptions = context.getBean(SpannerOptions.class);
				assertThat(spannerOptions.getEndpoint()).isEqualTo("localhost:9010");
			});
}
 

@Test
public void testEmulatorAutoConfigurationEnabledCustomHostPort() {
	this.contextRunner.withPropertyValues("spring.cloud.gcp.spanner.emulator.enabled=true",
			"spring.cloud.gcp.spanner.emulator-host=localhost:9090")
			.run(context -> {
				SpannerOptions spannerOptions = context.getBean(SpannerOptions.class);
				assertThat(spannerOptions.getEndpoint()).isEqualTo("localhost:9090");
			});
}
 

private static void createSpanner() throws IOException {
  // generate a unique instance id for this test run
  Random rnd = new Random();
  instanceId = "test-instance-" + rnd.nextInt(1000000);
  credentialsPath = getKeyFile();
  projectId = getProject();
  GoogleCredentials credentials = CloudSpannerConnection.getCredentialsFromFile(credentialsPath);
  Builder builder = SpannerOptions.newBuilder();
  builder.setProjectId(projectId);
  builder.setCredentials(credentials);
  builder.setHost(getHost());

  SpannerOptions options = builder.build();
  spanner = options.getService();
}