Cloud Spanner V1 Client - Class SpannerClient (1.91.0)

use Google\ApiCore\ApiException;
use Google\Cloud\Spanner\V1\BatchCreateSessionsRequest;
use Google\Cloud\Spanner\V1\BatchCreateSessionsResponse;
use Google\Cloud\Spanner\V1\Client\SpannerClient;

/**
 * @param string $formattedDatabase The database in which the new sessions are created. Please see
 *                                  {@see SpannerClient::databaseName()} for help formatting this field.
 * @param int    $sessionCount      The number of sessions to be created in this batch call.
 *                                  The API may return fewer than the requested number of sessions. If a
 *                                  specific number of sessions are desired, the client can make additional
 *                                  calls to BatchCreateSessions (adjusting
 *                                  [session_count][google.spanner.v1.BatchCreateSessionsRequest.session_count]
 *                                  as necessary).
 */
function batch_create_sessions_sample(string $formattedDatabase, int $sessionCount): void
{
    // Create a client.
    $spannerClient = new SpannerClient();

    // Prepare the request message.
    $request = (new BatchCreateSessionsRequest())
        ->setDatabase($formattedDatabase)
        ->setSessionCount($sessionCount);

    // Call the API and handle any network failures.
    try {
        /** @var BatchCreateSessionsResponse $response */
        $response = $spannerClient->batchCreateSessions($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedDatabase = SpannerClient::databaseName('[PROJECT]', '[INSTANCE]', '[DATABASE]');
    $sessionCount = 0;

    batch_create_sessions_sample($formattedDatabase, $sessionCount);
}

use Google\ApiCore\ApiException;
use Google\ApiCore\ServerStream;
use Google\Cloud\Spanner\V1\BatchWriteRequest;
use Google\Cloud\Spanner\V1\BatchWriteRequest\MutationGroup;
use Google\Cloud\Spanner\V1\BatchWriteResponse;
use Google\Cloud\Spanner\V1\Client\SpannerClient;
use Google\Cloud\Spanner\V1\Mutation;

/**
 * @param string $formattedSession The session in which the batch request is to be run. Please see
 *                                 {@see SpannerClient::sessionName()} for help formatting this field.
 */
function batch_write_sample(string $formattedSession): void
{
    // Create a client.
    $spannerClient = new SpannerClient();

    // Prepare the request message.
    $mutationGroupsMutations = [new Mutation()];
    $mutationGroup = (new MutationGroup())
        ->setMutations($mutationGroupsMutations);
    $mutationGroups = [$mutationGroup,];
    $request = (new BatchWriteRequest())
        ->setSession($formattedSession)
        ->setMutationGroups($mutationGroups);

    // Call the API and handle any network failures.
    try {
        /** @var ServerStream $stream */
        $stream = $spannerClient->batchWrite($request);

        /** @var BatchWriteResponse $element */
        foreach ($stream->readAll() as $element) {
            printf('Element data: %s' . PHP_EOL, $element->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedSession = SpannerClient::sessionName(
        '[PROJECT]',
        '[INSTANCE]',
        '[DATABASE]',
        '[SESSION]'
    );

    batch_write_sample($formattedSession);
}

use Google\ApiCore\ApiException;
use Google\Cloud\Spanner\V1\BeginTransactionRequest;
use Google\Cloud\Spanner\V1\Client\SpannerClient;
use Google\Cloud\Spanner\V1\Transaction;
use Google\Cloud\Spanner\V1\TransactionOptions;

/**
 * @param string $formattedSession The session in which the transaction runs. Please see
 *                                 {@see SpannerClient::sessionName()} for help formatting this field.
 */
function begin_transaction_sample(string $formattedSession): void
{
    // Create a client.
    $spannerClient = new SpannerClient();

    // Prepare the request message.
    $options = new TransactionOptions();
    $request = (new BeginTransactionRequest())
        ->setSession($formattedSession)
        ->setOptions($options);

    // Call the API and handle any network failures.
    try {
        /** @var Transaction $response */
        $response = $spannerClient->beginTransaction($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedSession = SpannerClient::sessionName(
        '[PROJECT]',
        '[INSTANCE]',
        '[DATABASE]',
        '[SESSION]'
    );

    begin_transaction_sample($formattedSession);
}

use Google\ApiCore\ApiException;
use Google\Cloud\Spanner\V1\Client\SpannerClient;
use Google\Cloud\Spanner\V1\CommitRequest;
use Google\Cloud\Spanner\V1\CommitResponse;
use Google\Cloud\Spanner\V1\Mutation;

/**
 * @param string $formattedSession The session in which the transaction to be committed is running. Please see
 *                                 {@see SpannerClient::sessionName()} for help formatting this field.
 */
function commit_sample(string $formattedSession): void
{
    // Create a client.
    $spannerClient = new SpannerClient();

    // Prepare the request message.
    $mutations = [new Mutation()];
    $request = (new CommitRequest())
        ->setSession($formattedSession)
        ->setMutations($mutations);

    // Call the API and handle any network failures.
    try {
        /** @var CommitResponse $response */
        $response = $spannerClient->commit($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedSession = SpannerClient::sessionName(
        '[PROJECT]',
        '[INSTANCE]',
        '[DATABASE]',
        '[SESSION]'
    );

    commit_sample($formattedSession);
}

use Google\ApiCore\ApiException;
use Google\Cloud\Spanner\V1\Client\SpannerClient;
use Google\Cloud\Spanner\V1\CreateSessionRequest;
use Google\Cloud\Spanner\V1\Session;

/**
 * @param string $formattedDatabase The database in which the new session is created. Please see
 *                                  {@see SpannerClient::databaseName()} for help formatting this field.
 */
function create_session_sample(string $formattedDatabase): void
{
    // Create a client.
    $spannerClient = new SpannerClient();

    // Prepare the request message.
    $request = (new CreateSessionRequest())
        ->setDatabase($formattedDatabase);

    // Call the API and handle any network failures.
    try {
        /** @var Session $response */
        $response = $spannerClient->createSession($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedDatabase = SpannerClient::databaseName('[PROJECT]', '[INSTANCE]', '[DATABASE]');

    create_session_sample($formattedDatabase);
}

use Google\ApiCore\ApiException;
use Google\Cloud\Spanner\V1\Client\SpannerClient;
use Google\Cloud\Spanner\V1\DeleteSessionRequest;

/**
 * @param string $formattedName The name of the session to delete. Please see
 *                              {@see SpannerClient::sessionName()} for help formatting this field.
 */
function delete_session_sample(string $formattedName): void
{
    // Create a client.
    $spannerClient = new SpannerClient();

    // Prepare the request message.
    $request = (new DeleteSessionRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        $spannerClient->deleteSession($request);
        printf('Call completed successfully.' . PHP_EOL);
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = SpannerClient::sessionName('[PROJECT]', '[INSTANCE]', '[DATABASE]', '[SESSION]');

    delete_session_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\Cloud\Spanner\V1\Client\SpannerClient;
use Google\Cloud\Spanner\V1\ExecuteBatchDmlRequest;
use Google\Cloud\Spanner\V1\ExecuteBatchDmlRequest\Statement;
use Google\Cloud\Spanner\V1\ExecuteBatchDmlResponse;
use Google\Cloud\Spanner\V1\TransactionSelector;

/**
 * @param string $formattedSession The session in which the DML statements should be performed. Please see
 *                                 {@see SpannerClient::sessionName()} for help formatting this field.
 * @param string $statementsSql    The DML string.
 * @param int    $seqno            A per-transaction sequence number used to identify this request.
 *                                 This field makes each request idempotent such that if the request is
 *                                 received multiple times, at most one will succeed.
 *
 *                                 The sequence number must be monotonically increasing within the
 *                                 transaction. If a request arrives for the first time with an out-of-order
 *                                 sequence number, the transaction may be aborted. Replays of previously
 *                                 handled requests will yield the same response as the first execution.
 */
function execute_batch_dml_sample(
    string $formattedSession,
    string $statementsSql,
    int $seqno
): void {
    // Create a client.
    $spannerClient = new SpannerClient();

    // Prepare the request message.
    $transaction = new TransactionSelector();
    $statement = (new Statement())
        ->setSql($statementsSql);
    $statements = [$statement,];
    $request = (new ExecuteBatchDmlRequest())
        ->setSession($formattedSession)
        ->setTransaction($transaction)
        ->setStatements($statements)
        ->setSeqno($seqno);

    // Call the API and handle any network failures.
    try {
        /** @var ExecuteBatchDmlResponse $response */
        $response = $spannerClient->executeBatchDml($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedSession = SpannerClient::sessionName(
        '[PROJECT]',
        '[INSTANCE]',
        '[DATABASE]',
        '[SESSION]'
    );
    $statementsSql = '[SQL]';
    $seqno = 0;

    execute_batch_dml_sample($formattedSession, $statementsSql, $seqno);
}

use Google\ApiCore\ApiException;
use Google\Cloud\Spanner\V1\Client\SpannerClient;
use Google\Cloud\Spanner\V1\ExecuteSqlRequest;
use Google\Cloud\Spanner\V1\ResultSet;

/**
 * @param string $formattedSession The session in which the SQL query should be performed. Please see
 *                                 {@see SpannerClient::sessionName()} for help formatting this field.
 * @param string $sql              The SQL string.
 */
function execute_sql_sample(string $formattedSession, string $sql): void
{
    // Create a client.
    $spannerClient = new SpannerClient();

    // Prepare the request message.
    $request = (new ExecuteSqlRequest())
        ->setSession($formattedSession)
        ->setSql($sql);

    // Call the API and handle any network failures.
    try {
        /** @var ResultSet $response */
        $response = $spannerClient->executeSql($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedSession = SpannerClient::sessionName(
        '[PROJECT]',
        '[INSTANCE]',
        '[DATABASE]',
        '[SESSION]'
    );
    $sql = '[SQL]';

    execute_sql_sample($formattedSession, $sql);
}

use Google\ApiCore\ApiException;
use Google\ApiCore\ServerStream;
use Google\Cloud\Spanner\V1\Client\SpannerClient;
use Google\Cloud\Spanner\V1\ExecuteSqlRequest;
use Google\Cloud\Spanner\V1\PartialResultSet;

/**
 * @param string $formattedSession The session in which the SQL query should be performed. Please see
 *                                 {@see SpannerClient::sessionName()} for help formatting this field.
 * @param string $sql              The SQL string.
 */
function execute_streaming_sql_sample(string $formattedSession, string $sql): void
{
    // Create a client.
    $spannerClient = new SpannerClient();

    // Prepare the request message.
    $request = (new ExecuteSqlRequest())
        ->setSession($formattedSession)
        ->setSql($sql);

    // Call the API and handle any network failures.
    try {
        /** @var ServerStream $stream */
        $stream = $spannerClient->executeStreamingSql($request);

        /** @var PartialResultSet $element */
        foreach ($stream->readAll() as $element) {
            printf('Element data: %s' . PHP_EOL, $element->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedSession = SpannerClient::sessionName(
        '[PROJECT]',
        '[INSTANCE]',
        '[DATABASE]',
        '[SESSION]'
    );
    $sql = '[SQL]';

    execute_streaming_sql_sample($formattedSession, $sql);
}

use Google\ApiCore\ApiException;
use Google\Cloud\Spanner\V1\Client\SpannerClient;
use Google\Cloud\Spanner\V1\GetSessionRequest;
use Google\Cloud\Spanner\V1\Session;

/**
 * @param string $formattedName The name of the session to retrieve. Please see
 *                              {@see SpannerClient::sessionName()} for help formatting this field.
 */
function get_session_sample(string $formattedName): void
{
    // Create a client.
    $spannerClient = new SpannerClient();

    // Prepare the request message.
    $request = (new GetSessionRequest())
        ->setName($formattedName);

    // Call the API and handle any network failures.
    try {
        /** @var Session $response */
        $response = $spannerClient->getSession($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedName = SpannerClient::sessionName('[PROJECT]', '[INSTANCE]', '[DATABASE]', '[SESSION]');

    get_session_sample($formattedName);
}

use Google\ApiCore\ApiException;
use Google\ApiCore\PagedListResponse;
use Google\Cloud\Spanner\V1\Client\SpannerClient;
use Google\Cloud\Spanner\V1\ListSessionsRequest;
use Google\Cloud\Spanner\V1\Session;

/**
 * @param string $formattedDatabase The database in which to list sessions. Please see
 *                                  {@see SpannerClient::databaseName()} for help formatting this field.
 */
function list_sessions_sample(string $formattedDatabase): void
{
    // Create a client.
    $spannerClient = new SpannerClient();

    // Prepare the request message.
    $request = (new ListSessionsRequest())
        ->setDatabase($formattedDatabase);

    // Call the API and handle any network failures.
    try {
        /** @var PagedListResponse $response */
        $response = $spannerClient->listSessions($request);

        /** @var Session $element */
        foreach ($response as $element) {
            printf('Element data: %s' . PHP_EOL, $element->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedDatabase = SpannerClient::databaseName('[PROJECT]', '[INSTANCE]', '[DATABASE]');

    list_sessions_sample($formattedDatabase);
}

use Google\ApiCore\ApiException;
use Google\Cloud\Spanner\V1\Client\SpannerClient;
use Google\Cloud\Spanner\V1\PartitionQueryRequest;
use Google\Cloud\Spanner\V1\PartitionResponse;

/**
 * @param string $formattedSession The session used to create the partitions. Please see
 *                                 {@see SpannerClient::sessionName()} for help formatting this field.
 * @param string $sql              The query request to generate partitions for. The request will
 *                                 fail if the query is not root partitionable. For a query to be root
 *                                 partitionable, it needs to satisfy a few conditions. For example, if the
 *                                 query execution plan contains a distributed union operator, then it must be
 *                                 the first operator in the plan. For more information about other
 *                                 conditions, see [Read data in
 *                                 parallel](https://cloud.google.com/spanner/docs/reads#read_data_in_parallel).
 *
 *                                 The query request must not contain DML commands, such as INSERT, UPDATE, or
 *                                 DELETE. Use
 *                                 [ExecuteStreamingSql][google.spanner.v1.Spanner.ExecuteStreamingSql] with a
 *                                 PartitionedDml transaction for large, partition-friendly DML operations.
 */
function partition_query_sample(string $formattedSession, string $sql): void
{
    // Create a client.
    $spannerClient = new SpannerClient();

    // Prepare the request message.
    $request = (new PartitionQueryRequest())
        ->setSession($formattedSession)
        ->setSql($sql);

    // Call the API and handle any network failures.
    try {
        /** @var PartitionResponse $response */
        $response = $spannerClient->partitionQuery($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedSession = SpannerClient::sessionName(
        '[PROJECT]',
        '[INSTANCE]',
        '[DATABASE]',
        '[SESSION]'
    );
    $sql = '[SQL]';

    partition_query_sample($formattedSession, $sql);
}

use Google\ApiCore\ApiException;
use Google\Cloud\Spanner\V1\Client\SpannerClient;
use Google\Cloud\Spanner\V1\KeySet;
use Google\Cloud\Spanner\V1\PartitionReadRequest;
use Google\Cloud\Spanner\V1\PartitionResponse;

/**
 * @param string $formattedSession The session used to create the partitions. Please see
 *                                 {@see SpannerClient::sessionName()} for help formatting this field.
 * @param string $table            The name of the table in the database to be read.
 */
function partition_read_sample(string $formattedSession, string $table): void
{
    // Create a client.
    $spannerClient = new SpannerClient();

    // Prepare the request message.
    $keySet = new KeySet();
    $request = (new PartitionReadRequest())
        ->setSession($formattedSession)
        ->setTable($table)
        ->setKeySet($keySet);

    // Call the API and handle any network failures.
    try {
        /** @var PartitionResponse $response */
        $response = $spannerClient->partitionRead($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedSession = SpannerClient::sessionName(
        '[PROJECT]',
        '[INSTANCE]',
        '[DATABASE]',
        '[SESSION]'
    );
    $table = '[TABLE]';

    partition_read_sample($formattedSession, $table);
}

use Google\ApiCore\ApiException;
use Google\Cloud\Spanner\V1\Client\SpannerClient;
use Google\Cloud\Spanner\V1\KeySet;
use Google\Cloud\Spanner\V1\ReadRequest;
use Google\Cloud\Spanner\V1\ResultSet;

/**
 * @param string $formattedSession The session in which the read should be performed. Please see
 *                                 {@see SpannerClient::sessionName()} for help formatting this field.
 * @param string $table            The name of the table in the database to be read.
 * @param string $columnsElement   The columns of [table][google.spanner.v1.ReadRequest.table] to be
 *                                 returned for each row matching this request.
 */
function read_sample(string $formattedSession, string $table, string $columnsElement): void
{
    // Create a client.
    $spannerClient = new SpannerClient();

    // Prepare the request message.
    $columns = [$columnsElement,];
    $keySet = new KeySet();
    $request = (new ReadRequest())
        ->setSession($formattedSession)
        ->setTable($table)
        ->setColumns($columns)
        ->setKeySet($keySet);

    // Call the API and handle any network failures.
    try {
        /** @var ResultSet $response */
        $response = $spannerClient->read($request);
        printf('Response data: %s' . PHP_EOL, $response->serializeToJsonString());
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedSession = SpannerClient::sessionName(
        '[PROJECT]',
        '[INSTANCE]',
        '[DATABASE]',
        '[SESSION]'
    );
    $table = '[TABLE]';
    $columnsElement = '[COLUMNS]';

    read_sample($formattedSession, $table, $columnsElement);
}

use Google\ApiCore\ApiException;
use Google\Cloud\Spanner\V1\Client\SpannerClient;
use Google\Cloud\Spanner\V1\RollbackRequest;

/**
 * @param string $formattedSession The session in which the transaction to roll back is running. Please see
 *                                 {@see SpannerClient::sessionName()} for help formatting this field.
 * @param string $transactionId    The transaction to roll back.
 */
function rollback_sample(string $formattedSession, string $transactionId): void
{
    // Create a client.
    $spannerClient = new SpannerClient();

    // Prepare the request message.
    $request = (new RollbackRequest())
        ->setSession($formattedSession)
        ->setTransactionId($transactionId);

    // Call the API and handle any network failures.
    try {
        $spannerClient->rollback($request);
        printf('Call completed successfully.' . PHP_EOL);
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedSession = SpannerClient::sessionName(
        '[PROJECT]',
        '[INSTANCE]',
        '[DATABASE]',
        '[SESSION]'
    );
    $transactionId = '...';

    rollback_sample($formattedSession, $transactionId);
}

use Google\ApiCore\ApiException;
use Google\ApiCore\ServerStream;
use Google\Cloud\Spanner\V1\Client\SpannerClient;
use Google\Cloud\Spanner\V1\KeySet;
use Google\Cloud\Spanner\V1\PartialResultSet;
use Google\Cloud\Spanner\V1\ReadRequest;

/**
 * @param string $formattedSession The session in which the read should be performed. Please see
 *                                 {@see SpannerClient::sessionName()} for help formatting this field.
 * @param string $table            The name of the table in the database to be read.
 * @param string $columnsElement   The columns of [table][google.spanner.v1.ReadRequest.table] to be
 *                                 returned for each row matching this request.
 */
function streaming_read_sample(
    string $formattedSession,
    string $table,
    string $columnsElement
): void {
    // Create a client.
    $spannerClient = new SpannerClient();

    // Prepare the request message.
    $columns = [$columnsElement,];
    $keySet = new KeySet();
    $request = (new ReadRequest())
        ->setSession($formattedSession)
        ->setTable($table)
        ->setColumns($columns)
        ->setKeySet($keySet);

    // Call the API and handle any network failures.
    try {
        /** @var ServerStream $stream */
        $stream = $spannerClient->streamingRead($request);

        /** @var PartialResultSet $element */
        foreach ($stream->readAll() as $element) {
            printf('Element data: %s' . PHP_EOL, $element->serializeToJsonString());
        }
    } catch (ApiException $ex) {
        printf('Call failed with message: %s' . PHP_EOL, $ex->getMessage());
    }
}

/**
 * Helper to execute the sample.
 *
 * This sample has been automatically generated and should be regarded as a code
 * template only. It will require modifications to work:
 *  - It may require correct/in-range values for request initialization.
 *  - It may require specifying regional endpoints when creating the service client,
 *    please see the apiEndpoint client configuration option for more details.
 */
function callSample(): void
{
    $formattedSession = SpannerClient::sessionName(
        '[PROJECT]',
        '[INSTANCE]',
        '[DATABASE]',
        '[SESSION]'
    );
    $table = '[TABLE]';
    $columnsElement = '[COLUMNS]';

    streaming_read_sample($formattedSession, $table, $columnsElement);
}