google-cloud-spanner 0.21.0

data/lib/google/cloud/spanner/v1.rb

@@ -0,0 +1,17 @@
+
+# Copyright 2016 Google Inc. All rights reserved.
+#
+# 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 "google/cloud/spanner/v1/spanner_client"

data/lib/google/cloud/spanner/v1/doc/google/protobuf/duration.rb

@@ -0,0 +1,77 @@
+# Copyright 2017, Google Inc. All rights reserved.
+#
+# 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.
+
+module Google
+  module Protobuf
+    # A Duration represents a signed, fixed-length span of time represented
+    # as a count of seconds and fractions of seconds at nanosecond
+    # resolution. It is independent of any calendar and concepts like "day"
+    # or "month". It is related to Timestamp in that the difference between
+    # two Timestamp values is a Duration and it can be added or subtracted
+    # from a Timestamp. Range is approximately +-10,000 years.
+    #
+    # Example 1: Compute Duration from two Timestamps in pseudo code.
+    #
+    #     Timestamp start = ...;
+    #     Timestamp end = ...;
+    #     Duration duration = ...;
+    #
+    #     duration.seconds = end.seconds - start.seconds;
+    #     duration.nanos = end.nanos - start.nanos;
+    #
+    #     if (duration.seconds < 0 && duration.nanos > 0) {
+    #       duration.seconds += 1;
+    #       duration.nanos -= 1000000000;
+    #     } else if (durations.seconds > 0 && duration.nanos < 0) {
+    #       duration.seconds -= 1;
+    #       duration.nanos += 1000000000;
+    #     }
+    #
+    # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
+    #
+    #     Timestamp start = ...;
+    #     Duration duration = ...;
+    #     Timestamp end = ...;
+    #
+    #     end.seconds = start.seconds + duration.seconds;
+    #     end.nanos = start.nanos + duration.nanos;
+    #
+    #     if (end.nanos < 0) {
+    #       end.seconds -= 1;
+    #       end.nanos += 1000000000;
+    #     } else if (end.nanos >= 1000000000) {
+    #       end.seconds += 1;
+    #       end.nanos -= 1000000000;
+    #     }
+    #
+    # Example 3: Compute Duration from datetime.timedelta in Python.
+    #
+    #     td = datetime.timedelta(days=3, minutes=10)
+    #     duration = Duration()
+    #     duration.FromTimedelta(td)
+    # @!attribute [rw] seconds
+    #   @return [Integer]
+    #     Signed seconds of the span of time. Must be from -315,576,000,000
+    #     to +315,576,000,000 inclusive.
+    # @!attribute [rw] nanos
+    #   @return [Integer]
+    #     Signed fractions of a second at nanosecond resolution of the span
+    #     of time. Durations less than one second are represented with a 0
+    #     +seconds+ field and a positive or negative +nanos+ field. For durations
+    #     of one second or more, a non-zero value for the +nanos+ field must be
+    #     of the same sign as the +seconds+ field. Must be from -999,999,999
+    #     to +999,999,999 inclusive.
+    class Duration; end
+  end
+end

data/lib/google/cloud/spanner/v1/doc/google/protobuf/struct.rb

@@ -0,0 +1,73 @@
+# Copyright 2017, Google Inc. All rights reserved.
+#
+# 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.
+
+module Google
+  module Protobuf
+    # +Struct+ represents a structured data value, consisting of fields
+    # which map to dynamically typed values. In some languages, +Struct+
+    # might be supported by a native representation. For example, in
+    # scripting languages like JS a struct is represented as an
+    # object. The details of that representation are described together
+    # with the proto support for the language.
+    #
+    # The JSON representation for +Struct+ is JSON object.
+    # @!attribute [rw] fields
+    #   @return [Hash{String => Google::Protobuf::Value}]
+    #     Unordered map of dynamically typed values.
+    class Struct; end
+
+    # +Value+ represents a dynamically typed value which can be either
+    # null, a number, a string, a boolean, a recursive struct value, or a
+    # list of values. A producer of value is expected to set one of that
+    # variants, absence of any variant indicates an error.
+    #
+    # The JSON representation for +Value+ is JSON value.
+    # @!attribute [rw] null_value
+    #   @return [Google::Protobuf::NullValue]
+    #     Represents a null value.
+    # @!attribute [rw] number_value
+    #   @return [Float]
+    #     Represents a double value.
+    # @!attribute [rw] string_value
+    #   @return [String]
+    #     Represents a string value.
+    # @!attribute [rw] bool_value
+    #   @return [true, false]
+    #     Represents a boolean value.
+    # @!attribute [rw] struct_value
+    #   @return [Google::Protobuf::Struct]
+    #     Represents a structured value.
+    # @!attribute [rw] list_value
+    #   @return [Google::Protobuf::ListValue]
+    #     Represents a repeated +Value+.
+    class Value; end
+
+    # +ListValue+ is a wrapper around a repeated field of values.
+    #
+    # The JSON representation for +ListValue+ is JSON array.
+    # @!attribute [rw] values
+    #   @return [Array<Google::Protobuf::Value>]
+    #     Repeated field of dynamically typed values.
+    class ListValue; end
+
+    # +NullValue+ is a singleton enumeration to represent the null value for the
+    # +Value+ type union.
+    #
+    #  The JSON representation for +NullValue+ is JSON +null+.
+    module NullValue
+      # Null value.
+      NULL_VALUE = 0
+    end
+  end
+end

data/lib/google/cloud/spanner/v1/doc/google/protobuf/timestamp.rb

@@ -0,0 +1,81 @@
+# Copyright 2017, Google Inc. All rights reserved.
+#
+# 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.
+
+module Google
+  module Protobuf
+    # A Timestamp represents a point in time independent of any time zone
+    # or calendar, represented as seconds and fractions of seconds at
+    # nanosecond resolution in UTC Epoch time. It is encoded using the
+    # Proleptic Gregorian Calendar which extends the Gregorian calendar
+    # backwards to year one. It is encoded assuming all minutes are 60
+    # seconds long, i.e. leap seconds are "smeared" so that no leap second
+    # table is needed for interpretation. Range is from
+    # 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z.
+    # By restricting to that range, we ensure that we can convert to
+    # and from  RFC 3339 date strings.
+    # See {https://www.ietf.org/rfc/rfc3339.txt}[https://www.ietf.org/rfc/rfc3339.txt].
+    #
+    # Example 1: Compute Timestamp from POSIX +time()+.
+    #
+    #     Timestamp timestamp;
+    #     timestamp.set_seconds(time(NULL));
+    #     timestamp.set_nanos(0);
+    #
+    # Example 2: Compute Timestamp from POSIX +gettimeofday()+.
+    #
+    #     struct timeval tv;
+    #     gettimeofday(&tv, NULL);
+    #
+    #     Timestamp timestamp;
+    #     timestamp.set_seconds(tv.tv_sec);
+    #     timestamp.set_nanos(tv.tv_usec * 1000);
+    #
+    # Example 3: Compute Timestamp from Win32 +GetSystemTimeAsFileTime()+.
+    #
+    #     FILETIME ft;
+    #     GetSystemTimeAsFileTime(&ft);
+    #     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
+    #
+    #     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
+    #     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
+    #     Timestamp timestamp;
+    #     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
+    #     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
+    #
+    # Example 4: Compute Timestamp from Java +System.currentTimeMillis()+.
+    #
+    #     long millis = System.currentTimeMillis();
+    #
+    #     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
+    #         .setNanos((int) ((millis % 1000) * 1000000)).build();
+    #
+    #
+    # Example 5: Compute Timestamp from current time in Python.
+    #
+    #     timestamp = Timestamp()
+    #     timestamp.GetCurrentTime()
+    # @!attribute [rw] seconds
+    #   @return [Integer]
+    #     Represents seconds of UTC time since Unix epoch
+    #     1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
+    #     9999-12-31T23:59:59Z inclusive.
+    # @!attribute [rw] nanos
+    #   @return [Integer]
+    #     Non-negative fractions of a second at nanosecond resolution. Negative
+    #     second values with fractions must still have non-negative nanos values
+    #     that count forward in time. Must be from 0 to 999,999,999
+    #     inclusive.
+    class Timestamp; end
+  end
+end

data/lib/google/cloud/spanner/v1/doc/google/spanner/v1/keys.rb

@@ -0,0 +1,148 @@
+# Copyright 2017, Google Inc. All rights reserved.
+#
+# 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.
+
+module Google
+  module Spanner
+    module V1
+      # KeyRange represents a range of rows in a table or index.
+      #
+      # A range has a start key and an end key. These keys can be open or
+      # closed, indicating if the range includes rows with that key.
+      #
+      # Keys are represented by lists, where the ith value in the list
+      # corresponds to the ith component of the table or index primary key.
+      # Individual values are encoded as described Here.
+      #
+      # For example, consider the following table definition:
+      #
+      #     CREATE TABLE UserEvents (
+      #       UserName STRING(MAX),
+      #       EventDate STRING(10)
+      #     ) PRIMARY KEY(UserName, EventDate);
+      #
+      # The following keys name rows in this table:
+      #
+      #     ["Bob", "2014-09-23"]
+      #     ["Alfred", "2015-06-12"]
+      #
+      # Since the +UserEvents+ table's +PRIMARY KEY+ clause names two
+      # columns, each +UserEvents+ key has two elements; the first is the
+      # +UserName+, and the second is the +EventDate+.
+      #
+      # Key ranges with multiple components are interpreted
+      # lexicographically by component using the table or index key's declared
+      # sort order. For example, the following range returns all events for
+      # user +"Bob"+ that occurred in the year 2015:
+      #
+      #     "start_closed": ["Bob", "2015-01-01"]
+      #     "end_closed": ["Bob", "2015-12-31"]
+      #
+      # Start and end keys can omit trailing key components. This affects the
+      # inclusion and exclusion of rows that exactly match the provided key
+      # components: if the key is closed, then rows that exactly match the
+      # provided components are included; if the key is open, then rows
+      # that exactly match are not included.
+      #
+      # For example, the following range includes all events for +"Bob"+ that
+      # occurred during and after the year 2000:
+      #
+      #     "start_closed": ["Bob", "2000-01-01"]
+      #     "end_closed": ["Bob"]
+      #
+      # The next example retrieves all events for +"Bob"+:
+      #
+      #     "start_closed": ["Bob"]
+      #     "end_closed": ["Bob"]
+      #
+      # To retrieve events before the year 2000:
+      #
+      #     "start_closed": ["Bob"]
+      #     "end_open": ["Bob", "2000-01-01"]
+      #
+      # The following range includes all rows in the table:
+      #
+      #     "start_closed": []
+      #     "end_closed": []
+      #
+      # This range returns all users whose +UserName+ begins with any
+      # character from A to C:
+      #
+      #     "start_closed": ["A"]
+      #     "end_open": ["D"]
+      #
+      # This range returns all users whose +UserName+ begins with B:
+      #
+      #     "start_closed": ["B"]
+      #     "end_open": ["C"]
+      #
+      # Key ranges honor column sort order. For example, suppose a table is
+      # defined as follows:
+      #
+      #     CREATE TABLE DescendingSortedTable {
+      #       Key INT64,
+      #       ...
+      #     ) PRIMARY KEY(Key DESC);
+      #
+      # The following range retrieves all rows with key values between 1
+      # and 100 inclusive:
+      #
+      #     "start_closed": ["100"]
+      #     "end_closed": ["1"]
+      #
+      # Note that 100 is passed as the start, and 1 is passed as the end,
+      # because +Key+ is a descending column in the schema.
+      # @!attribute [rw] start_closed
+      #   @return [Google::Protobuf::ListValue]
+      #     If the start is closed, then the range includes all rows whose
+      #     first +len(start_closed)+ key columns exactly match +start_closed+.
+      # @!attribute [rw] start_open
+      #   @return [Google::Protobuf::ListValue]
+      #     If the start is open, then the range excludes rows whose first
+      #     +len(start_open)+ key columns exactly match +start_open+.
+      # @!attribute [rw] end_closed
+      #   @return [Google::Protobuf::ListValue]
+      #     If the end is closed, then the range includes all rows whose
+      #     first +len(end_closed)+ key columns exactly match +end_closed+.
+      # @!attribute [rw] end_open
+      #   @return [Google::Protobuf::ListValue]
+      #     If the end is open, then the range excludes rows whose first
+      #     +len(end_open)+ key columns exactly match +end_open+.
+      class KeyRange; end
+
+      # +KeySet+ defines a collection of Cloud Spanner keys and/or key ranges. All
+      # the keys are expected to be in the same table or index. The keys need
+      # not be sorted in any particular way.
+      #
+      # If the same key is specified multiple times in the set (for example
+      # if two ranges, two keys, or a key and a range overlap), Cloud Spanner
+      # behaves as if the key were only specified once.
+      # @!attribute [rw] keys
+      #   @return [Array<Google::Protobuf::ListValue>]
+      #     A list of specific keys. Entries in +keys+ should have exactly as
+      #     many elements as there are columns in the primary or index key
+      #     with which this +KeySet+ is used.  Individual key values are
+      #     encoded as described Here.
+      # @!attribute [rw] ranges
+      #   @return [Array<Google::Spanner::V1::KeyRange>]
+      #     A list of key ranges. See KeyRange for more information about
+      #     key range specifications.
+      # @!attribute [rw] all
+      #   @return [true, false]
+      #     For convenience +all+ can be set to +true+ to indicate that this
+      #     +KeySet+ matches all keys in the table or index. Note that any keys
+      #     specified in +keys+ or +ranges+ are only yielded once.
+      class KeySet; end
+    end
+  end
+end

data/lib/google/cloud/spanner/v1/doc/google/spanner/v1/mutation.rb

@@ -0,0 +1,80 @@
+# Copyright 2017, Google Inc. All rights reserved.
+#
+# 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.
+
+module Google
+  module Spanner
+    module V1
+      # A modification to one or more Cloud Spanner rows.  Mutations can be
+      # applied to a Cloud Spanner database by sending them in a
+      # Commit call.
+      # @!attribute [rw] insert
+      #   @return [Google::Spanner::V1::Mutation::Write]
+      #     Insert new rows in a table. If any of the rows already exist,
+      #     the write or transaction fails with error +ALREADY_EXISTS+.
+      # @!attribute [rw] update
+      #   @return [Google::Spanner::V1::Mutation::Write]
+      #     Update existing rows in a table. If any of the rows does not
+      #     already exist, the transaction fails with error +NOT_FOUND+.
+      # @!attribute [rw] insert_or_update
+      #   @return [Google::Spanner::V1::Mutation::Write]
+      #     Like Insert, except that if the row already exists, then
+      #     its column values are overwritten with the ones provided. Any
+      #     column values not explicitly written are preserved.
+      # @!attribute [rw] replace
+      #   @return [Google::Spanner::V1::Mutation::Write]
+      #     Like Insert, except that if the row already exists, it is
+      #     deleted, and the column values provided are inserted
+      #     instead. Unlike Insert_or_update, this means any values not
+      #     explicitly written become +NULL+.
+      # @!attribute [rw] delete
+      #   @return [Google::Spanner::V1::Mutation::Delete]
+      #     Delete rows from a table. Succeeds whether or not the named
+      #     rows were present.
+      class Mutation
+        # Arguments to Insert, Update, Insert_or_update, and
+        # Replace operations.
+        # @!attribute [rw] table
+        #   @return [String]
+        #     Required. The table whose rows will be written.
+        # @!attribute [rw] columns
+        #   @return [Array<String>]
+        #     The names of the columns in Table to be written.
+        #
+        #     The list of columns must contain enough columns to allow
+        #     Cloud Spanner to derive values for all primary key columns in the
+        #     row(s) to be modified.
+        # @!attribute [rw] values
+        #   @return [Array<Google::Protobuf::ListValue>]
+        #     The values to be written. +values+ can contain more than one
+        #     list of values. If it does, then multiple rows are written, one
+        #     for each entry in +values+. Each list in +values+ must have
+        #     exactly as many entries as there are entries in Columns
+        #     above. Sending multiple lists is equivalent to sending multiple
+        #     +Mutation+s, each containing one +values+ entry and repeating
+        #     Table and Columns. Individual values in each list are
+        #     encoded as described Here.
+        class Write; end
+
+        # Arguments to Delete operations.
+        # @!attribute [rw] table
+        #   @return [String]
+        #     Required. The table whose rows will be deleted.
+        # @!attribute [rw] key_set
+        #   @return [Google::Spanner::V1::KeySet]
+        #     Required. The primary keys of the rows within Table to delete.
+        class Delete; end
+      end
+    end
+  end
+end