sequel_core 2.0.1 → 2.1.0

data/CHANGELOG

@@ -1,3 +1,49 @@
+=== HEAD
+
+* Support bitwise operators for NumericExpressions: &, |, ^, ~, <<, >> (jeremyevans)
+
+* No longer raise an error for Dataset#filter(true) or Dataset#filter(false) (jeremyevans)
+
+* Allow Dataset #filter, #or, #exclude and other methods that call them to use both the block and regular arguments (jeremyevans)
+
+* ParseTree support is now officially deprecated, use Sequel.use_parse_tree = false to use the expression (blockless) filters inside blocks (jeremyevans)
+
+* Remove :pool_reuse_connections ConnectionPool/Database option, MySQL users need to be careful with nested queries (jeremyevans)
+
+* Allow Dataset#graph :select option to take an array of columns to select (jeremyevans)
+
+* Allow Dataset#to_hash to be called with only one argument, allowing for easy creation of lookup tables for a single key (jeremyevans)
+
+* Allow join_table to accept a block providing the aliases and previous joins, that allows you to specify arbitrary conditions properly qualified (jeremyevans)
+
+* Support NATURAL, CROSS, and USING joins in join_table (jeremyevans)
+
+* Make sure HAVING comes before ORDER BY, per the SQL standard and at least MySQL, PostgreSQL, and SQLite (juco)
+
+* Add cast_numeric and cast_string methods for use in the Sequel DSL, that have default types and wrap the object in the correct class (jeremyevans)
+
+* Add Symbol#qualify, for adding a table/schema qualifier to a column/table name (jeremyevans)
+
+* Remove Module#metaprivate, since it duplicates the standard Module#private_class_method (jeremyevans)
+
+* Support the SQL CASE expression via Array#case and Hash#case (jeremyevans)
+
+* Support the SQL EXTRACT function: :date.extract(:year) (jeremyevans)
+
+* Convert numeric fields to BigDecimal in PostgreSQL adapter (jeremyevans)
+
+* Add :decimal fields to the schema parser (jeremyevans)
+
+* The expr argument in join table now allows the same argument as filter, so it can take a string or a blockless filter expression (brushbox, jeremyevans)
+
+* No longer assume the expr argument to join_table references the primary key column (jeremyevans)
+
+* Rename the Sequel.time_class setting to Sequel.datetime_class (jeremyevans)
+
+* Add savepoint/nesting support to postgresql transactions (elven)
+
+* Use the specified table alias when joining a dataset, instead of the automatically generated alias (brushbox)
+
 === 2.0.1 (2008-06-04)
 
 * Have PostgreSQL money type use BigDecimal instead of Float (jeremyevans)
@@ -10,6 +56,10 @@
 
 * Add StringExpression#+, for simple SQL string concatenation (:x.sql_string + :y) (jeremyevans)
 
+* Make StringMethods.like to a case sensensitive search on MySQL (use ilike for the old behavior) (jeremyevans)
+
+* Add StringMethods.ilike, for case insensitive pattern matching (jeremyevans)
+
 * Refactor ComplexExpression into three subclasses and a few modules, so operators that don't make sense are not defined for the class (jeremyevans)
 
 === 2.0.0 (2008-06-01)

data/README

@@ -9,8 +9,7 @@ Sequel makes it easy to deal with multiple records without having to break your
 * {Source code}[http://github.com/jeremyevans/sequel]
 * {Bug tracking}[http://code.google.com/p/ruby-sequel/issues/list]
 * {Google group}[http://groups.google.com/group/sequel-talk]
-* {RubyForge page}[http://rubyforge.org/projects/sequel/]
-* {API RDoc}[http://sequel.rubyforge.org]
+* {RDoc}[http://sequel.rubyforge.org]
 
 To check out the source code:
   

data/Rakefile

@@ -9,7 +9,7 @@ include FileUtils
 # Configuration
 ##############################################################################
 NAME = "sequel_core"
-VERS = "2.0.1"
+VERS = "2.1.0"
 CLEAN.include ["**/.*.sw?", "pkg", ".config", "rdoc", "coverage"]
 RDOC_OPTS = ["--quiet", "--line-numbers", "--inline-source", '--title', \
   'Sequel: The Database Toolkit for Ruby: Core Library and Adapters', \

data/bin/sequel

@@ -14,13 +14,15 @@ db_opts = {}
 echo = nil
 env = nil
 logfile = nil
+migrate_dir = nil
+migrate_ver = nil
 
 opts = OptionParser.new do |opts|
   opts.banner = "Sequel: The Database Toolkit for Ruby"
   opts.define_head "Usage: sequel <uri|path> [options]"
   opts.separator ""
   opts.separator "Examples:"
-  opts.separator "  sequel sqlite:///blog.db"
+  opts.separator "  sequel sqlite://blog.db"
   opts.separator "  sequel postgres://localhost/my_blog"
   opts.separator "  sequel config/database.yml"
   opts.separator ""
@@ -28,23 +30,31 @@ opts = OptionParser.new do |opts|
   opts.separator ""
   opts.separator "Options:"
 
+  opts.on_tail("-?", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+
   opts.on("-l", "--log logfile", "log SQL statements to log file") do |v|
     logfile = v
   end
   
-  opts.on("-E", "--echo", "echo SQL statements") do |v|
-    echo = v
+  opts.on("-e", "--env ENV", "use environment config for database") do |v|
+    env = v
   end
   
-  opts.on("-e", "--env ENV", "use environment config for database") do |env|
-    env = env
+  opts.on("-E", "--echo", "echo SQL statements") do
+    echo = true
   end
   
-  opts.on_tail("-?", "--help", "Show this message") do
-    puts opts
-    exit
+  opts.on("-m", "--migrate-directory DIR", "run the migrations in directory") do |v|
+    migrate_dir = v
   end
-
+  
+  opts.on("-M", "--migrate-version VER", "migrate the database to version given") do |v|
+    migrate_ver = Integer(v)
+  end
+  
   opts.on_tail("-v", "--version", "Show version") do
     class << Gem; attr_accessor :loaded_specs; end
     begin
@@ -66,7 +76,7 @@ db = ARGV.shift
 
 if db.blank?
   puts opts
-  exit
+  exit 1
 end
 
 if logfile || echo
@@ -91,12 +101,17 @@ begin
   end
   DB = Sequel.connect(*opts)
   DB.test_connection
+  if migrate_dir
+    Sequel::Migrator.apply(DB, migrate_dir, migrate_ver)
+    exit
+  end
 rescue => e
   puts e.message
   puts e.backtrace.first
-  exit
+  exit 1
 end
 
+
 require 'irb'
 puts "Your database is stored in DB..."
 IRB.start

data/doc/dataset_filtering.rdoc

@@ -113,7 +113,7 @@ This works with other hash values, such as arrays and ranges:
   items.filter({:category => ['ruby', 'other']} | (:price - 100 > 200)).sql
   #=> "SELECT * FROM items WHERE ((category IN ('ruby', 'other')) OR ((price - 100) <= 200))"
 
-  items.filter({:price == (100..200)} & :active).sql
+  items.filter({:price => (100..200)} & :active).sql
   #=> "SELECT * FROM items WHERE ((price >= 100 AND price <= 200) AND active)"
 
 === Negating conditions
@@ -175,7 +175,14 @@ Array#sql_string_join also takes a join argument:
 
 Most SQL expressions that you can can create with expressions you can also express inside blocks.  This was previously the only way to specify expressions using ruby code.  Filtering with blocks requires that you install ParseTree, ruby2ruby, and their dependencies.  It's slower than using the equivalent expression without a block, and the syntax inside the block is different in some cases. Because it requires ParseTree, it can only be used with MRI (Matz's Ruby Interpreter) 1.8.*, as ParseTree doesn't run on any other ruby implementation (blockless filters should work on other ruby implementations).
 
-In general, filtering with a block should only be used with legacy code.  While it is not officially deprecated, usage of blocks when filtering is discouraged.
+In general, filtering with a block should only be used with legacy code.  ParseTree filters are currently deprecated, and support for them will be removed in Sequel 2.2.  To use the expression filtering syntax inside blocks, set:
+
+  Sequel.use_parse_tree = false
+  # or
+  SEQUEL_NO_PARSE_TREE = true
+  require 'sequel'
+
+These will become no-ops in Sequel 2.2, as the expression syntax inside blocks will be the only supported behavior.
 
 To filter with a block, supply a block to filter with the appropriate ruby code:
 

data/lib/sequel_core/adapters/adapter_skeleton.rb

@@ -1,5 +1,3 @@
-# require 'adapter_lib'
-
 module Sequel
   module Adapter
     class Database < Sequel::Database

data/lib/sequel_core/adapters/mysql.rb

@@ -256,7 +256,7 @@ module Sequel
 
       private
       def connection_pool_default_options
-        super.merge(:pool_reuse_connections=>:last_resort, :pool_convert_exceptions=>false)
+        super.merge(:pool_convert_exceptions=>false)
       end
 
       def schema_ds_dataset
@@ -285,28 +285,6 @@ module Sequel
       TRUE = '1'
       FALSE = '0'
 
-      # Join processing changed after MySQL v5.0.12. NATURAL
-      # joins are SQL:2003 consistent.
-      JOIN_TYPES  =  { :cross => 'INNER JOIN'.freeze,
-        :straight => 'STRAIGHT_JOIN'.freeze,
-        :natural_left => 'NATURAL LEFT JOIN'.freeze,
-        :natural_right => 'NATURAL RIGHT JOIN'.freeze,
-        :natural_left_outer => 'NATURAL LEFT OUTER JOIN'.freeze,
-        :natural_right_outer => 'NATURAL RIGHT OUTER JOIN'.freeze,
-        :left => 'LEFT JOIN'.freeze,
-        :right => 'RIGHT JOIN'.freeze,
-        :left_outer => 'LEFT OUTER JOIN'.freeze,
-        :right_outer => 'RIGHT OUTER JOIN'.freeze,
-        :natural_inner => 'NATURAL LEFT JOIN'.freeze,
-        # :full_outer => 'FULL OUTER JOIN'.freeze,
-        #
-        # A full outer join, nor a workaround implementation of
-        # :full_outer, is not yet possible in Sequel. See issue
-        # #195 which probably depends on issue #113 being
-        # resolved.
-        :inner => 'INNER JOIN'.freeze
-      }
-
       def literal(v)
         case v
         when LiteralString
@@ -340,18 +318,18 @@ module Sequel
       #   @ds.join_table(:natural_left_outer, :nodes)
       #   # join SQL is 'NATURAL LEFT OUTER JOIN nodes'
       def join_table(type, table, expr=nil, table_alias=nil)
-        raise(Error::InvalidJoinType, "Invalid join type: #{type}") unless join_type = JOIN_TYPES[type || :inner]
-
-        server_version = (@opts[:server_version] ||= @db.server_version)
         type = :inner if (type == :cross) && !expr.nil?
-        return super(type, table, expr, table_alias) unless (server_version >= 50014) && /natural|cross|straight/.match(type.to_s)
-  
-        table = if Array === table
-          "( #{table.collect{|t| quote_identifier(t)}.join(', ')} )"
-        else
-          quote_identifier(table)
+        raise(Sequel::Error::InvalidJoinType, "MySQL doesn't support FULL OUTER JOIN") if type == :full_outer
+        super(type, table, expr, table_alias)
+      end
+      
+
+      def join_type_sql(join_type)
+        case join_type
+        when :straight then 'STRAIGHT_JOIN'
+        when :natural_inner then 'NATURAL LEFT JOIN'
+        else super
         end
-        clone(:join => "#{@opts[:join]} #{join_type} #{table}")
       end
 
       def insert_default_values_sql
@@ -384,70 +362,6 @@ module Sequel
         end
       end
 
-      # MySQL expects the having clause before the order by clause.
-      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
-
-        if distinct = opts[:distinct]
-          distinct_clause = distinct.empty? ? "DISTINCT" : "DISTINCT ON (#{column_list(distinct)})"
-          sql = "SELECT #{distinct_clause} #{select_columns}"
-        else
-          sql = "SELECT #{select_columns}"
-        end
-        
-        if opts[:from]
-          sql << " FROM #{source_list(opts[:from])}"
-        end
-        
-        if join = opts[:join]
-          sql << join
-        end
-
-        if where = opts[:where]
-          sql << " WHERE #{literal(where)}"
-        end
-
-        if group = opts[:group]
-          sql << " GROUP BY #{column_list(group)}"
-        end
-
-        if having = opts[:having]
-          sql << " HAVING #{literal(having)}"
-        end
-
-        if order = opts[:order]
-          sql << " ORDER BY #{column_list(order)}"
-        end
-
-        if limit = opts[:limit]
-          sql << " LIMIT #{limit}"
-          if offset = opts[:offset]
-            sql << " OFFSET #{offset}"
-          end
-        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
-
-        sql
-      end
-      alias_method :sql, :select_sql
-      
       def full_text_search(cols, terms, opts = {})
         mode = opts[:boolean] ? " IN BOOLEAN MODE" : ""
         s = if Array === terms

data/lib/sequel_core/adapters/odbc_mssql.rb

@@ -54,7 +54,7 @@ module Sequel
           end
 
           if join = opts[:join]
-            sql << join
+            join.each{|j| sql << literal(j)}
           end
 
           if where = opts[:where]

data/lib/sequel_core/adapters/oracle.rb

@@ -135,7 +135,7 @@ module Sequel
         end
         
         if join = opts[:join]
-          sql << join
+          join.each{|j| sql << literal(j)}
         end
 
         if where = opts[:where]

data/lib/sequel_core/adapters/postgres.rb

@@ -63,7 +63,7 @@ module Sequel
         end
       end
     
-      attr_accessor :transaction_in_progress
+      attr_accessor :transaction_depth
       
       SELECT_CURRVAL = "SELECT currval('%s')".freeze
           
@@ -174,7 +174,8 @@ module Sequel
       1114 => lambda{ |s| s.to_sequel_time }, # timestamp without time zone
       1184 => lambda{ |s| s.to_sequel_time }, # timestamp with time zone
       1186 => lambda{ |s| s.to_i }, # interval
-      1266 => lambda{ |s| s.to_time } # time with time zone
+      1266 => lambda{ |s| s.to_time }, # time with time zone
+      1700 => lambda{ |s| s.to_d }, # numeric
     }
 
     if Adapter.respond_to?(:translate_results=)
@@ -291,35 +292,50 @@ module Sequel
       end
     
       SQL_BEGIN = 'BEGIN'.freeze
+      SQL_SAVEPOINT = 'SAVEPOINT autopoint_%d'.freeze
       SQL_COMMIT = 'COMMIT'.freeze
+      SQL_ROLLBACK_TO_SAVEPOINT = 'ROLLBACK TO SAVEPOINT autopoint_%d'.freeze
       SQL_ROLLBACK = 'ROLLBACK'.freeze
+      SQL_RELEASE_SAVEPOINT = 'RELEASE SAVEPOINT autopoint_%d'.freeze
   
       def transaction
         @pool.hold do |conn|
-          if conn.transaction_in_progress
-            yield conn
+          conn.transaction_depth = 0 if conn.transaction_depth.nil?
+          if conn.transaction_depth > 0
+            log_info(SQL_SAVEPOINT % conn.transaction_depth)
+            conn.execute(SQL_SAVEPOINT % conn.transaction_depth)
           else
             log_info(SQL_BEGIN)
             conn.execute(SQL_BEGIN)
-            begin
-              conn.transaction_in_progress = true
-              yield
-            rescue ::Exception => e
+          end
+          begin
+            conn.transaction_depth += 1
+            yield
+          rescue ::Exception => e
+            if conn.transaction_depth > 1
+              log_info(SQL_ROLLBACK_TO_SAVEPOINT % [conn.transaction_depth - 1])
+              conn.execute(SQL_ROLLBACK_TO_SAVEPOINT % [conn.transaction_depth - 1])
+            else
               log_info(SQL_ROLLBACK)
               conn.execute(SQL_ROLLBACK) rescue nil
-              raise convert_pgerror(e) unless Error::Rollback === e
-            ensure
-              unless e
-                begin
+            end
+            raise convert_pgerror(e) unless Error::Rollback === e
+          ensure
+            unless e
+              begin
+                if conn.transaction_depth < 2
                   log_info(SQL_COMMIT)
                   conn.execute(SQL_COMMIT)
-                rescue => e
-                  log_info(e.message)
-                  raise convert_pgerror(e)
+                else
+                  log_info(SQL_RELEASE_SAVEPOINT % [conn.transaction_depth - 1])
+                  conn.execute(SQL_RELEASE_SAVEPOINT % [conn.transaction_depth - 1])
                 end
+              rescue => e
+                log_info(e.message)
+                raise convert_pgerror(e)
               end
-              conn.transaction_in_progress = nil
             end
+            conn.transaction_depth -= 1
           end
         end
       end
@@ -360,7 +376,7 @@ module Sequel
 
       # PostgreSQL currently can always reuse connections.  It doesn't need the pool to convert exceptions, either.
       def connection_pool_default_options
-        super.merge(:pool_reuse_connections=>:always, :pool_convert_exceptions=>false)
+        super.merge(:pool_convert_exceptions=>false)
       end
 
       def schema_ds_filter(table_name, opts)