google-cloud-spanner 1.4.0 → 1.5.0

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

@@ -99,7 +99,7 @@ module Google
             Google::Spanner::V1::Mutation.new(
               insert_or_update: Google::Spanner::V1::Mutation::Write.new(
                 table: table, columns: row.keys.map(&:to_s),
-                values: [Convert.raw_to_value(row.values).list_value]
+                values: [Convert.object_to_grpc_value(row.values).list_value]
               )
             )
           end
@@ -157,7 +157,7 @@ module Google
             Google::Spanner::V1::Mutation.new(
               insert: Google::Spanner::V1::Mutation::Write.new(
                 table: table, columns: row.keys.map(&:to_s),
-                values: [Convert.raw_to_value(row.values).list_value]
+                values: [Convert.object_to_grpc_value(row.values).list_value]
               )
             )
           end
@@ -214,7 +214,7 @@ module Google
             Google::Spanner::V1::Mutation.new(
               update: Google::Spanner::V1::Mutation::Write.new(
                 table: table, columns: row.keys.map(&:to_s),
-                values: [Convert.raw_to_value(row.values).list_value]
+                values: [Convert.object_to_grpc_value(row.values).list_value]
               )
             )
           end
@@ -273,7 +273,7 @@ module Google
             Google::Spanner::V1::Mutation.new(
               replace: Google::Spanner::V1::Mutation::Write.new(
                 table: table, columns: row.keys.map(&:to_s),
-                values: [Convert.raw_to_value(row.values).list_value]
+                values: [Convert.object_to_grpc_value(row.values).list_value]
               )
             )
           end
@@ -334,7 +334,7 @@ module Google
           end
           key_list = keys.map do |key|
             key = [key] unless key.is_a? Array
-            Convert.raw_to_value(key).list_value
+            Convert.object_to_grpc_value(key).list_value
           end
           Google::Spanner::V1::KeySet.new keys: key_list
         end

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

@@ -31,106 +31,43 @@ module Google
           def to_query_params params, types = nil
             types ||= {}
             formatted_params = params.map do |key, obj|
-              [String(key), raw_to_value_and_type(obj, types[key])]
+              [String(key), object_to_grpc_value_and_type(obj, types[key])]
             end
             Hash[formatted_params]
           end
 
-          def raw_to_value_and_type obj, type = nil
+          def object_to_grpc_value_and_type obj, field = nil
             obj = obj.to_column_value if obj.respond_to? :to_column_value
-            if NilClass === obj
-              if type
-                if type.is_a?(Array) && type.count == 1
-                  [Google::Protobuf::Value.new(null_value: :NULL_VALUE),
-                   Google::Spanner::V1::Type.new(
-                     code: :ARRAY, array_element_type:
-                      Google::Spanner::V1::Type.new(code: type.first))]
-                # elsif type.is_a? Fields
-                else
-                  [Google::Protobuf::Value.new(null_value: :NULL_VALUE),
-                   Google::Spanner::V1::Type.new(code: type)]
-                end
-              else
-                raise ArgumentError, "Must provide type for nil values."
-              end
-            elsif String === obj
-              [raw_to_value(obj), Google::Spanner::V1::Type.new(code: :STRING)]
-            elsif Symbol === obj
-              [raw_to_value(obj.to_s),
-               Google::Spanner::V1::Type.new(code: :STRING)]
-            elsif TrueClass === obj
-              [raw_to_value(obj), Google::Spanner::V1::Type.new(code: :BOOL)]
-            elsif FalseClass === obj
-              [raw_to_value(obj), Google::Spanner::V1::Type.new(code: :BOOL)]
-            elsif Integer === obj
-              [raw_to_value(obj.to_s),
-               Google::Spanner::V1::Type.new(code: :INT64)]
-            elsif Numeric === obj # Any number not an integer gets to be a float
-              [raw_to_value(obj),
-               Google::Spanner::V1::Type.new(code: :FLOAT64)]
-            elsif Time === obj || DateTime === obj
-              [raw_to_value(obj),
-               Google::Spanner::V1::Type.new(code: :TIMESTAMP)]
-            elsif Date === obj
-              [raw_to_value(obj.to_s),
-               Google::Spanner::V1::Type.new(code: :DATE)]
-            elsif Array === obj
-              if type && !type.is_a?(Array)
-                raise ArgumentError, "Array values must have an Array type."
-              end
-              type ||= begin
-                # Find the param type for the first non-nil item the list
-                nested_param_value = obj.detect { |x| !x.nil? }
-                if nested_param_value.nil?
-                  raise ArgumentError, "Array values must have an Array type."
-                end
-                [raw_to_value_and_type(nested_param_value).last.code]
-              end
-              [raw_to_value(obj),
-               Google::Spanner::V1::Type.new(
-                code: :ARRAY, array_element_type:
-                  Google::Spanner::V1::Type.new(code: type.first))]
-            elsif Hash === obj
-              field_pairs = obj.map do |key, value|
-                [key, raw_to_value_and_type(value).last]
-              end
-              formatted_fields = field_pairs.map do |name, param_type|
-                Google::Spanner::V1::StructType::Field.new(
-                  name: String(name), type: param_type
-                )
-              end
-              [raw_to_value(obj),
-               Google::Spanner::V1::Type.new(
-                code: :STRUCT,
-                struct_type: Google::Spanner::V1::StructType.new(
-                  fields: formatted_fields
-                ))]
-            elsif obj.respond_to?(:read) && obj.respond_to?(:rewind)
-              obj.rewind
-              [raw_to_value(obj),
-               Google::Spanner::V1::Type.new(code: :BYTES)]
-            else
-              raise ArgumentError,
-                    "A parameter of type #{obj.class} is not supported."
+
+            if obj.respond_to? :to_grpc_value_and_type
+              return obj.to_grpc_value_and_type
             end
+
+            field ||= field_for_object obj
+            [object_to_grpc_value(obj, field), grpc_type_for_field(field)]
           end
 
-          def raw_to_value obj
+          def object_to_grpc_value obj, field = nil
             obj = obj.to_column_value if obj.respond_to? :to_column_value
 
-            if NilClass === obj
+            if obj.respond_to? :to_grpc_value_and_type
+              return obj.to_grpc_value_and_type.first
+            end
+
+            case obj
+            when NilClass
               Google::Protobuf::Value.new null_value: :NULL_VALUE
-            elsif String === obj
-              Google::Protobuf::Value.new string_value: obj
-            elsif Symbol === obj
+            when String
               Google::Protobuf::Value.new string_value: obj.to_s
-            elsif TrueClass === obj
+            when Symbol
+              Google::Protobuf::Value.new string_value: obj.to_s
+            when TrueClass
               Google::Protobuf::Value.new bool_value: true
-            elsif FalseClass === obj
+            when FalseClass
               Google::Protobuf::Value.new bool_value: false
-            elsif Integer === obj
+            when Integer
               Google::Protobuf::Value.new string_value: obj.to_s
-            elsif Numeric === obj # Any number not an integer gets to be a float
+            when Numeric
               if obj == Float::INFINITY
                 Google::Protobuf::Value.new string_value: "Infinity"
               elsif obj == -Float::INFINITY
@@ -140,42 +77,110 @@ module Google
               else
                 Google::Protobuf::Value.new number_value: obj.to_f
               end
-            elsif Time === obj || DateTime === obj
+            when Time
+              Google::Protobuf::Value.new(string_value:
+                obj.to_time.utc.strftime("%FT%T.%NZ"))
+            when DateTime
               Google::Protobuf::Value.new(string_value:
                 obj.to_time.utc.strftime("%FT%T.%NZ"))
-            elsif Date === obj
+            when Date
               Google::Protobuf::Value.new string_value: obj.to_s
-            elsif Array === obj
+            when Array
+              arr_field = nil
+              arr_field = field.first if Array === field
               Google::Protobuf::Value.new list_value:
                 Google::Protobuf::ListValue.new(values:
-                  obj.map { |o| raw_to_value(o) })
-            elsif Hash === obj
-              Google::Protobuf::Value.new struct_value:
-                Google::Protobuf::Struct.new(fields:
-                  Hash[obj.map { |k, v| [String(k), raw_to_value(v)] }])
-            elsif obj.respond_to?(:read) && obj.respond_to?(:rewind)
-              obj.rewind
-              content = obj.read.force_encoding("ASCII-8BIT")
-              encoded_content = Base64.strict_encode64(content)
-              Google::Protobuf::Value.new(string_value: encoded_content)
+                  obj.map { |o| object_to_grpc_value(o, arr_field) })
+            when Hash
+              if field.is_a? Fields
+                field.struct(obj).to_grpc_value
+              else
+                raise ArgumentError,
+                      "A hash value cannot be set to type #{field}."
+              end
             else
-              raise ArgumentError,
-                    "A value of type #{obj.class} is not supported."
+              if obj.respond_to?(:read) && obj.respond_to?(:rewind)
+                obj.rewind
+                content = obj.read.force_encoding("ASCII-8BIT")
+                encoded_content = Base64.strict_encode64(content)
+                Google::Protobuf::Value.new(string_value: encoded_content)
+              else
+                raise ArgumentError,
+                      "A value of type #{obj.class} is not supported."
+              end
             end
           end
 
-          def row_to_pairs row_types, row
-            row_types.zip(row).map do |field, value|
-              [field.name.to_sym, value_to_raw(value, field.type)]
+          def field_for_object obj
+            case obj
+            when NilClass
+              raise ArgumentError, "Cannot determine type for nil values."
+            when String
+              :STRING
+            when Symbol
+              :STRING
+            when TrueClass
+              :BOOL
+            when FalseClass
+              :BOOL
+            when Integer
+              :INT64
+            when Numeric
+              :FLOAT64
+            when Time
+              :TIMESTAMP
+            when DateTime
+              :TIMESTAMP
+            when Date
+              :DATE
+            when Array
+              if obj.empty?
+                raise ArgumentError,
+                      "Cannot determine type for empty array values."
+              end
+              non_nil_fields = obj.compact.map { |e| field_for_object e }.compact
+              if non_nil_fields.empty?
+                raise ArgumentError,
+                      "Cannot determine type for array of nil values."
+              end
+              if non_nil_fields.uniq.count > 1
+                raise ArgumentError,
+                      "Cannot determine type for array of different values."
+              end
+              [non_nil_fields.first]
+            when Hash
+              raw_type_pairs = obj.map do |key, value|
+                [key, field_for_object(value)]
+              end
+              Fields.new Hash[raw_type_pairs]
+            when Data
+              obj.fields
+            else
+              if obj.respond_to?(:read) && obj.respond_to?(:rewind)
+                :BYTES
+              else
+                raise ArgumentError,
+                      "Cannot determine type for #{obj.class} values."
+              end
             end
           end
 
-          def row_to_raw row_types, row
-            Hash[row_to_pairs(row_types, row)]
+          def grpc_type_for_field field
+            return field.to_grpc_type if field.respond_to? :to_grpc_type
+
+            if Array === field
+              Google::Spanner::V1::Type.new(
+                code: :ARRAY,
+                array_element_type: grpc_type_for_field(field.first)
+              )
+            else
+              Google::Spanner::V1::Type.new(code: field)
+            end
           end
 
-          def value_to_raw value, type
+          def grpc_value_to_object value, type
             return nil if value.kind == :null_value
+
             case type.code
             when :BOOL
               value.bool_value
@@ -205,13 +210,23 @@ module Google
               StringIO.new Base64.decode64 value.string_value
             when :ARRAY
               value.list_value.values.map do |v|
-                value_to_raw v, type.array_element_type
+                grpc_value_to_object v, type.array_element_type
               end
             when :STRUCT
               Data.from_grpc value.list_value.values, type.struct_type.fields
             end
           end
 
+          def row_to_pairs row_types, row
+            row_types.zip(row).map do |field, value|
+              [field.name.to_sym, grpc_value_to_object(value, field.type)]
+            end
+          end
+
+          def row_to_object row_types, row
+            Hash[row_to_pairs(row_types, row)]
+          end
+
           def number_to_duration number
             return nil if number.nil?
 
@@ -247,8 +262,8 @@ module Google
 
           def to_key_range range
             range_opts = {
-              start_closed: raw_to_value(Array(range.begin)).list_value,
-              end_closed: raw_to_value(Array(range.end)).list_value }
+              start_closed: object_to_grpc_value(Array(range.begin)).list_value,
+              end_closed: object_to_grpc_value(Array(range.end)).list_value }
 
             if range.respond_to?(:exclude_begin?) && range.exclude_begin?
               range_opts[:start_open] = range_opts[:start_closed]
@@ -274,7 +289,7 @@ module Google
 
             key_list = keys.map do |key|
               key = [key] unless key.is_a? Array
-              raw_to_value(key).list_value
+              object_to_grpc_value(key).list_value
             end
             Google::Spanner::V1::KeySet.new keys: key_list
           end

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

@@ -42,7 +42,8 @@ module Google
       #
       class Data
         ##
-        # Returns the names and values of the data as an array of field objects.
+        # Returns the configuration object ({Fields}) of the names and types of
+        # the data.
         #
         # @return [Array<Array>] An array containing name and value pairs.
         #
@@ -109,14 +110,15 @@ module Google
         #
         def [] key
           if key.is_a? Integer
-            return Convert.value_to_raw(@grpc_values[key],
-                                        @grpc_fields[key].type)
+            return Convert.grpc_value_to_object(@grpc_values[key],
+                                                @grpc_fields[key].type)
           end
           name_count = @grpc_fields.find_all { |f| f.name == String(key) }.count
           return nil if name_count.zero?
           raise DuplicateNameError if name_count > 1
           index = @grpc_fields.find_index { |f| f.name == String(key) }
-          Convert.value_to_raw(@grpc_values[index], @grpc_fields[index].type)
+          Convert.grpc_value_to_object(@grpc_values[index],
+                                       @grpc_fields[index].type)
         end
 
         ##
@@ -184,13 +186,44 @@ module Google
           "#<#{self.class.name} #{self}>"
         end
 
+        ##
+        # @private
+        def to_grpc_value
+          if @grpc_values.nil?
+            return Google::Protobuf::Value.new null_value: :NULL_VALUE
+          end
+
+          Google::Protobuf::Value.new(
+            list_value: Google::Protobuf::ListValue.new(
+              values: @grpc_values
+            )
+          )
+        end
+
+        ##
+        # @private
+        def to_grpc_type
+          Google::Spanner::V1::Type.new(
+            code: :STRUCT,
+            struct_type: Google::Spanner::V1::StructType.new(
+              fields: @grpc_fields
+            )
+          )
+        end
+
+        ##
+        # @private
+        def to_grpc_value_and_type
+          [to_grpc_value, to_grpc_type]
+        end
+
         ##
         # @private Creates a new Data instance from
         # Spanner values and fields.
         def self.from_grpc grpc_values, grpc_fields
           new.tap do |d|
-            d.instance_variable_set :@grpc_values, grpc_values
-            d.instance_variable_set :@grpc_fields, grpc_fields
+            d.instance_variable_set :@grpc_values, Array(grpc_values)
+            d.instance_variable_set :@grpc_fields, Array(grpc_fields)
           end
         end
       end

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

@@ -36,25 +36,91 @@ module Google
       #   results = db.execute "SELECT * FROM users"
       #
       #   results.fields.pairs.each do |name, type|
-      #     puts "Column #{name} is type {type}"
+      #     puts "Column #{name} is type #{type}"
       #   end
       #
       class Fields
         ##
-        # @private
+        # Creates {Fields} object from types. See {Client#fields}.
+        #
+        # This object can be used to create {Data} objects by providing values
+        # that match the field types. See {Fields#struct}.
+        #
+        # See [Data Types - Constructing a
+        # STRUCT](https://cloud.google.com/spanner/docs/data-types#constructing-a-struct).
+        #
+        # @param [Array, Hash] types Accepts an array or hash types.
+        #
+        #   Arrays can contain just the type value, or a sub-array of the
+        #   field's name and type value. Hash keys must contain the field name
+        #   as a `Symbol` or `String`, or the field position as an `Integer`.
+        #   Hash values must contain the type value. If a Hash is used the
+        #   fields will be created using the same order as the Hash keys.
+        #
+        #   Supported type values incude:
+        #
+        #   * `:BOOL`
+        #   * `:BYTES`
+        #   * `:DATE`
+        #   * `:FLOAT64`
+        #   * `:INT64`
+        #   * `:STRING`
+        #   * `:TIMESTAMP`
+        #   * `Array` - Lists are specified by providing the type code in an
+        #     array. For example, an array of integers are specified as
+        #     `[:INT64]`.
+        #   * {Fields} - Nested Structs are specified by providing a Fields
+        #     object.
+        #
+        # @return [Fields] The fields of the given types.
+        #
+        # @example Create a STRUCT value with named fields using Fields object:
+        #   require "google/cloud/spanner"
+        #
+        #   named_type = Google::Cloud::Spanner::Fields.new(
+        #     { id: :INT64, name: :STRING, active: :BOOL }
+        #   )
+        #   named_data = named_type.struct(
+        #     { id: 42, name: nil, active: false }
+        #   )
+        #
+        # @example Create a STRUCT value with anonymous field names:
+        #   require "google/cloud/spanner"
+        #
+        #   anon_type = Google::Cloud::Spanner::Fields.new(
+        #     [:INT64, :STRING, :BOOL]
+        #   )
+        #   anon_data = anon_type.struct [42, nil, false]
+        #
+        # @example Create a STRUCT value with duplicate field names:
+        #   require "google/cloud/spanner"
+        #
+        #   dup_type = Google::Cloud::Spanner::Fields.new(
+        #     [[:x, :INT64], [:x, :STRING], [:x, :BOOL]]
+        #   )
+        #   dup_data = dup_type.struct [42, nil, false]
+        #
         def initialize types
-          @fields = []
-          if types.is_a? Array
-            types.each do |type|
-              @fields << field(type)
-            end
-          elsif types.is_a? Hash
-            types.each do |type|
-              @fields << field(type)
-            end
-          else
+          types = types.to_a if types.is_a? Hash
+
+          unless types.is_a? Array
             raise ArgumentError, "can only accept Array or Hash"
           end
+
+          sorted_types, unsorted_types = types.partition do |type|
+            type.is_a?(Array) && type.count == 2 && type.first.is_a?(Integer)
+          end
+
+          verify_sorted_types! sorted_types, types.count
+
+          @grpc_fields = Array.new(types.count) do |index|
+            sorted_type = sorted_types.assoc index
+            if sorted_type
+              to_grpc_field sorted_type.last
+            else
+              to_grpc_field unsorted_types.shift
+            end
+          end
         end
 
         ##
@@ -66,7 +132,7 @@ module Google
         # @return [Array<Symbol>] An array containing the types of the data.
         #
         def types
-          @fields.map(&:type).map do |type|
+          @grpc_fields.map(&:type).map do |type|
             if type.code == :ARRAY
               if type.array_element_type.code == :STRUCT
                 [Fields.from_grpc(type.array_element_type.struct_type.fields)]
@@ -90,7 +156,7 @@ module Google
         #   data.
         #
         def keys
-          @fields.each_with_index.map do |field, index|
+          @grpc_fields.map.with_index do |field, index|
             if field.name.empty?
               index
             else
@@ -134,69 +200,157 @@ module Google
         #
         def [] key
           return types[key] if key.is_a? Integer
-          name_count = @fields.find_all { |f| f.name == String(key) }.count
+          name_count = @grpc_fields.find_all { |f| f.name == String(key) }.count
           return nil if name_count.zero?
           raise DuplicateNameError if name_count > 1
-          index = @fields.find_index { |f| f.name == String(key) }
+          index = @grpc_fields.find_index { |f| f.name == String(key) }
           types[index]
         end
 
+        # rubocop:disable all
+
         ##
-        # Returns the type codes as an array. Do not use this method if the data
-        # has more than one member with the same name. (See {#duplicate_names?})
+        # Creates a new {Data} object given the data values matching the fields.
+        # Can be provided as either an Array of values, or a Hash where the hash
+        # keys match the field name or match the index position of the field.
         #
-        # @raise [Google::Cloud::Spanner::DuplicateNameError] if the data
-        #   contains duplicate names.
+        # For more information, see [Data Types - Constructing a
+        # STRUCT](https://cloud.google.com/spanner/docs/data-types#constructing-a-struct).
         #
-        # @return [Array<Symbol>] An array containing the type codes.
+        # @param [Array, Hash] data Accepts an array or hash data values.
         #
-        def to_a
-          Array.new(keys.count) do |i|
-            field = self[i]
-            if field.is_a? Fields
-              field.to_h
-            elsif field.is_a? Array
-              field.map { |f| f.is_a?(Fields) ? f.to_h : f }
-            else
-              field
+        #   Arrays can contain just the data value, nested arrays will be
+        #   treated as lists of values. Values must be provided in the same
+        #   order as the fields, and there is no way to associate values to the
+        #   field names.
+        #
+        #   Hash keys must contain the field name as a `Symbol` or `String`, or
+        #   the field position as an `Integer`. Hash values must contain the
+        #   data value. Hash values will be matched to the fields, so they don't
+        #   need to match the same order as the fields.
+        #
+        # @return [Data] A new Data object.
+        #
+        # @example Create a STRUCT value with named fields using Fields object:
+        #   require "google/cloud/spanner"
+        #
+        #   spanner = Google::Cloud::Spanner.new
+        #
+        #   db = spanner.client "my-instance", "my-database"
+        #
+        #   named_type = db.fields(
+        #     { id: :INT64, name: :STRING, active: :BOOL }
+        #   )
+        #   named_data = named_type.struct(
+        #     { id: 42, name: nil, active: false }
+        #   )
+        #
+        # @example Create a STRUCT value with anonymous field names:
+        #   require "google/cloud/spanner"
+        #
+        #   spanner = Google::Cloud::Spanner.new
+        #
+        #   db = spanner.client "my-instance", "my-database"
+        #
+        #   anon_type = db.fields [:INT64, :STRING, :BOOL]
+        #   anon_data = anon_type.struct [42, nil, false]
+        #
+        # @example Create a STRUCT value with duplicate field names:
+        #   require "google/cloud/spanner"
+        #
+        #   spanner = Google::Cloud::Spanner.new
+        #
+        #   db = spanner.client "my-instance", "my-database"
+        #
+        #   dup_type = db.fields [[:x, :INT64], [:x, :STRING], [:x, :BOOL]]
+        #   dup_data = dup_type.struct [42, nil, false]
+        #
+        def struct data
+          # create local copy of types so they are parsed just once.
+          cached_types = types
+          if data.nil?
+            return Data.from_grpc nil, @grpc_fields
+          elsif data.is_a? Array
+            # Convert data in the order it was recieved
+            values = data.map.with_index do |datum, index|
+              Convert.object_to_grpc_value_and_type(datum, cached_types[index]).first
             end
+            return Data.from_grpc values, @grpc_fields
+          elsif data.is_a? Hash
+            # Pull values from hash in order of the fields,
+            # we can't always trust the Hash to be in order.
+            values = @grpc_fields.map.with_index do |field, index|
+              if data.key? index
+                Convert.object_to_grpc_value_and_type(data[index],
+                                              cached_types[index]).first
+              elsif !field.name.to_s.empty?
+                if data.key? field.name.to_s
+                  Convert.object_to_grpc_value_and_type(data[field.name.to_s],
+                                                cached_types[index]).first
+                elsif data.key? field.name.to_s.to_sym
+                  Convert.object_to_grpc_value_and_type(data[field.name.to_s.to_sym],
+                                                cached_types[index]).first
+                else
+                  raise "data value for field #{field.name} missing"
+                end
+              else
+                raise "data value for field #{index} missing"
+              end
+            end
+            return Data.from_grpc values, @grpc_fields
           end
+          raise ArgumentError, "can only accept Array or Hash"
+        end
+        alias data struct
+        alias new struct
+
+        # rubocop:enable all
+
+        ##
+        # Returns the type codes as an array. Do not use this method if the data
+        # has more than one member with the same name. (See {#duplicate_names?})
+        #
+        # @return [Array<Symbol|Array<Symbol>|Fields|Array<Fields>>] An array
+        #   containing the type codes.
+        #
+        def to_a
+          types
         end
 
         ##
         # Returns the names or indexes and corresponding type codes as a hash.
         #
-        # @return [Hash<(String,Integer)=>Symbol>] A hash containing the names
-        #   or indexes and corresponding types.
+        # @raise [Google::Cloud::Spanner::DuplicateNameError] if the data
+        #   contains duplicate names.
+        #
+        # @return [Hash<(Symbol|Integer) =>
+        #   (Symbol|Array<Symbol>|Fields|Array<Fields>)] A hash containing the
+        #   names or indexes and corresponding types.
         #
         def to_h
           raise DuplicateNameError if duplicate_names?
-          hashified_pairs = pairs.map do |key, value|
-            if value.is_a? Fields
-              [key, value.to_h]
-            elsif value.is_a? Array
-              [key, value.map { |v| v.is_a?(Fields) ? v.to_h : v }]
-            else
-              [key, value]
-            end
-          end
-          Hash[hashified_pairs]
+          Hash[pairs]
         end
 
         # @private
-        def data data
-          # TODO: match order of types
-          data = data.values if data.is_a?(Hash)
-          values = data.map { |datum| Convert.raw_to_value datum }
-          Data.from_grpc values, @fields
+        def count
+          @grpc_fields.count
         end
-        alias new data
+        alias size count
 
         # @private
         def == other
           return false unless other.is_a? Fields
           pairs == other.pairs
         end
+        alias eql? ==
+
+        # @private
+        def hash
+          # The Protobuf object looks to maintain consistent hash values
+          # for objects with the same configuration.
+          to_grpc_type.hash
+        end
 
         # @private
         def to_s
@@ -215,40 +369,78 @@ module Google
           "#<#{self.class.name} #{self}>"
         end
 
+        ##
+        # @private
+        def to_grpc_type
+          Google::Spanner::V1::Type.new(
+            code: :STRUCT,
+            struct_type: Google::Spanner::V1::StructType.new(
+              fields: @grpc_fields
+            )
+          )
+        end
+
         ##
         # @private Creates a new Fields instance from a
         # Google::Spanner::V1::Metadata::Row_type::Fields.
         def self.from_grpc fields
           new([]).tap do |f|
-            f.instance_variable_set :@fields, fields
+            f.instance_variable_set :@grpc_fields, Array(fields)
           end
         end
 
         protected
 
-        def field pair
+        # rubocop:disable all
+
+        def verify_sorted_types! sorted_types, total_count
+          sorted_unique_positions = sorted_types.map(&:first).uniq.sort
+          return if sorted_unique_positions.empty?
+
+          if sorted_unique_positions.first < 0
+            raise ArgumentError, "cannot specify position less than 0"
+          end
+          if sorted_unique_positions.last >= total_count
+            raise ArgumentError, "cannot specify position more than field count"
+          end
+          if sorted_types.count != sorted_unique_positions.count
+            raise ArgumentError, "cannot specify position more than once"
+          end
+        end
+
+        def to_grpc_field pair
           if pair.is_a?(Array)
-            unless pair.count == 2
-              raise ArgumentError, "can only accept pairs of name and type"
-            end
-            if pair.first.nil? || pair.first.is_a?(Integer)
-              Google::Spanner::V1::StructType::Field.new(
-                type: Google::Spanner::V1::Type.new(code: pair.last)
-              )
+            if pair.count == 2
+              if pair.first.is_a?(Integer)
+                Google::Spanner::V1::StructType::Field.new(
+                  type: Convert.grpc_type_for_field(pair.last)
+                )
+              else
+                Google::Spanner::V1::StructType::Field.new(
+                  name: String(pair.first),
+                  type: Convert.grpc_type_for_field(pair.last)
+                )
+              end
             else
               Google::Spanner::V1::StructType::Field.new(
-                name: String(pair.first),
-                type: Google::Spanner::V1::Type.new(code: pair.last)
+                type: Google::Spanner::V1::Type.new(
+                  code: :ARRAY,
+                  array_element_type: Convert.grpc_type_for_field(pair.last)
+                )
               )
             end
           else
+            # TODO: Handle Fields object
+            # TODO: Handle Hash by creating Fields object
             unless pair.is_a?(Symbol)
               raise ArgumentError, "type must be a symbol"
             end
             Google::Spanner::V1::StructType::Field.new(
-              type: Google::Spanner::V1::Type.new(code: pair)
+              type: Convert.grpc_type_for_field(pair)
             )
           end
+
+          # rubocop:enable all
         end
       end
     end