sequel 2.6.0 → 2.7.0

data/CHANGELOG

@@ -1,3 +1,67 @@
+=== 2.7.0 (2008-11-03)
+
+* Transform AssociationReflection from a single class to a class hierarchy (jeremyevans)
+
+* Optimize Date object creation in PostgreSQL adapter (jeremyevans)
+
+* Allow easier creation of custom association types, though support for them may still be suboptimal (jeremyevans)
+
+* Add :eager_grapher option to associations, which the user can use to override the default eager_graph code (jeremyevans)
+
+* Associations are now inherited when a model class is subclassed (jeremyevans)
+
+* Instance methods added by associations are now added to an anonymous module the class includes, allowing you to override them and use super (jeremyevans)
+
+* Add #add_graph_aliases (select_more for graphs), and allow use of arbitrary expressions when graphing (jeremyevans)
+
+* Fix a corner case where the wrong table name is used in eager_graph (jeremyevans)
+
+* Make Dataset#join_table take an option hash instead of a table_alias argument, add support for :implicit_qualifier option (jeremyevans)
+
+* Add :left_primary_key and :right_primary_key options to many_to_many associations (jeremyevans)
+
+* Add :primary_key option to one_to_many and many_to_one associations (jeremyevans)
+
+* Make after_load association callbacks take effect when eager loading via eager (jeremyevans)
+
+* Add a :uniq association option to many_to_many associations (jeremyevans)
+
+* Support using any expression as the argument to Symbol#like (jeremyevans)
+
+* Much better support for multiple schemas in PostgreSQL (jeremyevans) (#243)
+
+* The first argument to Model#initalize can no longer be nil, it must be a hash if it is given (jeremyevans)
+
+* Remove Sequel::Model.lazy_load_schema= setting (jeremyevans)
+
+* Lazily load model instance options such as raise_on_save_failure, for better performance (jeremyevans)
+
+* Make Model::Validiation::Errors more Rails-compatible (jeremyevans)
+
+* Refactor model hooks for performance (jeremyevans)
+
+* Major performance enhancement when fetching rows using PostgreSQL (jeremyevans)
+
+* Don't typecast serialized columns in models (jeremyevans)
+
+* Add Array#sql_array to handle ruby arrays of all two pairs as SQL arrays (jeremyevans) (#245)
+
+* Add ComplexExpression#== and #eql?, for checking equality (rubymage) (#244)
+
+* Allow full text search on PostgreSQL to include rows where a search column is NULL (jeremyevans)
+
+* PostgreSQL full text search queries with multiple columns are joined with space to prevent joining border words to one (michalbugno)
+
+* Don't modify a dataset's cached column information if calling #each with an option that modifies the columns (jeremyevans)
+
+* The PostgreSQL adapter will now generally default to using a unix socket in /tmp if no host is specified, instead of a tcp socket to localhost (jeremyevans)
+
+* Make Dataset#sql call Dataset#select_sql instead of being an alias, to allow for easier subclassing (jeremyevans)
+
+* Split Oracle adapter into shared and unshared parts, so Oracle is better supported when using JDBC (jeremyevans)
+
+* Fix automatic loading of Oracle driver when using JDBC adapter (bburton333) (#242)
+
 === 2.6.0 (2008-10-11)
 
 * Make the sqlite adapter respect the Sequel.datetime_class setting, for timestamp and datetime types (jeremyevans)

data/Rakefile

@@ -12,7 +12,7 @@ require "fileutils"
 include FileUtils
 
 NAME = 'sequel'
-VERS = '2.6.0'
+VERS = '2.7.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/adapters/jdbc.rb

@@ -3,7 +3,7 @@ require 'java'
 module Sequel
   # Houses Sequel's JDBC support when running on JRuby.
   # Support for individual database types is done using sub adapters.
-  # PostgreSQL, MySQL, SQLite, and MSSQL all have relatively good support,
+  # PostgreSQL, MySQL, SQLite, Oracle, and MSSQL all have relatively good support,
   # close the the level supported by the native adapter.
   # PostgreSQL, MySQL, SQLite can load necessary support using
   # the jdbc-* gem, if it is installed, though they will work if you
@@ -51,7 +51,11 @@ module Sequel
         JDBC.load_gem('sqlite3')
         org.sqlite.JDBC
       end,
-      :oracle=>proc{oracle.jdbc.driver.OracleDriver},
+      :oracle=>proc do |db|
+        require 'sequel_core/adapters/jdbc/oracle'
+        db.extend(Sequel::JDBC::Oracle::DatabaseMethods)
+        Java::oracle.jdbc.driver.OracleDriver
+      end,
       :sqlserver=>proc do |db|
         require 'sequel_core/adapters/shared/mssql'
         db.extend(Sequel::MSSQL::DatabaseMethods)

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

@@ -0,0 +1,23 @@
+require 'sequel_core/adapters/shared/oracle'
+
+module Sequel
+  module JDBC
+    # Database and Dataset support for Oracle databases accessed via JDBC.
+    module Oracle
+      # Instance methods for Oracle Database objects accessed via JDBC.
+      module DatabaseMethods
+        include Sequel::Oracle::DatabaseMethods
+        
+        # Return Sequel::JDBC::Oracle::Dataset object with the given opts.
+        def dataset(opts=nil)
+          Sequel::JDBC::Oracle::Dataset.new(self, opts)
+        end
+      end
+      
+      # Dataset class for Oracle datasets accessed via JDBC.
+      class Dataset < JDBC::Dataset
+        include Sequel::Oracle::DatasetMethods
+      end
+    end
+  end
+end

data/lib/sequel_core/adapters/oracle.rb

@@ -1,8 +1,10 @@
 require 'oci8'
+require 'sequel_core/adapters/shared/oracle'
 
 module Sequel
   module Oracle
     class Database < Sequel::Database
+      include DatabaseMethods
       set_adapter_scheme :oracle
       
       def connect(server)
@@ -37,16 +39,6 @@ module Sequel
       end
       alias_method :do, :execute
       
-      def tables
-        from(:tab).select(:tname).filter(:tabtype => 'TABLE').map do |r|
-          r[:tname].downcase.to_sym
-        end
-      end
-
-      def table_exists?(name)
-        from(:tab).filter(:tname => name.to_s.upcase, :tabtype => 'TABLE').count > 0
-      end
-
       def transaction(server=nil)
         synchronize(server) do |conn|
           return yield(conn) if @transactions.include?(Thread.current)
@@ -68,6 +60,8 @@ module Sequel
     end
     
     class Dataset < Sequel::Dataset
+      include DatasetMethods
+
       def literal(v)
         case v
         when OraDate
@@ -92,73 +86,6 @@ module Sequel
         end
         self
       end
-
-      def empty?
-        db[:dual].where(exists).get(1) == nil
-      end
-
-      # Formats a SELECT statement using the given options and the dataset
-      # options.
-      def select_sql(opts = nil)
-        opts = opts ? @opts.merge(opts) : @opts
-
-        if sql = opts[:sql]
-          return sql
-        end
-
-        columns = opts[:select]
-        select_columns = columns ? column_list(columns) : WILDCARD
-        sql = opts[:distinct] ? \
-        "SELECT DISTINCT #{select_columns}" : \
-        "SELECT #{select_columns}"
-        
-        if opts[:from]
-          sql << " FROM #{source_list(opts[:from])}"
-        end
-        
-        if join = opts[:join]
-          join.each{|j| sql << literal(j)}
-        end
-
-        if where = opts[:where]
-          sql << " WHERE #{literal(where)}"
-        end
-
-        if group = opts[:group]
-          sql << " GROUP BY #{expression_list(group)}"
-        end
-
-        if having = opts[:having]
-          sql << " HAVING #{literal(having)}"
-        end
-
-        if union = opts[:union]
-          sql << (opts[:union_all] ? \
-            " UNION ALL #{union.sql}" : " UNION #{union.sql}")
-        elsif intersect = opts[:intersect]
-          sql << (opts[:intersect_all] ? \
-            " INTERSECT ALL #{intersect.sql}" : " INTERSECT #{intersect.sql}")
-        elsif except = opts[:except]
-          sql << (opts[:except_all] ? \
-            " EXCEPT ALL #{except.sql}" : " EXCEPT #{except.sql}")
-        end
-
-        if order = opts[:order]
-          sql << " ORDER BY #{expression_list(order)}"
-        end
-
-        if limit = opts[:limit]
-          if (offset = opts[:offset]) && (offset > 0)
-            sql = "SELECT * FROM (SELECT raw_sql_.*, ROWNUM raw_rnum_ FROM(#{sql}) raw_sql_ WHERE ROWNUM <= #{limit + offset}) WHERE raw_rnum_ > #{offset}"
-          else
-            sql = "SELECT * FROM (#{sql}) WHERE ROWNUM <= #{limit}"
-          end
-        end
-
-        sql
-      end
-
-      alias sql select_sql
     end
   end
 end

data/lib/sequel_core/adapters/postgres.rb

@@ -83,7 +83,7 @@ module Sequel
     
     # Hash with integer keys and proc values for converting PostgreSQL types.
     PG_TYPES = {
-      16 => lambda{ |s| Postgres.string_to_bool(s) }, # boolean
+      16 => lambda{ |s| s == 't' }, # boolean
       17 => lambda{ |s| Adapter.unescape_bytea(s).to_blob }, # bytea
       20 => lambda{ |s| s.to_i }, # int8
       21 => lambda{ |s| s.to_i }, # int2
@@ -93,7 +93,7 @@ module Sequel
       700 => lambda{ |s| s.to_f }, # float4
       701 => lambda{ |s| s.to_f }, # float8
       790 => lambda{ |s| s.to_d }, # money
-      1082 => lambda{ |s| s.to_date }, # date
+      1082 => lambda{ |s| @use_iso_date_format ? Date.new(*s.split("-").map{|x| x.to_i}) : s.to_date }, # date
       1083 => lambda{ |s| s.to_time }, # time without time zone
       1114 => lambda{ |s| s.to_sequel_time }, # timestamp without time zone
       1184 => lambda{ |s| s.to_sequel_time }, # timestamp with time zone
@@ -102,16 +102,12 @@ module Sequel
       1700 => lambda{ |s| s.to_d }, # numeric
     }
     
-    # Module method for converting a PostgreSQL string to a boolean value.
-    def self.string_to_bool(s)
-      if(s.blank?)
-        nil
-      elsif(s.downcase == 't' || s.downcase == 'true')
-        true
-      else
-        false
-      end
-    end
+    @use_iso_date_format = true
+
+    # As an optimization, Sequel sets the date style to ISO, so that PostgreSQL provides
+    # the date in a known format that Sequel can parse faster.  This can be turned off
+    # if you require a date style other than ISO.
+    metaattr_accessor :use_iso_date_format
     
     # PGconn subclass for connection specific methods used with the
     # pg, postgres, or postgres-pr driver.
@@ -119,6 +115,13 @@ module Sequel
       include Sequel::Postgres::AdapterMethods
       self.translate_results = false if respond_to?(:translate_results=)
       
+      # Apply connection settings for this connection.  Current sets
+      # the date style to ISO in order make Date object creation in ruby faster,
+      # if Postgres.use_iso_date_format is true.
+      def apply_connection_settings
+        async_exec("SET DateStyle = 'ISO, YMD'") if Postgres.use_iso_date_format
+      end
+
       # Execute the given SQL with this connection.  If a block is given,
       # yield the results, otherwise, return the number of changed rows.
       def execute(sql, args=nil)
@@ -138,6 +141,12 @@ module Sequel
           q.clear
         end
       end
+
+      # Reapply the connection settings if the connection is reset.
+      def reset(*args, &block)
+        super(*args, &block)
+        apply_connection_settings
+      end
       
       if SEQUEL_POSTGRES_USES_PG
         # Hash of prepared statements for this connection.  Keys are
@@ -170,14 +179,14 @@ module Sequel
         @primary_keys = {}
         @primary_key_sequences = {}
       end
-      
+
       # Connects to the database.  In addition to the standard database
       # options, using the :encoding or :charset option changes the
       # client encoding for the connection.
       def connect(server)
         opts = server_opts(server)
         conn = Adapter.connect(
-          opts[:host] || 'localhost',
+          (opts[:host] unless opts[:host].blank?),
           opts[:port] || 5432,
           nil, '',
           opts[:database],
@@ -185,8 +194,13 @@ module Sequel
           opts[:password]
         )
         if encoding = opts[:encoding] || opts[:charset]
-          conn.set_client_encoding(encoding)
+          if conn.respond_to?(:set_client_encoding)
+            conn.set_client_encoding(encoding)
+          else
+            conn.async_exec("set client_encoding to '#{encoding}'")
+          end
         end
+        conn.apply_connection_settings
         conn.db = self
         conn
       end
@@ -280,21 +294,20 @@ module Sequel
     class Dataset < Sequel::Dataset
       include Sequel::Postgres::DatasetMethods
       
-      # yield all rows returned by executing the given SQL and converting
+      # Yield all rows returned by executing the given SQL and converting
       # the types.
       def fetch_rows(sql)
-        @columns = []
+        cols = []
         execute(sql) do |res|
-          (0...res.ntuples).each do |recnum|
+          res.nfields.times do |fieldnum|
+            cols << [fieldnum, PG_TYPES[res.ftype(fieldnum)], res.fname(fieldnum).to_sym]
+          end
+          @columns = cols.map{|c| c.at(2)}
+          res.ntuples.times do |recnum|
             converted_rec = {}
-            (0...res.nfields).each do |fieldnum|
-              fieldsym = res.fname(fieldnum).to_sym
-              @columns << fieldsym
-              converted_rec[fieldsym] = if value = res.getvalue(recnum,fieldnum)
-                (PG_TYPES[res.ftype(fieldnum)] || lambda{|s| s.to_s}).call(value)
-              else
-                value
-              end
+            cols.each do |fieldnum, type_proc, fieldsym|
+              value = res.getvalue(recnum, fieldnum)
+              converted_rec[fieldsym] = (value && type_proc) ? type_proc.call(value) : value
             end
             yield converted_rec
           end

data/lib/sequel_core/adapters/shared/mssql.rb

@@ -120,7 +120,6 @@ module Sequel
         
         sql
       end
-      alias_method :sql, :select_sql
     end
   end
 end

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

@@ -156,7 +156,7 @@ module Sequel
 
       # Transforms an CROSS JOIN to an INNER JOIN if the expr is not nil.
       # Raises an error on use of :full_outer type, since MySQL doesn't support it.
-      def join_table(type, table, expr=nil, table_alias=nil)
+      def join_table(type, table, expr=nil, table_alias={})
         type = :inner if (type == :cross) && !expr.nil?
         raise(Sequel::Error, "MySQL doesn't support FULL OUTER JOIN") if type == :full_outer
         super(type, table, expr, table_alias)

data/lib/sequel_core/adapters/shared/oracle.rb

@@ -0,0 +1,82 @@
+module Sequel
+  module Oracle
+    module DatabaseMethods
+      def tables
+        from(:tab).select(:tname).filter(:tabtype => 'TABLE').map do |r|
+          r[:tname].downcase.to_sym
+        end
+      end
+
+      def table_exists?(name)
+        from(:tab).filter(:tname => name.to_s.upcase, :tabtype => 'TABLE').count > 0
+      end
+    end
+    
+    module DatasetMethods
+      def empty?
+        db[:dual].where(exists).get(1) == nil
+      end
+
+      # Formats a SELECT statement using the given options and the dataset
+      # options.
+      def select_sql(opts = nil)
+        opts = opts ? @opts.merge(opts) : @opts
+
+        if sql = opts[:sql]
+          return sql
+        end
+
+        columns = opts[:select]
+        select_columns = columns ? column_list(columns) : '*'
+        sql = opts[:distinct] ? \
+        "SELECT DISTINCT #{select_columns}" : \
+        "SELECT #{select_columns}"
+        
+        if opts[:from]
+          sql << " FROM #{source_list(opts[:from])}"
+        end
+        
+        if join = opts[:join]
+          join.each{|j| sql << literal(j)}
+        end
+
+        if where = opts[:where]
+          sql << " WHERE #{literal(where)}"
+        end
+
+        if group = opts[:group]
+          sql << " GROUP BY #{expression_list(group)}"
+        end
+
+        if having = opts[:having]
+          sql << " HAVING #{literal(having)}"
+        end
+
+        if union = opts[:union]
+          sql << (opts[:union_all] ? \
+            " UNION ALL #{union.sql}" : " UNION #{union.sql}")
+        elsif intersect = opts[:intersect]
+          sql << (opts[:intersect_all] ? \
+            " INTERSECT ALL #{intersect.sql}" : " INTERSECT #{intersect.sql}")
+        elsif except = opts[:except]
+          sql << (opts[:except_all] ? \
+            " EXCEPT ALL #{except.sql}" : " EXCEPT #{except.sql}")
+        end
+
+        if order = opts[:order]
+          sql << " ORDER BY #{expression_list(order)}"
+        end
+
+        if limit = opts[:limit]
+          if (offset = opts[:offset]) && (offset > 0)
+            sql = "SELECT * FROM (SELECT raw_sql_.*, ROWNUM raw_rnum_ FROM(#{sql}) raw_sql_ WHERE ROWNUM <= #{limit + offset}) WHERE raw_rnum_ > #{offset}"
+          else
+            sql = "SELECT * FROM (#{sql}) WHERE ROWNUM <= #{limit}"
+          end
+        end
+
+        sql
+      end
+    end
+  end
+end