activerecord-spanner-adapter 1.5.1 → 1.6.1

data/lib/activerecord_spanner_adapter/base.rb

@@ -4,6 +4,7 @@
 # license that can be found in the LICENSE file or at
 # https://opensource.org/licenses/MIT.
 
+require "active_record/gem_version"
 require "activerecord_spanner_adapter/relation"
 
 module ActiveRecord
@@ -14,6 +15,8 @@ module ActiveRecord
   end
 
   class Base
+    VERSION_7_1 = Gem::Version.create "7.1.0"
+
     # Creates an object (or multiple objects) and saves it to the database. This method will use mutations instead
     # of DML if there is no active transaction, or if the active transaction has been created with the option
     # isolation: :buffered_mutations.
@@ -30,7 +33,9 @@ module ActiveRecord
       return super unless spanner_adapter?
       return super if active_transaction?
 
-      transaction isolation: :buffered_mutations do
+      # Only use mutations to create new records if the primary key is generated client-side.
+      isolation = sequence_name ? nil : :buffered_mutations
+      transaction isolation: isolation do
         return super
       end
     end
@@ -43,35 +48,74 @@ module ActiveRecord
       spanner_adapter? && connection&.current_spanner_transaction&.isolation == :buffered_mutations
     end
 
-    def self._insert_record values
-      return super unless buffered_mutations? || (primary_key && values.is_a?(Hash))
+    def self._insert_record values, returning = []
+      if !(buffered_mutations? || (primary_key && values.is_a?(Hash))) || !spanner_adapter?
+        return super values if ActiveRecord.gem_version < VERSION_7_1
+        return super
+      end
 
-      return _buffer_record values, :insert if buffered_mutations?
+      # Mutations cannot be used in combination with a sequence, as mutations do not support a THEN RETURN clause.
+      if buffered_mutations? && sequence_name
+        raise StatementInvalid, "Mutations cannot be used to create records that use a sequence " \
+                                     "to generate the primary key. #{self} uses #{sequence_name}."
+      end
 
-      primary_key_value =
-        if primary_key.is_a? Array
-          _set_composite_primary_key_values primary_key, values
-        else
-          _set_single_primary_key_value primary_key, values
-        end
+      return _buffer_record values, :insert, returning if buffered_mutations?
+
+      _insert_record_dml values, returning
+    end
+
+    def self._insert_record_dml values, returning
+      primary_key_value = _set_primary_key_value values
       if ActiveRecord::VERSION::MAJOR >= 7
         im = Arel::InsertManager.new arel_table
         im.insert(values.transform_keys { |name| arel_table[name] })
       else
         im = arel_table.compile_insert _substitute_values(values)
       end
-      connection.insert(im, "#{self} Create", primary_key || false, primary_key_value)
+      result = connection.insert(im, "#{self} Create", primary_key || false, primary_key_value)
+
+      _convert_primary_key result, returning
+    end
+
+    def self._set_primary_key_value values
+      if primary_key.is_a? Array
+        _set_composite_primary_key_values primary_key, values
+      else
+        _set_single_primary_key_value primary_key, values
+      end
+    end
+
+    def self._convert_primary_key primary_key_value, returning
+      # Rails 7.1 and higher supports composite primary keys, and therefore require the provider to return an array
+      # instead of a single value in all cases. The order of the values should be equal to the order of the returning
+      # columns (or the primary key if no returning columns were specified).
+      return primary_key_value if ActiveRecord.gem_version < VERSION_7_1
+      return primary_key_value if primary_key_value.is_a?(Array) && primary_key_value.length == 1
+      return [primary_key_value] unless primary_key_value.is_a? Array
+
+      # Re-order the returned values according to the returning columns if it is not equal to the primary key of the
+      # table.
+      keys = returning || primary_key
+      return primary_key_value if keys == primary_key
+
+      primary_key_values_hash = Hash[primary_key.zip(primary_key_value)]
+      values = []
+      keys.each do |column|
+        values.append primary_key_values_hash[column]
+      end
+      values
     end
 
-    def self._upsert_record values
-      _buffer_record values, :insert_or_update
+    def self._upsert_record values, returning
+      _buffer_record values, :insert_or_update, returning
     end
 
     def self.insert_all _attributes, **_kwargs
       raise NotImplementedError, "Cloud Spanner does not support skip_duplicates. Use insert! or upsert instead."
     end
 
-    def self.insert_all! attributes, **_kwargs
+    def self.insert_all! attributes, returning: nil, **_kwargs
       return super unless spanner_adapter?
       return super if active_transaction? && !buffered_mutations?
 
@@ -90,7 +134,7 @@ module ActiveRecord
       end
     end
 
-    def self.upsert_all attributes, **_kwargs
+    def self.upsert_all attributes, returning: nil, unique_by: nil, **_kwargs
       return super unless spanner_adapter?
       if active_transaction? && !buffered_mutations?
         raise NotImplementedError, "Cloud Spanner does not support upsert using DML. " \
@@ -102,18 +146,18 @@ module ActiveRecord
       # The mutations will be sent as one batch when the transaction is committed.
       if active_transaction?
         attributes.each do |record|
-          _upsert_record record
+          _upsert_record record, returning
         end
       else
         transaction isolation: :buffered_mutations do
           attributes.each do |record|
-            _upsert_record record
+            _upsert_record record, returning
           end
         end
       end
     end
 
-    def self._buffer_record values, method
+    def self._buffer_record values, method, returning
       primary_key_value =
         if primary_key.is_a? Array
           _set_composite_primary_key_values primary_key, values
@@ -132,10 +176,9 @@ module ActiveRecord
       mutation = Google::Cloud::Spanner::V1::Mutation.new(
         "#{method}": write
       )
-
       connection.current_spanner_transaction.buffer mutation
 
-      primary_key_value
+      _convert_primary_key primary_key_value, returning
     end
 
     def self._set_composite_primary_key_values primary_key, values
@@ -174,6 +217,7 @@ module ActiveRecord
     def self._set_single_primary_key_value primary_key, values
       primary_key_value = values[primary_key] || values[primary_key.to_sym]
 
+      return primary_key_value if sequence_name
       return primary_key_value unless prefetch_primary_key?
 
       if primary_key_value.nil?

data/lib/activerecord_spanner_adapter/foreign_key.rb

@@ -6,7 +6,7 @@
 
 module ActiveRecordSpannerAdapter
   class ForeignKey
-    attr_accessor :table_name, :name, :columns, :ref_table, :ref_columns,
+    attr_accessor :table_schema, :table_name, :name, :columns, :ref_schema, :ref_table, :ref_columns,
                   :on_delete, :on_update
 
     def initialize \
@@ -16,10 +16,14 @@ module ActiveRecordSpannerAdapter
         ref_table,
         ref_columns,
         on_delete: nil,
-        on_update: nil
+        on_update: nil,
+        table_schema: "",
+        ref_schema: ""
+      @table_schema = table_schema
       @table_name = table_name
       @name = name
       @columns = Array(columns)
+      @ref_schema = ref_schema
       @ref_table = ref_table
       @ref_columns = Array(ref_columns)
       @on_delete = on_delete unless on_delete == "NO ACTION"

data/lib/activerecord_spanner_adapter/index/column.rb

@@ -7,16 +7,18 @@
 module ActiveRecordSpannerAdapter
   class Index
     class Column
-      attr_accessor :table_name, :index_name, :name, :order, :ordinal_position
+      attr_accessor :table_name, :schema_name, :index_name, :name, :order, :ordinal_position
 
       def initialize \
           table_name,
           index_name,
           name,
+          schema_name: "",
           order: nil,
           ordinal_position: nil
         @table_name = table_name.to_s
         @index_name = index_name.to_s
+        @schema_name = schema_name.to_s
         @name = name.to_s
         @order = order.to_s.upcase if order
         @ordinal_position = ordinal_position

data/lib/activerecord_spanner_adapter/index.rb

@@ -8,7 +8,7 @@ require "activerecord_spanner_adapter/index/column"
 
 module ActiveRecordSpannerAdapter
   class Index
-    attr_accessor :table, :name, :columns, :type, :unique, :null_filtered,
+    attr_accessor :schema, :table, :name, :columns, :type, :unique, :null_filtered,
                   :interleave_in, :storing, :state
 
     def initialize \
@@ -20,7 +20,9 @@ module ActiveRecordSpannerAdapter
         null_filtered: false,
         interleave_in: nil,
         storing: nil,
-        state: nil
+        state: nil,
+        schema: ""
+      @schema = schema.to_s
       @table = table.to_s
       @name = name.to_s
       @columns = Array(columns)

data/lib/activerecord_spanner_adapter/information_schema.rb

@@ -15,6 +15,8 @@ module ActiveRecordSpannerAdapter
   class InformationSchema
     include ActiveRecord::ConnectionAdapters::Quoting
 
+    IsRails71OrLater = ActiveRecord.gem_version >= Gem::Version.create("7.1.0")
+
     attr_reader :connection
 
     def initialize connection
@@ -22,7 +24,7 @@ module ActiveRecordSpannerAdapter
       @mutex = Mutex.new
     end
 
-    def tables table_name: nil, schema_name: nil, view: nil
+    def tables table_name: nil, schema_name: "", view: nil
       sql = +"SELECT TABLE_CATALOG, TABLE_SCHEMA, TABLE_NAME, PARENT_TABLE_NAME, ON_DELETE_ACTION"
       sql << " FROM INFORMATION_SCHEMA.TABLES"
       sql << " WHERE TABLE_SCHEMA=%<schema_name>s"
@@ -43,17 +45,17 @@ module ActiveRecordSpannerAdapter
         )
 
         if [:full, :columns].include? view
-          table.columns = table_columns table.name
+          table.columns = table_columns table.name, schema_name: schema_name
         end
 
         if [:full, :indexes].include? view
-          table.indexes = indexes table.name
+          table.indexes = indexes table.name, schema_name: table.schema_name
         end
         table
       end
     end
 
-    def table table_name, schema_name: nil, view: nil
+    def table table_name, schema_name: "", view: nil
       tables(
         table_name: table_name,
         schema_name: schema_name,
@@ -61,52 +63,62 @@ module ActiveRecordSpannerAdapter
       ).first
     end
 
-    def table_columns table_name, column_name: nil
+    def table_columns table_name, column_name: nil, schema_name: ""
+      primary_keys = table_primary_keys(table_name).map(&:name)
       sql = +"SELECT COLUMN_NAME, SPANNER_TYPE, IS_NULLABLE, GENERATION_EXPRESSION,"
       sql << " CAST(COLUMN_DEFAULT AS STRING) AS COLUMN_DEFAULT, ORDINAL_POSITION"
       sql << " FROM INFORMATION_SCHEMA.COLUMNS"
       sql << " WHERE TABLE_NAME=%<table_name>s"
+      sql << " AND TABLE_SCHEMA=%<schema_name>s"
       sql << " AND COLUMN_NAME=%<column_name>s" if column_name
       sql << " ORDER BY ORDINAL_POSITION ASC"
 
-      column_options = column_options table_name, column_name
+      column_options = column_options table_name, column_name, schema_name: schema_name
       execute_query(
         sql,
         table_name: table_name,
-        column_name: column_name
+        column_name: column_name,
+        schema_name: schema_name
       ).map do |row|
-        type, limit = parse_type_and_limit row["SPANNER_TYPE"]
-        column_name = row["COLUMN_NAME"]
-        options = column_options[column_name]
+        _create_column table_name, row, primary_keys, column_options, schema_name: schema_name
+      end
+    end
 
-        default = row["COLUMN_DEFAULT"]
-        default_function = row["GENERATION_EXPRESSION"]
+    def _create_column table_name, row, primary_keys, column_options, schema_name: ""
+      type, limit = parse_type_and_limit row["SPANNER_TYPE"]
+      column_name = row["COLUMN_NAME"]
+      options = column_options[column_name]
+      primary_key = primary_keys.include? column_name
 
-        if /\w+\(.*\)/.match?(default)
-          default_function ||= default
-          default = nil
-        end
+      default = row["COLUMN_DEFAULT"]
+      default_function = row["GENERATION_EXPRESSION"]
 
-        if default && type == "STRING"
-          default = unquote_string default
-        end
+      if default && default.length < 200 && /\w+\(.*\)/.match?(default)
+        default_function ||= default
+        default = nil
+      end
 
-        Table::Column.new \
-          table_name,
-          column_name,
-          type,
-          limit: limit,
-          allow_commit_timestamp: options["allow_commit_timestamp"],
-          ordinal_position: row["ORDINAL_POSITION"],
-          nullable: row["IS_NULLABLE"] == "YES",
-          default: default,
-          default_function: default_function,
-          generated: row["GENERATION_EXPRESSION"].present?
+      if default && type == "STRING"
+        default = unquote_string default
       end
+
+      Table::Column.new \
+        table_name,
+        column_name,
+        type,
+        schema_name: schema_name,
+        limit: limit,
+        allow_commit_timestamp: options["allow_commit_timestamp"],
+        ordinal_position: row["ORDINAL_POSITION"],
+        nullable: row["IS_NULLABLE"] == "YES",
+        default: default,
+        default_function: default_function,
+        generated: row["GENERATION_EXPRESSION"].present?,
+        primary_key: primary_key
     end
 
-    def table_column table_name, column_name
-      table_columns(table_name, column_name: column_name).first
+    def table_column table_name, column_name, schema_name: ""
+      table_columns(table_name, column_name: column_name, schema_name: schema_name).first
     end
 
     # Returns the primary key columns of the given table. By default it will only return the columns that are not part
@@ -114,43 +126,49 @@ module ActiveRecordSpannerAdapter
     # ActiveRecord. The parent primary key columns are filtered out by default to allow interleaved tables to be
     # considered as tables with a single-column primary key by ActiveRecord. The actual primary key of the table will
     # include both the parent primary key columns and the 'own' primary key columns of a table.
-    def table_primary_keys table_name, include_parent_keys = false
+    def table_primary_keys table_name, include_parent_keys = IsRails71OrLater, schema_name: ""
       sql = +"WITH TABLE_PK_COLS AS ( "
-      sql << "SELECT C.TABLE_NAME, C.COLUMN_NAME, C.INDEX_NAME, C.COLUMN_ORDERING, C.ORDINAL_POSITION "
+      sql << "SELECT C.TABLE_CATALOG, C.TABLE_SCHEMA, C.TABLE_NAME, C.COLUMN_NAME, "
+      sql << "C.INDEX_NAME, C.COLUMN_ORDERING, C.ORDINAL_POSITION "
       sql << "FROM INFORMATION_SCHEMA.INDEX_COLUMNS C "
       sql << "WHERE C.INDEX_TYPE = 'PRIMARY_KEY' "
       sql << "AND TABLE_CATALOG = '' "
       sql << "AND TABLE_SCHEMA = '') "
       sql << "SELECT INDEX_NAME, COLUMN_NAME, COLUMN_ORDERING, ORDINAL_POSITION "
       sql << "FROM TABLE_PK_COLS "
-      sql << "INNER JOIN INFORMATION_SCHEMA.TABLES T USING (TABLE_NAME) "
+      sql << "INNER JOIN INFORMATION_SCHEMA.TABLES T USING (TABLE_CATALOG, TABLE_SCHEMA, TABLE_NAME) "
       sql << "WHERE TABLE_NAME = %<table_name>s "
       sql << "AND TABLE_CATALOG = '' "
-      sql << "AND TABLE_SCHEMA = '' "
+      sql << "AND TABLE_SCHEMA = %<schema_name>s "
       unless include_parent_keys
         sql << "AND (T.PARENT_TABLE_NAME IS NULL OR COLUMN_NAME NOT IN ( "
         sql << "  SELECT COLUMN_NAME "
         sql << "  FROM TABLE_PK_COLS "
-        sql << "  WHERE TABLE_NAME = T.PARENT_TABLE_NAME "
+        sql << "  WHERE TABLE_CATALOG = T.TABLE_CATALOG "
+        sql << "  AND TABLE_SCHEMA=T.TABLE_SCHEMA "
+        sql << "  AND TABLE_NAME = T.PARENT_TABLE_NAME "
         sql << ")) "
       end
       sql << "ORDER BY ORDINAL_POSITION"
       execute_query(
         sql,
-        table_name: table_name
+        table_name: table_name,
+        schema_name: schema_name
       ).map do |row|
         Index::Column.new \
           table_name,
           row["INDEX_NAME"],
           row["COLUMN_NAME"],
+          schema_name: schema_name,
           order: row["COLUMN_ORDERING"],
           ordinal_position: row["ORDINAL_POSITION"]
       end
     end
 
-    def indexes table_name, index_name: nil, index_type: nil
+    def indexes table_name, schema_name: "", index_name: nil, index_type: nil
       table_indexes_columns = index_columns(
         table_name,
+        schema_name: schema_name,
         index_name: index_name
       )
 
@@ -158,7 +176,7 @@ module ActiveRecordSpannerAdapter
       sql << " FROM INFORMATION_SCHEMA.INDEXES"
       sql << " WHERE TABLE_NAME=%<table_name>s"
       sql << " AND TABLE_CATALOG = ''"
-      sql << " AND TABLE_SCHEMA = ''"
+      sql << " AND TABLE_SCHEMA = %<schema_name>s"
       sql << " AND INDEX_NAME=%<index_name>s" if index_name
       sql << " AND INDEX_TYPE=%<index_type>s" if index_type
       sql << " AND SPANNER_IS_MANAGED=FALSE"
@@ -166,6 +184,7 @@ module ActiveRecordSpannerAdapter
       execute_query(
         sql,
         table_name: table_name,
+        schema_name: schema_name,
         index_name: index_name,
         index_type: index_type
       ).map do |row|
@@ -189,89 +208,120 @@ module ActiveRecordSpannerAdapter
           null_filtered: row["IS_NULL_FILTERED"],
           interleave_in: row["PARENT_TABLE_NAME"],
           storing: storing,
-          state: row["INDEX_STATE"]
+          state: row["INDEX_STATE"],
+          schema: schema_name
       end
     end
 
-    def index table_name, index_name
-      indexes(table_name, index_name: index_name).first
+    def index table_name, index_name, schema_name: ""
+      indexes(table_name, index_name: index_name, schema_name: schema_name).first
     end
 
-    def index_columns table_name, index_name: nil
+    def index_columns table_name, schema_name: "", index_name: nil
       sql = +"SELECT INDEX_NAME, COLUMN_NAME, COLUMN_ORDERING, ORDINAL_POSITION"
       sql << " FROM INFORMATION_SCHEMA.INDEX_COLUMNS"
       sql << " WHERE TABLE_NAME=%<table_name>s"
       sql << " AND TABLE_CATALOG = ''"
-      sql << " AND TABLE_SCHEMA = ''"
+      sql << " AND TABLE_SCHEMA = %<schema_name>s"
       sql << " AND INDEX_NAME=%<index_name>s" if index_name
       sql << " ORDER BY ORDINAL_POSITION ASC"
 
       execute_query(
         sql,
-        table_name: table_name, index_name: index_name
+        table_name: table_name, schema_name: schema_name, index_name: index_name
       ).map do |row|
         Index::Column.new \
           table_name,
           row["INDEX_NAME"],
           row["COLUMN_NAME"],
+          schema_name: schema_name,
           order: row["COLUMN_ORDERING"],
           ordinal_position: row["ORDINAL_POSITION"]
       end
     end
 
-    def indexes_by_columns table_name, column_names
+    def indexes_by_columns table_name, column_names, schema_name: ""
       column_names = Array(column_names).map(&:to_s)
 
-      indexes(table_name).select do |index|
+      indexes(table_name, schema_name: schema_name).select do |index|
         index.columns.any? { |c| column_names.include? c.name }
       end
     end
 
-    def foreign_keys table_name
+    def foreign_keys from_table_name, from_schema_name: ""
       sql = <<~SQL
-        SELECT cc.table_name AS to_table,
-               cc.column_name AS primary_key,
-               fk.column_name as column,
-               fk.constraint_name AS name,
-               rc.update_rule AS on_update,
-               rc.delete_rule AS on_delete
-        FROM information_schema.referential_constraints rc
-        INNER JOIN information_schema.key_column_usage fk ON rc.constraint_name = fk.constraint_name
-        INNER JOIN information_schema.constraint_column_usage cc ON rc.constraint_name = cc.constraint_name
-        WHERE fk.table_name = %<table_name>s
-          AND fk.constraint_schema = %<constraint_schema>s
+        SELECT CONSTRAINT_CATALOG, CONSTRAINT_SCHEMA, CONSTRAINT_NAME, UPDATE_RULE, DELETE_RULE,
+               FK_CATALOG, FK_SCHEMA, FK_TABLE,
+               PK_CATALOG, PK_SCHEMA, PK_TABLE,
+               ARRAY_AGG(FK_COLUMN) AS FK_COLUMNS, ARRAY_AGG(PK_COLUMN) AS PK_COLUMNS
+        FROM (SELECT CONSTRAINTS.CONSTRAINT_CATALOG,
+                     CONSTRAINTS.CONSTRAINT_SCHEMA,
+                     CONSTRAINTS.CONSTRAINT_NAME,
+                     CONSTRAINTS.UPDATE_RULE,
+                     CONSTRAINTS.DELETE_RULE,
+                     CHILD.TABLE_CATALOG  AS FK_CATALOG,
+                     CHILD.TABLE_SCHEMA   AS FK_SCHEMA,
+                     CHILD.TABLE_NAME     AS FK_TABLE,
+                     CHILD.COLUMN_NAME    AS FK_COLUMN,
+                     PARENT.TABLE_CATALOG AS PK_CATALOG,
+                     PARENT.TABLE_SCHEMA  AS PK_SCHEMA,
+                     PARENT.TABLE_NAME    AS PK_TABLE,
+                     PARENT.COLUMN_NAME   AS PK_COLUMN
+              FROM INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS CONSTRAINTS
+                       INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE CHILD
+                                  ON CONSTRAINTS.CONSTRAINT_CATALOG = CHILD.CONSTRAINT_CATALOG
+                                      AND CONSTRAINTS.CONSTRAINT_SCHEMA = CHILD.CONSTRAINT_SCHEMA
+                                      AND CONSTRAINTS.CONSTRAINT_NAME = CHILD.CONSTRAINT_NAME
+                       INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE PARENT
+                                  ON CONSTRAINTS.UNIQUE_CONSTRAINT_CATALOG = PARENT.CONSTRAINT_CATALOG
+                                      AND CONSTRAINTS.UNIQUE_CONSTRAINT_SCHEMA = PARENT.CONSTRAINT_SCHEMA
+                                      AND CONSTRAINTS.UNIQUE_CONSTRAINT_NAME = PARENT.CONSTRAINT_NAME
+                                      AND PARENT.ORDINAL_POSITION = CHILD.POSITION_IN_UNIQUE_CONSTRAINT
+              ORDER BY CHILD.TABLE_CATALOG, CHILD.TABLE_SCHEMA, CHILD.TABLE_NAME, CHILD.POSITION_IN_UNIQUE_CONSTRAINT
+        ) FOREIGN_KEYS
+        WHERE FK_TABLE = %<table_name>s
+          AND FK_SCHEMA = %<constraint_schema>s
+        GROUP BY CONSTRAINT_CATALOG, CONSTRAINT_SCHEMA, CONSTRAINT_NAME, UPDATE_RULE, DELETE_RULE,
+                 FK_CATALOG, FK_SCHEMA, FK_TABLE,
+                 PK_CATALOG, PK_SCHEMA, PK_TABLE
       SQL
 
       rows = execute_query(
-        sql, table_name: table_name, constraint_schema: ""
+        sql, table_name: from_table_name, constraint_schema: from_schema_name
       )
 
       rows.map do |row|
         ForeignKey.new(
-          table_name,
-          row["name"],
-          row["column"],
-          row["to_table"],
-          row["primary_key"],
-          on_delete: row["on_delete"],
-          on_update: row["on_update"]
+          from_table_name,
+          row["CONSTRAINT_NAME"],
+          row["FK_COLUMNS"],
+          row["PK_TABLE"],
+          row["PK_COLUMNS"],
+          on_delete: row["DELETE_RULE"],
+          on_update: row["UPDATE_RULE"],
+          table_schema: from_schema_name,
+          ref_schema: row["PK_SCHEMA"]
         )
       end
     end
 
-    def check_constraints table_name
+    def check_constraints table_name, schema_name: ""
       sql = <<~SQL.squish
         SELECT tc.TABLE_NAME,
                tc.CONSTRAINT_NAME,
                cc.CHECK_CLAUSE
         FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
-        INNER JOIN INFORMATION_SCHEMA.CHECK_CONSTRAINTS cc ON tc.CONSTRAINT_NAME = cc.CONSTRAINT_NAME
+        INNER JOIN INFORMATION_SCHEMA.CHECK_CONSTRAINTS cc
+            ON tc.CONSTRAINT_CATALOG = cc.CONSTRAINT_CATALOG
+           AND tc.CONSTRAINT_SCHEMA = cc.CONSTRAINT_SCHEMA
+           AND tc.CONSTRAINT_NAME = cc.CONSTRAINT_NAME
         WHERE tc.TABLE_NAME = %<table_name>s
+          AND tc.CONSTRAINT_SCHEMA = %<schema_name>s
           AND tc.CONSTRAINT_TYPE = 'CHECK'
           AND NOT (tc.CONSTRAINT_NAME LIKE 'CK_IS_NOT_NULL_%%' AND cc.CHECK_CLAUSE LIKE '%%IS NOT NULL')
       SQL
 
-      rows = execute_query sql, table_name: table_name
+      rows = execute_query sql, table_name: table_name, schema_name: schema_name
 
       rows.map do |row|
         ActiveRecord::ConnectionAdapters::CheckConstraintDefinition.new(
@@ -354,16 +404,18 @@ module ActiveRecordSpannerAdapter
       [value[start...(start + length)].to_i(base)].pack "U"
     end
 
-    def column_options table_name, column_name
+    def column_options table_name, column_name, schema_name: ""
       sql = +"SELECT COLUMN_NAME, OPTION_NAME, OPTION_TYPE, OPTION_VALUE"
       sql << " FROM INFORMATION_SCHEMA.COLUMN_OPTIONS"
       sql << " WHERE TABLE_NAME=%<table_name>s"
+      sql << " AND TABLE_SCHEMA=%<schema_name>s"
       sql << " AND COLUMN_NAME=%<column_name>s" if column_name
 
       column_options = Hash.new { |h, k| h[k] = {} }
       execute_query(
         sql,
         table_name: table_name,
+        schema_name: schema_name,
         column_name: column_name
       ).each_with_object(column_options) do |row, options|
         next unless row["OPTION_TYPE"] == "BOOL"

data/lib/activerecord_spanner_adapter/primary_key.rb

@@ -18,7 +18,7 @@ module ActiveRecord
         end
 
         def fetch_primary_and_parent_key
-          return connection.schema_cache.primary_and_parent_keys table_name \
+          return connection.spanner_schema_cache.primary_and_parent_keys table_name \
             if ActiveRecord::Base != self && table_exists?
         end
 

data/lib/activerecord_spanner_adapter/table/column.rb

@@ -7,22 +7,24 @@
 module ActiveRecordSpannerAdapter
   class Table
     class Column
-      attr_accessor :table_name, :name, :type, :limit, :ordinal_position,
+      attr_accessor :schema_name, :table_name, :name, :type, :limit, :ordinal_position,
                     :allow_commit_timestamp, :default, :default_function, :generated,
-                    :primary_key
-      attr_writer :nullable
+                    :primary_key, :nullable
 
       def initialize \
           table_name,
           name,
           type,
+          schema_name: "",
           limit: nil,
           ordinal_position: nil,
           nullable: true,
           allow_commit_timestamp: nil,
           default: nil,
           default_function: nil,
-          generated: nil
+          generated: nil,
+          primary_key: false
+        @schema_name = schema_name.to_s
         @table_name = table_name.to_s
         @name = name.to_s
         @type = type
@@ -33,12 +35,7 @@ module ActiveRecordSpannerAdapter
         @default = default
         @default_function = default_function
         @generated = generated == true
-        @primary_key = false
-      end
-
-      def nullable
-        return false if primary_key
-        @nullable
+        @primary_key = primary_key
       end
 
       def spanner_type

data/lib/activerecord_spanner_adapter/version.rb

@@ -5,5 +5,5 @@
 # https://opensource.org/licenses/MIT.
 
 module ActiveRecordSpannerAdapter
-  VERSION = "1.5.1".freeze
+  VERSION = "1.6.1".freeze
 end