sequel 3.21.0 → 3.41.0

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 database_error_classes
+        [StandardError]
+      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/db2.rb

@@ -1,139 +1,232 @@
 require 'db2/db2cli'
+Sequel.require %w'shared/db2', 'adapters'
 
 module Sequel
   module DB2
+
+    @convert_smallint_to_bool = true
+
+    # Underlying error raised by Sequel, since ruby-db2 doesn't
+    # use exceptions.
+    class DB2Error < StandardError
+    end
+
+    class << self
+      # Whether to convert smallint values to bool, true by default.
+      # Can also be overridden per dataset.
+      attr_accessor :convert_smallint_to_bool
+    end
+
+    tt = Class.new do
+      def boolean(s) !s.to_i.zero? end
+      def date(s) Date.new(s.year, s.month, s.day) end
+      def time(s) Sequel::SQLTime.create(s.hour, s.minute, s.second) end
+    end.new
+
+    # Hash holding type translation methods, used by Dataset#fetch_rows.
+    DB2_TYPES = {
+      :boolean  => tt.method(:boolean),
+      DB2CLI::SQL_BLOB => ::Sequel::SQL::Blob.method(:new),
+      DB2CLI::SQL_TYPE_DATE => tt.method(:date),
+      DB2CLI::SQL_TYPE_TIME => tt.method(:time),
+      DB2CLI::SQL_DECIMAL => ::BigDecimal.method(:new)
+    }
+    DB2_TYPES[DB2CLI::SQL_CLOB] = DB2_TYPES[DB2CLI::SQL_BLOB]
+
     class Database < Sequel::Database
-      set_adapter_scheme :db2
+      include DatabaseMethods
 
-      include DB2CLI
+      set_adapter_scheme :db2
 
       TEMPORARY = 'GLOBAL TEMPORARY '.freeze
+      rc, NullHandle = DB2CLI.SQLAllocHandle(DB2CLI::SQL_HANDLE_ENV, DB2CLI::SQL_NULL_HANDLE)
       
-      rc, @@env = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE)
-      #check_error(rc, "Could not allocate DB2 environment")
+      # Hash of connection procs for converting
+      attr_reader :conversion_procs
+
+      def initialize(opts={})
+        super
+        @conversion_procs = DB2_TYPES.dup
+        @conversion_procs[DB2CLI::SQL_TYPE_TIMESTAMP] = method(:to_application_timestamp_db2)
+      end
 
       def connect(server)
         opts = server_opts(server)
-        rc, dbc = SQLAllocHandle(SQL_HANDLE_DBC, @@env) 
-        check_error(rc, "Could not allocate database connection")
-        
-        rc = SQLConnect(dbc, opts[:database], opts[:user], opts[:password]) 
-        check_error(rc, "Could not connect to database")
-        
+        dbc = checked_error("Could not allocate database connection"){DB2CLI.SQLAllocHandle(DB2CLI::SQL_HANDLE_DBC, NullHandle)}
+        checked_error("Could not connect to database"){DB2CLI.SQLConnect(dbc, opts[:database], opts[:user], opts[:password])}
         dbc
       end
       
-      def test_connection(server=nil)
-        synchronize(server){|conn|}
-        true
+      def disconnect_connection(conn)
+        DB2CLI.SQLDisconnect(conn)
+        DB2CLI.SQLFreeHandle(DB2CLI::SQL_HANDLE_DBC, conn)
       end
 
-      def dataset(opts = nil)
-        DB2::Dataset.new(self, opts)
+      def execute(sql, opts={}, &block)
+        synchronize(opts[:server]){|conn| log_connection_execute(conn, sql, &block)}
       end
-      
-      def execute(sql, opts={})
+      alias do execute
+
+      def execute_insert(sql, opts={})
         synchronize(opts[:server]) do |conn|
-          rc, sth = SQLAllocHandle(SQL_HANDLE_STMT, @handle) 
-          check_error(rc, "Could not allocate statement")
-
-          begin
-            rc = log_yield(sql){SQLExecDirect(sth, sql)}
-            check_error(rc, "Could not execute statement")
-            
-            yield(sth) if block_given?
-
-            rc, rpc = SQLRowCount(sth)
-            check_error(rc, "Could not get RPC") 
-            rpc
-          ensure
-            rc = SQLFreeHandle(SQL_HANDLE_STMT, sth)
-            check_error(rc, "Could not free statement")
+          log_connection_execute(conn, sql)
+          sql = "SELECT IDENTITY_VAL_LOCAL() FROM SYSIBM.SYSDUMMY1"
+          log_connection_execute(conn, sql) do |sth|
+            name, buflen, datatype, size, digits, nullable = checked_error("Could not describe column"){DB2CLI.SQLDescribeCol(sth, 1, 256)}
+            if DB2CLI.SQLFetch(sth) != DB2CLI::SQL_NO_DATA_FOUND
+              v, _ = checked_error("Could not get data"){DB2CLI.SQLGetData(sth, 1, datatype, size)}
+              if v.is_a?(String) 
+                return v.to_i
+              else
+                return nil
+              end
+            end
           end
         end
       end
-      alias_method :do, :execute
-      
-      private
       
+      ERROR_MAP = {}
+      %w'SQL_INVALID_HANDLE SQL_STILL_EXECUTING SQL_ERROR'.each do |s|
+        ERROR_MAP[DB2CLI.const_get(s)] = s
+      end
       def check_error(rc, msg)
         case rc
-        when SQL_SUCCESS, SQL_SUCCESS_WITH_INFO
+        when DB2CLI::SQL_SUCCESS, DB2CLI::SQL_SUCCESS_WITH_INFO, DB2CLI::SQL_NO_DATA_FOUND
           nil
+        when DB2CLI::SQL_INVALID_HANDLE, DB2CLI::SQL_STILL_EXECUTING
+          e = DB2Error.new("#{ERROR_MAP[rc]}: #{msg}")
+          e.set_backtrace(caller)
+          raise_error(e, :disconnect=>true)
         else
-          raise DatabaseError, msg
+          e = DB2Error.new("#{ERROR_MAP[rc] || "Error code #{rc}"}: #{msg}")
+          e.set_backtrace(caller)
+          raise_error(e, :disconnect=>true)
         end
       end
 
-      def disconnect_connection(conn)
-        rc = SQLDisconnect(conn)
-        check_error(rc, "Could not disconnect from database")
+      def checked_error(msg)
+        rc, *ary= yield
+        check_error(rc, msg)
+        ary.length <= 1 ? ary.first : ary
+      end
+
+      def to_application_timestamp_db2(v)
+        to_application_timestamp(v.to_s)
+      end
+
+      private
+
+      def database_error_classes
+        [DB2Error]
+      end
+
+      def begin_transaction(conn, opts={})
+        log_yield(TRANSACTION_BEGIN){DB2CLI.SQLSetConnectAttr(conn, DB2CLI::SQL_ATTR_AUTOCOMMIT, DB2CLI::SQL_AUTOCOMMIT_OFF)}
+      end
+
+      def remove_transaction(conn, committed)
+        DB2CLI.SQLSetConnectAttr(conn, DB2CLI::SQL_ATTR_AUTOCOMMIT, DB2CLI::SQL_AUTOCOMMIT_ON)
+      ensure
+        super
+      end
+
+      def rollback_transaction(conn, opts={})
+        log_yield(TRANSACTION_ROLLBACK){DB2CLI.SQLEndTran(DB2CLI::SQL_HANDLE_DBC, conn, DB2CLI::SQL_ROLLBACK)}
+      end
 
-        rc = SQLFreeHandle(SQL_HANDLE_DBC, conn)
-        check_error(rc, "Could not free Database handle")
+      def commit_transaction(conn, opts={})
+        log_yield(TRANSACTION_COMMIT){DB2CLI.SQLEndTran(DB2CLI::SQL_HANDLE_DBC, conn, DB2CLI::SQL_COMMIT)}
+      end
+    
+      def log_connection_execute(conn, sql)
+        sth = checked_error("Could not allocate statement"){DB2CLI.SQLAllocHandle(DB2CLI::SQL_HANDLE_STMT, conn)}
+
+        begin
+          checked_error("Could not execute statement: #{sql}"){log_yield(sql){DB2CLI.SQLExecDirect(sth, sql)}}
+          
+          if block_given?
+            yield(sth)
+          else
+            checked_error("Could not get RPC"){DB2CLI.SQLRowCount(sth)}
+          end
+        ensure
+          checked_error("Could not free statement"){DB2CLI.SQLFreeHandle(DB2CLI::SQL_HANDLE_STMT, sth)}
+        end
+      end
+
+      # Convert smallint type to boolean if convert_smallint_to_bool is true
+      def schema_column_type(db_type)
+        if DB2.convert_smallint_to_bool && db_type =~ /smallint/i 
+          :boolean
+        else
+          super
+        end
       end
     end
     
     class Dataset < Sequel::Dataset
+      include DatasetMethods
+
+      Database::DatasetClass = self
       MAX_COL_SIZE = 256
       
+      # Whether to convert smallint to boolean arguments for this dataset.
+      # Defaults to the DB2 module setting.
+      def convert_smallint_to_bool
+        defined?(@convert_smallint_to_bool) ? @convert_smallint_to_bool : (@convert_smallint_to_bool = DB2.convert_smallint_to_bool)
+      end
+
+      # Override the default DB2.convert_smallint_to_bool setting for this dataset.
+      attr_writer :convert_smallint_to_bool
+
       def fetch_rows(sql)
         execute(sql) do |sth|
-          @column_info = get_column_info(sth)
-          @columns = @column_info.map {|c| output_identifier(c[:name])}
-          while (rc = SQLFetch(@handle)) != SQL_NO_DATA_FOUND
-            @db.check_error(rc, "Could not fetch row")
-            yield hash_row(sth)
+          offset = @opts[:offset]
+          db = @db
+          i = 1
+          column_info = get_column_info(sth)
+          cols = column_info.map{|c| c.at(1)}
+          cols.delete(row_number_column) if offset
+          @columns = cols
+          errors = [DB2CLI::SQL_NO_DATA_FOUND, DB2CLI::SQL_ERROR]
+          until errors.include?(rc = DB2CLI.SQLFetch(sth))
+            db.check_error(rc, "Could not fetch row")
+            row = {}
+            column_info.each do |i, c, t, s, pr|
+              v, _ = db.checked_error("Could not get data"){DB2CLI.SQLGetData(sth, i, t, s)}
+              row[c] = if v == DB2CLI::Null
+                nil
+              elsif pr
+                pr.call(v)
+              else
+                v
+              end
+            end
+            row.delete(row_number_column) if offset
+            yield row
           end
         end
         self
       end
       
-      # DB2 supports window functions
-      def supports_window_functions?
-        true
-      end
-      
       private
 
       def get_column_info(sth)
-        rc, column_count = SQLNumResultCols(sth)
-        @db.check_error(rc, "Could not get number of result columns")
+        db = @db
+        column_count = db.checked_error("Could not get number of result columns"){DB2CLI.SQLNumResultCols(sth)}
+        convert = convert_smallint_to_bool
+        cps = db.conversion_procs
 
         (1..column_count).map do |i| 
-          rc, name, buflen, datatype, size, digits, nullable = SQLDescribeCol(sth, i, MAX_COL_SIZE)
-          @b.check_error(rc, "Could not describe column")
-          
-          {:name => name, :db2_type => datatype, :precision => size}
+          name, buflen, datatype, size, digits, nullable = db.checked_error("Could not describe column"){DB2CLI.SQLDescribeCol(sth, i, MAX_COL_SIZE)}
+          pr = if datatype == DB2CLI::SQL_SMALLINT && convert && size <= 5 && digits <= 1
+            cps[:boolean]
+          else
+            cps[datatype]
+          end
+          [i, output_identifier(name), datatype, size, pr]
         end 
       end
-      
-      def hash_row(sth)
-        row = {}
-        @column_info.each_with_index do |c, i|
-          rc, v = SQLGetData(sth, i+1, c[:db2_type], c[:precision]) 
-          @db.check_error(rc, "Could not get data")
-          
-          row[output_identifier(c[:name])] = convert_type(v)
-        end
-        row
-      end
-      
-      def convert_type(v)
-        case v
-        when DB2CLI::Date 
-          DBI::Date.new(v.year, v.month, v.day)
-        when DB2CLI::Time
-          DBI::Time.new(v.hour, v.minute, v.second)
-        when DB2CLI::Timestamp 
-          DBI::Timestamp.new(v.year, v.month, v.day,
-            v.hour, v.minute, v.second, v.fraction)
-        when DB2CLI::Null
-          nil
-        else  
-          v
-        end
-      end
     end
   end
 end

data/lib/sequel/adapters/dbi.rb

@@ -62,11 +62,11 @@ module Sequel
         end
         ::DBI.connect(dbname, opts[:user], opts[:password])
       end
-      
-      def dataset(opts = nil)
-        DBI::Dataset.new(self, opts)
+
+      def disconnect_connection(c)
+        c.disconnect
       end
-    
+      
       def execute(sql, opts={})
         synchronize(opts[:server]) do |conn|
           r = log_yield(sql){conn.execute(sql)}
@@ -79,35 +79,33 @@ module Sequel
         synchronize(opts[:server]){|conn| log_yield(sql){conn.do(sql)}}
       end
       alias_method :execute_dui, :do
-
-      private
-
-      def disconnect_connection(c)
-        c.disconnect
-      end
     end
     
     class Dataset < Sequel::Dataset
+      Database::DatasetClass = self
+
       def fetch_rows(sql)
         execute(sql) do |s|
           begin
-            @columns = s.column_names.map{|c| output_identifier(c)}
-            s.fetch{|r| yield hash_row(s, r)}
+            columns = cols = s.column_names.map{|c| output_identifier(c)}
+            if opts[:offset] && offset_returns_row_number_column?
+              rn = row_number_column
+              columns = columns.dup
+              columns.delete(rn)
+            end
+            @columns = columns
+            s.fetch do |r|
+              row = {}
+              cols.each{|c| row[c] = r.shift}
+              row.delete(rn) if rn
+              yield row
+            end
           ensure
             s.finish rescue nil
           end
         end
         self
       end
-      
-      private
-      
-      def hash_row(stmt, row)
-        @columns.inject({}) do |m, c|
-          m[c] = row.shift
-          m
-        end
-      end
     end
   end
 end

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

@@ -9,11 +9,6 @@ module Sequel
       module DatabaseMethods
         include Sequel::MySQL::DatabaseMethods
         
-        # Return instance of Sequel::DataObjects::MySQL::Dataset with the given opts.
-        def dataset(opts=nil)
-          Sequel::DataObjects::MySQL::Dataset.new(self, opts)
-        end
-        
         private
         
         # The database name for the given database.  Need to parse it out
@@ -23,25 +18,36 @@ module Sequel
           (m = /\/(.*)/.match(URI.parse(uri).path)) && m[1]
         end
 
+        # Recognize the tinyint(1) column as boolean.
         def schema_column_type(db_type)
           db_type == 'tinyint(1)' ? :boolean : super
         end
+
+        # Apply the connectiong setting SQLs for every new connection.
+        def setup_connection(conn)
+          mysql_connection_setting_sqls.each{|sql| log_yield(sql){conn.create_command(sql).execute_non_query}}
+          super
+        end
       end
       
       # Dataset class for MySQL datasets accessed via DataObjects.
       class Dataset < DataObjects::Dataset
         include Sequel::MySQL::DatasetMethods
+        APOS = Dataset::APOS
+        APOS_RE = Dataset::APOS_RE
+        DOUBLE_APOS = Dataset::DOUBLE_APOS
         
-        # Use execute_insert to execute the replace_sql.
-        def replace(*args)
-          execute_insert(replace_sql(*args))
+        # The DataObjects MySQL driver uses the number of rows actually modified in the update,
+        # instead of the number of matched by the filter.
+        def provides_accurate_rows_matched?
+          false
         end
-        
+      
         private
         
         # do_mysql sets NO_BACKSLASH_ESCAPES, so use standard SQL string escaping
-        def literal_string(s)
-          "'#{s.gsub("'", "''")}'"
+        def literal_string_append(sql, s)
+          sql << APOS << s.gsub(APOS_RE, DOUBLE_APOS) << APOS
         end
       end
     end

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

@@ -7,40 +7,6 @@ module Sequel
     # Adapter, Database, and Dataset support for accessing a PostgreSQL
     # database via DataObjects.
     module Postgres
-      # Methods to add to the DataObjects adapter/connection to allow it to work
-      # with the shared PostgreSQL code.
-      module AdapterMethods
-        include Sequel::Postgres::AdapterMethods
-        
-        # Give the DataObjects adapter a direct execute method, which creates
-        # a statement with the given sql and executes it.
-        def execute(sql, args=nil)
-          command = create_command(sql)
-          begin
-            if block_given?
-              begin
-                yield(reader = @db.log_yield(sql){command.execute_reader})
-              ensure
-                reader.close if reader
-              end
-            else
-              @db.log_yield(sql){command.execute_non_query}
-            end
-          rescue ::DataObjects::Error => e
-            @db.send(:raise_error, e)
-          end
-        end
-        
-        private
-        
-        # DataObjects specific method of getting specific values from a result set.
-        def single_value(reader)
-          while(reader.next!) do
-            return reader.values.at(0)
-          end
-        end
-      end
-    
       # Methods to add to Database instances that access PostgreSQL via
       # DataObjects.
       module DatabaseMethods
@@ -49,25 +15,7 @@ module Sequel
         # Add the primary_keys and primary_key_sequences instance variables,
         # so we can get the correct return values for inserted rows.
         def self.extended(db)
-          db.instance_eval do
-            @primary_keys = {}
-            @primary_key_sequences = {}
-          end
-        end
-        
-        # Return instance of Sequel::DataObjects::Postgres::Dataset with the given opts.
-        def dataset(opts=nil)
-          Sequel::DataObjects::Postgres::Dataset.new(self, opts)
-        end
-        
-        # Run the INSERT sql on the database and return the primary key
-        # for the record.
-        def execute_insert(sql, opts={})
-          synchronize(opts[:server]) do |conn|
-            com = conn.create_command(sql)
-            log_yield(sql){com.execute_non_query}
-            insert_result(conn, opts[:table], opts[:values])
-          end
+          db.send(:initialize_postgres_adapter)
         end
         
         private
@@ -75,17 +23,10 @@ module Sequel
         # Extend the adapter with the DataObjects PostgreSQL AdapterMethods
         def setup_connection(conn)
           conn = super(conn)
-          conn.extend(Sequel::DataObjects::Postgres::AdapterMethods)
-          conn.db = self
-          conn.apply_connection_settings
+          connection_configuration_sqls.each{|sql| log_yield(sql){conn.create_command(sql).execute_non_query}}
           conn
         end
       end
-      
-      # Dataset subclass used for datasets that connect to PostgreSQL via DataObjects.
-      class Dataset < DataObjects::Dataset
-        include Sequel::Postgres::DatasetMethods
-      end
     end
   end
 end

data/lib/sequel/adapters/do/sqlite.rb

@@ -8,11 +8,6 @@ module Sequel
       module DatabaseMethods
         include Sequel::SQLite::DatabaseMethods
         
-        # Return Sequel::DataObjects::SQLite::Dataset object with the given opts.
-        def dataset(opts=nil)
-          Sequel::DataObjects::SQLite::Dataset.new(self, opts)
-        end
-        
         private
         
         # Default to a single connection for a memory database.
@@ -30,11 +25,6 @@ module Sequel
           super
         end
       end
-      
-      # Dataset class for SQLite datasets accessed via DataObjects.
-      class Dataset < DataObjects::Dataset
-        include Sequel::SQLite::DatasetMethods
-      end
     end
   end
 end