activerecord7-redshift-adapter-pennylane 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6815f12cf77e7328f50e3a2ada99bbb916ca2fef0864951950254ac5a1126c13
-  data.tar.gz: 00d93584414a5466d84a85c96a07eaef16cfe112f493d07aab8ac6d68278dc41
+  metadata.gz: e8108a9c785d7604af14ffbaca6265c6350c119406c09951c0a73a2aba888471
+  data.tar.gz: a71d3843e77264799115393dd6ba8bb50717722c292aab9e3e73b0d0463d634e
 SHA512:
-  metadata.gz: 15dfb8bb0b0b6aa0157bb4013f16f1d73775cee2460688efffb968479f8f1c9cc560a63fe615c44cd28699a441f6ad1e659844ad941f95090c0c058b4088b90b
-  data.tar.gz: b3c3ee936bc36246df51c10823723a15879cd47901db1971c4db86ec02a419f61c98d32f8ddae64325c7b4780d087e327324d21382aabf6d8494c511776beb2a
+  metadata.gz: e4fd3c18f5255e06b5e0cb855c516b538304e00de9293108fde3eeb2fa7a90df2539824259af6201b4b14cd3c2d0b148c7357e29bdf00559cfcf1e700cb23ea5
+  data.tar.gz: 96c5852565ca6416135a7a19b49fc384007fbfb7a2bed043dd3d4804caaa765c5ba8fde811e5dc298531bc971d291acdf513b4708276fcddb76f2de489060dbe

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

@@ -57,14 +57,8 @@ module ActiveRecord
           execute "DROP DATABASE #{quote_table_name(name)}"
         end
 
-        # Returns the list of all tables in the schema search path or a specified schema.
-        def tables(name = nil)
-          if name
-            ActiveSupport::Deprecation.warn(<<-MSG.squish)
-              Passing arguments to #tables is deprecated without replacement.
-            MSG
-          end
-
+        # Returns an array of table names defined in the database.
+        def tables
           select_values('SELECT tablename FROM pg_tables WHERE schemaname = ANY(current_schemas(false))', 'SCHEMA')
         end
 
@@ -83,13 +77,17 @@ module ActiveRecord
         # If the schema is not specified as part of +name+ then it will only find tables within
         # the current schema search path (regardless of permissions to access tables in other schemas)
         def table_exists?(name)
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            #table_exists? currently checks both tables and views.
-            This behavior is deprecated and will be changed with Rails 5.1 to only check tables.
-            Use #data_source_exists? instead.
-          MSG
+          name = Utils.extract_schema_qualified_name(name.to_s)
+          return false unless name.identifier
 
-          data_source_exists?(name)
+          select_value(<<-SQL, 'SCHEMA').to_i > 0
+              SELECT COUNT(*)
+              FROM pg_class c
+              LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
+              WHERE c.relkind = 'r' -- (r)elation/table
+              AND c.relname = '#{name.identifier}'
+              AND n.nspname = #{name.schema ? "'#{name.schema}'" : 'ANY (current_schemas(false))'}
+          SQL
         end
 
         def data_source_exists?(name)
@@ -154,7 +152,7 @@ module ActiveRecord
             default_value = extract_value_from_default(default)
             type_metadata = fetch_type_metadata(column_name, type, oid, fmod)
             default_function = extract_default_function(default_value, default)
-            new_column(column_name, default_value, type_metadata, notnull == 'f', table_name, default_function)
+            new_column(column_name, default_value, type_metadata, !notnull, table_name, default_function)
           end
         end
 
@@ -185,7 +183,7 @@ module ActiveRecord
 
         # Returns an array of schema names.
         def schema_names
-          select_value(<<-SQL, 'SCHEMA')
+          select_values(<<-SQL, 'SCHEMA')
             SELECT nspname
               FROM pg_namespace
              WHERE nspname !~ '^pg_.*'

data/lib/active_record/connection_adapters/redshift_7_1/database_statements.rb

@@ -4,227 +4,175 @@ module ActiveRecord
   module ConnectionAdapters
     module Redshift
       module DatabaseStatements
-        def explain(arel, binds = [])
-          sql = "EXPLAIN #{to_sql(arel, binds)}"
-          ExplainPrettyPrinter.new.pp(exec_query(sql, 'EXPLAIN', binds))
-        end
-
-        class ExplainPrettyPrinter # :nodoc:
-          # Pretty prints the result of a EXPLAIN in a way that resembles the output of the
-          # PostgreSQL shell:
-          #
-          #                                     QUERY PLAN
-          #   ------------------------------------------------------------------------------
-          #    Nested Loop Left Join  (cost=0.00..37.24 rows=8 width=0)
-          #      Join Filter: (posts.user_id = users.id)
-          #      ->  Index Scan using users_pkey on users  (cost=0.00..8.27 rows=1 width=4)
-          #            Index Cond: (id = 1)
-          #      ->  Seq Scan on posts  (cost=0.00..28.88 rows=8 width=4)
-          #            Filter: (posts.user_id = 1)
-          #   (6 rows)
-          #
-          def pp(result)
-            header = result.columns.first
-            lines  = result.rows.map(&:first)
-
-            # We add 2 because there's one char of padding at both sides, note
-            # the extra hyphens in the example above.
-            width = [header, *lines].map(&:length).max + 2
-
-            pp = []
-
-            pp << header.center(width).rstrip
-            pp << '-' * width
-
-            pp += lines.map { |line| " #{line}" }
-
-            nrows = result.rows.length
-            rows_label = nrows == 1 ? 'row' : 'rows'
-            pp << "(#{nrows} #{rows_label})"
-
-            "#{pp.join("\n")}\n"
-          end
+        def explain(arel, binds = [], options = [])
+          sql    = build_explain_clause(options) + " " + to_sql(arel, binds)
+          result = internal_exec_query(sql, "EXPLAIN", binds)
+          PostgreSQL::ExplainPrettyPrinter.new.pp(result)
         end
 
-        def select_value(arel, name = nil, binds = [])
-          # In Rails 5.2, arel_from_relation replaced binds_from_relation,
-          # so we see which method exists to get the variables
-          #
-          # In Rails 6.0 to_sql_and_binds began only returning sql, with
-          # to_sql_and_binds serving as a replacement
-          if respond_to?(:arel_from_relation, true)
-            arel = arel_from_relation(arel)
-            sql, binds = to_sql_and_binds(arel, binds)
-          else
-            arel, binds = binds_from_relation arel, binds
-            sql = to_sql(arel, binds)
-          end
-          execute_and_clear(sql, name, binds) do |result|
-            result.getvalue(0, 0) if result.ntuples > 0 && result.nfields > 0
-          end
-        end
-
-        def select_values(arel, name = nil)
-          # In Rails 5.2, arel_from_relation replaced binds_from_relation,
-          # so we see which method exists to get the variables
-          #
-          # In Rails 6.0 to_sql_and_binds began only returning sql, with
-          # to_sql_and_binds serving as a replacement
-          if respond_to?(:arel_from_relation, true)
-            arel = arel_from_relation(arel)
-            sql, binds = to_sql_and_binds(arel, [])
-          else
-            arel, binds = binds_from_relation arel, []
-            sql = to_sql(arel, binds)
-          end
+        # Queries the database and returns the results in an Array-like object
+        def query(sql, name = nil) # :nodoc:
+          mark_transaction_written_if_write(sql)
 
-          execute_and_clear(sql, name, binds) do |result|
-            if result.nfields > 0
-              result.column_values(0)
-            else
-              []
+          log(sql, name) do
+            with_raw_connection do |conn|
+              result = conn.async_exec(sql).map_types!(@type_map_for_results).values
+              verified!
+              result
             end
           end
         end
 
-        # Executes a SELECT query and returns an array of rows. Each row is an
-        # array of field values.
-        def select_rows(arel, name = nil, binds = [])
-          if respond_to?(:arel_from_relation, true)
-            arel = arel_from_relation(arel)
-            sql, binds = to_sql_and_binds(arel, [])
-          else
-            arel, binds = binds_from_relation arel, []
-            sql = to_sql(arel, binds)
-          end
-          execute_and_clear(sql, name, binds, &:values)
-        end
-
-        # The internal PostgreSQL identifier of the money data type.
-        MONEY_COLUMN_TYPE_OID = 790 # :nodoc:
-        # The internal PostgreSQL identifier of the BYTEA data type.
-        BYTEA_COLUMN_TYPE_OID = 17 # :nodoc:
-
-        # create a 2D array representing the result set
-        def result_as_array(res) # :nodoc:
-          # check if we have any binary column and if they need escaping
-          ftypes = Array.new(res.nfields) do |i|
-            [i, res.ftype(i)]
-          end
-
-          rows = res.values
-          return rows unless ftypes.any? do |_, x|
-            [BYTEA_COLUMN_TYPE_OID, MONEY_COLUMN_TYPE_OID].include?(x)
-          end
-
-          typehash = ftypes.group_by { |_, type| type }
-          binaries = typehash[BYTEA_COLUMN_TYPE_OID] || []
-          monies   = typehash[MONEY_COLUMN_TYPE_OID] || []
-
-          rows.each do |row|
-            # unescape string passed BYTEA field (OID == 17)
-            binaries.each do |index, _|
-              row[index] = unescape_bytea(row[index])
-            end
-
-            # If this is a money type column and there are any currency symbols,
-            # then strip them off. Indeed it would be prettier to do this in
-            # PostgreSQLColumn.string_to_decimal but would break form input
-            # fields that call value_before_type_cast.
-            monies.each do |index, _|
-              data = row[index]
-              # Because money output is formatted according to the locale, there are two
-              # cases to consider (note the decimal separators):
-              #  (1) $12,345,678.12
-              #  (2) $12.345.678,12
-              case data
-              when /^-?\D+[\d,]+\.\d{2}$/ # (1)
-                data.gsub!(/[^-\d.]/, '')
-              when /^-?\D+[\d.]+,\d{2}$/ # (2)
-                data.gsub!(/[^-\d,]/, '').sub!(/,/, '.')
-              end
-            end
-          end
-        end
+        READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
+          :close, :declare, :fetch, :move, :set, :show
+        ) # :nodoc:
+        private_constant :READ_QUERY
 
-        # Queries the database and returns the results in an Array-like object
-        def query(sql, name = nil) # :nodoc:
-          log(sql, name) do
-            result_as_array @raw_connection.async_exec(sql)
-          end
+        def write_query?(sql) # :nodoc:
+          !READ_QUERY.match?(sql)
+        rescue ArgumentError # Invalid encoding
+          !READ_QUERY.match?(sql.b)
         end
 
         # Executes an SQL statement, returning a PG::Result object on success
         # or raising a PG::Error exception otherwise.
-        def execute(sql, name = nil)
-          log(sql, name) do
-            @raw_connection.async_exec(sql)
+        #
+        # Setting +allow_retry+ to true causes the db to reconnect and retry
+        # executing the SQL statement in case of a connection-related exception.
+        # This option should only be enabled for known idempotent queries.
+        #
+        # Note: the PG::Result object is manually memory managed; if you don't
+        # need it specifically, you may want consider the <tt>exec_query</tt> wrapper.
+        def execute(...) # :nodoc:
+          super
+        ensure
+          @notice_receiver_sql_warnings = []
+        end
+
+        def raw_execute(sql, name, async: false, allow_retry: false, materialize_transactions: true)
+          log(sql, name, async: async) do
+            with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
+              result = conn.async_exec(sql)
+              verified!
+              handle_warnings(result)
+              result
+            end
           end
         end
 
-        def exec_query(sql, name = 'SQL', binds = [], prepare: false)
-          execute_and_clear(sql, name, binds, prepare: prepare) do |result|
+        def internal_exec_query(sql, name = "SQL", binds = [], prepare: false, async: false, allow_retry: false, materialize_transactions: true) # :nodoc:
+          execute_and_clear(sql, name, binds, prepare: prepare, async: async, allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |result|
             types = {}
             fields = result.fields
             fields.each_with_index do |fname, i|
               ftype = result.ftype i
               fmod  = result.fmod i
-              types[fname] = get_oid_type(ftype, fmod, fname)
+              types[fname] = types[i] = get_oid_type(ftype, fmod, fname)
             end
-            ActiveRecord::Result.new(fields, result.values, types)
+            build_result(columns: fields, rows: result.values, column_types: types)
           end
         end
-        alias internal_exec_query exec_query
 
-        def exec_delete(sql, name = nil, binds = [])
-          execute_and_clear(sql, name, binds, &:cmd_tuples)
+        def exec_delete(sql, name = nil, binds = []) # :nodoc:
+          execute_and_clear(sql, name, binds) { |result| result.cmd_tuples }
         end
-        alias exec_update exec_delete
+        alias :exec_update :exec_delete
 
-        def sql_for_insert(sql, pk, binds, returning)
-          if pk.nil?
-            # Extract the table from the insert sql. Yuck.
-            table_ref = extract_table_ref_from_insert_sql(sql)
-            pk = primary_key(table_ref) if table_ref
-          end
-
-          sql = "#{sql} RETURNING #{quote_column_name(pk)}" if pk && use_insert_returning?
-
-          super
-        end
-
-        def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil, returning: nil)
-          val = exec_query(sql, name, binds)
-          if !use_insert_returning? && pk
+        def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil, returning: nil) # :nodoc:
+          if use_insert_returning? || pk == false
+            super
+          else
+            result = internal_exec_query(sql, name, binds)
             unless sequence_name
               table_ref = extract_table_ref_from_insert_sql(sql)
-              sequence_name = default_sequence_name(table_ref, pk)
-              return val unless sequence_name
+              if table_ref
+                pk = primary_key(table_ref) if pk.nil?
+                pk = suppress_composite_primary_key(pk)
+                sequence_name = default_sequence_name(table_ref, pk)
+              end
+              return result unless sequence_name
             end
             last_insert_id_result(sequence_name)
-          else
-            val
           end
         end
 
         # Begins a transaction.
         def begin_db_transaction
-          execute 'BEGIN'
+          internal_execute('BEGIN', allow_retry: true, materialize_transactions: false)
         end
 
         def begin_isolated_db_transaction(isolation)
           begin_db_transaction
-          execute "SET TRANSACTION ISOLATION LEVEL #{transaction_isolation_levels.fetch(isolation)}"
+          internal_execute("SET TRANSACTION ISOLATION LEVEL #{transaction_isolation_levels.fetch(isolation)}", allow_retry: true, materialize_transactions: false)
         end
 
         # Commits a transaction.
         def commit_db_transaction
-          execute 'COMMIT'
+          internal_execute('COMMIT', allow_retry: false, materialize_transactions: true)
         end
 
         # Aborts a transaction.
         def exec_rollback_db_transaction
-          execute 'ROLLBACK'
+          internal_execute('ROLLBACK', allow_retry: false, materialize_transactions: true)
+        end
+
+        def exec_restart_db_transaction # :nodoc:
+          cancel_any_running_query
+          exec_rollback_db_transaction
+          begin_db_transaction
+        end
+
+        # From https://www.postgresql.org/docs/current/functions-datetime.html#FUNCTIONS-DATETIME-CURRENT
+        HIGH_PRECISION_CURRENT_TIMESTAMP = Arel.sql("CURRENT_TIMESTAMP").freeze # :nodoc:
+        private_constant :HIGH_PRECISION_CURRENT_TIMESTAMP
+
+        def high_precision_current_timestamp
+          HIGH_PRECISION_CURRENT_TIMESTAMP
+        end
+
+        def build_explain_clause(options = [])
+          return "EXPLAIN" if options.empty?
+
+          "EXPLAIN (#{options.join(", ").upcase})"
+        end
+
+        private
+
+        IDLE_TRANSACTION_STATUSES = [PG::PQTRANS_IDLE, PG::PQTRANS_INTRANS, PG::PQTRANS_INERROR]
+        private_constant :IDLE_TRANSACTION_STATUSES
+
+        def cancel_any_running_query
+          return if @raw_connection.nil? || IDLE_TRANSACTION_STATUSES.include?(@raw_connection.transaction_status)
+
+          @raw_connection.cancel
+          @raw_connection.block
+        rescue PG::Error
+        end
+
+        # Returns the current ID of a table's sequence.
+        def last_insert_id_result(sequence_name)
+          internal_exec_query("SELECT currval(#{quote(sequence_name)})", "SQL")
+        end
+
+        def returning_column_values(result)
+          result.rows.first
+        end
+
+        def suppress_composite_primary_key(pk)
+          pk unless pk.is_a?(Array)
+        end
+
+        def handle_warnings(sql)
+          @notice_receiver_sql_warnings.each do |warning|
+            next if warning_ignored?(warning)
+
+            warning.sql = sql
+            ActiveRecord.db_warnings_action.call(warning)
+          end
+        end
+
+        def warning_ignored?(warning)
+          ["WARNING", "ERROR", "FATAL", "PANIC"].exclude?(warning.level) || super
         end
       end
     end

data/lib/active_record/connection_adapters/redshift_7_1/quoting.rb

@@ -4,21 +4,26 @@ module ActiveRecord
   module ConnectionAdapters
     module Redshift
       module Quoting
+        QUOTED_COLUMN_NAMES = Concurrent::Map.new # :nodoc:
+        QUOTED_TABLE_NAMES = Concurrent::Map.new # :nodoc:
+
         # Escapes binary strings for bytea input to the database.
         def escape_bytea(value)
-          @raw_connection.escape_bytea(value) if value
+          valid_raw_connection.escape_bytea(value) if value
         end
 
         # Unescapes bytea output from a database to the binary string it represents.
         # NOTE: This is NOT an inverse of escape_bytea! This is only to be used
         # on escaped binary output from database drive.
         def unescape_bytea(value)
-          @raw_connection.unescape_bytea(value) if value
+          valid_raw_connection.unescape_bytea(value) if value
         end
 
         # Quotes strings for use in SQL input.
         def quote_string(s) # :nodoc:
-          @raw_connection.escape(s)
+          with_raw_connection(allow_retry: true, materialize_transactions: false) do |connection|
+            connection.escape(s)
+          end
         end
 
         # Checks the following cases:
@@ -30,7 +35,7 @@ module ActiveRecord
         # - "schema.name".table_name
         # - "schema.name"."table.name"
         def quote_table_name(name)
-          Utils.extract_schema_qualified_name(name.to_s).quoted
+          QUOTED_TABLE_NAMES[name] ||= Utils.extract_schema_qualified_name(name.to_s).quoted.freeze
         end
 
         def quote_table_name_for_assignment(_table, attr)
@@ -39,7 +44,7 @@ module ActiveRecord
 
         # Quotes column names for use in SQL queries.
         def quote_column_name(name) # :nodoc:
-          PG::Connection.quote_ident(name.to_s)
+          QUOTED_COLUMN_NAMES[name] ||= PG::Connection.quote_ident(super).freeze
         end
 
         # Quotes schema names for use in SQL queries.
@@ -49,13 +54,16 @@ module ActiveRecord
 
         # Quote date/time values for use in SQL input.
         def quoted_date(value) # :nodoc:
-          result = super
-
           if value.year <= 0
-            bce_year = format('%04d', -value.year + 1)
-            result = "#{result.sub(/^-?\d+/, bce_year)} BC"
+            bce_year = format("%04d", -value.year + 1)
+            super.sub(/^-?\d+/, bce_year) + " BC"
+          else
+            super
           end
-          result
+        end
+
+        def quoted_binary(value) # :nodoc:
+          "'#{escape_bytea(value.to_s)}'"
         end
 
         # Does not quote function default values for UUID columns
@@ -69,14 +77,24 @@ module ActiveRecord
 
         def quote(value)
           case value
-          when Type::Binary::Data
-            "'#{escape_bytea(value.to_s)}'"
-          when Float
-            if value.infinite? || value.nan?
-              "'#{value}'"
-            else
+          when Numeric
+            if value.finite?
               super
+            else
+              "'#{value}'"
             end
+          when Type::Binary::Data
+            "'#{escape_bytea(value.to_s)}'"
+          else
+            super
+          end
+        end
+
+        def quote_default_expression(value, column) # :nodoc:
+          if value.is_a?(Proc)
+            value.call
+          elsif column.type == :uuid && value.is_a?(String) && value.include?("()")
+            value # Does not quote function default values for UUID columns
           else
             super
           end
@@ -93,6 +111,50 @@ module ActiveRecord
             super
           end
         end
+
+        def lookup_cast_type_from_column(column) # :nodoc:
+          verify! if type_map.nil?
+          type_map.lookup(column.oid, column.fmod, column.sql_type)
+        end
+
+        def column_name_matcher
+          COLUMN_NAME
+        end
+
+        def column_name_with_order_matcher
+          COLUMN_NAME_WITH_ORDER
+        end
+
+        COLUMN_NAME = /
+          \A
+          (
+            (?:
+              # "schema_name"."table_name"."column_name"::type_name | function(one or no argument)::type_name
+              ((?:\w+\.|"\w+"\.){,2}(?:\w+|"\w+")(?:::\w+)? | \w+\((?:|\g<2>)\)(?:::\w+)?)
+            )
+            (?:(?:\s+AS)?\s+(?:\w+|"\w+"))?
+          )
+          (?:\s*,\s*\g<1>)*
+          \z
+        /ix
+
+        COLUMN_NAME_WITH_ORDER = /
+          \A
+          (
+            (?:
+              # "schema_name"."table_name"."column_name"::type_name | function(one or no argument)::type_name
+              ((?:\w+\.|"\w+"\.){,2}(?:\w+|"\w+")(?:::\w+)? | \w+\((?:|\g<2>)\)(?:::\w+)?)
+            )
+            (?:\s+COLLATE\s+"\w+")?
+            (?:\s+ASC|\s+DESC)?
+            (?:\s+NULLS\s+(?:FIRST|LAST))?
+          )
+          (?:\s*,\s*\g<1>)*
+          \z
+        /ix
+
+        private_constant :COLUMN_NAME, :COLUMN_NAME_WITH_ORDER
+
       end
     end
   end

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

@@ -57,14 +57,8 @@ module ActiveRecord
           execute "DROP DATABASE #{quote_table_name(name)}"
         end
 
-        # Returns the list of all tables in the schema search path or a specified schema.
-        def tables(name = nil)
-          if name
-            ActiveSupport::Deprecation.warn(<<-MSG.squish)
-              Passing arguments to #tables is deprecated without replacement.
-            MSG
-          end
-
+        # Returns an array of table names defined in the database.
+        def tables
           select_values('SELECT tablename FROM pg_tables WHERE schemaname = ANY(current_schemas(false))', 'SCHEMA')
         end
 
@@ -83,13 +77,17 @@ module ActiveRecord
         # If the schema is not specified as part of +name+ then it will only find tables within
         # the current schema search path (regardless of permissions to access tables in other schemas)
         def table_exists?(name)
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            #table_exists? currently checks both tables and views.
-            This behavior is deprecated and will be changed with Rails 5.1 to only check tables.
-            Use #data_source_exists? instead.
-          MSG
+          name = Utils.extract_schema_qualified_name(name.to_s)
+          return false unless name.identifier
 
-          data_source_exists?(name)
+          select_value(<<-SQL, 'SCHEMA').to_i > 0
+              SELECT COUNT(*)
+              FROM pg_class c
+              LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
+              WHERE c.relkind = 'r' -- (r)elation/table
+              AND c.relname = '#{name.identifier}'
+              AND n.nspname = #{name.schema ? "'#{name.schema}'" : 'ANY (current_schemas(false))'}
+          SQL
         end
 
         def data_source_exists?(name)
@@ -154,7 +152,7 @@ module ActiveRecord
             default_value = extract_value_from_default(default)
             type_metadata = fetch_type_metadata(column_name, type, oid, fmod)
             default_function = extract_default_function(default_value, default)
-            new_column(column_name, default_value, type_metadata, notnull == 'f', table_name, default_function)
+            new_column(column_name, default_value, type_metadata, !notnull, table_name, default_function)
           end
         end
 
@@ -185,7 +183,7 @@ module ActiveRecord
 
         # Returns an array of schema names.
         def schema_names
-          select_value(<<-SQL, 'SCHEMA')
+          select_values(<<-SQL, 'SCHEMA')
             SELECT nspname
               FROM pg_namespace
              WHERE nspname !~ '^pg_.*'