sequel 3.14.0 → 3.15.0

data/CHANGELOG

@@ -1,3 +1,33 @@
+=== 3.15.0 (2010-09-01)
+
+* Make emulated alter_table tasks on SQLite correctly preserve foreign keys (DirtYiCE, jeremyevans)
+
+* Add support for sequel_pg to the native postgres adapter when pg is used (jeremyevans)
+
+* Make class MyModel < Sequel::Model(DB[:table]) reload safe (jeremyevans)
+
+* Fix a possible error when using the do (DataObjects) adapter with postgres (jeremyevans)
+
+* Handle a many_to_many :join_table option that uses an implicit alias (mluu, jeremyevans)
+
+* Work around bug in Microsoft's SQL Server JDBC Adapter version 3.0 (jfirebaugh)
+
+* Make eager graphing a model that uses an aliased table name work correctly (jeremyevans)
+
+* Make class_table_inheritance plugin work with non integer primary keys on SQLite (jeremyevans, russm)
+
+* Add :auto_increment field to column schema values on MySQL if the column is auto incrementing (dbd)
+
+* Handle DSN-less ODBC connections better (Ricardo Ramalho)
+
+* Exclude temporary tables when parsing the schema on PostgreSQL (jeremyevans) (#306)
+
+* Add Mysql2 adapter (brianmario)
+
+* Handle Mysql::Error exceptions when disconnecting in the MySQL adapter (jeremyevans)
+
+* Make typecasting work correctly for attributes loaded lazily when using the lazy attributes plugin (jeremyevans)
+
 === 3.14.0 (2010-08-02)
 
 * Handle OCIInvalidHandle errors when disconnecting in the Oracle adapter (jeremyevans)

data/README.rdoc

@@ -12,8 +12,8 @@ toolkit for Ruby.
   two-phase commit, transaction isolation, master/slave
   configurations, and database sharding.
 * Sequel currently has adapters for ADO, Amalgalite, DataObjects,
-  DB2, DBI, Firebird, Informix, JDBC, MySQL, ODBC, OpenBase, Oracle,
-  PostgreSQL and SQLite3.
+  DB2, DBI, Firebird, Informix, JDBC, MySQL, Mysql2, ODBC, OpenBase,
+  Oracle, PostgreSQL and SQLite3.
 
 == Resources
 

data/doc/cheat_sheet.rdoc

@@ -29,7 +29,7 @@ Without a filename argument, the sqlite adapter will setup a new sqlite database
   dataset = DB["SELECT age FROM users WHERE name = ?", name]
   dataset.map(:age)
   DB.fetch("SELECT name FROM users") do |row|
-    p r[:name]
+    p row[:name]
   end
 
 == Create a dataset

data/doc/release_notes/3.15.0.txt

@@ -0,0 +1,78 @@
+= Performance Enhancements
+
+* A mysql2 adapter was added to Sequel.  It offers a large (2-6x)
+  performance increase over the standard mysql adapter. In order to
+  use it, you need to install mysql2, and change your connection
+  strings to use mysql2:// instead of mysql://.
+  
+* Support for sequel_pg was added to the native postgres adapter,
+  when pg is being used as the backend.  sequel_pg also offers a
+  large (2-6x) performance increase over the default row fetching
+  code that the Sequel postgres adapter uses.  In order to use it,
+  you just need to install sequel_pg, and the postgres adapter will
+  pick it up automatically.
+  
+* Mass assignment has been made about 10x faster by caching the
+  allowed setter methods in the model.
+
+= Other Improvements
+
+* The following construct is now safe to use in environments that
+  reload code without unloading existing constants:
+  
+    class MyModel < Sequel::Model(DB[:table])
+    end
+    
+  Previously, this would raise a superclass mismatch TypeError.
+
+* Sequel now handles the case where both an implicit and an explicit
+  table alias are given to join_table, preferring the explicit alias.
+  This can happen if you are using models with aliased table names
+  and eager graphing them.  Previously, this would result in invalid
+  SQL, with both aliases being used.
+
+* You can use use an aliased table for the :join_table option
+  of a many_to_many association.
+
+* The active_model plugin now supports the final release of
+  ActiveModel 3.0.0.
+  
+* Typecasting now works correctly for attributes loaded lazily
+  when using the lazy_attributes plugin.
+  
+* The class_table_inheritance plugin now works with non-integer
+  primary keys on SQLite.
+
+* Temporary tables are now ignored when parsing the schema on
+  PostgreSQL.
+
+* On MySQL, an :auto_increment key with a true value is added to
+  the Database#schema output hash if the related column is
+  auto incrementing.
+
+* The mysql adapter now handles Mysql::Error exceptions raised when
+  disconnecting.
+
+* On SQLite, emulated alter_table commands that require dropping
+  the table now preserve the foreign key information, if SQLite
+  foreign key support is enabled (it is by default).
+
+* DSN-less connections now work correctly in more cases in the
+  ODBC adapter.
+
+* A workaround has been added for a bug in the Microsoft SQL
+  Server JDBC Driver 3.0, involving it incorrectly returning a
+  smallint instead of a char type for the IS_AUTOINCREMENT
+  metadata value.
+
+* An bug in the error handling when connecting to PostgreSQL using
+  the do (DataObjects) adapter has been fixed.
+
+= Backwards Compatibility
+
+* The caching of allowed mass assignment methods can result in the
+  incorrect exception class being raised if you manually undefine
+  instance setter methods in the model class.  If you do this, you
+  need to clear the setter methods cache manually:
+  
+    MyModel.clear_setter_methods_cache

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

@@ -27,7 +27,7 @@ module Sequel
               @db.log_yield(sql){command.execute_non_query}
             end
           rescue ::DataObjects::Error => e
-            raise_error(e)
+            @db.send(:raise_error, e)
           end
         end
         

data/lib/sequel/adapters/jdbc.rb

@@ -572,19 +572,27 @@ module Sequel
         i = 0
         meta.getColumnCount.times{cols << [output_identifier(meta.getColumnLabel(i+=1)), i]}
         @columns = cols.map{|c| c.at(0)}
-        row = {}
-        blk = if @convert_types
-          lambda{|n, i| row[n] = convert_type(result.getObject(i))}
-        else
-          lambda{|n, i| row[n] = result.getObject(i)}
-        end
+        blk = result_set_object_getter
         # get rows
         while result.next
           row = {}
-          cols.each(&blk)
+          cols.each do |n, i|
+            row[n] = blk.call(result, n, i)
+          end
           yield row
         end
       end
+
+      # Proc that takes the ResultSet and an integer field number and returns
+      # the object for that field.  Respects the @convert_types setting to
+      # convert Java types to ruby types.
+      def result_set_object_getter
+        if @convert_types
+          lambda {|result, n, i| convert_type(result.getObject(i))}
+        else
+          lambda {|result, n, i| result.getObject(i)}
+        end
+      end
     end
   end
 end

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

@@ -46,6 +46,28 @@ 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.

data/lib/sequel/adapters/mysql.rb

@@ -29,7 +29,6 @@ module Sequel
     end
     
     @convert_invalid_date_time = false
-    @convert_tinyint_to_bool = true
 
     class << self
       # By default, Sequel raises an exception if in invalid date or time is used.
@@ -37,11 +36,6 @@ module Sequel
       # like 0000-00-00 and times like 838:00:00 as nil values.  If set to :string,
       # it returns the strings as is.  
       attr_accessor :convert_invalid_date_time
-
-      # Sequel converts the column type tinyint(1) to a boolean by default when
-      # using the native MySQL adapter.  You can turn off the conversion by setting
-      # this to false.
-      attr_accessor :convert_tinyint_to_bool
     end
 
     # If convert_invalid_date_time is nil, :nil, or :string and
@@ -227,6 +221,8 @@ module Sequel
       # Closes given database connection.
       def disconnect_connection(c)
         c.close
+      rescue Mysql::Error
+        nil
       end
       
       # Executes a prepared statement on an available connection.  If the

data/lib/sequel/adapters/mysql2.rb

@@ -0,0 +1,176 @@
+require 'mysql2' unless defined? Mysql2
+
+Sequel.require %w'shared/mysql', 'adapters'
+
+module Sequel
+  # Module for holding all Mysql2-related classes and modules for Sequel.
+  module Mysql2
+    # Database class for MySQL databases used with Sequel.
+    class Database < Sequel::Database
+      include Sequel::MySQL::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)/
+
+      set_adapter_scheme :mysql2
+
+      # Connect to the database.  In addition to the usual database options,
+      # the following options have effect:
+      #
+      # * :auto_is_null - Set to true to use MySQL default behavior of having
+      #   a filter for an autoincrement column equals NULL to return the last
+      #   inserted row.
+      # * :charset - Same as :encoding (:encoding takes precendence)
+      # * :compress - Set to false to not compress results from the server
+      # * :config_default_group - The default group to read from the in
+      #   the MySQL config file.
+      # * :config_local_infile - If provided, sets the Mysql::OPT_LOCAL_INFILE
+      #   option on the connection with the given value.
+      # * :encoding - Set all the related character sets for this
+      #   connection (connection, client, database, server, and results).
+      # * :socket - Use a unix socket file instead of connecting via TCP/IP.
+      # * :timeout - Set the timeout in seconds before the server will
+      #   disconnect this connection.
+      def connect(server)
+        opts = server_opts(server)
+        opts[:host] ||= 'localhost'
+        opts[:username] ||= opts[:user]
+        conn = ::Mysql2::Client.new(opts)
+
+        sqls = []
+        # Set encoding a slightly different way after connecting,
+        # in case the READ_DEFAULT_GROUP overrode the provided encoding.
+        # Doesn't work across implicit reconnects, but Sequel doesn't turn on
+        # that feature.
+        if encoding = opts[:encoding] || opts[:charset]
+          sqls << "SET NAMES #{conn.escape(encoding.to_s)}"
+        end
+
+        # increase timeout so mysql server doesn't disconnect us
+        sqls << "SET @@wait_timeout = #{opts[:timeout] || 2592000}"
+
+        # By default, MySQL 'where id is null' selects the last inserted id
+        sqls << "SET SQL_AUTO_IS_NULL=0" unless opts[:auto_is_null]
+
+        sqls.each{|sql| log_yield(sql){conn.query(sql)}}
+
+        conn
+      end
+
+      # Returns instance of Sequel::MySQL::Dataset with the given options.
+      def dataset(opts = nil)
+        Mysql2::Dataset.new(self, opts)
+      end
+
+      # Executes the given SQL using an available connection, yielding the
+      # connection if the block is given.
+      def execute(sql, opts={}, &block)
+        if opts[:sproc]
+          call_sproc(sql, opts, &block)
+        else
+          synchronize(opts[:server]){|conn| _execute(conn, sql, opts, &block)}
+        end
+      end
+
+      # Return the version of the MySQL server two which we are connecting.
+      def server_version(server=nil)
+        @server_version ||= (synchronize(server){|conn| conn.server_info[:id]} || super)
+      end
+
+      private
+
+      # Execute the given SQL on the given connection.  If the :type
+      # option is :select, yield the result of the query, otherwise
+      # yield the connection if a block is given.
+      def _execute(conn, sql, opts)
+        begin
+          r = log_yield(sql){conn.query(sql, :symbolize_keys => true, :database_timezone => Sequel.database_timezone, :application_timezone => Sequel.application_timezone)}
+          if opts[:type] == :select
+            yield r if r
+          elsif block_given?
+            yield conn
+          end
+        rescue ::Mysql2::Error => e
+          raise_error(e, :disconnect=>MYSQL_DATABASE_DISCONNECT_ERRORS.match(e.message))
+        end
+      end
+
+      # MySQL connections use the query method to execute SQL without a result
+      def connection_execute_method
+        :query
+      end
+
+      # The MySQL adapter main error class is Mysql2::Error
+      def database_error_classes
+        [::Mysql2::Error]
+      end
+
+      # The database name when using the native adapter is always stored in
+      # the :database option.
+      def database_name
+        @opts[:database]
+      end
+
+      # Closes given database connection.
+      def disconnect_connection(c)
+        c.close
+      end
+
+      # Convert tinyint(1) type to boolean if convert_tinyint_to_bool is true
+      def schema_column_type(db_type)
+        Sequel::MySQL.convert_tinyint_to_bool && db_type == 'tinyint(1)' ? :boolean : super
+      end
+    end
+
+    # Dataset class for MySQL datasets accessed via the native driver.
+    class Dataset < Sequel::Dataset
+      include Sequel::MySQL::DatasetMethods
+
+      # Delete rows matching this dataset
+      def delete
+        execute_dui(delete_sql){|c| return c.affected_rows}
+      end
+
+      # Yield all rows matching this dataset.
+      def fetch_rows(sql, &block)
+        execute(sql) do |r|
+          @columns = r.fields
+          r.each(:cast_booleans => Sequel::MySQL.convert_tinyint_to_bool, &block)
+        end
+        self
+      end
+
+      # Insert a new value into this dataset
+      def insert(*values)
+        execute_dui(insert_sql(*values)){|c| return c.last_id}
+      end
+
+      # Replace (update or insert) the matching row.
+      def replace(*args)
+        execute_dui(replace_sql(*args)){|c| return c.last_id}
+      end
+
+      # Update the matching rows.
+      def update(values={})
+        execute_dui(update_sql(values)){|c| return c.affected_rows}
+      end
+
+      private
+
+      # Set the :type option to :select if it hasn't been set.
+      def execute(sql, opts={}, &block)
+        super(sql, {:type=>:select}.merge(opts), &block)
+      end
+
+      # Set the :type option to :dui if it hasn't been set.
+      def execute_dui(sql, opts={}, &block)
+        super(sql, {:type=>:dui}.merge(opts), &block)
+      end
+
+      # Handle correct quoting of strings using ::Mysql2::Client#escape.
+      def literal_string(v)
+        db.synchronize{|c| "'#{c.escape(v)}'"}
+      end
+    end
+  end
+end

data/lib/sequel/adapters/odbc.rb

@@ -30,7 +30,7 @@ module Sequel
             if :driver == param and not (value =~ GUARDED_DRV_NAME)
               value = DRV_NAME_GUARDS % value
             end
-            drv.attrs[param.to_s.capitalize] = value
+            drv.attrs[param.to_s.upcase] = value.to_s
           end
           db = ::ODBC::Database.new
           conn = db.drvconnect(drv)

data/lib/sequel/adapters/postgres.rb

@@ -502,3 +502,16 @@ module Sequel
     end
   end
 end
+
+if SEQUEL_POSTGRES_USES_PG
+  begin
+    require 'sequel_pg'
+  rescue LoadError
+    if RUBY_PLATFORM =~ /mingw|mswin/
+      begin
+        require "#{RUBY_VERSION[0...3]}/sequel_pg"
+      rescue LoadError
+      end
+    end
+  end
+end

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

@@ -3,7 +3,15 @@ module Sequel
   Dataset::NON_SQL_OPTIONS << :on_duplicate_key_update
 
   module MySQL
+    @convert_tinyint_to_bool = true
+
     class << self
+      # Sequel converts the column type tinyint(1) to a boolean by default when
+      # using the native MySQL or Mysql2 adapter.  You can turn off the conversion by setting
+      # this to false. This setting is ignored when connecting to MySQL via the do or jdbc
+      # adapters, both of which automatically do the conversion.
+      attr_accessor :convert_tinyint_to_bool
+
       # Set the default charset used for CREATE TABLE.  You can pass the
       # :charset option to create_table to override this setting.
       attr_accessor :default_charset
@@ -233,7 +241,7 @@ module Sequel
         m = output_identifier_meth
         im = input_identifier_meth
         metadata_dataset.with_sql("DESCRIBE ?", SQL::Identifier.new(im.call(table_name))).map do |row|
-          row.delete(:Extra)
+          row[:auto_increment] = true if row.delete(:Extra).to_s =~ /auto_increment/io
           row[:allow_null] = row.delete(:Null) == 'YES'
           row[:default] = row.delete(:Default)
           row[:primary_key] = row.delete(:Key) == 'PRI'