sequel 3.39.0 → 3.40.0

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

@@ -11,12 +11,6 @@ module Sequel
         # delete query.
         ROWS_AFFECTED = "SELECT @@ROWCOUNT AS AffectedRows"
         
-        # Just execute so it doesn't attempt to return the number of rows modified.
-        def execute_ddl(sql, opts={})
-          execute(sql, opts)
-        end
-        alias execute_insert execute_ddl
-        
         # Issue a separate query to get the rows modified.  ADO appears to
         # use pass by reference with an integer variable, which is obviously
         # not supported directly in ruby, and I'm not aware of a workaround.

data/lib/sequel/adapters/cubrid.rb

@@ -0,0 +1,143 @@
+require 'cubrid'
+Sequel.require 'adapters/shared/cubrid'
+
+module Sequel
+  module Cubrid
+     CUBRID_TYPE_PROCS = {
+       ::Cubrid::DATE => lambda{|t| Date.new(t.year, t.month, t.day)},
+       ::Cubrid::TIME => lambda{|t| SQLTime.create(t.hour, t.min, t.sec)},
+       21 => lambda{|s| s.to_i}
+     }
+
+    class Database < Sequel::Database
+      include Sequel::Cubrid::DatabaseMethods
+
+      ROW_COUNT = "SELECT ROW_COUNT()".freeze
+      LAST_INSERT_ID = "SELECT LAST_INSERT_ID()".freeze
+
+      set_adapter_scheme :cubrid
+      
+      def connect(server)
+        opts = server_opts(server)
+        conn = ::Cubrid.connect(
+          opts[:database],
+          opts[:host] || 'localhost',
+          opts[:port] || 30000,
+          opts[:user] || 'public',
+          opts[:password] || ''
+        )
+        conn.auto_commit = true
+        conn
+      end
+
+      def server_version
+        @server_version ||= synchronize{|c| c.server_version}
+      end
+      
+      def execute(sql, opts={})
+        synchronize(opts[:server]) do |conn|
+          r = log_yield(sql) do
+            begin
+              conn.query(sql)
+            rescue => e
+              raise_error(e)
+            end
+          end
+          if block_given?
+            yield(r)
+          else
+            begin
+              case opts[:type]
+              when :dui
+                # This is cubrid's API, but it appears to be completely broken,
+                # giving StandardError: ERROR: CCI, -18, Invalid request handle
+                #r.affected_rows
+
+                # Work around bugs by using the ROW_COUNT function.
+                begin
+                  r2 = conn.query(ROW_COUNT)
+                  r2.each{|a| return a.first.to_i}
+                ensure
+                  r2.close if r2
+                end
+              when :insert
+                begin
+                  r2 = conn.query(LAST_INSERT_ID)
+                  r2.each{|a| return a.first.to_i}
+                ensure
+                  r2.close if r2
+                end
+              end
+            ensure
+              r.close
+            end
+          end
+        end
+      end
+
+      def execute_ddl(sql, opts={})
+        execute(sql, opts.merge(:type=>:ddl))
+      end
+
+      def execute_dui(sql, opts={})
+        execute(sql, opts.merge(:type=>:dui))
+      end
+
+      def execute_insert(sql, opts={})
+        execute(sql, opts.merge(:type=>:insert))
+      end
+
+      private
+
+      def begin_transaction(conn, opts={})
+        log_yield(TRANSACTION_BEGIN){conn.auto_commit = false}
+      end
+      
+      def commit_transaction(conn, opts={})
+        log_yield(TRANSACTION_COMMIT){conn.commit}
+      end
+
+      def disconnect_connection(c)
+        c.close
+      end
+
+      def remove_transaction(conn, committed)
+        conn.auto_commit = true
+      ensure
+        super
+      end
+      
+      # This doesn't actually work, as the cubrid ruby driver
+      # does not implement transactions correctly.
+      def rollback_transaction(conn, opts={})
+        log_yield(TRANSACTION_ROLLBACK){conn.rollback}
+      end
+    end
+    
+    class Dataset < Sequel::Dataset
+      include Sequel::Cubrid::DatasetMethods
+      COLUMN_INFO_NAME = "name".freeze
+      COLUMN_INFO_TYPE = "type_name".freeze
+
+      Database::DatasetClass = self
+      
+      def fetch_rows(sql)
+        execute(sql) do |stmt|
+          begin
+            procs = 
+            cols = stmt.column_info.map{|c| [output_identifier(c[COLUMN_INFO_NAME]), CUBRID_TYPE_PROCS[c[COLUMN_INFO_TYPE]]]}
+            @columns = cols.map{|c| c.first}
+            stmt.each do |r|
+              row = {}
+              cols.zip(r).each{|(k, p), v| row[k] = (v && p) ? p.call(v) : v}
+              yield row
+            end
+          ensure
+            stmt.close
+          end
+        end
+        self
+      end
+    end
+  end
+end

data/lib/sequel/adapters/jdbc.rb

@@ -122,6 +122,12 @@ module Sequel
         db.extend(Sequel::JDBC::Progress::DatabaseMethods)
         db.extend_datasets Sequel::Progress::DatasetMethods
         com.progress.sql.jdbc.JdbcProgressDriver
+      end,
+      :cubrid=>proc do |db|
+        Sequel.ts_require 'adapters/jdbc/cubrid'
+        db.extend(Sequel::JDBC::Cubrid::DatabaseMethods)
+        db.extend_datasets Sequel::Cubrid::DatasetMethods
+        Java::cubrid.jdbc.driver.CUBRIDDriver
       end
     }
     
@@ -248,13 +254,7 @@ module Sequel
               when :ddl
                 log_yield(sql){stmt.execute(sql)}
               when :insert
-                log_yield(sql) do
-                  if requires_return_generated_keys?
-                    stmt.executeUpdate(sql, JavaSQL::Statement.RETURN_GENERATED_KEYS)
-                  else
-                    stmt.executeUpdate(sql)
-                  end
-                end
+                log_yield(sql){execute_statement_insert(stmt, sql)}
                 last_insert_id(conn, opts.merge(:stmt=>stmt))
               else
                 log_yield(sql){stmt.executeUpdate(sql)}
@@ -264,7 +264,7 @@ module Sequel
         end
       end
       alias execute_dui execute
-      
+
       # Execute the given DDL SQL, which should not return any
       # values or rows.
       def execute_ddl(sql, opts={})
@@ -361,7 +361,7 @@ module Sequel
             cps = cps[1]
           else
             log_yield("CLOSE #{name}"){cps[1].close} if cps
-            cps = log_yield("PREPARE#{" #{name}:" if name} #{sql}"){conn.prepareStatement(sql)}
+            cps = log_yield("PREPARE#{" #{name}:" if name} #{sql}"){prepare_jdbc_statement(conn, sql, opts)}
             cps_sync(conn){|cpsh| cpsh[name] = [sql, cps]} if name
           end
           i = 0
@@ -380,8 +380,8 @@ module Sequel
               when :ddl
                 log_yield(msg, args){cps.execute}
               when :insert
-                log_yield(msg, args){cps.executeUpdate}
-                last_insert_id(conn, opts.merge(:prepared=>true))
+                log_yield(msg, args){execute_prepared_statement_insert(cps)}
+                last_insert_id(conn, opts.merge(:prepared=>true, :stmt=>cps))
               else
                 log_yield(msg, args){cps.executeUpdate}
               end
@@ -394,6 +394,16 @@ module Sequel
         end
       end
 
+      # Execute the prepared insert statement
+      def execute_prepared_statement_insert(stmt)
+        stmt.executeUpdate
+      end
+      
+      # Execute the insert SQL using the statement
+      def execute_statement_insert(stmt, sql)
+        stmt.executeUpdate(sql)
+      end
+      
       # Gets the connection from JNDI.
       def get_connection_from_jndi
         jndi_name = JNDI_URI_REGEXP.match(uri)[1]
@@ -461,6 +471,11 @@ module Sequel
         end
       end
 
+      # Created a JDBC prepared statement on the connection with the given SQL.
+      def prepare_jdbc_statement(conn, sql, opts)
+        conn.prepareStatement(sql)
+      end
+
       # Java being java, you need to specify the type of each argument
       # for the prepared statement, and bind it individually.  This
       # guesses which JDBC method to use, and hopefully JRuby will convert
@@ -545,13 +560,6 @@ module Sequel
       ensure
         stmt.close if stmt
       end
-
-      # This method determines whether or not to add
-      # Statement.RETURN_GENERATED_KEYS as an argument when inserting rows.
-      # Sub-adapters that require this should override this method.
-      def requires_return_generated_keys?
-        false
-      end
     end
     
     class Dataset < Sequel::Dataset

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

@@ -0,0 +1,52 @@
+Sequel.require 'adapters/shared/cubrid'
+Sequel.require 'adapters/jdbc/transactions'
+
+module Sequel
+  module JDBC
+    module Cubrid
+      module DatabaseMethods
+        include Sequel::Cubrid::DatabaseMethods
+        include Sequel::JDBC::Transactions
+
+        def supports_savepoints?
+          false
+        end
+      
+        private
+        
+        # Get the last inserted id using LAST_INSERT_ID().
+        def last_insert_id(conn, opts={})
+          if stmt = opts[:stmt]
+            rs = stmt.getGeneratedKeys
+            begin
+              if rs.next
+                rs.getInt(1)
+              end
+            rescue NativeException
+              nil
+            ensure
+              rs.close
+            end
+          end
+        end
+
+        # Use execute instead of executeUpdate.
+        def execute_prepared_statement_insert(stmt)
+          stmt.execute
+        end
+      
+        # Return generated keys for insert statements, and use
+        # execute intead of executeUpdate as CUBRID doesn't
+        # return generated keys in executeUpdate.
+        def execute_statement_insert(stmt, sql)
+          stmt.execute(sql, JavaSQL::Statement.RETURN_GENERATED_KEYS)
+        end
+
+        # Return generated keys for insert statements.
+        def prepare_jdbc_statement(conn, sql, opts)
+          opts[:type] == :insert ? conn.prepareStatement(sql, JavaSQL::Statement.RETURN_GENERATED_KEYS) : super
+        end
+      end
+    end
+  end
+end

data/lib/sequel/adapters/jdbc/derby.rb

@@ -148,6 +148,11 @@ module Sequel
             super
           end
         end
+
+        # Derby uses clob for text types.
+        def uses_clob_for_text?
+          true
+        end
       end
       
       # Dataset class for Derby datasets accessed via JDBC.
@@ -174,15 +179,10 @@ module Sequel
         EMULATED_FUNCTION_MAP = {:char_length=>'length'.freeze}
 
         # Derby doesn't support an expression between CASE and WHEN,
-        # so emulate it by using an equality statement for all of the
+        # so remove 
         # conditions.
         def case_expression_sql_append(sql, ce)
-          if ce.expression?
-            e = ce.expression
-            case_expression_sql_append(sql, ::Sequel::SQL::CaseExpression.new(ce.conditions.map{|c, r| [::Sequel::SQL::BooleanExpression.new(:'=', e, c), r]}, ce.default))
-          else
-            super
-          end
+          super(sql, ce.with_merged_expression)
         end
 
         # If the type is String, trim the extra spaces since CHAR is used instead

data/lib/sequel/adapters/jdbc/hsqldb.rb

@@ -83,6 +83,11 @@ module Sequel
             super
           end
         end
+
+        # HSQLDB uses clob for text types.
+        def uses_clob_for_text?
+          true
+        end
       end
       
       # Dataset class for HSQLDB datasets accessed via JDBC.

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

@@ -42,12 +42,17 @@ module Sequel
           end
         end
 
-        # MySQL 5.1.12 JDBC adapter requires this to be true,
+        # MySQL 5.1.12 JDBC adapter requires generated keys
         # and previous versions don't mind.
-        def requires_return_generated_keys?
-          true
+        def execute_statement_insert(stmt, sql)
+          stmt.executeUpdate(sql, JavaSQL::Statement.RETURN_GENERATED_KEYS)
         end
-      
+
+        # Return generated keys for insert statements.
+        def prepare_jdbc_statement(conn, sql, opts)
+          opts[:type] == :insert ? conn.prepareStatement(sql, JavaSQL::Statement.RETURN_GENERATED_KEYS) : super
+        end
+
         # Convert tinyint(1) type to boolean
         def schema_column_type(db_type)
           db_type == 'tinyint(1)' ? :boolean : super

data/lib/sequel/adapters/mysql.rb

@@ -41,9 +41,6 @@ module Sequel
       include Sequel::MySQL::DatabaseMethods
       include Sequel::MySQL::PreparedStatements::DatabaseMethods
       
-      # Mysql::Error messages that indicate the current connection should be disconnected
-      MYSQL_DATABASE_DISCONNECT_ERRORS = /\A(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)/
-       
       # Regular expression used for getting accurate number of rows
       # matched by an update statement.
       AFFECTED_ROWS_RE = /Rows matched:\s+(\d+)\s+Changed:\s+\d+\s+Warnings:\s+\d+/.freeze

data/lib/sequel/adapters/mysql2.rb

@@ -9,9 +9,6 @@ module Sequel
       include Sequel::MySQL::DatabaseMethods
       include Sequel::MySQL::PreparedStatements::DatabaseMethods
 
-      # Mysql::Error messages that indicate the current connection should be disconnected
-      MYSQL_DATABASE_DISCONNECT_ERRORS = /\A(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|This connection is still waiting for a result, try again once you have the result|closed MySQL connection)/
-
       set_adapter_scheme :mysql2
       
       # Whether to convert tinyint columns to bool for this database

data/lib/sequel/adapters/oracle.rb

@@ -13,7 +13,10 @@ module Sequel
       # ORA-03114: not connected to ORACLE
       CONNECTION_ERROR_CODES = [ 28, 1012, 3113, 3114 ]      
       
-      ORACLE_TYPES = {:blob=>lambda{|b| Sequel::SQL::Blob.new(b.read)}}
+      ORACLE_TYPES = {
+        :blob=>lambda{|b| Sequel::SQL::Blob.new(b.read)},
+        :clob=>lambda{|b| b.read}
+      }
 
       # Hash of conversion procs for this database.
       attr_reader :conversion_procs

data/lib/sequel/adapters/postgres.rb

@@ -95,7 +95,7 @@ module Sequel
     # PGconn subclass for connection specific methods used with the
     # pg, postgres, or postgres-pr driver.
     class Adapter < ::PGconn
-      DISCONNECT_ERROR_RE = /\Acould not receive data from server: Software caused connection abort/
+      DISCONNECT_ERROR_RE = /\Acould not receive data from server/
       
       self.translate_results = false if respond_to?(:translate_results=)
       
@@ -109,7 +109,7 @@ module Sequel
       def check_disconnect_errors
         begin
           yield
-        rescue PGError =>e
+        rescue PGError => e
           disconnect = false
           begin
             s = status
@@ -121,7 +121,7 @@ module Sequel
           disconnect ||= e.message =~ DISCONNECT_ERROR_RE
           disconnect ? raise(Sequel.convert_exception_class(e, Sequel::DatabaseDisconnectError)) : raise
         ensure
-          block if status_ok
+          block if status_ok && !disconnect
         end
       end
 
@@ -382,7 +382,7 @@ module Sequel
             synchronize(opts[:server]) do |conn|
               begin
                 channels = Array(channels)
-                channels.each{|channel| conn.execute("LISTEN #{channel}")}
+                channels.each{|channel| conn.execute("LISTEN #{dataset.send(:table_ref, channel)}")}
                 opts[:after_listen].call(conn) if opts[:after_listen]
                 timeout = opts[:timeout] ? [opts[:timeout]] : []
                 if l = opts[:loop]

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

@@ -7,8 +7,15 @@ module Sequel
       end
 
       # Doesn't work, due to security restrictions on MSysObjects
-      def tables
-        from(:MSysObjects).filter(:Type=>1, :Flags=>0).select_map(:Name).map{|x| x.to_sym}
+      #def tables
+      #  from(:MSysObjects).filter(:Type=>1, :Flags=>0).select_map(:Name).map{|x| x.to_sym}
+      #end
+      
+      # Access doesn't support renaming tables from an SQL query,
+      # so create a copy of the table and then drop the from table.
+      def rename_table(from_table, to_table)
+        create_table(to_table, :as=>from(from_table))
+        drop_table(from_table)
       end
 
       # Access uses type Counter for an autoincrementing keys
@@ -18,6 +25,29 @@ module Sequel
 
       private
 
+      def alter_table_op_sql(table, op)
+        case op[:op]
+        when :set_column_type
+          "ALTER COLUMN #{quote_identifier(op[:name])} #{type_literal(op)}"
+        else
+          super
+        end
+      end
+
+      # Access doesn't support CREATE TABLE AS, it only supports SELECT INTO.
+      # Emulating CREATE TABLE AS using SELECT INTO is only possible if a dataset
+      # is given as the argument, it can't work with a string, so raise an
+      # Error if a string is given.
+      def create_table_as(name, ds, options)
+        raise(Error, "must provide dataset instance as value of create_table :as option on Access") unless ds.is_a?(Sequel::Dataset)
+        run(ds.into(name).sql)
+      end
+    
+      # The SQL to drop an index for the table.
+      def drop_index_sql(table, op)
+        "DROP INDEX #{quote_identifier(op[:name] || default_index_name(table, op[:columns]))} ON #{quote_schema_table(table)}"
+      end
+      
       def identifier_input_method_default
         nil
       end
@@ -25,21 +55,155 @@ module Sequel
       def identifier_output_method_default
         nil
       end
+      
+      # Access doesn't have a 64-bit integer type, so use integer and hope
+      # the user isn't using more than 32 bits.
+      def type_literal_generic_bignum(column)
+        :integer
+      end
+
+      # Access doesn't have a true boolean class, so it uses bit
+      def type_literal_generic_trueclass(column)
+        :bit
+      end
+      
+      # Access uses image type for blobs
+      def type_literal_generic_file(column)
+        :image
+      end
     end
   
     module DatasetMethods
-      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'select limit distinct columns from join where group order having compounds')
+      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'select distinct limit columns into from join where group order having compounds')
       DATE_FORMAT = '#%Y-%m-%d#'.freeze
       TIMESTAMP_FORMAT = '#%Y-%m-%d %H:%M:%S#'.freeze
       TOP = " TOP ".freeze
       BRACKET_CLOSE = Dataset::BRACKET_CLOSE
       BRACKET_OPEN = Dataset::BRACKET_OPEN
+      PAREN_CLOSE = Dataset::PAREN_CLOSE
+      PAREN_OPEN = Dataset::PAREN_OPEN
+      INTO = Dataset::INTO
+      FROM = Dataset::FROM
+      NOT_EQUAL = ' <> '.freeze
+      OPS = {:'%'=>' Mod '.freeze, :'||'=>' & '.freeze}
+      BOOL_FALSE = '0'.freeze
+      BOOL_TRUE = '-1'.freeze
+      DATE_FUNCTION = 'Date()'.freeze
+      NOW_FUNCTION = 'Now()'.freeze
+      TIME_FUNCTION = 'Time()'.freeze
+      CAST_TYPES = {String=>:CStr, Integer=>:CLng, Date=>:CDate, Time=>:CDate, DateTime=>:CDate, Numeric=>:CDec, BigDecimal=>:CDec, File=>:CStr, Float=>:CDbl, TrueClass=>:CBool, FalseClass=>:CBool}
+
+      EXTRACT_MAP = {:year=>"'yyyy'", :month=>"'m'", :day=>"'d'", :hour=>"'h'", :minute=>"'n'", :second=>"'s'"}
+      COMMA = Dataset::COMMA
+      DATEPART_OPEN = "datepart(".freeze
+
+      # Access doesn't support CASE, but it can be emulated with nested
+      # IIF function calls.
+      def case_expression_sql_append(sql, ce)
+        literal_append(sql, ce.with_merged_expression.conditions.reverse.inject(ce.default){|exp,(cond,val)| Sequel::SQL::Function.new(:IIF, cond, val, exp)})
+      end
+
+      # Access doesn't support CAST, it uses separate functions for
+      # type conversion
+      def cast_sql_append(sql, expr, type)
+        sql << CAST_TYPES.fetch(type, type).to_s
+        sql << PAREN_OPEN
+        literal_append(sql, expr)
+        sql << PAREN_CLOSE
+      end
+
+      def complex_expression_sql_append(sql, op, args)
+        case op
+        when :ILIKE
+          super(sql, :LIKE, args)
+        when :'NOT ILIKE'
+          super(sql, :'NOT LIKE', args)
+        when :'!='
+          sql << PAREN_OPEN
+          literal_append(sql, args.at(0))
+          sql << NOT_EQUAL
+          literal_append(sql, args.at(1))
+          sql << PAREN_CLOSE
+        when :'%', :'||'
+          sql << PAREN_OPEN
+          c = false
+          op_str = OPS[op]
+          args.each do |a|
+            sql << op_str if c
+            literal_append(sql, a)
+            c ||= true
+          end
+          sql << PAREN_CLOSE
+        when :extract
+          part = args.at(0)
+          raise(Sequel::Error, "unsupported extract argument: #{part.inspect}") unless format = EXTRACT_MAP[part]
+          sql << DATEPART_OPEN << format.to_s << COMMA
+          literal_append(sql, args.at(1))
+          sql << PAREN_CLOSE
+        else
+          super
+        end
+      end
+
+      # Use Date() and Now() for CURRENT_DATE and CURRENT_TIMESTAMP
+      def constant_sql_append(sql, constant)
+        case constant
+        when :CURRENT_DATE
+          sql << DATE_FUNCTION
+        when :CURRENT_TIMESTAMP
+          sql << NOW_FUNCTION
+        when :CURRENT_TIME
+          sql << TIME_FUNCTION
+        else
+          super
+        end
+      end
+
+      # Emulate cross join by using multiple tables in the FROM clause.
+      def cross_join(table)
+        clone(:from=>@opts[:from] + [table])
+      end
+
+      def emulated_function_sql_append(sql, f)
+        case f.f
+        when :char_length
+          literal_append(sql, SQL::Function.new(:len, f.args.first))
+        else
+          super
+        end
+      end
+      
+      # Specify a table for a SELECT ... INTO query.
+      def into(table)
+        clone(:into => table)
+      end
 
       # Access doesn't support INTERSECT or EXCEPT
       def supports_intersect_except?
         false
       end
 
+      # Access does not support IS TRUE
+      def supports_is_true?
+        false
+      end
+      
+      # Access doesn't support JOIN USING
+      def supports_join_using?
+        false
+      end
+
+      # Access does not support multiple columns for the IN/NOT IN operators
+      def supports_multiple_column_in?
+        false
+      end
+
+      # Access doesn't support truncate, so do a delete instead.
+      def truncate
+        delete
+        nil
+      end
+      
       private
 
       # Access uses # to quote dates
@@ -53,6 +217,44 @@ module Sequel
       end
       alias literal_time literal_datetime
 
+      # Use 0 for false on MSSQL
+      def literal_false
+        BOOL_FALSE
+      end
+
+      # Use 0 for false on MSSQL
+      def literal_true
+        BOOL_TRUE
+      end
+
+      # Access requires parentheses when joining more than one table
+      def select_from_sql(sql)
+        if f = @opts[:from]
+          sql << FROM
+          if (j = @opts[:join]) && !j.empty?
+            sql << (PAREN_OPEN * j.length)
+          end
+          source_list_append(sql, f)
+        end
+      end
+
+      def select_into_sql(sql)
+        if i = @opts[:into]
+          sql << INTO
+          identifier_append(sql, i)
+        end
+      end
+
+      # Access requires parentheses when joining more than one table
+      def select_join_sql(sql)
+        if js = @opts[:join]
+          js.each do |j|
+            literal_append(sql, j)
+            sql << PAREN_CLOSE
+          end
+        end
+      end
+
       # Access uses TOP for limits
       def select_limit_sql(sql)
         if l = @opts[:limit]