sequel 3.39.0 → 3.40.0

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

@@ -0,0 +1,216 @@
+Sequel.require 'adapters/utils/split_alter_table'
+
+module Sequel
+  module Cubrid
+    module DatabaseMethods
+      include Sequel::Database::SplitAlterTable
+
+      AUTOINCREMENT = 'AUTO_INCREMENT'.freeze
+      COLUMN_DEFINITION_ORDER = [:auto_increment, :default, :null, :unique, :primary_key, :references]
+
+      def database_type
+        :cubrid
+      end
+
+      def indexes(table, opts={})
+        m = output_identifier_meth
+        m2 = input_identifier_meth
+        indexes = {}
+        metadata_dataset.
+          from(:db_index___i).
+          join(:db_index_key___k, :index_name=>:index_name, :class_name=>:class_name).
+          where(:i__class_name=>m2.call(table), :is_primary_key=>'NO').
+          order(:k__key_order).
+          select(:i__index_name, :k__key_attr_name___column, :is_unique).
+          each do |row|
+            index = indexes[m.call(row[:index_name])] ||= {:columns=>[], :unique=>row[:is_unique]=='YES'}
+            index[:columns] << m.call(row[:column])
+          end
+        indexes
+      end
+
+      def supports_savepoints?
+        false
+      end
+
+      def schema_parse_table(table_name, opts)
+        m = output_identifier_meth(opts[:dataset])
+        m2 = input_identifier_meth(opts[:dataset])
+
+        pks = metadata_dataset.
+          from(:db_index___i).
+          join(:db_index_key___k, :index_name=>:index_name, :class_name=>:class_name).
+          where(:i__class_name=>m2.call(table_name), :is_primary_key=>'YES').
+          order(:k__key_order).
+          select_map(:k__key_attr_name).
+          map{|c| m.call(c)}
+
+        metadata_dataset.
+          from(:db_attribute).
+          where(:class_name=>m2.call(table_name)).
+          order(:def_order).
+          select(:attr_name, :data_type___db_type, :default_value___default, :is_nullable___allow_null).
+          map do |row|
+            name = m.call(row.delete(:attr_name))
+            row[:allow_null] = row[:allow_null] == 'YES'
+            row[:primary_key] = pks.include?(name)
+            row[:type] = schema_column_type(row[:db_type])
+            [name, row]
+          end
+      end
+
+      def tables(opts={})
+        _tables('CLASS')
+      end
+
+      def views(opts={})
+        _tables('VCLASS')
+      end
+
+      private
+
+      def _tables(type)
+        m = output_identifier_meth
+        metadata_dataset.
+          from(:db_class).
+          where(:is_system_class=>'NO', :class_type=>type).
+          select_map(:class_name).
+          map{|c| m.call(c)}
+      end
+
+      def alter_table_op_sql(table, op)
+        case op[:op]
+        when :rename_column
+          "RENAME COLUMN #{quote_identifier(op[:name])} AS #{quote_identifier(op[:new_name])}"
+        when :set_column_type, :set_column_null, :set_column_default
+          o = op[:op]
+          opts = schema(table).find{|x| x.first == op[:name]}
+          opts = opts ? opts.last.dup : {}
+          opts[:name] = o == :rename_column ? op[:new_name] : op[:name]
+          opts[:type] = o == :set_column_type ? op[:type] : opts[:db_type]
+          opts[:null] = o == :set_column_null ? op[:null] : opts[:allow_null]
+          opts[:default] = o == :set_column_default ? op[:default] : opts[:ruby_default]
+          opts.delete(:default) if opts[:default] == nil
+          "CHANGE COLUMN #{quote_identifier(op[:name])} #{column_definition_sql(op.merge(opts))}"
+        else
+          super
+        end
+      end
+
+      def alter_table_sql(table, op)
+        case op[:op]
+        when :drop_index
+          "ALTER TABLE #{quote_schema_table(table)} #{drop_index_sql(table, op)}"
+        else
+          super
+        end
+      end
+
+      def auto_increment_sql
+        AUTOINCREMENT
+      end
+
+      # CUBRID requires auto increment before primary key
+      def column_definition_order
+        COLUMN_DEFINITION_ORDER
+      end
+
+      # CUBRID requires FOREIGN KEY keywords before a column reference
+      def column_references_sql(column)
+        sql = super
+        sql = " FOREIGN KEY#{sql}" unless column[:columns]
+        sql
+      end
+
+      def connection_execute_method
+        :query
+      end
+
+      # CUBRID is case insensitive, so don't modify identifiers
+      def identifier_input_method_default
+        nil
+      end
+
+      # CUBRID is case insensitive, so don't modify identifiers
+      def identifier_output_method_default
+        nil
+      end
+
+      # CUBRID doesn't support booleans, it recommends using smallint.
+      def type_literal_generic_trueclass(column)
+        :smallint
+      end
+
+      # CUBRID uses clob for text types.
+      def uses_clob_for_text?
+        true
+      end
+    end
+    
+    module DatasetMethods
+      SELECT_CLAUSE_METHODS = Sequel::Dataset.clause_methods(:select, %w'select distinct columns from join where group having compounds order limit')
+      LIMIT = Sequel::Dataset::LIMIT
+      COMMA = Sequel::Dataset::COMMA
+      BOOL_FALSE = '0'.freeze
+      BOOL_TRUE = '1'.freeze
+
+      def complex_expression_sql_append(sql, op, args)
+        case op
+        when :ILIKE
+          super(sql, :LIKE, [SQL::Function.new(:upper, args.at(0)), SQL::Function.new(:upper, args.at(1))])
+        when :"NOT ILIKE"
+          super(sql, :"NOT LIKE", [SQL::Function.new(:upper, args.at(0)), SQL::Function.new(:upper, args.at(1))])
+        else
+          super
+        end
+      end
+
+      def supports_join_using?
+        false
+      end
+
+      def supports_multiple_column_in?
+        false
+      end
+
+      def supports_timestamp_usecs?
+        false
+      end
+
+      # CUBRID supposedly supports TRUNCATE, but it appears not to work in my testing.
+      # Fallback to using DELETE.
+      def truncate
+        delete
+        nil
+      end
+
+      private
+
+      def literal_false
+        BOOL_FALSE
+      end
+
+      def literal_true
+        BOOL_TRUE
+      end
+     
+      # CUBRID doesn't support CTEs or FOR UPDATE.
+      def select_clause_methods
+        SELECT_CLAUSE_METHODS
+      end
+
+      # CUBRID requires a limit to use an offset,
+      # and requires a FROM table if a limit is used.
+      def select_limit_sql(sql)
+        if @opts[:from] && (l = @opts[:limit])
+          sql << LIMIT
+          if o = @opts[:offset]
+            literal_append(sql, o)
+            sql << COMMA
+          end
+          literal_append(sql, l)
+        end
+      end
+    end
+  end
+end

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

@@ -123,10 +123,10 @@ module Sequel
       end
 
       # Supply columns with NOT NULL if they are part of a composite
-      # primary/foreign key
+      # primary key or unique constraint
       def column_list_sql(g)
         ks = []
-        g.constraints.each{|c| ks = c[:columns] if [:primary_key, :foreign_key].include? c[:type]} 
+        g.constraints.each{|c| ks = c[:columns] if [:primary_key, :unique].include?(c[:type])} 
         g.columns.each{|c| c[:null] = false if ks.include?(c[:name]) }
         super
       end
@@ -189,6 +189,11 @@ module Sequel
         :smallint
       end
       alias type_literal_generic_falseclass type_literal_generic_trueclass
+
+      # DB2 uses clob for text types.
+      def uses_clob_for_text?
+        true
+      end
     end
 
     module DatasetMethods

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

@@ -1,4 +1,4 @@
-Sequel.require 'adapters/utils/emulate_offset_with_row_number'
+Sequel.require %w'emulate_offset_with_row_number split_alter_table', 'adapters/utils/'
 
 module Sequel
   Dataset::NON_SQL_OPTIONS << :disable_insert_output
@@ -13,6 +13,8 @@ module Sequel
       SQL_ROLLBACK_TO_SAVEPOINT = 'IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION autopoint_%d'.freeze
       SQL_SAVEPOINT = 'SAVE TRANSACTION autopoint_%d'.freeze
       MSSQL_DEFAULT_RE = /\A(?:\(N?('.*')\)|\(\((-?\d+(?:\.\d+)?)\)\))\z/
+
+      include Sequel::Database::SplitAlterTable
       
       # Whether to use N'' to quote strings, which allows unicode characters inside the
       # strings.  True by default for compatibility, can be set to false for a possible
@@ -110,39 +112,6 @@ module Sequel
         AUTO_INCREMENT
       end
       
-      # Preprocess the array of operations.  If it looks like some operations depend
-      # on results of earlier operations and may require reloading the schema to
-      # work correctly, split those operations into separate lists, and between each
-      # list, remove the cached schema so that the later operations deal with the
-      # then current table schema.
-      def apply_alter_table(name, ops)
-        modified_columns = []
-        op_groups = [[]]
-        ops.each do |op|
-          case op[:op]
-          when :add_column, :set_column_type, :set_column_null
-            if modified_columns.include?(op[:name])
-              op_groups << []
-            else
-              modified_columns << op[:name]
-            end
-          when :rename_column
-            if modified_columns.include?(op[:name]) || modified_columns.include?(op[:new_name])
-              op_groups << []
-            end
-            modified_columns << op[:name] unless modified_columns.include?(op[:name])
-            modified_columns << op[:new_name] unless modified_columns.include?(op[:new_name])
-          end
-          op_groups.last << op
-        end
-
-        op_groups.each do |ops|
-          next if ops.empty?
-          alter_table_sql_list(name, ops).each{|sql| execute_ddl(sql)}
-          remove_cached_schema(name)
-        end
-      end
-    
       # MSSQL specific syntax for altering tables.
       def alter_table_sql(table, op)
         case op[:op]

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

@@ -1,3 +1,5 @@
+Sequel.require 'adapters/utils/split_alter_table'
+
 module Sequel
   Dataset::NON_SQL_OPTIONS << :insert_ignore
   Dataset::NON_SQL_OPTIONS << :update_ignore
@@ -34,6 +36,8 @@ module Sequel
       COLUMN_DEFINITION_ORDER = [:collate, :null, :default, :unique, :primary_key, :auto_increment, :references]
       PRIMARY = 'PRIMARY'.freeze
       MYSQL_TIMESTAMP_RE = /\ACURRENT_(?:DATE|TIMESTAMP)?\z/
+
+      include Sequel::Database::SplitAlterTable
       
       # MySQL's cast rules are restrictive in that you can't just cast to any possible
       # database type.
@@ -170,39 +174,6 @@ module Sequel
       
       private
       
-      # Preprocess the array of operations.  If it looks like some operations depend
-      # on results of earlier operations and may require reloading the schema to
-      # work correctly, split those operations into separate lists, and between each
-      # list, remove the cached schema so that the later operations deal with the
-      # then current table schema.
-      def apply_alter_table(name, ops)
-        modified_columns = []
-        op_groups = [[]]
-        ops.each do |op|
-          case op[:op]
-          when :add_column, :set_column_type, :set_column_null, :set_column_default
-            if modified_columns.include?(op[:name])
-              op_groups << []
-            else
-              modified_columns << op[:name]
-            end
-          when :rename_column
-            if modified_columns.include?(op[:name]) || modified_columns.include?(op[:new_name])
-              op_groups << []
-            end
-            modified_columns << op[:name] unless modified_columns.include?(op[:name])
-            modified_columns << op[:new_name] unless modified_columns.include?(op[:new_name])
-          end
-          op_groups.last << op
-        end
-
-        op_groups.each do |ops|
-          next if ops.empty?
-          alter_table_sql_list(name, ops).each{|sql| execute_ddl(sql)}
-          remove_cached_schema(name)
-        end
-      end
-    
       # Use MySQL specific syntax for some alter table operations.
       def alter_table_op_sql(table, op)
         case op[:op]

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

@@ -6,6 +6,17 @@ module Sequel
     # prepared statements and stored procedures.
     module PreparedStatements
       module DatabaseMethods
+        disconnect_errors = <<-END.split("\n").map{|l| l.strip}
+        Commands out of sync; you can't run this command now
+        Can't connect to local MySQL server through socket
+        MySQL server has gone away
+        Lost connection to MySQL server during query
+        This connection is still waiting for a result, try again once you have the result
+        closed MySQL connection
+        END
+        # Error messages for mysql and mysql2 that indicate the current connection should be disconnected
+        MYSQL_DATABASE_DISCONNECT_ERRORS = /\A#{Regexp.union(disconnect_errors)}/o
+       
         # Support stored procedures on MySQL
         def call_sproc(name, opts={}, &block)
           args = opts[:args] || [] 

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

@@ -178,6 +178,11 @@ module Sequel
       def temporary_table_sql
         TEMPORARY
       end
+
+      # Oracle uses clob for text types.
+      def uses_clob_for_text?
+        true
+      end
     end
 
     module DatasetMethods

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

@@ -369,7 +369,7 @@ module Sequel
       # :server :: The server to which to send the NOTIFY statement, if the sharding support
       #            is being used.
       def notify(channel, opts={})
-        execute_ddl("NOTIFY #{channel}#{", #{literal(opts[:payload].to_s)}" if opts[:payload]}", opts)
+        execute_ddl("NOTIFY #{dataset.send(:table_ref, channel)}#{", #{literal(opts[:payload].to_s)}" if opts[:payload]}", opts)
       end
 
       # Return primary key for the given table.
@@ -735,6 +735,7 @@ module Sequel
       def initialize_postgres_adapter
         @primary_keys = {}
         @primary_key_sequences = {}
+        @conversion_procs = PG_TYPES.dup
         reset_conversion_procs
       end
 

data/lib/sequel/adapters/utils/split_alter_table.rb

@@ -0,0 +1,36 @@
+module Sequel::Database::SplitAlterTable
+  private
+
+  # Preprocess the array of operations.  If it looks like some operations depend
+  # on results of earlier operations and may require reloading the schema to
+  # work correctly, split those operations into separate lists, and between each
+  # list, remove the cached schema so that the later operations deal with the
+  # then current table schema.
+  def apply_alter_table(name, ops)
+    modified_columns = []
+    op_groups = [[]]
+    ops.each do |op|
+      case op[:op]
+      when :add_column, :set_column_type, :set_column_null, :set_column_default
+        if modified_columns.include?(op[:name])
+          op_groups << []
+        else
+          modified_columns << op[:name]
+        end
+      when :rename_column
+        if modified_columns.include?(op[:name]) || modified_columns.include?(op[:new_name])
+          op_groups << []
+        end
+        modified_columns << op[:name] unless modified_columns.include?(op[:name])
+        modified_columns << op[:new_name] unless modified_columns.include?(op[:new_name])
+      end
+      op_groups.last << op
+    end
+
+    op_groups.each do |ops|
+      next if ops.empty?
+      alter_table_sql_list(name, ops).each{|sql| execute_ddl(sql)}
+      remove_cached_schema(name)
+    end
+  end
+end

data/lib/sequel/database/connecting.rb

@@ -6,7 +6,7 @@ module Sequel
     # ---------------------
 
     # Array of supported database adapters
-    ADAPTERS = %w'ado amalgalite db2 dbi do firebird ibmdb informix jdbc mock mysql mysql2 odbc openbase oracle postgres sqlite swift tinytds'.collect{|x| x.to_sym}
+    ADAPTERS = %w'ado amalgalite cubrid db2 dbi do firebird ibmdb informix jdbc mock mysql mysql2 odbc openbase oracle postgres sqlite swift tinytds'.collect{|x| x.to_sym}
 
     # Whether to use the single threaded connection pool by default
     @@single_threaded = false