sequel 4.36.0 → 5.61.0

data/lib/sequel/adapters/shared/sqlanywhere.rb

@@ -1,54 +1,28 @@
 # frozen-string-literal: true
 
+require_relative '../utils/columns_limit_1'
+
 module Sequel
   module SqlAnywhere
-
-    @convert_smallint_to_bool = true
-
-    class << self
-      # Whether to convert smallint values to bool, false by default.
-      # Can also be overridden per dataset.
-      attr_accessor :convert_smallint_to_bool
-    end
+    Sequel::Database.set_shared_adapter_scheme(:sqlanywhere, self)
 
     module DatabaseMethods
-      extend Sequel::Database::ResetIdentifierMangling
-
       attr_reader :conversion_procs
 
-      # Override the default SqlAnywhere.convert_smallint_to_bool setting for this database.
-      attr_writer :convert_smallint_to_bool
-
-      AUTO_INCREMENT = 'IDENTITY'.freeze
-      SQL_BEGIN = "BEGIN TRANSACTION".freeze
-      SQL_COMMIT = "COMMIT TRANSACTION".freeze
-      SQL_ROLLBACK = "IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION".freeze
-      TEMPORARY = "GLOBAL TEMPORARY ".freeze
-      SMALLINT_RE = /smallint/i.freeze
-      DECIMAL_TYPE_RE = /numeric/io
-
-      # Whether to convert smallint to boolean arguments for this dataset.
-      # Defaults to the SqlAnywhere module setting.
-      def convert_smallint_to_bool
-        defined?(@convert_smallint_to_bool) ? @convert_smallint_to_bool : (@convert_smallint_to_bool = ::Sequel::SqlAnywhere.convert_smallint_to_bool)
-      end
+      # Set whether to convert smallint type to boolean for this Database instance
+      attr_accessor :convert_smallint_to_bool
 
-      # Sysbase Server uses the :sqlanywhere type.
       def database_type
         :sqlanywhere
       end
 
-      def to_application_timestamp_sa(v)
-        to_application_timestamp(v.to_s) if v
+      def freeze
+        @conversion_procs.freeze
+        super
       end
 
-      # Convert smallint type to boolean if convert_smallint_to_bool is true
-      def schema_column_type(db_type)
-        if convert_smallint_to_bool && db_type =~ SMALLINT_RE
-          :boolean
-        else
-          super
-        end
+      def to_application_timestamp_sa(v)
+        to_application_timestamp(v.to_s) if v
       end
 
       def schema_parse_table(table, opts)
@@ -56,15 +30,15 @@ module Sequel
         im = input_identifier_meth(opts[:dataset])
         metadata_dataset.
          from{sa_describe_query("select * from #{im.call(table)}").as(:a)}.
-         join(:syscolumn___b, :table_id=>:base_table_id, :column_id=>:base_column_id).
-         order(:a__column_number).
+         join(Sequel[:syscolumn].as(:b), :table_id=>:base_table_id, :column_id=>:base_column_id).
+         order{a[:column_number]}.
          map do |row|
           auto_increment = row.delete(:is_autoincrement)
           row[:auto_increment] = auto_increment == 1 || auto_increment == true
           row[:primary_key] = row.delete(:pkey) == 'Y'
-          row[:allow_null] = row[:nulls_allowed].is_a?(Fixnum) ? row.delete(:nulls_allowed) == 1 : row.delete(:nulls_allowed)
+          row[:allow_null] = row[:nulls_allowed].is_a?(Integer) ? row.delete(:nulls_allowed) == 1 : row.delete(:nulls_allowed)
           row[:db_type] = row.delete(:domain_name)
-          row[:type] = if row[:db_type] =~ DECIMAL_TYPE_RE and (row[:scale].is_a?(Fixnum) ? row[:scale] == 0 : !row[:scale])
+          row[:type] = if row[:db_type] =~ /numeric/i and (row[:scale].is_a?(Integer) ? row[:scale] == 0 : !row[:scale])
             :integer
           else
             schema_column_type(row[:db_type])
@@ -77,13 +51,18 @@ module Sequel
       def indexes(table, opts = OPTS)
         m = output_identifier_meth
         im = input_identifier_meth
+        table = table.value if table.is_a?(Sequel::SQL::Identifier)
         indexes = {}
         metadata_dataset.
-         from(:dbo__sysobjects___z).
-         select(:z__name___table_name, :i__name___index_name, :si__indextype___type, :si__colnames___columns).
-         join(:dbo__sysindexes___i, :id___i=> :id___z).
-         join(:sys__sysindexes___si, :iname=> :name___i).
-         where(:z__type => 'U', :table_name=>im.call(table)).
+         from(Sequel[:dbo][:sysobjects].as(:z)).
+         select{[
+           z[:name].as(:table_name),
+           i[:name].as(:index_name),
+           si[:indextype].as(:type),
+           si[:colnames].as(:columns)]}.
+         join(Sequel[:dbo][:sysindexes].as(:i), :id=>:id).
+         join(Sequel[:sys][:sysindexes].as(:si), :iname=> :name).
+         where{{z[:type] => 'U', :table_name=>im.call(table)}}.
          each do |r|
           indexes[m.call(r[:index_name])] =
             {:unique=>(r[:type].downcase=='unique'),
@@ -97,11 +76,16 @@ module Sequel
         im = input_identifier_meth
         fk_indexes = {}
         metadata_dataset.
-         from(:sys__sysforeignkey___fk).
-         select(:fk__role___name, :fks__columns___column_map, :si__indextype___type, :si__colnames___columns, :fks__primary_tname___table_name).
-         join(:sys__sysforeignkeys___fks, :role => :role).
-         join_table(:inner, :sys__sysindexes___si, [:iname=> :fk__role], {:implicit_qualifier => :fk}).
-         where(:fks__foreign_tname=>im.call(table)).
+         from{sys[:sysforeignkey].as(:fk)}.
+         select{[
+           fk[:role].as(:name),
+           fks[:columns].as(:column_map),
+           si[:indextype].as(:type),
+           si[:colnames].as(:columns),
+           fks[:primary_tname].as(:table_name)]}.
+         join(Sequel[:sys][:sysforeignkeys].as(:fks), :role => :role).
+         join(Sequel[:sys][:sysindexes].as(:si), {:iname => Sequel[:fk][:role]}, {:implicit_qualifier => :fk}).
+         where{{fks[:foreign_tname]=>im.call(table)}}.
          each do |r|
           unless r[:type].downcase == 'primary key'
             fk_indexes[r[:name]] =
@@ -138,27 +122,28 @@ module Sequel
 
       # Sybase uses the IDENTITY column for autoincrementing columns.
       def auto_increment_sql
-        AUTO_INCREMENT
+        'IDENTITY'
       end
       
-      # SQL fragment for marking a table as temporary
+      # Sybase does not allow adding primary key constraints to NULLable columns.
+      def can_add_primary_key_constraint_on_nullable_columns?
+        false
+      end
+
       def temporary_table_sql
-        TEMPORARY
+        "GLOBAL TEMPORARY "
       end
 
-      # SQL to BEGIN a transaction.
       def begin_transaction_sql
-        SQL_BEGIN
+        "BEGIN TRANSACTION"
       end
 
-      # SQL to ROLLBACK a transaction.
       def rollback_transaction_sql
-        SQL_ROLLBACK
+        "IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION"
       end
 
-      # SQL to COMMIT a transaction.
       def commit_transaction_sql
-        SQL_COMMIT
+        "COMMIT TRANSACTION"
       end
 
       # Sybase has both datetime and timestamp classes, most people are going
@@ -167,12 +152,6 @@ module Sequel
         :datetime
       end
 
-      # Sybase has both datetime and timestamp classes, most people are going
-      # to want datetime
-      def type_literal_generic_time(column)
-        column[:only_time] ? :time : :datetime
-      end
-      
       # Sybase doesn't have a true boolean class, so it uses integer
       def type_literal_generic_trueclass(column)
         :smallint
@@ -183,7 +162,6 @@ module Sequel
         :image
       end
 
-      # Sybase specific syntax for altering tables.
       def alter_table_sql(table, op)
         case op[:op]
         when :add_column
@@ -231,12 +209,21 @@ module Sequel
         "ALTER TABLE #{quote_schema_table(name)} RENAME #{quote_schema_table(new_name)}"
       end
 
+      # Convert smallint type to boolean if convert_smallint_to_bool is true
+      def schema_column_type(db_type)
+        if convert_smallint_to_bool && db_type =~ /smallint/i
+          :boolean
+        else
+          super
+        end
+      end
+
       def tables_and_views(type, opts=OPTS)
         m = output_identifier_meth
         metadata_dataset.
-          from(:sysobjects___a).
-          where(:a__type=>type).
-          select_map(:a__name).
+          from{sysobjects.as(:a)}.
+          where{{a[:type]=>type}}.
+          select_map{a[:name]}.
           map{|n| m.call(n)}
       end
       
@@ -247,42 +234,23 @@ module Sequel
     end
 
     module DatasetMethods
-      BOOL_TRUE = '1'.freeze
-      BOOL_FALSE = '0'.freeze
-      WILDCARD = LiteralString.new('%').freeze
-      TOP = " TOP ".freeze
-      START_AT = " START AT ".freeze
-      SQL_WITH_RECURSIVE = "WITH RECURSIVE ".freeze
-      DATE_FUNCTION = 'today()'.freeze
-      NOW_FUNCTION = 'now()'.freeze
-      DATEPART = 'datepart'.freeze
-      REGEXP = 'REGEXP'.freeze
-      NOT_REGEXP = 'NOT REGEXP'.freeze
-      APOS = Dataset::APOS
-      APOS_RE = Dataset::APOS_RE
-      DOUBLE_APOS = Dataset::DOUBLE_APOS
-      BACKSLASH_RE = /\\/.freeze
-      QUAD_BACKSLASH = "\\\\\\\\".freeze
-      BLOB_START = "0x".freeze
-      HSTAR = "H*".freeze
-      CROSS_APPLY = 'CROSS APPLY'.freeze
-      OUTER_APPLY = 'OUTER APPLY'.freeze
-      ONLY_OFFSET = " TOP 2147483647".freeze
-
-      Dataset.def_sql_method(self, :insert, %w'with insert into columns values')
-      Dataset.def_sql_method(self, :select, %w'with select distinct limit columns into from join where group having order compounds lock')
+      Dataset.def_sql_method(self, :insert, %w'insert into columns values')
+      Dataset.def_sql_method(self, :select, %w'with select distinct limit columns into from join where group having window compounds order lock')
+      include ::Sequel::Dataset::ColumnsLimit1
 
       # Whether to convert smallint to boolean arguments for this dataset.
-      # Defaults to the SqlAnywhere module setting.
+      # Defaults to the IBMDB module setting.
       def convert_smallint_to_bool
-        defined?(@convert_smallint_to_bool) ? @convert_smallint_to_bool : (@convert_smallint_to_bool = @db.convert_smallint_to_bool)
+        opts.has_key?(:convert_smallint_to_bool) ? opts[:convert_smallint_to_bool] : db.convert_smallint_to_bool
       end
 
-      # Override the default SqlAnywhere.convert_smallint_to_bool setting for this dataset.
-      attr_writer :convert_smallint_to_bool
+      # Return a cloned dataset with the convert_smallint_to_bool option set.
+      def with_convert_smallint_to_bool(v)
+        clone(:convert_smallint_to_bool=>v)
+      end
 
       def supports_cte?(type=:select)
-        type == :select || type == :insert
+        type == :select
       end
 
       # SQLAnywhere supports GROUPING SETS
@@ -310,6 +278,14 @@ module Sequel
         false
       end
 
+      def supports_window_clause?
+        true
+      end
+
+      def supports_window_functions?
+        true
+      end
+
       # Uses CROSS APPLY to join the given table into the current dataset.
       def cross_apply(table)
         join_table(:cross_apply, table)
@@ -320,7 +296,6 @@ module Sequel
         true
       end
 
-      # SQLAnywhere uses + for string concatenation, and LIKE is case insensitive by default.
       def complex_expression_sql_append(sql, op, args)
         case op
         when :'||'
@@ -328,12 +303,12 @@ module Sequel
         when :<<, :>>
           complex_expression_emulate_append(sql, op, args)
         when :LIKE, :"NOT LIKE"
-          sql << Sequel::Dataset::PAREN_OPEN
-          literal_append(sql, args.at(0))
-          sql << Sequel::Dataset::SPACE << (op == :LIKE ? REGEXP : NOT_REGEXP) << Sequel::Dataset::SPACE
+          sql << '('
+          literal_append(sql, args[0])
+          sql << (op == :LIKE ? ' REGEXP ' : ' NOT REGEXP ')
           pattern = String.new
           last_c = ''
-          args.at(1).each_char do |c|
+          args[1].each_char do |c|
             if  c == '_' and not pattern.end_with?('\\') and last_c != '\\'
               pattern << '.'
             elsif c == '%' and not pattern.end_with?('\\') and last_c != '\\'
@@ -356,17 +331,17 @@ module Sequel
             end
           end
           literal_append(sql, pattern)
-          sql << Sequel::Dataset::ESCAPE
-          literal_append(sql, Sequel::Dataset::BACKSLASH)
-          sql << Sequel::Dataset::PAREN_CLOSE
+          sql << " ESCAPE "
+          literal_append(sql, "\\")
+          sql << ')'
         when :ILIKE, :"NOT ILIKE"
           super(sql, (op == :ILIKE ? :LIKE : :"NOT LIKE"), args)
         when :extract
-          sql << DATEPART + Sequel::Dataset::PAREN_OPEN
-          literal_append(sql, args.at(0))
+          sql << 'datepart('
+          literal_append(sql, args[0])
           sql << ','
-          literal_append(sql, args.at(1))
-          sql << Sequel::Dataset::PAREN_CLOSE
+          literal_append(sql, args[1])
+          sql << ')'
         else
           super
         end
@@ -377,13 +352,13 @@ module Sequel
         string.gsub(/[\\%_\[]/){|m| "\\#{m}"}
       end
 
-      # Use Date() and Now() for CURRENT_DATE and CURRENT_TIMESTAMP
+      # Use today() for CURRENT_DATE and now() for CURRENT_TIMESTAMP and CURRENT_TIME
       def constant_sql_append(sql, constant)
         case constant
         when :CURRENT_DATE
-          sql << DATE_FUNCTION
+          sql << 'today()'
         when :CURRENT_TIMESTAMP, :CURRENT_TIME
-          sql << NOW_FUNCTION
+          sql << 'now()'
         else
           super
         end
@@ -398,17 +373,17 @@ module Sequel
 
       # Use 1 for true on Sybase
       def literal_true
-        BOOL_TRUE
+        '1'
       end
 
       # Use 0 for false on Sybase
       def literal_false
-        BOOL_FALSE
+        '0'
       end
 
       # SQL fragment for String.  Doubles \ and ' by default.
       def literal_string_append(sql, v)
-        sql << APOS << v.gsub(BACKSLASH_RE, QUAD_BACKSLASH).gsub(APOS_RE, DOUBLE_APOS) << APOS
+        sql << "'" << v.gsub("\\", "\\\\\\\\").gsub("'", "''") << "'"
       end
 
       # SqlAnywhere uses a preceding X for hex escaping strings
@@ -416,7 +391,7 @@ module Sequel
         if v.empty?
           literal_append(sql, "")
         else
-          sql << BLOB_START << v.unpack(HSTAR).first
+          sql << "0x" << v.unpack("H*").first
         end
       end
 
@@ -425,28 +400,32 @@ module Sequel
         :values
       end
 
+      # SQLAnywhere does not natively support NULLS FIRST/LAST.
+      def requires_emulating_nulls_first?
+        true
+      end
+
       def select_into_sql(sql)
         if i = @opts[:into]
-          sql << Sequel::Dataset::INTO
+          sql << " INTO "
           identifier_append(sql, i)
         end
       end
 
-      # Sybase uses TOP N for limit.  For Sybase TOP (N) is used
-      # to allow the limit to be a bound variable.
+      # Sybase uses TOP N for limit.
       def select_limit_sql(sql)
         l = @opts[:limit]
         o = @opts[:offset]
         if l || o
           if l
-            sql << TOP
+            sql << " TOP "
             literal_append(sql, l)
           else
-            sql << ONLY_OFFSET
+            sql << " TOP 2147483647"
           end
 
           if o 
-            sql << START_AT + "("
+            sql << " START AT ("
             literal_append(sql, o)
             sql << " + 1)"
           end
@@ -455,15 +434,15 @@ module Sequel
 
       # Use WITH RECURSIVE instead of WITH if any of the CTEs is recursive
       def select_with_sql_base
-        opts[:with].any?{|w| w[:recursive]} ? SQL_WITH_RECURSIVE : super
+        opts[:with].any?{|w| w[:recursive]} ? "WITH RECURSIVE " : super
       end
 
       def join_type_sql(join_type)
         case join_type
         when :cross_apply
-          CROSS_APPLY
+          'CROSS APPLY'
         when :outer_apply
-          OUTER_APPLY
+          'OUTER APPLY'
         else
           super
         end