target.apidocs.com.google.api.services.spanner.v1.Spanner.Projects.Instances.Databases.Sessions.html Maven / Gradle / Ivy
Spanner.Projects.Instances.Databases.Sessions (Cloud Spanner API v1-rev20240711-2.0.0)
com.google.api.services.spanner.v1
Class Spanner.Projects.Instances.Databases.Sessions
- java.lang.Object
-
- com.google.api.services.spanner.v1.Spanner.Projects.Instances.Databases.Sessions
-
- Enclosing class:
- Spanner.Projects.Instances.Databases
public class Spanner.Projects.Instances.Databases.Sessions
extends Object
The "sessions" collection of methods.
-
-
Nested Class Summary
-
Constructor Summary
Constructors
Constructor and Description
Sessions()
-
Method Summary
-
-
Method Detail
-
batchCreate
public Spanner.Projects.Instances.Databases.Sessions.BatchCreate batchCreate(String database,
BatchCreateSessionsRequest content)
throws IOException
Creates multiple new sessions. This API can be used to initialize a session cache on the clients.
See https://goo.gl/TgSFN2 for best practices on session cache management.
Create a request for the method "sessions.batchCreate".
This request holds the parameters needed by the spanner server. After setting any optional
parameters, call the AbstractGoogleClientRequest.execute() method to invoke the remote operation.
- Parameters:
database - Required. The database in which the new sessions are created.content - the BatchCreateSessionsRequest- Returns:
- the request
- Throws:
IOException
-
batchWrite
public Spanner.Projects.Instances.Databases.Sessions.BatchWrite batchWrite(String session,
BatchWriteRequest content)
throws IOException
Batches the supplied mutation groups in a collection of efficient transactions. All mutations in
a group are committed atomically. However, mutations across groups can be committed non-
atomically in an unspecified order and thus, they must be independent of each other. Partial
failure is possible, i.e., some groups may have been committed successfully, while some may have
failed. The results of individual batches are streamed into the response as the batches are
applied. BatchWrite requests are not replay protected, meaning that each mutation group may be
applied more than once. Replays of non-idempotent mutations may have undesirable effects. For
example, replays of an insert mutation may produce an already exists error or if you use
generated or commit timestamp-based keys, it may result in additional rows being added to the
mutation's table. We recommend structuring your mutation groups to be idempotent to avoid this
issue.
Create a request for the method "sessions.batchWrite".
This request holds the parameters needed by the spanner server. After setting any optional
parameters, call the AbstractGoogleClientRequest.execute() method to invoke the remote operation.
- Parameters:
session - Required. The session in which the batch request is to be run.content - the BatchWriteRequest- Returns:
- the request
- Throws:
IOException
-
beginTransaction
public Spanner.Projects.Instances.Databases.Sessions.BeginTransaction beginTransaction(String session,
BeginTransactionRequest content)
throws IOException
Begins a new transaction. This step can often be skipped: Read, ExecuteSql and Commit can begin a
new transaction as a side-effect.
Create a request for the method "sessions.beginTransaction".
This request holds the parameters needed by the spanner server. After setting any optional
parameters, call the AbstractGoogleClientRequest.execute() method to invoke the remote operation.
- Parameters:
session - Required. The session in which the transaction runs.content - the BeginTransactionRequest- Returns:
- the request
- Throws:
IOException
-
commit
public Spanner.Projects.Instances.Databases.Sessions.Commit commit(String session,
CommitRequest content)
throws IOException
Commits a transaction. The request includes the mutations to be applied to rows in the database.
`Commit` might return an `ABORTED` error. This can occur at any time; commonly, the cause is
conflicts with concurrent transactions. However, it can also happen for a variety of other
reasons. If `Commit` returns `ABORTED`, the caller should re-attempt the transaction from the
beginning, re-using the same session. On very rare occasions, `Commit` might return `UNKNOWN`.
This can happen, for example, if the client job experiences a 1+ hour networking failure. At that
point, Cloud Spanner has lost track of the transaction outcome and we recommend that you perform
another read from the database to see the state of things as they are now.
Create a request for the method "sessions.commit".
This request holds the parameters needed by the spanner server. After setting any optional
parameters, call the AbstractGoogleClientRequest.execute() method to invoke the remote operation.
- Parameters:
session - Required. The session in which the transaction to be committed is running.content - the CommitRequest- Returns:
- the request
- Throws:
IOException
-
create
public Spanner.Projects.Instances.Databases.Sessions.Create create(String database,
CreateSessionRequest content)
throws IOException
Creates a new session. A session can be used to perform transactions that read and/or modify data
in a Cloud Spanner database. Sessions are meant to be reused for many consecutive transactions.
Sessions can only execute one transaction at a time. To execute multiple concurrent read-
write/write-only transactions, create multiple sessions. Note that standalone reads and queries
use a transaction internally, and count toward the one transaction limit. Active sessions use
additional server resources, so it is a good idea to delete idle and unneeded sessions. Aside
from explicit deletes, Cloud Spanner may delete sessions for which no operations are sent for
more than an hour. If a session is deleted, requests to it return `NOT_FOUND`. Idle sessions can
be kept alive by sending a trivial SQL query periodically, e.g., `"SELECT 1"`.
Create a request for the method "sessions.create".
This request holds the parameters needed by the spanner server. After setting any optional
parameters, call the AbstractGoogleClientRequest.execute() method to invoke the remote operation.
- Parameters:
database - Required. The database in which the new session is created.content - the CreateSessionRequest- Returns:
- the request
- Throws:
IOException
-
delete
public Spanner.Projects.Instances.Databases.Sessions.Delete delete(String name)
throws IOException
Ends a session, releasing server resources associated with it. This will asynchronously trigger
cancellation of any operations that are running with this session.
Create a request for the method "sessions.delete".
This request holds the parameters needed by the spanner server. After setting any optional
parameters, call the AbstractGoogleClientRequest.execute() method to invoke the remote operation.
- Parameters:
name - Required. The name of the session to delete.- Returns:
- the request
- Throws:
IOException
-
executeBatchDml
public Spanner.Projects.Instances.Databases.Sessions.ExecuteBatchDml executeBatchDml(String session,
ExecuteBatchDmlRequest content)
throws IOException
Executes a batch of SQL DML statements. This method allows many statements to be run with lower
latency than submitting them sequentially with ExecuteSql. Statements are executed in sequential
order. A request can succeed even if a statement fails. The ExecuteBatchDmlResponse.status field
in the response provides information about the statement that failed. Clients must inspect this
field to determine whether an error occurred. Execution stops after the first failed statement;
the remaining statements are not executed.
Create a request for the method "sessions.executeBatchDml".
This request holds the parameters needed by the spanner server. After setting any optional
parameters, call the AbstractGoogleClientRequest.execute() method to invoke the remote operation.
- Parameters:
session - Required. The session in which the DML statements should be performed.content - the ExecuteBatchDmlRequest- Returns:
- the request
- Throws:
IOException
-
executeSql
public Spanner.Projects.Instances.Databases.Sessions.ExecuteSql executeSql(String session,
ExecuteSqlRequest content)
throws IOException
Executes an SQL statement, returning all results in a single reply. This method cannot be used to
return a result set larger than 10 MiB; if the query yields more data than that, the query fails
with a `FAILED_PRECONDITION` error. Operations inside read-write transactions might return
`ABORTED`. If this occurs, the application should restart the transaction from the beginning. See
Transaction for more details. Larger result sets can be fetched in streaming fashion by calling
ExecuteStreamingSql instead.
Create a request for the method "sessions.executeSql".
This request holds the parameters needed by the spanner server. After setting any optional
parameters, call the AbstractGoogleClientRequest.execute() method to invoke the remote operation.
- Parameters:
session - Required. The session in which the SQL query should be performed.content - the ExecuteSqlRequest- Returns:
- the request
- Throws:
IOException
-
executeStreamingSql
public Spanner.Projects.Instances.Databases.Sessions.ExecuteStreamingSql executeStreamingSql(String session,
ExecuteSqlRequest content)
throws IOException
Like ExecuteSql, except returns the result set as a stream. Unlike ExecuteSql, there is no limit
on the size of the returned result set. However, no individual row in the result set can exceed
100 MiB, and no column value can exceed 10 MiB.
Create a request for the method "sessions.executeStreamingSql".
This request holds the parameters needed by the spanner server. After setting any optional
parameters, call the AbstractGoogleClientRequest.execute() method to invoke the remote operation.
- Parameters:
session - Required. The session in which the SQL query should be performed.content - the ExecuteSqlRequest- Returns:
- the request
- Throws:
IOException
-
get
public Spanner.Projects.Instances.Databases.Sessions.Get get(String name)
throws IOException
Gets a session. Returns `NOT_FOUND` if the session does not exist. This is mainly useful for
determining whether a session is still alive.
Create a request for the method "sessions.get".
This request holds the parameters needed by the spanner server. After setting any optional
parameters, call the AbstractGoogleClientRequest.execute() method to invoke the remote operation.
- Parameters:
name - Required. The name of the session to retrieve.- Returns:
- the request
- Throws:
IOException
-
list
public Spanner.Projects.Instances.Databases.Sessions.List list(String database)
throws IOException
Lists all sessions in a given database.
Create a request for the method "sessions.list".
This request holds the parameters needed by the spanner server. After setting any optional
parameters, call the AbstractGoogleClientRequest.execute() method to invoke the remote operation.
- Parameters:
database - Required. The database in which to list sessions.- Returns:
- the request
- Throws:
IOException
-
partitionQuery
public Spanner.Projects.Instances.Databases.Sessions.PartitionQuery partitionQuery(String session,
PartitionQueryRequest content)
throws IOException
Creates a set of partition tokens that can be used to execute a query operation in parallel. Each
of the returned partition tokens can be used by ExecuteStreamingSql to specify a subset of the
query result to read. The same session and read-only transaction must be used by the
PartitionQueryRequest used to create the partition tokens and the ExecuteSqlRequests that use the
partition tokens. Partition tokens become invalid when the session used to create them is
deleted, is idle for too long, begins a new transaction, or becomes too old. When any of these
happen, it is not possible to resume the query, and the whole operation must be restarted from
the beginning.
Create a request for the method "sessions.partitionQuery".
This request holds the parameters needed by the spanner server. After setting any optional
parameters, call the AbstractGoogleClientRequest.execute() method to invoke the remote operation.
- Parameters:
session - Required. The session used to create the partitions.content - the PartitionQueryRequest- Returns:
- the request
- Throws:
IOException
-
partitionRead
public Spanner.Projects.Instances.Databases.Sessions.PartitionRead partitionRead(String session,
PartitionReadRequest content)
throws IOException
Creates a set of partition tokens that can be used to execute a read operation in parallel. Each
of the returned partition tokens can be used by StreamingRead to specify a subset of the read
result to read. The same session and read-only transaction must be used by the
PartitionReadRequest used to create the partition tokens and the ReadRequests that use the
partition tokens. There are no ordering guarantees on rows returned among the returned partition
tokens, or even within each individual StreamingRead call issued with a partition_token.
Partition tokens become invalid when the session used to create them is deleted, is idle for too
long, begins a new transaction, or becomes too old. When any of these happen, it is not possible
to resume the read, and the whole operation must be restarted from the beginning.
Create a request for the method "sessions.partitionRead".
This request holds the parameters needed by the spanner server. After setting any optional
parameters, call the AbstractGoogleClientRequest.execute() method to invoke the remote operation.
- Parameters:
session - Required. The session used to create the partitions.content - the PartitionReadRequest- Returns:
- the request
- Throws:
IOException
-
read
public Spanner.Projects.Instances.Databases.Sessions.Read read(String session,
ReadRequest content)
throws IOException
Reads rows from the database using key lookups and scans, as a simple key/value style alternative
to ExecuteSql. This method cannot be used to return a result set larger than 10 MiB; if the read
matches more data than that, the read fails with a `FAILED_PRECONDITION` error. Reads inside
read-write transactions might return `ABORTED`. If this occurs, the application should restart
the transaction from the beginning. See Transaction for more details. Larger result sets can be
yielded in streaming fashion by calling StreamingRead instead.
Create a request for the method "sessions.read".
This request holds the parameters needed by the spanner server. After setting any optional
parameters, call the AbstractGoogleClientRequest.execute() method to invoke the remote operation.
- Parameters:
session - Required. The session in which the read should be performed.content - the ReadRequest- Returns:
- the request
- Throws:
IOException
-
rollback
public Spanner.Projects.Instances.Databases.Sessions.Rollback rollback(String session,
RollbackRequest content)
throws IOException
Rolls back a transaction, releasing any locks it holds. It is a good idea to call this for any
transaction that includes one or more Read or ExecuteSql requests and ultimately decides not to
commit. `Rollback` returns `OK` if it successfully aborts the transaction, the transaction was
already aborted, or the transaction is not found. `Rollback` never returns `ABORTED`.
Create a request for the method "sessions.rollback".
This request holds the parameters needed by the spanner server. After setting any optional
parameters, call the AbstractGoogleClientRequest.execute() method to invoke the remote operation.
- Parameters:
session - Required. The session in which the transaction to roll back is running.content - the RollbackRequest- Returns:
- the request
- Throws:
IOException
-
streamingRead
public Spanner.Projects.Instances.Databases.Sessions.StreamingRead streamingRead(String session,
ReadRequest content)
throws IOException
Like Read, except returns the result set as a stream. Unlike Read, there is no limit on the size
of the returned result set. However, no individual row in the result set can exceed 100 MiB, and
no column value can exceed 10 MiB.
Create a request for the method "sessions.streamingRead".
This request holds the parameters needed by the spanner server. After setting any optional
parameters, call the AbstractGoogleClientRequest.execute() method to invoke the remote operation.
- Parameters:
session - Required. The session in which the read should be performed.content - the ReadRequest- Returns:
- the request
- Throws:
IOException
Copyright © 2011–2024 Google. All rights reserved.
© 2015 - 2024 Weber Informatics LLC | Privacy Policy