sequel 0.0.19 → 0.0.20

data/CHANGELOG

@@ -1,3 +1,15 @@
+*0.0.20*
+
+* Refactored Dataset where clause construction to use expressions.
+
+* Implemented Proc expressions (adapted from a great idea by Sam Smoot.)
+
+* Fixed Model#map.
+
+* Documentation for ConnectionPool.
+
+* Specs for Database.
+
 *0.0.19*
 
 * More specs for Dataset.

data/README

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

data/Rakefile

@@ -6,7 +6,7 @@ require 'fileutils'
 include FileUtils
 
 NAME = "sequel"
-VERS = "0.0.19"
+VERS = "0.0.20"
 CLEAN.include ['**/.*.sw?', 'pkg/*', '.config', 'doc/*', 'coverage/*']
 RDOC_OPTS = ['--quiet', '--title', "Sequel: Concise ORM for Ruby",
   "--opname", "index.html",

data/lib/sequel.rb

@@ -5,6 +5,7 @@ require File.join(dir, 'database')
 require File.join(dir, 'connection_pool')
 require File.join(dir, 'schema')
 require File.join(dir, 'pretty_table')
+require File.join(dir, 'expressions')
 require File.join(dir, 'dataset')
 require File.join(dir, 'model')
 

data/lib/sequel/connection_pool.rb

@@ -1,11 +1,30 @@
 require 'thread'
 
 module Sequel
+  # A ConnectionPool manages access to database connections by keeping
+  # multiple connections and giving threads exclusive access to each
+  # connection.
   class ConnectionPool
-    attr_reader :max_size, :mutex
+    attr_reader :mutex
+    
+    # The maximum number of connections.
+    attr_reader :max_size
+    
+    # The proc used to create a new connection.
     attr_accessor :connection_proc
+    
     attr_reader :available_connections, :allocated, :created_count
   
+    # Constructs a new pool with a maximum size. If a block is supplied, it
+    # is used to create new connections as they are needed.
+    #
+    #   pool = ConnectionPool.new(10) {MyConnection.new(opts)}
+    #
+    # The connection creation proc can be changed at any time by assigning a 
+    # Proc to pool#connection_proc.
+    #
+    #   pool = ConnectionPool.new(10)
+    #   pool.connection_proc = proc {MyConnection.new(opts)}
     def initialize(max_size = 4, &block)
       @max_size = max_size
       @mutex = Mutex.new
@@ -16,10 +35,23 @@ module Sequel
       @created_count = 0
     end
     
+    # Returns the number of created connections.
     def size
       @created_count
     end
     
+    # Assigns a connection to the current thread, yielding the connection
+    # to the supplied block.
+    # 
+    #   pool.hold {|conn| conn.execute('DROP TABLE posts;')}
+    # 
+    # Pool#hold is re-entrant, meaning it can be called recursively in
+    # the same thread without blocking.
+    #
+    # If no connection is available, Pool#hold will block until a connection
+    # is available.
+    #
+    # Errors raised inside a hold call are wrapped in a SequelConnectionError.
     def hold
       t = Thread.current
       if (conn = owned_connection(t))
@@ -37,34 +69,42 @@ module Sequel
       raise SequelConnectionError.new(e)
     end
     
-    def owned_connection(thread)
-      @mutex.synchronize {@allocated[thread]}
-    end
-    
-    def acquire(thread)
-      @mutex.synchronize do
-        if conn = available
-          @allocated[thread] = conn
+    private
+      # Returns the connection owned by the supplied thread, if any.
+      def owned_connection(thread)
+        @mutex.synchronize {@allocated[thread]}
+      end
+      
+      # Assigns a connection to the supplied thread, if one is available.
+      def acquire(thread)
+        @mutex.synchronize do
+          if conn = available
+            @allocated[thread] = conn
+          end
         end
       end
-    end
-    
-    def available
-      @available_connections.pop || make_new
-    end
-    
-    def make_new
-      if @created_count < @max_size
-        @created_count += 1
-        @connection_proc.call
+      
+      # Returns an available connection. If no connection is available,
+      # tries to create a new connection.
+      def available
+        @available_connections.pop || make_new
       end
-    end
-    
-    def release(thread)
-      @mutex.synchronize do
-        @available_connections << @allocated[thread]
-        @allocated.delete(thread)
+      
+      # Creates a new connection if the size of the pool is less than the
+      # maximum size.
+      def make_new
+        if @created_count < @max_size
+          @created_count += 1
+          @connection_proc.call
+        end
+      end
+      
+      # Releases the connection assigned to the supplied thread.
+      def release(thread)
+        @mutex.synchronize do
+          @available_connections << @allocated[thread]
+          @allocated.delete(thread)
+        end
       end
     end
-  end
 end

data/lib/sequel/database.rb

@@ -8,15 +8,15 @@ module Sequel
   # The Database class is meant to be subclassed by database adapters in order
   # to provide the functionality needed for executing queries.
   class Database
-    attr_reader :opts, :pool
+    attr_reader :opts, :pool, :logger
     
     # Constructs a new instance of a database connection with the specified
     # options hash.
     #
     # Sequel::Database is an abstract class that is not useful by itself.
-    def initialize(opts = {})
+    def initialize(opts = {}, &block)
       @opts = opts
-      @pool = ConnectionPool.new(@opts[:max_connections] || 4)
+      @pool = ConnectionPool.new(@opts[:max_connections] || 4, &block)
       @logger = opts[:logger]
     end
     
@@ -36,6 +36,7 @@ module Sequel
     def execute(sql)
       raise NotImplementedError
     end
+    alias_method :<<, :execute
     
     # Acquires a database connection, yielding it to the passed block.
     def synchronize(&block)
@@ -44,19 +45,10 @@ module Sequel
 
     # Returns true if there is a database connection
     def test_connection
-      @pool.hold {|conn|} if @pool
+      @pool.hold {|conn|}
       true
     end
     
-    # call-seq:
-    #   db.execute(sql)
-    #   db << sql
-    #
-    # Executes an sql query.
-    def <<(sql)
-      execute(sql)
-    end
-
     # Creates a table. The easiest way to use this method is to provide a
     # block:
     #   DB.create_table :posts do
@@ -78,7 +70,7 @@ module Sequel
     # Drops a table.
     def drop_table(*names)
       transaction do
-        names.each {|n| execute Schema.drop_table_sql(n)}
+        execute(names.map {|n| Schema.drop_table_sql(n)}.join)
       end
     end
     
@@ -153,6 +145,7 @@ module Sequel
     # call-seq:
     #   Sequel::Database.connect(conn_string)
     #   Sequel.connect(conn_string)
+    #   Sequel.open(conn_string)
     #
     # Creates a new database object based on the supplied connection string.
     # The specified scheme determines the database class used, and the rest

data/lib/sequel/dataset.rb

@@ -112,23 +112,19 @@ module Sequel
         raise SequelError, "can't express #{v.inspect}:#{v.class} as a SQL literal"
       end
     end
-    
+
     AND_SEPARATOR = " AND ".freeze
-    EQUAL_COND = "(%s = %s)".freeze
+    EQUAL_EXPR = "(%s = %s)".freeze
     IN_EXPR = "(%s IN (%s))".freeze
-#    BETWEEN_EXPR = "(%s BETWEEN %s AND %s)".freeze
     INCLUSIVE_RANGE_EXPR = "(%s >= %s AND %s <= %s)".freeze
     EXCLUSIVE_RANGE_EXPR = "(%s >= %s AND %s < %s)".freeze
     NULL_EXPR = "(%s IS NULL)".freeze
     
-    # Formats an equality condition SQL expression.
-    def where_condition(left, right)
-      left = field_name(left)
+    def format_eq_expression(left, right)
       case right
       when Range:
         (right.exclude_end? ? EXCLUSIVE_RANGE_EXPR : INCLUSIVE_RANGE_EXPR) %
           [left, literal(right.begin), left, literal(right.end)]
-#        BETWEEN_EXPR % [field_name(left), literal(right.begin), literal(right.end)]
       when Array:
         IN_EXPR % [left, literal(right)]
       when NilClass:
@@ -136,7 +132,25 @@ module Sequel
       when Dataset:
         IN_EXPR % [left, right.sql]
       else
-        EQUAL_COND % [left, literal(right)]
+        EQUAL_EXPR % [left, literal(right)]
+      end
+    end
+    
+    def format_expression(left, op, right)
+      left = field_name(left)
+      case op
+      when :eql:
+        format_eq_expression(left, right)
+      when :not:
+        "NOT #{format_eq_expression(left, right)}"
+      when :lt:
+        "(#{left} < #{literal(right)})"
+      when :lte:
+        "(#{left} <= #{literal(right)})"
+      when :gt:
+        "(#{left} > #{literal(right)})"
+      when :gte:
+        "(#{left} >= #{literal(right)})"
       end
     end
     
@@ -146,10 +160,14 @@ module Sequel
       case where
       when Hash:
         parenthesize = false if where.size == 1
-        fmt = where.map {|kv| where_condition(*kv)}.join(AND_SEPARATOR)
+        fmt = where.map {|i| format_expression(i[0], :eql, i[1])}.
+          join(AND_SEPARATOR)
       when Array:
         fmt = where.shift
         fmt.gsub!('?') {|i| literal(where.shift)}
+      when Proc:
+        fmt = where.to_expressions.map {|e| format_expression(e.left, e.op, e.right)}.
+          join(AND_SEPARATOR)
       else
         fmt = where
       end
@@ -159,7 +177,7 @@ module Sequel
     # Formats a join condition.
     def join_cond_list(cond, join_table)
       cond.map do |kv|
-        EQUAL_COND % [
+        EQUAL_EXPR % [
           qualified_field_name(kv[0], join_table), 
           qualified_field_name(kv[1], @opts[:from])]
       end.join(AND_SEPARATOR)
@@ -216,48 +234,50 @@ module Sequel
     # Returns a copy of the dataset with the given conditions imposed upon it.  
     # If the query has been grouped, then the conditions are imposed in the 
     # HAVING clause. If not, then they are imposed in the WHERE clause.
-    def filter(*cond)
+    def filter(*cond, &block)
       clause = (@opts[:group] ? :having : :where)
       cond = cond.first if cond.size == 1
       parenthesize = !(cond.is_a?(Hash) || cond.is_a?(Array))
       if @opts[clause]
-        cond = AND_WHERE % [where_list(@opts[clause]), where_list(cond, parenthesize)]
+        cond = AND_WHERE % [where_list(@opts[clause]), where_list(block || cond, parenthesize)]
+        dup_merge(clause => cond)
+      else
+        dup_merge(clause => where_list(block || cond))
       end
-      dup_merge(clause => where_list(cond))
     end
 
     NOT_WHERE = "NOT %s".freeze
     AND_NOT_WHERE = "%s AND NOT %s".freeze
     
-    def exclude(*cond)
+    def exclude(*cond, &block)
       clause = (@opts[:group] ? :having : :where)
       cond = cond.first if cond.size == 1
       parenthesize = !(cond.is_a?(Hash) || cond.is_a?(Array))
       if @opts[clause]
-        cond = AND_NOT_WHERE % [where_list(@opts[clause]), where_list(cond, parenthesize)]
+        cond = AND_NOT_WHERE % [where_list(@opts[clause]), where_list(block || cond, parenthesize)]
       else
-        cond = NOT_WHERE % where_list(cond, true)
+        cond = NOT_WHERE % where_list(block || cond, true)
       end
       dup_merge(clause => cond)
     end
     
     # Returns a copy of the dataset with the where conditions changed. Raises 
     # if the dataset has been grouped. See also #filter
-    def where(*cond)
+    def where(*cond, &block)
       if @opts[:group]
         raise SequelError, "Can't specify a WHERE clause once the dataset has been grouped"
       else
-        filter(*cond)
+        filter(*cond, &block)
       end
     end
 
     # Returns a copy of the dataset with the having conditions changed. Raises 
     # if the dataset has not been grouped. See also #filter
-    def having(*cond)
+    def having(*cond, &block)
       unless @opts[:group]
         raise SequelError, "Can only specify a HAVING clause on a grouped dataset"
       else
-        filter(*cond)
+        filter(*cond, &block)
        end
      end
     

data/lib/sequel/expressions.rb

@@ -0,0 +1,70 @@
+# Based on great work by Sam Smoot
+# http://substantiality.net/archives/2007/4/16/datamapper-part-xiv-finder-block
+
+module Sequel
+  class Dataset
+    class BlankSlate #:nodoc:
+      instance_methods.each { |m| undef_method m unless m =~ /^(__|instance_eval)/ }
+    end
+
+    class Expression < BlankSlate
+      attr_reader :left, :right
+      attr_accessor :op
+
+      def initialize(left)
+        @left = left
+      end
+
+      def method_missing(sym, *right)
+        @op = case sym
+          when :==, :===, :in: :eql
+          when :=~: :like
+          when :"<=>": :not
+          when :<: :lt
+          when :<=: :lte
+          when :>: :gt
+          when :>=: :gte
+          else sym
+        end
+        @right = right.first
+        self
+      end
+      
+      def nil?
+        @op = :eql
+        @right = nil
+        self
+      end
+    end
+
+    class ExpressionCompiler < BlankSlate
+      def initialize(&block)
+        @block = block
+        @expressions = []
+      end
+
+      def method_missing(sym, *args)
+        expr = Expression.new(sym)
+        @expressions << expr
+        expr
+      end
+      
+      def SUM(sym)
+        expr = Expression.new(sym.SUM)
+        @expressions << expr
+        expr
+      end
+      
+      def __to_a__
+        instance_eval(&@block)
+        @expressions
+      end
+    end
+  end
+end
+
+class Proc
+  def to_expressions
+    Sequel::Dataset::ExpressionCompiler.new(&self).__to_a__
+  end
+end

data/lib/sequel/model.rb

@@ -174,7 +174,7 @@ module Sequel
     def self.order(*arg); dataset.order(*arg); end
     def self.first(*arg); dataset.first(*arg); end
     def self.count; dataset.count; end
-    def self.map(column); dataset.map(column); end
+    def self.map(*arg, &block); dataset.map(*arg, &block); end
     def self.hash_column(column); dataset.hash_column(primary_key, column); end
     def self.join(*args); dataset.join(*args); end
     def self.lock(mode, &block); dataset.lock(mode, &block); end

data/lib/sequel/postgres.rb

@@ -226,8 +226,8 @@ module Sequel
     
       LIKE = '%s ~ %s'.freeze
       LIKE_CI = '%s ~* %s'.freeze
-    
-      def where_condition(left, right)
+      
+      def format_eq_expression(left, right)
         case right
         when Regexp:
           (right.casefold? ? LIKE_CI : LIKE) %
@@ -236,6 +236,11 @@ module Sequel
           super
         end
       end
+      
+      def format_expression(left, op, right)
+        op = :eql if op == :like
+        super
+      end
     
       def each(opts = nil, &block)
         query_each(select_sql(opts), true, &block)

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.2
+rubygems_version: 0.9.0
 specification_version: 1
 name: sequel
 version: !ruby/object:Gem::Version 
-  version: 0.0.19
-date: 2007-04-16 00:00:00 +03:00
+  version: 0.0.20
+date: 2007-04-18 00:00:00 +03:00
 summary: Concise ORM for Ruby.
 require_paths: 
 - lib
@@ -35,18 +35,19 @@ files:
 - bin/sequel
 - doc/rdoc
 - lib/sequel
-- lib/sequel/pretty_table.rb
-- lib/sequel/model.rb
-- lib/sequel/schema.rb
-- lib/sequel/sqlite.rb
+- lib/sequel.rb
+- lib/sequel/connection_pool.rb
+- lib/sequel/core_ext.rb
 - lib/sequel/database.rb
 - lib/sequel/dataset.rb
+- lib/sequel/error.rb
+- lib/sequel/expressions.rb
+- lib/sequel/model.rb
 - lib/sequel/mysql.rb
 - lib/sequel/postgres.rb
-- lib/sequel/connection_pool.rb
-- lib/sequel/core_ext.rb
-- lib/sequel/error.rb
-- lib/sequel.rb
+- lib/sequel/pretty_table.rb
+- lib/sequel/schema.rb
+- lib/sequel/sqlite.rb
 - CHANGELOG
 test_files: []