sequel_core 2.1.0 → 2.2.0

data/CHANGELOG

@@ -1,4 +1,42 @@
-=== HEAD
+=== 2.2.0 (2008-07-05)
+
+* Filter blocks now yield a SQL::VirtualRow argument, which is useful if another library defines operator methods on Symbol (jeremyevans)
+
+* Add Symbol#identifier method, to make x__a be treated as "x__a" instead of "x"."a" (jeremyevans)
+
+* Dataset#update no longer takes a block, please use a hash argument with the expression syntax instead (jeremyevans)
+
+* ParseTree support has been removed from Sequel (jeremyevans)
+
+* Database#drop_column is now supported in the SQLite adapter (abhay)
+
+* Tinyint columns can now be considered integers instead of booleans by setting Sequel.convert_tinyint_to_bool = false (samsouder)
+
+* Allow the use of URL parameters in connection strings (jeremyevans)
+
+* Ignore any previously selected columns when using Dataset#graph for the first time (jeremyevans)
+
+* Dataset#graph now accepts a block which is passed to join_table (jeremyevans)
+
+* Make Dataset#columns ignore any filtering, ordering, and distinct clauses (jeremyevans)
+
+* Use the safer connection-specific string escaping methods for PostgreSQL (jeremyevans)
+
+* Database#transaction now yields a connection when using the Postgres adapter, just like it does for other adapters (jeremyevans)
+
+* Dataset#count now works for a limited dataset (divoxx)
+
+* Database#add_index is now supported in the SQLite adapter (abhay)
+
+* Sequel's MySQL adapter should no longer conflict with ActiveRecord's use of MySQL (careo)
+
+* Treat Hash as expression instead of column alias when used in DISTINCT, ORDER BY, and GROUP BY clauses (jeremyevans)
+
+* PostgreSQL bytea fields are now fully supported (dlee)
+
+* For PostgreSQL, don't raise an error when assigning a value to a SERIAL PRIMARY KEY field when inserting records (jeremyevans)
+
+=== 2.1.0 (2008-06-17)
 
 * Support bitwise operators for NumericExpressions: &, |, ^, ~, <<, >> (jeremyevans)
 

data/Rakefile

@@ -9,7 +9,7 @@ include FileUtils
 # Configuration
 ##############################################################################
 NAME = "sequel_core"
-VERS = "2.1.0"
+VERS = "2.2.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/doc/dataset_filtering.rdoc

@@ -145,114 +145,32 @@ Or against SQL functions:
 
 You can search SQL strings using the #like method:
 
-  items.filter(:name.like('Acme%').sql
+  items.filter(:name.like('Acme%')).sql
   #=> "SELECT * FROM items WHERE (name LIKE 'Acme%')"
 
 You can specify a Regexp as a like argument, but this will probably only work
 on PostgreSQL and MySQL:
 
-  items.filter(:name.like(/Acme.*/).sql
+  items.filter(:name.like(/Acme.*/)).sql
   #=> "SELECT * FROM items WHERE (name ~ 'Acme.*')"
 
 Like can also take more than one argument:
 
-  items.filter(:name.like('Acme%', /Beta.*/).sql
+  items.filter(:name.like('Acme%', /Beta.*/)).sql
   #=> "SELECT * FROM items WHERE ((name LIKE 'Acme%') OR (name ~ 'Beta.*'))"
 
 == String concatenation
 
 You can concatenate SQL strings using Array#sql_string_join: 
 
-  items.filter([:name, :comment].sql_string_join.like('%acme%').sql
+  items.filter([:name, :comment].sql_string_join.like('%acme%')).sql
   #=> "SELECT * FROM items WHERE ((name || comment) LIKE 'Acme%')"
 
 Array#sql_string_join also takes a join argument:
 
-  items.filter([:name, :comment].sql_string_join(' ').like('%acme%').sql
+  items.filter([:name, :comment].sql_string_join(' ').like('%acme%')).sql
   #=> "SELECT * FROM items WHERE ((name || ' ' || comment) LIKE 'Acme%')"
 
-== Filtering using expressions with blocks
-
-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.  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:
-
-  items.filter{:price < 100}.sql
-  #=> "SELECT * FROM items WHERE (price < 100) 
-
-Sequel is smart enough to literalize values correctly, even if you compare against arrays or ranges:
-
-  items.filter{:category == 'ruby'}.sql
-  #=> "SELECT * FROM items WHERE (category = 'ruby')"
-
-  items.filter{:category == ['ruby', 'other']}.sql
-  #=> "SELECT * FROM items WHERE (category IN ('ruby', 'other'))"
-
-  items.filter{:price == (100..200)}.sql
-  #=> "SELECT * FROM items WHERE (price >= 100 AND price <= 200)"
-
-=== Negating conditions
-
-You can use the negation operator (!) anywhere:
-
-  items.filter{:category != 'ruby'}.sql
-  #=> "SELECT * FROM items WHERE NOT (category = 'ruby')"
-
-  items.filter{!:active}.sql
-  #=> "SELECT * FROM items WHERE (active = 'f')"
-
-=== Comparing against column references
-
-You can also compare against other columns:
-
-  items.filter{:credit > :debit}.sql
-  #=> "SELECT * FROM items WHERE (credit > debit)
-
-Or against SQL functions:
-
-  items.filter{:price < :max[:price] + 100}.sql
-  #=> "SELECT * FROM items WHERE (price < (max(price) + 100))"
-
-=== Concatenating conditions with logical operators
-
-Expressions can be nested and combined using logical operators:
-
-  items.filter{(:price < 100 && :age < 27) || :category == 'ruby'}.sql
-  #=> "SELECT * FROM items WHERE (((price < 100) AND (age < 27)) OR (category = 'ruby'))"
-
-Another way to concatenate conditions is to specify each condition as a separate statement:
-
-  items.filter do
-    :price < 100
-    :category == 'ruby'
-  end.sql
-  #=> "SELECT * FROM items WHERE ((price < 100) AND (category = 'ruby'))"
-
-=== Special methods
-
-Inside blocks, Sequel recognizes the special methods nil/nil?, in/in? and like/like?:
-
-  items.filter{:price.nil?}.sql
-  #=> "SELECT * FROM items WHERE (price IS NULL)"
-
-  items.filter{:category.in ['ruby', 'other']}.sql
-  #=> "SELECT * FROM items WHERE (category IN ('ruby', 'other'))"
-
-  items.filter{:price.in 100..200}.sql
-  #=> "SELECT * FROM items WHERE (price >= 100 AND price <= 200)"
-
-  items.filter{:category.like 'ruby%'}.sql
-  #=> "SELECT * FROM items WHERE (category LIKE 'ruby%')"
-
 == Filtering using sub-queries
 
 One of the best features of Sequel is the ability to use datasets as sub-queries. Sub-queries can be very useful for filtering records, and many times provide a simpler alternative to table joins. Sub-queries can be used in all forms of filters:

data/lib/sequel_core.rb

@@ -2,7 +2,7 @@
   require f
 end
 %w"core_ext sql core_sql connection_pool exceptions pretty_table
-  dataset migration schema database worker object_graph deprecated".each do |f|
+  dataset migration schema database worker object_graph".each do |f|
   require "sequel_core/#{f}"
 end
 
@@ -13,8 +13,8 @@ end
 #
 #   DB = Sequel.sqlite # Memory database
 #   DB = Sequel.sqlite('blog.db')
-#   DB = Sequel.postgres('database_name', :user=>'user', \
-#          :password=>'password', :host=>'host', :port=>5432, \
+#   DB = Sequel.postgres('database_name', :user=>'user', 
+#          :password=>'password', :host=>'host', :port=>5432, 
 #          :max_connections=>10)
 #
 # If a block is given to these methods, it is passed the opened Database
@@ -27,20 +27,16 @@ end
 #
 #   Sequel.datetime_class = DateTime
 #
-# Sequel can either use ParseTree for block filters (deprecated but works),
-# or it can use the block filter syntax inside block filters (which will
-# be the only behavior allowed in Sequel 2.2). To set it not to use
-# ParseTree filters:
+# Sequel converts the column type tinyint to a boolean by default,
+# you can override the conversion to use tinyint as an integer:
 #
-#   Sequel.use_parse_tree = false
+#   Sequel.convert_tinyint_to_bool = false
 module Sequel
   @datetime_class = Time
-  @use_parse_tree = !defined?(SEQUEL_NO_PARSE_TREE)
-
+  @convert_tinyint_to_bool = true
+  
   metaattr_accessor :datetime_class
-  metaattr_accessor :use_parse_tree
-
-  Deprecation.deprecation_message_stream = $stderr
+  metaattr_accessor :convert_tinyint_to_bool
 
   # Creates a new database object based on the supplied connection string
   # and optional arguments.  The specified scheme determines the database
@@ -97,6 +93,17 @@ module Sequel
   def self.single_threaded=(value)
     Database.single_threaded = value
   end
+
+  # Always returns false, since ParseTree support has been removed.
+  def self.use_parse_tree
+    false
+  end
+
+  # Raises an error if attempting to turn ParseTree support on (since it no longer exists).
+  # Otherwise, is a no-op.
+  def self.use_parse_tree=(val)
+    raise(Error, 'ParseTree support has been removed from Sequel') if val
+  end
   
   ### Private Class Methods ###
 

data/lib/sequel_core/adapters/mysql.rb

@@ -4,7 +4,7 @@ require 'mysql'
 class Mysql::Result
   MYSQL_TYPES = {
     0   => :to_d,     # MYSQL_TYPE_DECIMAL
-    #1   => :to_i,     # MYSQL_TYPE_TINY
+    1   => :to_i,     # MYSQL_TYPE_TINY
     2   => :to_i,     # MYSQL_TYPE_SHORT
     3   => :to_i,     # MYSQL_TYPE_LONG
     4   => :to_f,     # MYSQL_TYPE_FLOAT
@@ -22,11 +22,11 @@ class Mysql::Result
     # 16  => :to_s,     # MYSQL_TYPE_BIT
     246 => :to_d,     # MYSQL_TYPE_NEWDECIMAL
     247 => :to_i,     # MYSQL_TYPE_ENUM
-    248 => :to_i      # MYSQL_TYPE_SET
-    # 249 => :to_s,     # MYSQL_TYPE_TINY_BLOB
-    # 250 => :to_s,     # MYSQL_TYPE_MEDIUM_BLOB
-    # 251 => :to_s,     # MYSQL_TYPE_LONG_BLOB
-    # 252 => :to_s,     # MYSQL_TYPE_BLOB
+    248 => :to_i,      # MYSQL_TYPE_SET
+    249 => :to_blob,     # MYSQL_TYPE_TINY_BLOB
+    250 => :to_blob,     # MYSQL_TYPE_MEDIUM_BLOB
+    251 => :to_blob,     # MYSQL_TYPE_LONG_BLOB
+    252 => :to_blob,     # MYSQL_TYPE_BLOB
     # 253 => :to_s,     # MYSQL_TYPE_VAR_STRING
     # 254 => :to_s,     # MYSQL_TYPE_STRING
     # 255 => :to_s      # MYSQL_TYPE_GEOMETRY
@@ -34,7 +34,7 @@ class Mysql::Result
 
   def convert_type(v, type)
     if v
-      if type == 1
+      if type == 1 && Sequel.convert_tinyint_to_bool
         # We special case tinyint here to avoid adding
         # a method to an ancestor of Fixnum
         v.to_i == 0 ? false : true
@@ -69,7 +69,7 @@ class Mysql::Result
     end
   end
 
-  def each_hash(with_table = nil)
+  def sequel_each_hash(with_table = nil)
     c = columns
     while row = fetch_row
       h = {}
@@ -77,6 +77,7 @@ class Mysql::Result
       yield h
     end
   end
+  
 end
 
 module Sequel
@@ -388,7 +389,7 @@ module Sequel
         opts = opts ? @opts.merge(opts) : @opts
 
         if order = opts[:order]
-          sql << " ORDER BY #{column_list(order)}"
+          sql << " ORDER BY #{expression_list(order)}"
         end
         if limit = opts[:limit]
           sql << " LIMIT #{limit}"
@@ -442,7 +443,7 @@ module Sequel
         opts = opts ? @opts.merge(opts) : @opts
 
         if order = opts[:order]
-          sql << " ORDER BY #{column_list(order)}"
+          sql << " ORDER BY #{expression_list(order)}"
         end
         if limit = opts[:limit]
           sql << " LIMIT #{limit}"
@@ -470,7 +471,7 @@ module Sequel
       def fetch_rows(sql)
         @db.execute_select(sql) do |r|
           @columns = r.columns
-          r.each_hash {|row| yield row}
+          r.sequel_each_hash {|row| yield row}
         end
         self
       end

data/lib/sequel_core/adapters/odbc_mssql.rb

@@ -38,7 +38,7 @@ module Sequel
           select_columns = columns ? column_list(columns) : WILDCARD
 
           if distinct = opts[:distinct]
-            distinct_clause = distinct.empty? ? "DISTINCT" : "DISTINCT ON (#{column_list(distinct)})"
+            distinct_clause = distinct.empty? ? "DISTINCT" : "DISTINCT ON (#{expression_list(distinct)})"
             sql = "SELECT #{top}#{distinct_clause} #{select_columns}"
           else
             sql = "SELECT #{top}#{select_columns}"
@@ -62,11 +62,11 @@ module Sequel
           end
 
           if group = opts[:group]
-            sql << " GROUP BY #{column_list(group)}"
+            sql << " GROUP BY #{expression_list(group)}"
           end
 
           if order = opts[:order]
-            sql << " ORDER BY #{column_list(order)}"
+            sql << " ORDER BY #{expression_list(order)}"
           end
 
           if having = opts[:having]

data/lib/sequel_core/adapters/oracle.rb

@@ -143,7 +143,7 @@ module Sequel
         end
 
         if group = opts[:group]
-          sql << " GROUP BY #{column_list(group)}"
+          sql << " GROUP BY #{expression_list(group)}"
         end
 
         if having = opts[:having]
@@ -162,7 +162,7 @@ module Sequel
         end
 
         if order = opts[:order]
-          sql << " ORDER BY #{column_list(order)}"
+          sql << " ORDER BY #{expression_list(order)}"
         end
 
         if limit = opts[:limit]

data/lib/sequel_core/adapters/postgres.rb

@@ -4,7 +4,41 @@ rescue LoadError => e
   begin 
     require 'postgres' 
     class PGconn
-      metaalias :escape_string, :escape unless self.respond_to?(:escape_string)
+      unless method_defined?(:escape_string)
+        if self.respond_to?(:escape)
+          def escape_string(str)
+            self.class.escape(str)
+          end
+        else
+          def escape_string(obj)
+            raise Sequel::Error, "string escaping not supported with this postgres driver.  Try using ruby-pg, ruby-postgres, or postgres-pr."
+          end
+        end
+      end
+      unless method_defined?(:escape_bytea)
+        if self.respond_to?(:escape_bytea)
+          def escape_bytea(obj)
+            self.class.escape_bytea(obj)
+          end
+        else
+          begin
+            require 'postgres-pr/typeconv/conv'
+            require 'postgres-pr/typeconv/bytea'
+            extend Postgres::Conversion
+            def escape_bytea(obj)
+              self.class.encode_bytea(obj)
+            end
+            metaalias :unescape_bytea, :decode_bytea
+          rescue
+            def escape_bytea(obj)
+              raise Sequel::Error, "bytea escaping not supported with this postgres driver.  Try using ruby-pg, ruby-postgres, or postgres-pr."
+            end
+            def self.unescape_bytea(obj)
+              raise Sequel::Error, "bytea unescaping not supported with this postgres driver.  Try using ruby-pg, ruby-postgres, or postgres-pr."
+            end
+          end
+        end
+      end
       alias_method :finish, :close unless method_defined?(:finish) 
     end
     class PGresult 
@@ -22,24 +56,6 @@ end
 module Sequel
   module Postgres
     class Adapter < ::PGconn
-      # the pure-ruby postgres adapter does not have a quote method.
-      TRUE = 'true'.freeze
-      FALSE = 'false'.freeze
-      NULL = 'NULL'.freeze
-      
-      def self.quote(obj)
-        case obj
-        when TrueClass
-          TRUE
-        when FalseClass
-          FALSE
-        when NilClass
-          NULL
-        else
-          "'#{escape_string(obj.to_s)}'"
-        end
-      end
-      
       def connected?
         status == Adapter::CONNECTION_OK
       end
@@ -160,7 +176,7 @@ module Sequel
 
     PG_TYPES = {
       16 => lambda{ |s| Adapter.string_to_bool(s) }, # boolean
-      17 => lambda{ |s| Adapter.unescape_bytea(s) }, # bytea
+      17 => lambda{ |s| Adapter.unescape_bytea(s).to_blob }, # bytea
       20 => lambda{ |s| s.to_i }, # int8
       21 => lambda{ |s| s.to_i }, # int2
       22 => lambda{ |s| s.to_i }, # int2vector
@@ -245,9 +261,7 @@ module Sequel
           result = conn.last_insert_id(table)
           return result if result
         rescue PGError => e
-          # An error could occur if the inserted values include a primary key
-          # value, while the primary key is serial.
-          raise Error.new(e.message =~ RE_CURRVAL_ERROR ? "Could not return primary key value for the inserted record. Are you specifying a primary key value for a serial primary key?" : e.message)
+          raise(Error, e.message) unless RE_CURRVAL_ERROR.match(e.message)
         end
         
         case values
@@ -310,7 +324,7 @@ module Sequel
           end
           begin
             conn.transaction_depth += 1
-            yield
+            yield conn
           rescue ::Exception => e
             if conn.transaction_depth > 1
               log_info(SQL_ROLLBACK_TO_SAVEPOINT % [conn.transaction_depth - 1])
@@ -393,17 +407,23 @@ module Sequel
       end
       
       PG_TIMESTAMP_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S".freeze
+      BOOL_FALSE = 'false'.freeze
+      BOOL_TRUE = 'true'.freeze
 
       def literal(v)
         case v
         when LiteralString
           v
-        when String, TrueClass, FalseClass
-          Adapter.quote(v)
+        when String
+          db.synchronize{|c| "'#{SQL::Blob === v ? c.escape_bytea(v) : c.escape_string(v)}'"}
         when Time
           "#{v.strftime(PG_TIMESTAMP_FORMAT)}.#{sprintf("%06d",v.usec)}'"
         when DateTime
           "#{v.strftime(PG_TIMESTAMP_FORMAT)}.#{sprintf("%06d", (v.sec_fraction * 86400000000).to_i)}'"
+        when TrueClass
+          BOOL_TRUE
+        when FalseClass
+          BOOL_FALSE
         else
           super
         end