activerecord-spanner-adapter 1.6.0 → 1.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ad2384bb1890bb224c89a146c42f615f89c6e2892848da5e701a091d90fa95b
-  data.tar.gz: 0e8a9c608068ff30011bc9bca68b10ab0d22b910260a37a6d4a492365adf78b0
+  metadata.gz: 931e6b17bf3e6d6b068c57ca879bc0dbb06933790101aa05415514c6448fd004
+  data.tar.gz: c4981e814899be433830e0380f69060dfa589ec39dfa7e831aad616e224030ec
 SHA512:
-  metadata.gz: 1894765bbc1e3dfac270d73199a4f235ae95724ca18145d6850cce27c38ef2018b59e9035cf2fa91bc30d3f650e080b8eea58c3e91a66035db3a4d07c35ca1be
-  data.tar.gz: 4a9b93d7990fa78f901864bed816e75ff5d0f9da34a530c7107f475d8fd06dc71817fbf8b2c1e0262e4656bf7ab363917ecf7b7c82315b6d5fa84cce0d22489d
+  metadata.gz: a989bdd8195d98206802a05294b09a53fe76c0684fba781d22dc15aaa5a38106ee3f193555cbe83e5f65254e3b39d95ed1cfb6445ded245ad80683d9752fdfd2
+  data.tar.gz: 0dbe1209ccad8da313fafb110bbb4fb2c1ef9ff9209230e88673f031ad02c0c372a13422fd2a5756fb0bc97a2318c003433350e071f64bcef37ba5a7754e868e

data/.github/workflows/rubocop.yaml

@@ -18,7 +18,7 @@ jobs:
       with:
         ruby-version: '2.7'
     - name: cache gems
-      uses: actions/cache@v3
+      uses: actions/cache@v4
       with:
         path: vendor/bundle
         key: ${{ runner.os }}-rubocop-${{ hashFiles('**/Gemfile.lock') }}

data/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "1.6.0"
+  ".": "1.6.1"
 }

data/.rubocop.yml

@@ -41,6 +41,6 @@ Style/WordArray:
 Style/RegexpLiteral:
   Enabled: false
 Metrics/MethodLength:
-  Max: 40
+  Max: 60
 Metrics/BlockLength:
   Max: 30

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+### 1.6.1 (2024-02-05)
+
+#### Bug Fixes
+
+* _insert_record failed for other adapters ([#298](https://github.com/googleapis/ruby-spanner-activerecord/issues/298)) 
+
 ### 1.6.0 (2023-12-20)
 
 #### Features

data/Gemfile

@@ -8,9 +8,11 @@ gem "minitest", "~> 5.20.0"
 gem "minitest-rg", "~> 5.3.0"
 gem "pry", "~> 0.13.0"
 gem "pry-byebug", "~> 3.9.0"
+# Add sqlite3 for testing for compatibility with other adapters.
+gem "sqlite3"
 
 # Required for samples and testing.
-install_if -> { ENV.fetch("AR_VERSION", "~> 6.1.6.1").dup.to_s.sub!("~>", "").strip < "7.1.0" && !ENV["SKIP_COMPOSITE_PK"] } do
+install_if -> { ENV.fetch("AR_VERSION", "~> 6.1.6.1").dup.to_s.sub("~>", "").strip < "7.1.0" && !ENV["SKIP_COMPOSITE_PK"] } do
   gem "composite_primary_keys"
 end
 

data/benchmarks/application.rb

@@ -12,7 +12,7 @@ require_relative "models/singer"
 require_relative "models/album"
 
 class Application
-  def self.run # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+  def self.run # rubocop:disable Metrics/AbcSize
     ActiveRecord::Base.logger.level = Logger::WARN
     config = ActiveRecord::Base.connection_config
     spanner = Google::Cloud::Spanner.new project: config[:project], credentials: config[:credentials]

data/examples/snippets/read-only-transactions/application.rb

@@ -10,7 +10,7 @@ require_relative "models/singer"
 require_relative "models/album"
 
 class Application
-  def self.run # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+  def self.run # rubocop:disable Metrics/AbcSize
     # Use a read-only transaction to execute multiple reads at the same commit timestamp.
     # The Spanner ActiveRecord adapter supports the custom isolation level :read_only that
     # will start a read-only Spanner transaction with a strong timestamp bound.

data/lib/active_record/connection_adapters/spanner/schema_creation.rb

@@ -11,7 +11,6 @@ module ActiveRecord
         private
 
         # rubocop:disable Naming/MethodName, Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
-        # rubocop:disable Metrics/MethodLength
 
         def visit_TableDefinition o
           create_sql = +"CREATE TABLE #{quote_table_name o.name} "
@@ -133,7 +132,6 @@ module ActiveRecord
         end
 
         # rubocop:enable Naming/MethodName, Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
-        # rubocop:enable Metrics/MethodLength
 
         def add_column_options! column, sql, options
           if options[:null] == false || options[:primary_key] == true

data/lib/active_record/connection_adapters/spanner/schema_statements.rb

@@ -40,6 +40,15 @@ module ActiveRecord
         end
         alias data_source_exists? table_exists?
 
+        def extract_schema_qualified_name string
+          schema, name = string.to_s.scan(/[^`.\s]+|`[^`]*`/)
+          unless name
+            name = schema
+            schema = nil
+          end
+          [schema, name]
+        end
+
         def create_table table_name, id: :primary_key, **options
           td = create_table_definition table_name, options
 

data/lib/activerecord_spanner_adapter/base.rb

@@ -49,7 +49,10 @@ module ActiveRecord
     end
 
     def self._insert_record values, returning = []
-      return super unless buffered_mutations? || (primary_key && values.is_a?(Hash))
+      if !(buffered_mutations? || (primary_key && values.is_a?(Hash))) || !spanner_adapter?
+        return super values if ActiveRecord.gem_version < VERSION_7_1
+        return super
+      end
 
       # Mutations cannot be used in combination with a sequence, as mutations do not support a THEN RETURN clause.
       if buffered_mutations? && sequence_name
@@ -59,6 +62,10 @@ module ActiveRecord
 
       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

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

@@ -24,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"
@@ -45,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,
@@ -63,26 +63,28 @@ 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|
-        _create_column table_name, row, primary_keys, column_options
+        _create_column table_name, row, primary_keys, column_options, schema_name: schema_name
       end
     end
 
-    def _create_column table_name, row, primary_keys, column_options
+    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]
@@ -104,6 +106,7 @@ module ActiveRecordSpannerAdapter
         table_name,
         column_name,
         type,
+        schema_name: schema_name,
         limit: limit,
         allow_commit_timestamp: options["allow_commit_timestamp"],
         ordinal_position: row["ORDINAL_POSITION"],
@@ -114,8 +117,8 @@ module ActiveRecordSpannerAdapter
         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
@@ -123,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 = IsRails71OrLater
+    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
       )
 
@@ -167,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"
@@ -175,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|
@@ -198,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(
@@ -363,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/table/column.rb

@@ -7,7 +7,7 @@
 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, :nullable
 
@@ -15,6 +15,7 @@ module ActiveRecordSpannerAdapter
           table_name,
           name,
           type,
+          schema_name: "",
           limit: nil,
           ordinal_position: nil,
           nullable: true,
@@ -23,6 +24,7 @@ module ActiveRecordSpannerAdapter
           default_function: nil,
           generated: nil,
           primary_key: false
+        @schema_name = schema_name.to_s
         @table_name = table_name.to_s
         @name = name.to_s
         @type = type

data/lib/activerecord_spanner_adapter/version.rb

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

data/lib/spanner_client_ext.rb

@@ -68,7 +68,12 @@ module Google
           snp_grpc = service.create_snapshot \
             path, timestamp: (timestamp || read_timestamp),
             staleness: (staleness || exact_staleness)
-          Snapshot.from_grpc snp_grpc, self
+          num_args = Snapshot.method(:from_grpc).arity
+          if num_args == 3
+            Snapshot.from_grpc snp_grpc, self, nil
+          else
+            Snapshot.from_grpc snp_grpc, self
+          end
         end
 
         def create_pdml

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-spanner-adapter
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.6.1
 platform: ruby
 authors:
 - Google LLC
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-12-20 00:00:00.000000000 Z
+date: 2024-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: google-cloud-spanner
@@ -577,7 +577,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
+rubygems_version: 3.5.3
 signing_key: 
 specification_version: 4
 summary: Rails ActiveRecord connector for Google Spanner Database