sequel 0.1.9.12 → 0.2.0

data/CHANGELOG

@@ -1,3 +1,55 @@
+=== 0.2.0 (2007-09-02)
+
+* Fixed Model.drop_table (thanks Duane Johnson.)
+
+* Dataset#each can now return rows for arbitrary SQL by specifying :sql option.
+
+* Added spec for postgres adapter.
+
+* Fixed Model.method_missing to work with new SQL generation.
+
+* Fixed #compare_expr to support regexps.
+
+* Fixed postgres, mysql adapters to support regexps.
+
+* More specs for block filters. Updated README.
+
+* Added support for globals and $X macros in block filters.
+
+* Fixed Sequelizer to not fail if ParseTree or Ruby2Ruby gems are missing.
+
+* Renamed String#expr into String#lit (#expr should be deprecated in future versions).
+
+* Renamed Sequel::ExpressionString into LiteralString.
+
+* Fixed Symbol#[] to return an ExpressionString, so as not to be literalized.
+
+* Renamed Dataset::Expressions to Dataset::Sequelizer.
+
+* Renamed Expressions#format_re_expression to match_expr.
+
+* Renamed Expressions#format_eq_expression to compare_expr.
+
+* Added support for Regexp in MySQL adapter.
+
+* Refactored Regexp expressions into a separate #format_re_expression method.
+
+* Added support for arithmetic in proc filters.
+
+* Added support for nested proc expressions, more specs.
+
+* Added support for SQL function using symbols, e.g. :sum[:x].
+
+* Fixed deadlock bug in ConnectionPool.
+
+* Removed deprecated old expressions.rb.
+
+* Rewrote Proc filter feature using ParseTree.
+
+* Added support for additional functions on columns using Symbol#method_missing.
+
+* Added support for supplying filter block to DB#[] method, to allow stuff like DB[:nodes] {:path =~ /^icex1/}.
+
 === 0.1.9.12 (2007-08-26)
 
 * Added spec for PrettyTable.

data/README

@@ -163,13 +163,13 @@ Or lists of values:
 
   my_posts = posts.filter(:category => ['ruby', 'postgres', 'linux'])
   
-Sequel now also accepts expressions as closures:
+Sequel now also accepts expressions as closures, AKA block filters:
 
-  my_posts = posts.filter {category == ['ruby', 'postgres', 'linux']}
+  my_posts = posts.filter {:category == ['ruby', 'postgres', 'linux']}
   
 Which also lets you do stuff like:
 
-  my_posts = posts.filter {stamp > 1.month.ago}
+  my_posts = posts.filter {:stamp > 1.month.ago}
   
 Some adapters (like postgresql) will also let you specify Regexps:
 

data/Rakefile

@@ -6,7 +6,7 @@ require 'fileutils'
 include FileUtils
 
 NAME = "sequel"
-VERS = "0.1.9.12"
+VERS = "0.2.0"
 CLEAN.include ['**/.*.sw?', 'pkg/*', '.config', 'doc/*', 'coverage/*']
 RDOC_OPTS = ['--quiet', '--title', "Sequel: Concise ORM for Ruby",
   "--opname", "index.html",
@@ -44,6 +44,8 @@ spec = Gem::Specification.new do |s|
   s.executables = ['sequel']
 
   s.add_dependency('metaid')
+  s.add_dependency('ParseTree')
+  s.add_dependency('ruby2ruby')
   
   s.required_ruby_version = '>= 1.8.4'
 

data/lib/sequel.rb

@@ -1,7 +1,7 @@
 require 'metaid'
 
 files = %w[
-  core_ext error connection_pool pretty_table expressions 
+  core_ext error connection_pool pretty_table
   dataset migration model schema database 
 ]
 dir = File.join(File.dirname(__FILE__), 'sequel')

data/lib/sequel/connection_pool.rb

@@ -94,7 +94,8 @@ module Sequel
       def make_new
         if @created_count < @max_size
           @created_count += 1
-          @connection_proc.call
+          @connection_proc ? @connection_proc.call : \
+            (raise SequelError, "No connection proc specified")
         end
       end
       

data/lib/sequel/core_ext.rb

@@ -18,10 +18,10 @@ class Array
 end
 
 module Sequel
-  # ExpressionString is used to represent literal SQL expressions. An 
-  # ExpressionString is copied verbatim into an SQL statement. Instances of
-  # ExpressionString can be created by calling String#expr.
-  class ExpressionString < ::String
+  # LiteralString is used to represent literal SQL expressions. An 
+  # LiteralString is copied verbatim into an SQL statement. Instances of
+  # LiteralString can be created by calling String#expr.
+  class LiteralString < ::String
   end
 end
 
@@ -39,19 +39,21 @@ class String
     to_sql.split(';').map {|s| s.strip}
   end
 
-  # Converts a string into an ExpressionString, in order to override string
+  # Converts a string into an LiteralString, in order to override string
   # literalization, e.g.:
   #
   #   DB[:items].filter(:abc => 'def').sql #=>
   #     "SELECT * FROM items WHERE (abc = 'def')"
   #
-  #   DB[:items].filter(:abc => 'def'.expr).sql #=>
+  #   DB[:items].filter(:abc => 'def'.lit).sql #=>
   #     "SELECT * FROM items WHERE (abc = def)"
   #
-  def expr
-    Sequel::ExpressionString.new(self)
+  def lit
+    Sequel::LiteralString.new(self)
   end
   
+  alias_method :expr, :lit
+  
   # Converts a string into a Time object.
   def to_time
     Time.parse(self)
@@ -93,18 +95,6 @@ module FieldCompositionMethods
       s
     end
   end
-
-  # Formats a min(x) expression.
-  def MIN; "min(#{to_field_name})"; end
-
-  # Formats a max(x) expression.
-  def MAX; "max(#{to_field_name})"; end
-
-  # Formats a sum(x) expression.
-  def SUM; "sum(#{to_field_name})"; end
-
-  # Formats an avg(x) expression.
-  def AVG; "avg(#{to_field_name})"; end
 end
 
 class String
@@ -139,6 +129,18 @@ class Symbol
       s
     end
   end
+  
+  # Converts missing method calls into functions on columns, if the
+  # method name is made of all upper case letters.
+  def method_missing(sym)
+    ((s = sym.to_s) =~ /^([A-Z]+)$/) ? \
+      "#{s.downcase}(#{to_field_name})" : super
+  end
+  
+  # Formats an SQL function with optional parameters
+  def [](*args)
+    "#{to_s}(#{args.join(', ')})".lit
+  end
 end
 
 

data/lib/sequel/database.rb

@@ -63,8 +63,12 @@ module Sequel
       Sequel::Dataset.new(self)
     end
 
-    # Returns a new dataset with the from method invoked.
-    def from(*args); dataset.from(*args); end
+    # Returns a new dataset with the from method invoked. If a block is given,
+    # it is used as a filter on the dataset.
+    def from(*args, &block)
+      ds = dataset.from(*args)
+      block ? ds.filter(&block) : ds
+    end
     
     # Returns a new dataset with the select method invoked.
     def select(*args); dataset.select(*args); end

data/lib/sequel/dataset.rb

@@ -1,8 +1,9 @@
 require 'time'
 require 'date'
 
-require File.join(File.dirname(__FILE__), 'dataset/dataset_sql')
-require File.join(File.dirname(__FILE__), 'dataset/dataset_convenience')
+require File.join(File.dirname(__FILE__), 'dataset/sequelizer')
+require File.join(File.dirname(__FILE__), 'dataset/sql')
+require File.join(File.dirname(__FILE__), 'dataset/convenience')
 
 module Sequel
   # A Dataset represents a view of a the data in a database, constrained by
@@ -63,8 +64,9 @@ module Sequel
   #   end
   class Dataset
     include Enumerable
-    include SQL # in dataset/dataset_sql.rb
-    include Convenience # in dataset/dataset_convenience.rb
+    include Sequelizer
+    include SQL
+    include Convenience
     
     attr_reader :db
     attr_accessor :opts

data/lib/sequel/dataset/sequelizer.rb

@@ -0,0 +1,246 @@
+class Sequel::Dataset
+  # The Sequelizer module includes methods for translating Ruby expressions
+  # into SQL expressions, making it possible to specify dataset filters using
+  # blocks, e.g.:
+  #
+  #   DB[:items].filter {:price < 100}
+  #   DB[:items].filter {:category == 'ruby' && :date < 3.days.ago}
+  #
+  # Block filters can refer to literals, variables, constants, arguments, 
+  # instance variables or anything else in order to create parameterized 
+  # queries. Block filters can also refer to other dataset objects as 
+  # sub-queries. Block filters are pretty much limitless!
+  #
+  # Block filters are based on ParseTree. If you do not have the ParseTree
+  # gem installed, block filters will raise an error.
+  #
+  # To enable full block filter support make sure you have both ParseTree and
+  # Ruby2Ruby installed:
+  #
+  #   sudo gem install parsetree
+  #   sudo gem install ruby2ruby
+  module Sequelizer
+    # Formats an comparison expression involving a left value and a right
+    # value. Comparison expressions differ according to the class of the right
+    # value. The stock implementation supports Range (inclusive and exclusive),
+    # Array (as a list of values to compare against), Dataset (as a subquery to
+    # compare against), or a regular value.
+    #
+    #   dataset.compare_expr('id', 1..20) #=>
+    #     "(id >= 1 AND id <= 20)"
+    #   dataset.compare_expr('id', [3,6,10]) #=>
+    #     "(id IN (3, 6, 10))"
+    #   dataset.compare_expr('id', DB[:items].select(:id)) #=>
+    #     "(id IN (SELECT id FROM items))"
+    #   dataset.compare_expr('id', nil) #=>
+    #     "(id IS NULL)"
+    #   dataset.compare_expr('id', 3) #=>
+    #     "(id = 3)"
+    def compare_expr(l, r)
+      case r
+      when Range:
+        r.exclude_end? ? \
+          "(#{l} >= #{literal(r.begin)} AND #{l} < #{literal(r.end)})" : \
+          "(#{l} >= #{literal(r.begin)} AND #{l} <= #{literal(r.end)})"
+      when Array:
+        "(#{literal(l)} IN (#{literal(r)}))"
+      when Sequel::Dataset:
+        "(#{literal(l)} IN (#{r.sql}))"
+      when NilClass:
+        "(#{literal(l)} IS NULL)"
+      when Regexp:
+        match_expr(l, r)
+      else
+        "(#{literal(l)} = #{literal(r)})"
+      end
+    end
+    
+    # Formats a string matching expression. The stock implementation supports
+    # matching against strings only using the LIKE operator. Specific adapters
+    # can override this method to provide support for regular expressions.
+    def match_expr(l, r)
+      case r
+      when String:
+        "(#{literal(l)} LIKE #{literal(r)})"
+      else
+        raise SequelError, "Unsupported match pattern class (#{r.class})."
+      end
+    end
+
+    # Evaluates a method call. This method is used to evaluate Ruby expressions
+    # referring to indirect values, e.g.:
+    #
+    #   dataset.filter {:category => category.to_s}
+    #   dataset.filter {:x > y[0..3]}
+    #
+    # This method depends on the Ruby2Ruby gem. If you do not have Ruby2Ruby 
+    # installed, this method will raise an error.
+    def ext_expr(e, b)
+      eval(RubyToRuby.new.process(e), b)
+    end
+
+    # Translates a method call parse-tree to SQL expression. The following 
+    # operators are recognized and translated to SQL expressions: >, <, >=, <=,
+    # ==, =~, +, -, *, /, %:
+    #
+    #   :x == 1 #=> "(x = 1)"
+    #   (:x + 100) < 200 #=> "((x + 100) < 200)"
+    #
+    # The in, in?, nil and nil? method calls are intercepted and passed to 
+    # #compare_expr.
+    #
+    #   :x.in [1, 2, 3] #=> "(x IN (1, 2, 3))"
+    #   :x.in?(DB[:y].select(:z)) #=> "(x IN (SELECT z FROM y))"
+    #   :x.nil? #=> "(x IS NULL)"
+    #
+    # The like and like? method calls are intercepted and passed to #match_expr.
+    #
+    #   :x.like? 'ABC%' #=> "(x LIKE 'ABC%')"
+    #
+    # The method also supports SQL functions by invoking Symbol#[]:
+    #
+    #   :avg[:x] #=> "avg(x)"
+    #   :substring[:x, 5] #=> "substring(x, 5)"
+    #
+    # All other method calls are evaulated as normal Ruby code.
+    def call_expr(e, b)
+      case op = e[2]
+      when :>, :<, :>=, :<=
+        l = pt_expr(e[1], b)
+        r = pt_expr(e[3][1], b)
+        "(#{l} #{op} #{r})"
+      when :==
+        l = eval_expr(e[1], b)
+        r = eval_expr(e[3][1], b)
+        compare_expr(l, r)
+      when :=~
+        l = eval_expr(e[1], b)
+        r = eval_expr(e[3][1], b)
+        match_expr(l, r)
+      when :+, :-, :*, :/, :%
+        l = pt_expr(e[1], b)
+        r = pt_expr(e[3][1], b)
+        "(#{l} #{op} #{r})"
+      when :in, :in?
+        # in/in? operators are supported using two forms:
+        #   :x.in([1, 2, 3])
+        #   :x.in(1, 2, 3) # variable arity
+        l = eval_expr(e[1], b)
+        r = eval_expr((e[3].size == 2) ? e[3][1] : e[3], b)
+        compare_expr(l, r)
+      when :nil, :nil?
+        l = eval_expr(e[1], b)
+        compare_expr(l, nil)
+      when :like, :like?
+        l = eval_expr(e[1], b)
+        r = eval_expr(e[3][1], b)
+        match_expr(l, r)
+      else
+        if (op == :[]) && (e[1][0] == :lit) && (Symbol === e[1][1])
+          # SQL Functions, e.g.: :sum[:x]
+          e[1][1][*pt_expr(e[3], b)]
+        else
+          # external code
+          ext_expr(e, b)
+        end
+      end
+    end
+    
+    # Evaluates a parse-tree into an SQL expression.
+    def eval_expr(e, b)
+      case e[0]
+      when :call # method call
+        call_expr(e, b)
+      when :ivar, :cvar, :dvar, :vcall, :const, :gvar # local ref
+        eval(e[1].to_s, b)
+      when :nth_ref:
+        eval("$#{e[1]}", b)
+      when :lvar: # local context
+        if e[1] == :block
+          pr = eval(e[1].to_s, b)
+          "#{proc_to_sql(pr)}"
+        else
+          eval(e[1].to_s, b)
+        end
+      when :lit, :str # literal
+         e[1]
+      when :dot2 # inclusive range
+        eval_expr(e[1], b)..eval_expr(e[2], b)
+      when :dot3 # exclusive range
+        eval_expr(e[1], b)...eval_expr(e[2], b)
+      when :colon2 # qualified constant ref
+        eval_expr(e[1], b).const_get(e[2])
+      when :false: false
+      when :true: true
+      when :nil: nil
+      when :array
+        # array
+        e[1..-1].map {|i| eval_expr(i, b)}
+      when :match3
+        # =~/!~ operator
+        l = eval_expr(e[2], b)
+        r = eval_expr(e[1], b)
+        compare_expr(l, r)
+      when :iter
+        eval_expr(e[3], b)
+      when :dasgn, :dasgn_curr
+        # assignment
+        l = e[1]
+        r = eval_expr(e[2], b)
+        raise SequelError, "Invalid expression #{l} = #{r}. Did you mean :#{l} == #{r}?"
+      else
+        raise SequelError, "Invalid expression tree: #{e.inspect}"
+      end
+    end
+    
+    def pt_expr(e, b)
+      case e[0]
+      when :not # negation: !x, (x != y), (x !~ y)
+        if (e[1][0] == :lit) && (Symbol === e[1][1])
+          # translate (!:x) into (x = 'f')
+          compare_expr(e[1][1], false)
+        else
+          "(NOT #{pt_expr(e[1], b)})"
+        end
+      when :block, :and # block of statements, x && y
+        "(#{e[1..-1].map {|i| pt_expr(i, b)}.join(" AND ")})"
+      when :or # x || y
+        "(#{pt_expr(e[1], b)} OR #{pt_expr(e[2], b)})"
+      when :call, :vcall, :iter # method calls, blocks
+        eval_expr(e, b)
+      else # literals
+        if e == [:lvar, :block]
+          eval_expr(e, b)
+        else
+          literal(eval_expr(e, b))
+        end
+      end
+    end
+
+    # Translates a Ruby block into an SQL expression.
+    def proc_to_sql(proc)
+      c = Class.new {define_method(:m, &proc)}
+      pt_expr(ParseTree.translate(c, :m)[2][2], proc.binding)
+    end
+  end
+end
+
+begin
+  require 'parse_tree'
+rescue LoadError
+  module Sequel::Dataset::Sequelizer
+    def proc_to_sql(proc)
+      raise SequelError, "You must have the ParseTree gem installed in order to use block filters."
+    end
+  end
+end
+
+begin
+  require 'ruby2ruby'
+rescue LoadError
+  module Sequel::Dataset::Sequelizer
+    def ext_expr(e)
+      raise SequelError, "You must have the Ruby2Ruby gem installed in order to use this block filter."
+    end
+  end
+end