# Generated by the protocol buffer compiler.  DO NOT EDIT!
# Source: google/spanner/v1/spanner.proto for package 'google.spanner.v1'
# Original file comments:
# Copyright 2019 Google LLC.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
#


require 'grpc'
require 'google/spanner/v1/spanner_pb'

module Google
  module Spanner
    module V1
      module Spanner
        # Cloud Spanner API
        #
        # The Cloud Spanner API can be used to manage sessions and execute
        # transactions on data stored in Cloud Spanner databases.
        class Service

          include GRPC::GenericService

          self.marshal_class_method = :encode
          self.unmarshal_class_method = :decode
          self.service_name = 'google.spanner.v1.Spanner'

          # 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.
          #
          # Cloud Spanner limits the number of sessions that can exist at any given
          # time; thus, it is a good idea to delete idle and/or unneeded sessions.
          # Aside from explicit deletes, Cloud Spanner can 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"`.
          rpc :CreateSession, CreateSessionRequest, Session
          # 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.
          rpc :BatchCreateSessions, BatchCreateSessionsRequest, BatchCreateSessionsResponse
          # Gets a session. Returns `NOT_FOUND` if the session does not exist.
          # This is mainly useful for determining whether a session is still
          # alive.
          rpc :GetSession, GetSessionRequest, Session
          # Lists all sessions in a given database.
          rpc :ListSessions, ListSessionsRequest, ListSessionsResponse
          # Ends a session, releasing server resources associated with it. This will
          # asynchronously trigger cancellation of any operations that are running with
          # this session.
          rpc :DeleteSession, DeleteSessionRequest, Google::Protobuf::Empty
          # 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][google.spanner.v1.Transaction] for more
          # details.
          #
          # Larger result sets can be fetched in streaming fashion by calling
          # [ExecuteStreamingSql][google.spanner.v1.Spanner.ExecuteStreamingSql]
          # instead.
          rpc :ExecuteSql, ExecuteSqlRequest, ResultSet
          # Like [ExecuteSql][google.spanner.v1.Spanner.ExecuteSql], except returns the
          # result set as a stream. Unlike
          # [ExecuteSql][google.spanner.v1.Spanner.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.
          rpc :ExecuteStreamingSql, ExecuteSqlRequest, stream(PartialResultSet)
          # Executes a batch of SQL DML statements. This method allows many statements
          # to be run with lower latency than submitting them sequentially with
          # [ExecuteSql][google.spanner.v1.Spanner.ExecuteSql].
          #
          # Statements are executed in order, sequentially.
          # [ExecuteBatchDmlResponse][Spanner.ExecuteBatchDmlResponse] will contain a
          # [ResultSet][google.spanner.v1.ResultSet] for each DML statement that has
          # successfully executed. If a statement fails, its error status will be
          # returned as part of the
          # [ExecuteBatchDmlResponse][Spanner.ExecuteBatchDmlResponse]. Execution will
          # stop at the first failed statement; the remaining statements will not run.
          #
          # ExecuteBatchDml is expected to return an OK status with a response even if
          # there was an error while processing one of the DML statements. Clients must
          # inspect response.status to determine if there were any errors while
          # processing the request.
          #
          # See more details in
          # [ExecuteBatchDmlRequest][Spanner.ExecuteBatchDmlRequest] and
          # [ExecuteBatchDmlResponse][Spanner.ExecuteBatchDmlResponse].
          rpc :ExecuteBatchDml, ExecuteBatchDmlRequest, ExecuteBatchDmlResponse
          # Reads rows from the database using key lookups and scans, as a
          # simple key/value style alternative to
          # [ExecuteSql][google.spanner.v1.Spanner.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][google.spanner.v1.Transaction] for more
          # details.
          #
          # Larger result sets can be yielded in streaming fashion by calling
          # [StreamingRead][google.spanner.v1.Spanner.StreamingRead] instead.
          rpc :Read, ReadRequest, ResultSet
          # Like [Read][google.spanner.v1.Spanner.Read], except returns the result set
          # as a stream. Unlike [Read][google.spanner.v1.Spanner.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.
          rpc :StreamingRead, ReadRequest, stream(PartialResultSet)
          # Begins a new transaction. This step can often be skipped:
          # [Read][google.spanner.v1.Spanner.Read],
          # [ExecuteSql][google.spanner.v1.Spanner.ExecuteSql] and
          # [Commit][google.spanner.v1.Spanner.Commit] can begin a new transaction as a
          # side-effect.
          rpc :BeginTransaction, BeginTransactionRequest, Transaction
          # 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.
          rpc :Commit, CommitRequest, CommitResponse
          # 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][google.spanner.v1.Spanner.Read] or
          # [ExecuteSql][google.spanner.v1.Spanner.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`.
          rpc :Rollback, RollbackRequest, Google::Protobuf::Empty
          # 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][google.spanner.v1.Spanner.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.
          rpc :PartitionQuery, PartitionQueryRequest, PartitionResponse
          # 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][google.spanner.v1.Spanner.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.
          rpc :PartitionRead, PartitionReadRequest, PartitionResponse
        end

        Stub = Service.rpc_stub_class
      end
    end
  end
end
