sequel 3.23.0 → 3.24.0

data/lib/sequel/adapters/db2.rb

@@ -93,9 +93,16 @@ module Sequel
       def supports_window_functions?
         true
       end
-      
+
       private
 
+      # Modify the sql to limit the number of rows returned
+      def select_limit_sql(sql)
+        if l = @opts[:limit]
+          sql << " FETCH FIRST #{l == 1 ? 'ROW' : "#{literal(l)} ROWS"} ONLY"
+        end
+      end
+      
       def get_column_info(sth)
         rc, column_count = SQLNumResultCols(sth)
         @db.check_error(rc, "Could not get number of result columns")

data/lib/sequel/adapters/firebird.rb

@@ -198,6 +198,7 @@ module Sequel
       NULL = LiteralString.new('NULL').freeze
       COMMA_SEPARATOR = ', '.freeze
       SELECT_CLAUSE_METHODS = clause_methods(:select, %w'with distinct limit columns from join where group having compounds order')
+      INSERT_CLAUSE_METHODS = clause_methods(:insert, %w'into columns values returning_select')
 
       # Yield all rows returned by executing the given SQL and converting
       # the types.
@@ -242,19 +243,13 @@ module Sequel
       def insert_select(*values)
         naked.clone(default_server_opts(:sql=>insert_returning_sql(nil, *values))).single_record
       end
-      
+
       def requires_sql_standard_datetimes?
         true
       end
 
-      # The order of clauses in the SELECT SQL statement
-      def select_clause_methods
-        SELECT_CLAUSE_METHODS
-      end
-      
-      def select_limit_sql(sql)
-        sql << " FIRST #{@opts[:limit]}" if @opts[:limit]
-        sql << " SKIP #{@opts[:offset]}" if @opts[:offset]
+      def supports_insert_select?
+        true
       end
 
       # Firebird does not support INTERSECT or EXCEPT
@@ -264,6 +259,16 @@ module Sequel
 
       private
 
+      def insert_clause_methods
+        INSERT_CLAUSE_METHODS
+      end
+
+      def insert_returning_select_sql(sql)
+        if opts.has_key?(:returning)
+          sql << " RETURNING #{column_list(Array(opts[:returning]))}"
+        end
+      end
+      
       def hash_row(stmt, row)
         @columns.inject({}) do |m, c|
           m[c] = row.shift
@@ -278,6 +283,17 @@ module Sequel
       def literal_true
         BOOL_TRUE
       end
+
+      # The order of clauses in the SELECT SQL statement
+      def select_clause_methods
+        SELECT_CLAUSE_METHODS
+      end
+      
+      def select_limit_sql(sql)
+        sql << " FIRST #{@opts[:limit]}" if @opts[:limit]
+        sql << " SKIP #{@opts[:offset]}" if @opts[:offset]
+      end
+
     end
   end
 end

data/lib/sequel/adapters/informix.rb

@@ -1,12 +1,13 @@
 require 'informix'
+Sequel.require 'adapters/shared/informix'
 
 module Sequel
   module Informix
     class Database < Sequel::Database
+      include DatabaseMethods
+
       set_adapter_scheme :informix
       
-      TEMPORARY = 'TEMP '.freeze
-      
       def connect(server)
         opts = server_opts(server)
         ::Informix.connect(opts[:database], opts[:user], opts[:password])
@@ -35,7 +36,7 @@ module Sequel
     end
     
     class Dataset < Sequel::Dataset
-      SELECT_CLAUSE_METHODS = clause_methods(:select, %w'limit distinct columns from join where having group compounds order')
+      include DatasetMethods
 
       def fetch_rows(sql)
         execute(sql) do |cursor|
@@ -56,22 +57,6 @@ module Sequel
         end
         self
       end
-
-      private
-
-      # Informix does not support INTERSECT or EXCEPT
-      def supports_intersect_except?
-        false
-      end
-
-      def select_clause_methods
-        SELECT_CLAUSE_METHODS
-      end
-
-      def select_limit_sql(sql)
-        sql << " SKIP #{@opts[:offset]}" if @opts[:offset]
-        sql << " FIRST #{@opts[:limit]}" if @opts[:limit]
-      end
     end
   end
 end

data/lib/sequel/adapters/jdbc.rb

@@ -53,14 +53,14 @@ module Sequel
         Java::oracle.jdbc.driver.OracleDriver
       end,
       :sqlserver=>proc do |db|
-        Sequel.ts_require 'adapters/jdbc/mssql'
-        db.extend(Sequel::JDBC::MSSQL::DatabaseMethods)
+        Sequel.ts_require 'adapters/jdbc/sqlserver'
+        db.extend(Sequel::JDBC::SQLServer::DatabaseMethods)
         db.send(:set_mssql_unicode_strings)
         com.microsoft.sqlserver.jdbc.SQLServerDriver
       end,
       :jtds=>proc do |db|
-        Sequel.ts_require 'adapters/jdbc/mssql'
-        db.extend(Sequel::JDBC::MSSQL::DatabaseMethods)
+        Sequel.ts_require 'adapters/jdbc/jtds'
+        db.extend(Sequel::JDBC::JTDS::DatabaseMethods)
         db.send(:set_mssql_unicode_strings)
         JDBC.load_gem('jtds')
         Java::net.sourceforge.jtds.jdbc.Driver
@@ -75,6 +75,11 @@ module Sequel
         Sequel.ts_require 'adapters/jdbc/as400'
         db.extend(Sequel::JDBC::AS400::DatabaseMethods)
         com.ibm.as400.access.AS400JDBCDriver
+      end,
+      :"informix-sqli"=>proc do |db|
+        Sequel.ts_require 'adapters/jdbc/informix'
+        db.extend(Sequel::JDBC::Informix::DatabaseMethods)
+        com.informix.jdbc.IfxDriver
       end
     }
     
@@ -248,12 +253,14 @@ module Sequel
         indexes
       end 
 
+      # Whether or not JNDI is being used for this connection.
+      def jndi?
+        !!(uri =~ JNDI_URI_REGEXP)
+      end
+      
       # All tables in this database
       def tables(opts={})
-        ts = []
-        m = output_identifier_meth
-        metadata(:getTables, nil, nil, nil, ['TABLE'].to_java(:string)){|h| ts << m.call(h[:table_name])}
-        ts
+        get_tables('TABLE', opts)
       end
       
       # The uri for this connection.  You can specify the uri
@@ -266,11 +273,11 @@ module Sequel
         ur =~ /^\Ajdbc:/ ? ur : "jdbc:#{ur}"
       end
 
-      # Whether or not JNDI is being used for this connection.
-      def jndi?
-        !!(uri =~ JNDI_URI_REGEXP)
+      # All views in this database
+      def views(opts={})
+        get_tables('VIEW', opts)
       end
-      
+
       private
          
       # Close given adapter connections
@@ -327,6 +334,12 @@ module Sequel
         end
       end
 
+      # Gets the connection from JNDI.
+      def get_connection_from_jndi
+        jndi_name = JNDI_URI_REGEXP.match(uri)[1]
+        JavaxNaming::InitialContext.new.lookup(jndi_name).connection
+      end
+            
       # Gets the JDBC connection uri from the JNDI resource.
       def get_uri_from_jndi
         conn = get_connection_from_jndi
@@ -335,12 +348,14 @@ module Sequel
         conn.close if conn
       end
       
-      # Gets the connection from JNDI.
-      def get_connection_from_jndi
-        jndi_name = JNDI_URI_REGEXP.match(uri)[1]
-        JavaxNaming::InitialContext.new.lookup(jndi_name).connection
+      # Backbone of the tables and views support.
+      def get_tables(type, opts)
+        ts = []
+        m = output_identifier_meth
+        metadata(:getTables, nil, nil, nil, [type].to_java(:string)){|h| ts << m.call(h[:table_name])}
+        ts
       end
-            
+
       # Support Date objects used in bound variables
       def java_sql_date(date)
         java.sql.Date.new(Time.local(date.year, date.month, date.day).to_i * 1000)
@@ -446,9 +461,11 @@ module Sequel
         table = im.call(table)
         pks, ts = [], []
         metadata(:getPrimaryKeys, nil, schema, table) do |h|
+          next if h[:table_schem] == 'INFORMATION_SCHEMA'
           pks << h[:column_name]
         end
         metadata(:getColumns, nil, schema, table, nil) do |h|
+          next if h[:table_schem] == 'INFORMATION_SCHEMA'
           s = {:type=>schema_column_type(h[:type_name]), :db_type=>h[:type_name], :default=>(h[:column_def] == '' ? nil : h[:column_def]), :allow_null=>(h[:nullable] != 0), :primary_key=>pks.include?(h[:column_name]), :column_size=>h[:column_size], :scale=>h[:decimal_digits]}
           if s[:db_type] =~ DECIMAL_TYPE_RE && s[:scale] == 0
             s[:type] = :integer

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

@@ -33,6 +33,11 @@ module Sequel
           {:primary_key => true, :type => :identity}
         end
 
+        # H2 supports CREATE TABLE IF NOT EXISTS syntax.
+        def supports_create_table_if_not_exists?
+          true
+        end
+      
         # H2 supports prepared transactions
         def supports_prepared_transactions?
           true

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

@@ -0,0 +1,31 @@
+Sequel.require 'adapters/shared/informix'
+
+module Sequel
+  module JDBC
+    # Database and Dataset instance methods for Informix specific
+    # support via JDBC.
+    module Informix
+      # Database instance methods for Informix databases accessed via JDBC.
+      module DatabaseMethods
+        include Sequel::Informix::DatabaseMethods
+        
+        # Return instance of Sequel::JDBC::Informix::Dataset with the given opts.
+        def dataset(opts=nil)
+          Sequel::JDBC::Informix::Dataset.new(self, opts)
+        end
+        
+        private
+        
+        # TODO: implement
+        def last_insert_id(conn, opts={})
+          nil
+        end
+      end
+      
+      # Dataset class for Informix datasets accessed via JDBC.
+      class Dataset < JDBC::Dataset
+        include Sequel::Informix::DatasetMethods
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+Sequel.require 'adapters/jdbc/mssql'
+
+module Sequel
+  module JDBC
+    # Database and Dataset instance methods for JTDS specific
+    # support via JDBC.
+    module JTDS
+      # Database instance methods for JTDS databases accessed via JDBC.
+      module DatabaseMethods
+        include Sequel::JDBC::MSSQL::DatabaseMethods
+        
+        # Return instance of Sequel::JDBC::JTDS::Dataset with the given opts.
+        def dataset(opts=nil)
+          Sequel::JDBC::JTDS::Dataset.new(self, opts)
+        end
+      end
+      
+      # Dataset class for JTDS datasets accessed via JDBC.
+      class Dataset < JDBC::Dataset
+        include Sequel::MSSQL::DatasetMethods
+
+        # Handle CLOB types retrieved via JTDS.
+        def convert_type(v)
+          case v
+          when Java::NetSourceforgeJtdsJdbc::ClobImpl
+            convert_type(v.getSubString(1, v.length))
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -16,11 +16,6 @@ module Sequel
         
         include Sequel::MSSQL::DatabaseMethods
         
-        # Return instance of Sequel::JDBC::MSSQL::Dataset with the given opts.
-        def dataset(opts=nil)
-          Sequel::JDBC::MSSQL::Dataset.new(self, opts)
-        end
-        
         private
         
         # Get the last inserted id using SCOPE_IDENTITY().
@@ -43,33 +38,6 @@ module Sequel
         def primary_key_index_re
           PRIMARY_KEY_INDEX_RE
         end
-
-        def metadata_dataset
-          ds = super
-          # Work around a bug in SQL Server JDBC Driver 3.0, where the metadata
-          # for the getColumns result set specifies an incorrect type for the
-          # IS_AUTOINCREMENT column. The column is a string, but the type is
-          # specified as a short. This causes getObject() to throw a
-          # com.microsoft.sqlserver.jdbc.SQLServerException: "The conversion
-          # from char to SMALLINT is unsupported." Using getString() rather
-          # than getObject() for this column avoids the problem.
-          # Reference: http://social.msdn.microsoft.com/Forums/en/sqldataaccess/thread/20df12f3-d1bf-4526-9daa-239a83a8e435
-          def ds.result_set_object_getter
-            lambda do |result, n, i|
-              if n == :is_autoincrement
-                @convert_types ? convert_type(result.getString(i)) : result.getString(i)
-              else
-                @convert_types ? convert_type(result.getObject(i)) : result.getObject(i)
-              end
-            end
-          end
-          ds
-        end
-      end
-      
-      # Dataset class for MSSQL datasets accessed via JDBC.
-      class Dataset < JDBC::Dataset
-        include Sequel::MSSQL::DatasetMethods
       end
     end
   end

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

@@ -56,6 +56,15 @@ module Sequel
         def schema_column_type(db_type)
           db_type == 'tinyint(1)' ? :boolean : super
         end
+      
+        # By default, MySQL 'where id is null' selects the last inserted id.
+        # Turn that off unless explicitly enabled.
+        def setup_connection(conn)
+          super
+          sql = "SET SQL_AUTO_IS_NULL=0"
+          statement(conn){|s| log_yield(sql){s.execute(sql)}} unless opts[:auto_is_null]
+          conn
+        end
       end
       
       # Dataset class for MySQL datasets accessed via JDBC.

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

@@ -0,0 +1,46 @@
+Sequel.require 'adapters/jdbc/mssql'
+
+module Sequel
+  module JDBC
+    # Database and Dataset instance methods for SQLServer specific
+    # support via JDBC.
+    module SQLServer
+      # Database instance methods for SQLServer databases accessed via JDBC.
+      module DatabaseMethods
+        include Sequel::JDBC::MSSQL::DatabaseMethods
+        
+        # Return instance of Sequel::JDBC::SQLServer::Dataset with the given opts.
+        def dataset(opts=nil)
+          Sequel::JDBC::SQLServer::Dataset.new(self, opts)
+        end
+        
+        def metadata_dataset
+          ds = super
+          # Work around a bug in SQL Server JDBC Driver 3.0, where the metadata
+          # for the getColumns result set specifies an incorrect type for the
+          # IS_AUTOINCREMENT column. The column is a string, but the type is
+          # specified as a short. This causes getObject() to throw a
+          # com.microsoft.sqlserver.jdbc.SQLServerException: "The conversion
+          # from char to SMALLINT is unsupported." Using getString() rather
+          # than getObject() for this column avoids the problem.
+          # Reference: http://social.msdn.microsoft.com/Forums/en/sqldataaccess/thread/20df12f3-d1bf-4526-9daa-239a83a8e435
+          def ds.result_set_object_getter
+            lambda do |result, n, i|
+              if n == :is_autoincrement
+                @convert_types ? convert_type(result.getString(i)) : result.getString(i)
+              else
+                @convert_types ? convert_type(result.getObject(i)) : result.getObject(i)
+              end
+            end
+          end
+          ds
+        end
+      end
+      
+      # Dataset class for SQLServer datasets accessed via JDBC.
+      class Dataset < JDBC::Dataset
+        include Sequel::MSSQL::DatasetMethods
+      end
+    end
+  end
+end

data/lib/sequel/adapters/postgres.rb

@@ -100,6 +100,11 @@ module Sequel
       def timestamp(s) ::Sequel.database_to_application_timestamp(s) end
     end.new
 
+    # Hash with type name symbols and callable values for converting PostgreSQL types.
+    # Non-builtin types that don't have fixed numbers should use this to register
+    # conversion procs.
+    PG_NAMED_TYPES = {}
+
     # Hash with integer keys and callable values for converting PostgreSQL types.
     PG_TYPES = {}
     {
@@ -194,6 +199,10 @@ module Sequel
       include Sequel::Postgres::DatabaseMethods
       
       set_adapter_scheme :postgres
+
+      # A hash of conversion procs, keyed by type integer (oid) and
+      # having callable values for the conversion proc for that type.
+      attr_reader :conversion_procs
       
       # Add the primary_keys and primary_key_sequences instance variables,
       # so we can get the correct return values for inserted rows.
@@ -225,6 +234,7 @@ module Sequel
         end
         conn.db = self
         conn.apply_connection_settings
+        @conversion_procs ||= get_conversion_procs(conn)
         conn
       end
       
@@ -305,6 +315,19 @@ module Sequel
           end
         end
       end
+
+      # Return the conversion procs hash to use for this database
+      def get_conversion_procs(conn)
+        procs = PG_TYPES.dup
+        conn.execute("SELECT oid, typname FROM pg_type where typtype = 'b'") do |res|
+          res.ntuples.times do |recnum|
+            if pr = PG_NAMED_TYPES[res.getvalue(recnum, 1).to_sym]
+              procs[res.getvalue(recnum, 0).to_i] ||= pr
+            end
+          end
+        end
+        procs
+      end
     end
     
     # Dataset class for PostgreSQL datasets that use the pg, postgres, or
@@ -372,6 +395,11 @@ module Sequel
             end
             LiteralString.new("#{prepared_arg_placeholder}#{i}#{"::#{type}" if type}")
           end
+
+          # Always assume a prepared argument.
+          def prepared_arg?(k)
+           true
+          end
         end
 
         # Allow use of bind arguments for PostgreSQL using the pg driver.
@@ -483,8 +511,9 @@ module Sequel
       # field numers, type conversion procs, and name symbol arrays.
       def fetch_rows_set_cols(res)
         cols = []
+        procs = db.conversion_procs
         res.nfields.times do |fieldnum|
-          cols << [fieldnum, PG_TYPES[res.ftype(fieldnum)], output_identifier(res.fname(fieldnum))]
+          cols << [fieldnum, procs[res.ftype(fieldnum)], output_identifier(res.fname(fieldnum))]
         end
         @columns = cols.map{|c| c.at(2)}
         cols