sequel 2.7.1 → 2.8.0

data/CHANGELOG

@@ -1,3 +1,59 @@
+=== 2.8.0 (2008-12-05)
+
+* Support drop column operations inside a transaction on sqlite (jeremyevans)
+
+* Support literal strings with placeholders and subselects in prepared statements (jeremyevans)
+
+* Have the connection pool remove disconnected connections when the adapter supports it (jeremyevans)
+
+* Make Dataset#exists return a LiteralString (jeremyevans)
+
+* Support multiple SQL statements in one query in the MySQL adapter (jeremyevans)
+
+* Add stored procedure support for the MySQL and JDBC adapters (jeremyevans, krsgoss) (#252)
+
+* Support options when altering a column's type (for changing enums, varchar size, etc.) (jeremyevans)
+
+* Support AliasedExpressions in tables when using implicitly qualified arguments in joins (jeremyevans)
+
+* Support Dataset#except on Oracle (jeremyevans)
+
+* Raise errors when EXCEPT/INTERSECT is used when not supported (jeremyevans)
+
+* Fix ordering of UNION, INTERSECT, and EXCEPT statements (jeremyevans) (#253)
+
+* Support aliasing subselects in the Oracle adapter (jeremyevans)
+
+* Add a subadapter for the Progress RDBMS to the ODBC adapter (:db_type=>'progress') (groveriffic) (#251)
+
+* Make MySQL and Oracle adapters raise an Error if asked to do a SELECT DISTINCT ON (jeremyevans)
+
+* Set standard_conforming_strings = ON by default when using PostgreSQL, turn off with Sequel::Postgres.force_standard_strings = false (jeremyevans) (#247)
+
+* Fix Database#rename_table when using PostgreSQL (jeremyevans) (#248)
+
+* Whether to upcase or quote identifiers can now be set separately, via Sequel.upcase_identifiers= or the :upcase_identifiers database option (jeremyevans)
+
+* Support transactions in the ODBC adapter (dlee)
+
+* Support multi_insert_sql and unicode string literals in MSSQL shared adapter (dlee)
+
+* Make PostgreSQL use the default schema if parsing the schema for all tables at once, even if :schema=>nil option is used (jeremyevans)
+
+* Make MySQL adapter not raise an error when giving an SQL::Identifier object to the schema modification methods such as create_table (jeremyevans)
+
+* The keys of the hash returned by Database#schema without a table name are now quoted strings instead of symbols (jeremyevans)
+
+* Make Database#schema to handle implicit schemas on all databases and multiple identifier object types (jeremyevans)
+
+* Remove Sequel.odbc_mssql method (jeremyevans) (#249)
+
+* More optimization of Model#initialize (jeremyevans)
+
+* Treat interval as it's own type, not an integer type (jeremyevans)
+
+* Allow use of implicitly qualified symbol as argument to Symbol#qualify (:a.qualify(:b__c)=>b.c.a), fixes model associations in different schemas (jeremyevans) (#246)
+
 === 2.7.1 (2008-11-04)
 
 * Fix PostgreSQL Date optimization so that it doesn't reject dates like 11/03/2008 (jeremyevans)

data/README

@@ -41,6 +41,7 @@ If you have any comments or suggestions please post to the Google group.
   DB = Sequel.sqlite # memory database
   
   DB.create_table :items do # Create a new table
+    primary_key :id
     column :name, :text
     column :price, :float
   end

data/Rakefile

@@ -12,7 +12,7 @@ require "fileutils"
 include FileUtils
 
 NAME = 'sequel'
-VERS = '2.7.1'
+VERS = '2.8.0'
 CLEAN.include ["**/.*.sw?", "pkg", ".config", "rdoc", "coverage", "www/public/*.html"]
 RDOC_OPTS = ["--quiet", "--line-numbers", "--inline-source", '--title', \
   'Sequel: The Database Toolkit for Ruby', '--main', 'README']

data/lib/sequel_core.rb

@@ -83,26 +83,19 @@ module Sequel
   # and speed is a priority, you may want to set this to true:
   #
   #   Sequel.single_threaded = true
-  #
-  # Note that some database adapters (e.g. MySQL) have issues with single threaded mode if
-  # you try to perform more than one query simultaneously.  For example, the
-  # following code will not work well in single threaded mode on MySQL:
-  #
-  #   DB[:items].each{|i| DB[:nodes].filter(:item_id=>i[:id]).each{|n| puts "#{i} #{n}"}}
-  #
-  # Basically, you can't issue another query inside a call to Dataset#each in single
-  # threaded mode.  There is a fairly easy fix, just use Dataset#all inside
-  # Dataset#each for the outer query:
-  #
-  #   DB[:items].all{|i| DB[:nodes].filter(:item_id=>i[:id]).each{|n| puts "#{i} #{n}"}}
-  #
-  # Dataset#all gets all of the returned objects before calling the block, so the query
-  # isn't left open. Some of the adapters do this internally, and thus don't have a
-  # problem issuing queries inside of Dataset#each.
   def self.single_threaded=(value)
     Database.single_threaded = value
   end
 
+  # Set whether to upcase identifiers for all databases by default. By default,
+  # Sequel upcases identifiers unless the database folds unquoted identifiers to
+  # lower case (MySQL, PostgreSQL, and SQLite).
+  #
+  #   Sequel.upcase_identifiers = false
+  def self.upcase_identifiers=(value)
+    Database.upcase_identifiers = value
+  end
+  
   # Always returns false, since ParseTree support has been removed.
   def self.use_parse_tree
     false

data/lib/sequel_core/adapters/ado.rb

@@ -32,10 +32,6 @@ module Sequel
         handle
       end
       
-      def disconnect
-        @pool.disconnect {|conn| conn.Close}
-      end
-    
       def dataset(opts = nil)
         ADO::Dataset.new(self, opts)
       end
@@ -49,20 +45,15 @@ module Sequel
         end
       end
       alias_method :do, :execute
+
+      private
+
+      def disconnect_connection(conn)
+        conn.Close
+      end
     end
     
     class Dataset < Sequel::Dataset
-      def literal(v)
-        case v
-        when Time
-          literal(v.iso8601)
-        when Date, DateTime
-          literal(v.to_s)
-        else
-          super
-        end
-      end
-
       def fetch_rows(sql)
         execute(sql) do |s|
           @columns = s.Fields.extend(Enumerable).map do |column|

data/lib/sequel_core/adapters/db2.rb

@@ -20,16 +20,6 @@ module Sequel
         dbc
       end
       
-      def disconnect
-        @pool.disconnect do |conn|
-          rc = SQLDisconnect(conn)
-          check_error(rc, "Could not disconnect from database")
-
-          rc = SQLFreeHandle(SQL_HANDLE_DBC, conn)
-          check_error(rc, "Could not free Database handle")
-        end
-      end
-    
       def test_connection(server=nil)
         synchronize(server){|conn|}
         true
@@ -72,6 +62,14 @@ module Sequel
           raise DatabaseError, msg
         end
       end
+
+      def disconnect_connection(conn)
+        rc = SQLDisconnect(conn)
+        check_error(rc, "Could not disconnect from database")
+
+        rc = SQLFreeHandle(SQL_HANDLE_DBC, conn)
+        check_error(rc, "Could not free Database handle")
+      end
     end
     
     class Dataset < Sequel::Dataset

data/lib/sequel_core/adapters/dbi.rb

@@ -51,10 +51,6 @@ module Sequel
         ::DBI.connect(dbname, opts[:user], opts[:password])
       end
       
-      def disconnect
-        @pool.disconnect {|c| c.disconnect}
-      end
-    
       def dataset(opts = nil)
         DBI::Dataset.new(self, opts)
       end
@@ -78,6 +74,12 @@ module Sequel
       def lowercase
         @lowercase ||= false
       end
+
+      private
+
+      def disconnect_connection(c)
+        c.disconnect
+      end
     end
     
     class Dataset < Sequel::Dataset

data/lib/sequel_core/adapters/informix.rb

@@ -5,20 +5,10 @@ module Sequel
     class Database < Sequel::Database
       set_adapter_scheme :informix
       
-      # AUTO_INCREMENT = 'IDENTITY(1,1)'.freeze
-      # 
-      # def auto_increment_sql
-      #   AUTO_INCREMENT
-      # end
-      
       def connect(server)
         opts = server_opts(server)
         ::Informix.connect(opts[:database], opts[:user], opts[:password])
       end
-      
-      def disconnect
-        @pool.disconnect{|c| c.close}
-      end
     
       def dataset(opts = nil)
         Sequel::Informix::Dataset.new(self, opts)
@@ -36,9 +26,19 @@ module Sequel
         synchronize(opts[:server]){|c| yield c.cursor(sql)}
       end
       alias_method :query, :execute
+      
+      private
+
+      def disconnect_connection(c)
+        c.close
+      end
     end
     
     class Dataset < Sequel::Dataset
+      include UnsupportedIntersectExcept
+
+      SELECT_CLAUSE_ORDER = %w'limit distinct columns from join where having group union order'.freeze
+
       def literal(v)
         case v
         when Time
@@ -50,18 +50,6 @@ module Sequel
         end
       end
 
-      def select_sql(opts = nil)
-        limit = opts.delete(:limit)
-        offset = opts.delete(:offset)
-        sql = super
-        if limit
-          limit = "FIRST #{limit}"
-          offset = offset ? "SKIP #{offset}" : ""
-          sql.sub!(/^select /i,"SELECT #{offset} #{limit} ")
-        end
-        sql
-      end
-      
       def fetch_rows(sql, &block)
         execute(sql) do |cursor|
           begin
@@ -72,6 +60,17 @@ module Sequel
         end
         self
       end
+
+      private
+
+      def select_clause_order
+        SELECT_CLAUSE_ORDER
+      end
+
+      def select_limit_sql(sql, opts)
+        sql << " SKIP #{opts[:offset]}" if opts[:offset]
+        sql << " FIRST #{opts[:limit]}" if opts[:limit]
+      end
     end
   end
 end

data/lib/sequel_core/adapters/jdbc.rb

@@ -1,4 +1,5 @@
 require 'java'
+require 'sequel_core/dataset/stored_procedures'
 
 module Sequel
   # Houses Sequel's JDBC support when running on JRuby.
@@ -93,6 +94,37 @@ module Sequel
         end
       end
       
+      # Execute the given stored procedure with the give name. If a block is
+      # given, the stored procedure should return rows.
+      def call_sproc(name, opts = {})
+        args = opts[:args] || []
+        sql = "{call #{name}(#{args.map{'?'}.join(',')})}"
+        synchronize(opts[:server]) do |conn|
+          cps = conn.prepareCall(sql)
+
+          i = 0
+          args.each{|arg| set_ps_arg(cps, arg, i+=1)}
+
+          begin
+            if block_given?
+              yield cps.executeQuery
+            else
+              case opts[:type]
+              when :insert
+                cps.executeUpdate
+                last_insert_id(conn, opts)
+              else
+                cps.executeUpdate
+              end
+            end
+          rescue NativeException, JavaSQL::SQLException => e
+            raise_error(e)
+          ensure
+            cps.close
+          end
+        end
+      end
+      
       # Connect to the database using JavaSQL::DriverManager.getConnection.
       def connect(server)
         setup_connection(JavaSQL::DriverManager.getConnection(uri(server_opts(server))))
@@ -103,14 +135,10 @@ module Sequel
         JDBC::Dataset.new(self, opts)
       end
       
-      # Close all adapter connections
-      def disconnect
-        @pool.disconnect {|c| c.close}
-      end
-      
       # Execute the given SQL.  If a block is given, if should be a SELECT
       # statement or something else that returns rows.
       def execute(sql, opts={}, &block)
+        return call_sproc(sql, opts, &block) if opts[:sproc]
         return execute_prepared_statement(sql, opts, &block) if sql.is_one_of?(Symbol, Dataset)
         log_info(sql)
         synchronize(opts[:server]) do |conn|
@@ -190,6 +218,11 @@ module Sequel
       
       private
       
+      # Close given adapter connections
+      def disconnect_connection(c)
+        c.close
+      end
+      
       # Execute the prepared statement.  If the provided name is a
       # dataset, use that as the prepared statement, otherwise use
       # it as a key to look it up in the prepared_statements hash.
@@ -287,6 +320,8 @@ module Sequel
     end
     
     class Dataset < Sequel::Dataset
+      include StoredProcedures
+      
       # Use JDBC PreparedStatements instead of emulated ones.  Statements
       # created using #prepare are cached at the connection level to allow
       # reuse.  This also supports bind variables by using unnamed
@@ -313,10 +348,27 @@ module Sequel
         end
       end
       
-      # Create an unnamed prepared statement and call it.  Allows the
-      # use of bind variables.
-      def call(type, hash, values=nil, &block)
-        prepare(type, nil, values).call(hash, &block)
+      # Use JDBC CallableStatements to execute stored procedures.  Only supported
+      # if the underlying database has stored procedure support.
+      module StoredProcedureMethods
+        include Sequel::Dataset::StoredProcedureMethods
+        
+        private
+        
+        # Execute the database stored procedure with the stored arguments.
+        def execute(sql, opts={}, &block)
+          super(@sproc_name, {:args=>@sproc_args, :sproc=>true, :type=>sql_query_type}.merge(opts), &block)
+        end
+        
+        # Same as execute, explicit due to intricacies of alias and super.
+        def execute_dui(sql, opts={}, &block)
+          super(@sproc_name, {:args=>@sproc_args, :sproc=>true, :type=>sql_query_type}.merge(opts), &block)
+        end
+        
+        # Same as execute, explicit due to intricacies of alias and super.
+        def execute_insert(sql, opts={}, &block)
+          super(@sproc_name, {:args=>@sproc_args, :sproc=>true, :type=>sql_query_type}.merge(opts), &block)
+        end
       end
       
       # Correctly return rows from the database and return them as hashes.
@@ -352,7 +404,7 @@ module Sequel
       
       # Create a named prepared statement that is stored in the
       # database (and connection) for reuse.
-      def prepare(type, name, values=nil)
+      def prepare(type, name=nil, values=nil)
         ps = to_prepared_statement(type, values)
         ps.extend(PreparedStatementMethods)
         if name
@@ -361,6 +413,13 @@ module Sequel
         end
         ps
       end
+      
+      private
+      
+      # Extend the dataset with the JDBC stored procedure methods.
+      def prepare_extend_sproc(ds)
+        ds.extend(StoredProcedureMethods)
+      end
     end
   end
 end

data/lib/sequel_core/adapters/jdbc/postgresql.rb

@@ -70,6 +70,7 @@ module Sequel
           conn = super(conn)
           conn.extend(Sequel::JDBC::Postgres::AdapterMethods)
           conn.db = self
+          conn.apply_connection_settings
           conn
         end
         

data/lib/sequel_core/adapters/mysql.rb

@@ -1,5 +1,6 @@
 require 'mysql'
 require 'sequel_core/adapters/shared/mysql'
+require 'sequel_core/dataset/stored_procedures'
 
 # Add methods to get columns, yield hashes with symbol keys, and do
 # type conversion.
@@ -85,6 +86,12 @@ module Sequel
       
       set_adapter_scheme :mysql
       
+      # Support stored procedures on MySQL
+      def call_sproc(name, opts={}, &block)
+        args = opts[:args] || [] 
+        execute("CALL #{name}(#{literal(args) unless args.empty?})", opts.merge(:sproc=>false), &block)
+      end
+      
       # Connect to the database.  In addition to the usual database options,
       # the following options have effect:
       #
@@ -125,14 +132,10 @@ module Sequel
         MySQL::Dataset.new(self, opts)
       end
       
-      # Closes all database connections.
-      def disconnect
-        @pool.disconnect {|c| c.close}
-      end
-      
       # Executes the given SQL using an available connection, yielding the
       # connection if the block is given.
       def execute(sql, opts={}, &block)
+        return call_sproc(sql, opts, &block) if opts[:sproc]
         return execute_prepared_statement(sql, opts, &block) if Symbol === sql
         begin
           synchronize(opts[:server]){|conn| _execute(conn, sql, opts, &block)}
@@ -178,11 +181,19 @@ module Sequel
         log_info(sql)
         conn.query(sql)
         if opts[:type] == :select
-          r = conn.use_result
-          begin
-            yield r
-          ensure
-            r.free
+          loop do
+            begin
+              r = conn.use_result
+            rescue Mysql::Error
+              nil
+            else
+              begin
+                yield r
+              ensure
+                r.free
+              end
+            end
+            break unless conn.respond_to?(:next_result) && conn.next_result
           end
         else
           yield conn if block_given?
@@ -200,6 +211,11 @@ module Sequel
         @opts[:database]
       end
       
+      # Closes given database connection.
+      def disconnect_connection(c)
+        c.close
+      end
+      
       # Executes a prepared statement on an available connection.  If the
       # prepared statement already exists for the connection and has the same
       # SQL, reuse it, otherwise, prepare the new statement.  Because of the
@@ -231,11 +247,27 @@ module Sequel
     # Dataset class for MySQL datasets accessed via the native driver.
     class Dataset < Sequel::Dataset
       include Sequel::MySQL::DatasetMethods
+      include StoredProcedures
+      
+      # Methods to add to MySQL prepared statement calls without using a
+      # real database prepared statement and bound variables.
+      module CallableStatementMethods
+        # Extend given dataset with this module so subselects inside subselects in
+        # prepared statements work.
+        def subselect_sql(ds)
+          ps = ds.to_prepared_statement(:select)
+          ps.extend(CallableStatementMethods)
+          ps.prepared_args = prepared_args
+          ps.prepared_sql
+        end
+      end
       
       # Methods for MySQL prepared statements using the native driver.
       module PreparedStatementMethods
         include Sequel::Dataset::UnnumberedArgumentMapper
         
+        private
+        
         # Execute the prepared statement with the bind arguments instead of
         # the given SQL.
         def execute(sql, opts={}, &block)
@@ -248,6 +280,34 @@ module Sequel
         end
       end
       
+      # Methods for MySQL stored procedures using the native driver.
+      module StoredProcedureMethods
+        include Sequel::Dataset::StoredProcedureMethods
+        
+        private
+        
+        # Execute the database stored procedure with the stored arguments.
+        def execute(sql, opts={}, &block)
+          super(@sproc_name, {:args=>@sproc_args, :sproc=>true}.merge(opts), &block)
+        end
+        
+        # Same as execute, explicit due to intricacies of alias and super.
+        def execute_dui(sql, opts={}, &block)
+          super(@sproc_name, {:args=>@sproc_args, :sproc=>true}.merge(opts), &block)
+        end
+      end
+      
+      # MySQL is different in that it supports prepared statements but not bound
+      # variables outside of prepared statements.  The default implementation
+      # breaks the use of subselects in prepared statements, so extend the
+      # temporary prepared statement that this creates with a module that
+      # fixes it.
+      def call(type, bind_arguments={}, values=nil)
+        ps = to_prepared_statement(type, values)
+        ps.extend(CallableStatementMethods)
+        ps.call(bind_arguments)
+      end
+      
       # Delete rows matching this dataset
       def delete(opts = nil)
         execute_dui(delete_sql(opts)){|c| c.affected_rows}
@@ -281,11 +341,14 @@ module Sequel
       
       # Store the given type of prepared statement in the associated database
       # with the given name.
-      def prepare(type, name, values=nil)
+      def prepare(type, name=nil, values=nil)
         ps = to_prepared_statement(type, values)
         ps.extend(PreparedStatementMethods)
-        ps.prepared_statement_name = name
-        db.prepared_statements[name] = ps
+        if name
+          ps.prepared_statement_name = name
+          db.prepared_statements[name] = ps
+        end
+        ps
       end
       
       # Replace (update or insert) the matching row.
@@ -309,6 +372,11 @@ module Sequel
       def execute_dui(sql, opts={}, &block)
         super(sql, {:type=>:dui}.merge(opts), &block)
       end
+      
+      # Extend the dataset with the MySQL stored procedure methods.
+      def prepare_extend_sproc(ds)
+        ds.extend(StoredProcedureMethods)
+      end
     end
   end
 end