sequel 2.9.0 → 2.10.0

data/doc/advanced_associations.rdoc

@@ -16,7 +16,7 @@ a different block when eager loading via Dataset#eager. Association blocks are
 useful for things like:
 
   Artist.one_to_many :gold_albums, :class=>:Album do |ds|
-    ds.filter(:copies_sold > 500000)
+    ds.filter{|o| o.copies_sold > 500000}
   end
 
 There are a whole bunch of options for changing how the association is eagerly
@@ -124,7 +124,7 @@ a swiss army chainsaw.
 Sequel supports the same callbacks that ActiveRecord does: :before_add,
 :before_remove, :after_add, and :after_remove. It also supports a
 callback that ActiveRecord does not, :after_load, which is called
-after the association has been loaded (when lazy loading).
+after the association has been loaded.
 
 Each of these options can be a Symbol specifying an instance method
 that takes one argument (the associated object), or a Proc that takes
@@ -150,7 +150,7 @@ otherwise modified:
   class Author < Sequel::Model
     one_to_many :authorships
   end
-  Author.first.authorships_dataset.filter(:number < 10).first
+  Author.first.authorships_dataset.filter{|o| o.number < 10}.first
  
 You can extend a dataset with a module easily with :extend:
 
@@ -180,18 +180,6 @@ model object, you'll have to use a closure:
   end
   Author.first.authorships_dataset.find_or_create_by_name('Bob')
 
-You can cheat if you want to:
-
-  module FindOrCreate
-    def find_or_create(vals)
-      # Exploits the fact that Sequel filters are ruby objects that
-      # can be introspected.
-      author_id = @opts[:where].args[1]
-      first(vals) || \
-        @opts[:models][nil].create(vals.merge(:author_id=>author_id))
-    end 
-  end
-
 ===has_many :through associations
 
 many_to_many handles the usual case of a has_many :through with a belongs_to in
@@ -310,7 +298,7 @@ Sequel::Model:
   Firm.find(:first).invoices
 
 It is significantly more code in Sequel Model, but quite a bit of it is setting
-the intermediate associate record (the client) and the reciprocal association
+the intermediate associated record (the client) and the reciprocal association
 in the associations cache for each object, which ActiveRecord won't do for you.
 The reason you would want to do this is that then firm.invoices.first.firm or
 firm.invoices.first.client doesn't do another query to get the firm/client.
@@ -551,7 +539,7 @@ node.children.  You can even eager load the relationship up to a certain depth:
   # Eager load three generations of generations of children for a given node 
   Node.filter(:id=>1).eager(:children=>{:children=>:children}).all.first
   # Load parents and grandparents for a group of nodes
-  Node.filter(:id < 10).eager(:parent=>:parent).all
+  Node.filter{|o| o.id < 10}.eager(:parent=>:parent).all
 
 What if you want to get all ancestors up to the root node, or all descendents,
 without knowing the depth of the tree?

data/doc/cheat_sheet.rdoc

@@ -29,7 +29,7 @@ Without a filename argument, the sqlite adapter will setup a new sqlite database
   DB.fetch("SELECT name FROM users") do |row|
     p r[:name]
   end
-  dataset = DB["SELECT age FROM users"]
+  dataset = DB["SELECT age FROM users WHERE name = ?", name]
   dataset.print
   dataset.map(:age)
 
@@ -70,17 +70,17 @@ Without a filename argument, the sqlite adapter will setup a new sqlite database
   dataset.map {|r| r[:name]}
   dataset.map(:name) # same effect as above
 
-  dataset.inject {|sum, r| sum + r[:value]}
+  dataset.inject(0){|sum, r| sum + r[:value]}
 
 == Filtering (see also doc/dataset_filtering.rdoc)
 
   dataset.filter(:name => 'abc')
   dataset.filter('name = ?', 'abc')
-  dataset.filter(:value > 100)
-  dataset.exclude(:value <= 100)
+  dataset.filter{|o| o.value > 100}
+  dataset.exclude{|o| o.value <= 100}
 
   dataset.filter(:value => 50..100)
-  dataset.where((:value >= 50) & (:value <= 100))
+  dataset.where{|o| (o.value >= 50) & (o.value <= 100)}
 
   dataset.where('value IN ?', [50,75,100])
 
@@ -91,11 +91,9 @@ Without a filename argument, the sqlite adapter will setup a new sqlite database
   # Filter using a subquery
   dataset.filter('price > ?', dataset.select('AVG(price) + 100'))
 
-=== Advanced filtering using ruby expressions without blocks
+=== Advanced filtering using ruby expressions
 
-Available as of Sequel 2.0:
-
-  DB[:items].filter(:price < 100).sql 
+  DB[:items].filter{|o| o.price < 100}.sql 
   #=> "SELECT * FROM items WHERE (price < 100)" 
 
   DB[:items].filter(:name.like('AL%')).sql 
@@ -103,7 +101,7 @@ Available as of Sequel 2.0:
 
 There's support for nested expressions with AND, OR and NOT:
 
-  DB[:items].filter((:x > 5) & (:y > 10)).sql 
+  DB[:items].filter{|o| (o.x > 5) & (o.y > 10)}.sql 
   #=> "SELECT * FROM items WHERE ((x > 5) AND (y > 10))" 
 
   DB[:items].filter({:x => 1, :y => 2}.sql_or & ~{:z => 3}).sql 
@@ -114,8 +112,8 @@ You can use arithmetic operators and specify SQL functions:
   DB[:items].filter((:x + :y) > :z).sql 
   #=> "SELECT * FROM items WHERE ((x + y) > z)" 
 
-  DB[:items].filter(:price < :AVG[:price] + 100).sql 
-  #=> "SELECT * FROM items WHERE (price < (AVG(price) + 100))" 
+  DB[:items].filter{|o| :price - 100 < o.AVG(:price)}.sql 
+  #=> "SELECT * FROM items WHERE ((price - 100) < AVG(price))" 
 
 == Ordering
 
@@ -151,23 +149,24 @@ You can use arithmetic operators and specify SQL functions:
   dataset.avg(:price)
   dataset.sum(:stock)
 
-  dataset.group(:category).select(:category, :AVG[:price])
+  dataset.group(:category).select(:category, :AVG.sql_function(:price))
 
 == SQL Functions / Literals
 
-  dataset.update(:updated_at => :NOW[])
+  dataset.update(:updated_at => :NOW.sql_function)
   dataset.update(:updated_at => 'NOW()'.lit)
 
   dataset.update(:updated_at => "DateValue('1/1/2001')".lit)
-  dataset.update(:updated_at => :DateValue['1/1/2001'])
+  dataset.update(:updated_at => :DateValue.sql_function('1/1/2001'))
 
 == Schema Manipulation
 
   DB.create_table :items do
     primary_key :id
-    text :name, :unique => true, :null => false
+    String :name, :unique => true, :null => false
     boolean :active, :default => true
     foreign_key :category_id, :categories
+    Time :created_at
     
     index :grade
   end
@@ -175,14 +174,13 @@ You can use arithmetic operators and specify SQL functions:
   DB.drop_table :items
 
   DB.create_table :test do
-    varchar :zipcode, :size => 10
+    String :zipcode, :size => 10
     enum :system, :elements => ['mac', 'linux', 'windows']
   end
 
 == Aliasing
 
   DB[:items].select(:name.as(:item_name))
-  DB[:items].select(:name => :item_name)
   DB[:items].select(:name___item_name)
   DB[:items___items_table].select(:items_table__name___item_name)
   # => "SELECT items_table.name AS item_name FROM items AS items_table"
@@ -221,5 +219,5 @@ Miscellaneous:
   dataset.where(:name => 'sequel').exists #=> "EXISTS ( SELECT 1 FROM items WHERE name = 'sequel' )"
   dataset.print #=> pretty table print to $stdout
   dataset.columns #=> array of columns in the result set, does a SELECT
-  DB.schema_for_table(:items) => [[:id, {:type=>:integer, ...}], [:name, {:type=>:string, ...}], ...]
-                                 # Works on PostgreSQL, MySQL, SQLite, and possibly elsewhere
+  DB.schema(:items) => [[:id, {:type=>:integer, ...}], [:name, {:type=>:string, ...}], ...]
+                       # Works on PostgreSQL, MySQL, SQLite, and JDBC

data/doc/dataset_filtering.rdoc

@@ -14,35 +14,11 @@ In order to prevent SQL injection, you can replace literal values with question
   items.filter('category = ?', 'ruby').sql
   #=> "SELECT * FROM items WHERE category = 'ruby'"
 
-== An aside: column references in Sequel
-
-Sequel expects column names to be specified using symbols. In addition, tuples always use symbols as their keys. This allows you to freely mix literal values and column references. For example, the two following lines produce equivalent SQL:
-
-  items.filter(:x => 1) #=> "SELECT * FROM items WHERE (x = 1)"
-  items.filter(1 => :x) #=> "SELECT * FROM items WHERE (1 = x)"
-
-=== Qualifying column names
-
-Column references can be qualified by using the double underscore special notation :table__column:
-
-  items.literal(:items__price) #=> "items.price"
-
-=== Column aliases
-
-You can also alias columns by using the triple undersecore special notation :column___alias or :table__column___alias:
-
-  items.literal(:price___p) #=> "price AS p"
-  items.literal(:items__price___p) #=> "items.price AS p"
-
-Another way to alias columns is to use the #AS method:
-
-  items.literal(:price.as(:p)) #=> "price AS p"
-
 === Specifying SQL functions
 
-Sequel also allows you to specify functions by using the Symbol#[] method:
+Sequel also allows you to specify functions by using the Symbol#sql_function method (and the Symbol#[] method on ruby 1.8):
 
-  items.literal(:avg[:price]) #=> "avg(price)"
+  items.literal(:avg.sql_function(:price)) #=> "avg(price)"
 
 == Filtering using a hash
 
@@ -76,10 +52,10 @@ Ranges (both inclusive and exclusive) can also be used:
 
 == Filtering using expressions
 
-New in Sequel 2.0 is the ability to use ruby expressions directly in the call to filter, without using a block:
+Sequel allows you to use ruby expressions directly in the call to filter, without using a block:
 
-  items.filter(:price < 100).sql
-  #=> "SELECT * FROM items WHERE (price < 100) 
+  items.filter(:price * 2 < 50).sql
+  #=> "SELECT * FROM items WHERE ((price * 2) < 50) 
 
 This works for the standard inequality and arithmetic operators:
 
@@ -133,13 +109,13 @@ You can use the negation operator (~) in most cases:
 
 You can also compare against other columns:
 
-  items.filter(:credit > :debit).sql
+  items.filter{|o| o.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))"
+  items.filter{|o| :price - 100 < o.max(:price)}.sql
+  #=> "SELECT * FROM items WHERE ((price - 100) < max(price))"
 
 == String search functions
 

data/doc/schema.rdoc

@@ -7,3 +7,23 @@ The recommended way to set up schema modifications in Sequel is through migratio
 The format of the individual migration files themselves is explained in the Sequel::Migration documentation.  Each migration file contains a single migration class.  The migration class acts a proxy for the related database (given on the command line if the sequel command line tool is used, or by the db argument to Sequel::Migration#apply if the API is used). The methods that can be used inside Sequel::Migration#up or Sequel::Migration#down are just Sequel::Database instance methods, such as create_table, drop_table, and alter_table.  Most database methods that alter the schema take regular arguments, but create_table and alter_table take a block.  The methods you can use inside the create_table block are documented in Sequel::Schema::Generator, and the methods you can use inside the alter_table block are documented in Sequel::Schema::AlterTableGenerator.
 
 Migrations are not required, you can just call the schema modification methods directly on the database object.  This is often done in test code and examples.  However, it is recommended that you use the migration framework unless the database schema will not be changing in the future, as it provides a way to easily handle modifications to existing database schema.
+
+Also, new in Sequel 2.10 is the ability to have database independent migrations using ruby classes as types.  When you use a ruby class as a type, Sequel translates it to the most comparable type in the database you are using.  Here's an example using all supported types:
+
+    DB.create_table(:cats) do
+      primary_key :id, :type=>Integer # integer
+      String :a                       # varchar(255)
+      column :b, File                 # blob
+      Fixnum :c                       # integer
+      foreign_key :d, :other_table, :type=>Bignum # bigint
+      Float :e                        # double precision
+      BigDecimal :f                   # numeric
+      Date :g                         # date
+      DateTime :h                     # timestamp
+      Time :i                         # timestamp
+      Numeric :j                      # numeric
+      TrueClass :k                    # boolean
+      FalseClass :l                   # boolean
+    end
+
+Basically, if you use one of the ruby classes above, it will translate into a database specific type.  If you use a lowercase method, symbol, or string to specify the type, Sequel won't attempt to translate it.

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 object_graph".each do |f|
+  dataset migration schema database object_graph version".each do |f|
   require "sequel_core/#{f}"
 end
 
@@ -69,6 +69,37 @@ module Sequel
   end
   metaalias :open, :connect
   
+  # Set the method to call on identifiers going into the database.  This affects
+  # the literalization of identifiers by calling this method on them before they are input.
+  # Sequel upcases identifiers in all SQL strings for most databases, so to turn that off:
+  #
+  #   Sequel.identifier_input_method = nil
+  # 
+  # to downcase instead:
+  #
+  #   Sequel.identifier_input_method = :downcase
+  #
+  # Other string methods work as well.
+  def self.identifier_input_method=(value)
+    Database.identifier_input_method = value
+  end
+  
+  # Set the method to call on identifiers coming out of the database.  This affects
+  # the literalization of identifiers by calling this method on them when they are
+  # retrieved from the database.  Sequel downcases identifiers retrieved for most
+  # databases, so to turn that off:
+  #
+  #   Sequel.identifier_output_method = nil
+  # 
+  # to upcase instead:
+  #
+  #   Sequel.identifier_output_method = :upcase
+  #
+  # Other string methods work as well.
+  def self.identifier_output_method=(value)
+    Database.identifier_output_method = value
+  end
+  
   # Set whether to quote identifiers for all databases by default. By default,
   # Sequel quotes identifiers in all SQL strings, so to turn that off:
   #
@@ -92,6 +123,9 @@ module Sequel
   # lower case (MySQL, PostgreSQL, and SQLite).
   #
   #   Sequel.upcase_identifiers = false
+  #
+  # This will set the indentifier_input_method to :upcase if value is true
+  # or nil if value is false.
   def self.upcase_identifiers=(value)
     Database.upcase_identifiers = value
   end

data/lib/sequel_core/adapters/ado.rb

@@ -58,7 +58,7 @@ module Sequel
         execute(sql) do |s|
           @columns = s.Fields.extend(Enumerable).map do |column|
             name = column.Name.empty? ? '(no column name)' : column.Name
-            name.to_sym
+            output_identifier(name)
           end
           
           unless s.eof

data/lib/sequel_core/adapters/db2.rb

@@ -89,7 +89,7 @@ module Sequel
       def fetch_rows(sql)
         execute(sql) do |sth|
           @column_info = get_column_info(sth)
-          @columns = @column_info.map {|c| c[:name]}
+          @columns = @column_info.map {|c| output_identifier(c[:name])}
           while (rc = SQLFetch(@handle)) != SQL_NO_DATA_FOUND
             @db.check_error(rc, "Could not fetch row")
             yield hash_row(sth)
@@ -118,7 +118,7 @@ module Sequel
           rc, v = SQLGetData(sth, i+1, c[:db2_type], c[:precision]) 
           @db.check_error(rc, "Could not get data")
           
-          @row[c[:name]] = convert_type(v)
+          row[output_identifier(c[:name])] = convert_type(v)
         end
         row
       end

data/lib/sequel_core/adapters/dbi.rb

@@ -3,8 +3,6 @@ require 'dbi'
 module Sequel
   module DBI
     class Database < Sequel::Database
-      attr_writer :lowercase
-      
       set_adapter_scheme :dbi
       
       DBI_ADAPTERS = {
@@ -69,11 +67,6 @@ module Sequel
         synchronize(opts[:server]){|conn| conn.do(sql)}
       end
       alias_method :execute_dui, :do
-      
-      # Converts all column names to lowercase
-      def lowercase
-        @lowercase ||= false
-      end
 
       private
 
@@ -97,10 +90,8 @@ module Sequel
       def fetch_rows(sql, &block)
         execute(sql) do |s|
           begin
-            @columns = s.column_names.map do |c|
-              @db.lowercase ? c.downcase.to_sym : c.to_sym
-            end
-            s.fetch {|r| yield hash_row(s, r)}
+            @columns = s.column_names.map{|c| output_identifier(c)}
+            s.fetch{|r| yield hash_row(s, r)}
           ensure
             s.finish rescue nil
           end

data/lib/sequel_core/adapters/do.rb

@@ -0,0 +1,205 @@
+require 'data_objects'
+
+module Sequel
+  # Module holding the DataObjects support for Sequel.  DataObjects is a
+  # ruby library with a standard API for accessing databases.
+  #
+  # The DataObjects adapter currently supports PostgreSQL, MySQL, and
+  # SQLite:
+  #
+  # *  Sequel.connect('do:sqlite3::memory:')
+  # *  Sequel.connect('do:postgres://user:password@host/database')
+  # *  Sequel.connect('do:mysql://user:password@host/database')
+  module DataObjects
+    # Contains procs keyed on sub adapter type that extend the
+    # given database object so it supports the correct database type.
+    DATABASE_SETUP = {:postgres=>proc do |db|
+        require 'do_postgres'
+        require 'sequel_core/adapters/do/postgres'
+        db.converted_exceptions << PostgresError
+        db.extend(Sequel::DataObjects::Postgres::DatabaseMethods)
+      end,
+      :mysql=>proc do |db|
+        require 'do_mysql'
+        require 'sequel_core/adapters/do/mysql'
+        db.converted_exceptions << MysqlError
+        db.extend(Sequel::DataObjects::MySQL::DatabaseMethods)
+      end,
+      :sqlite3=>proc do |db|
+        require 'do_sqlite3'
+        require 'sequel_core/adapters/do/sqlite'
+        db.converted_exceptions << Sqlite3Error
+        db.extend(Sequel::DataObjects::SQLite::DatabaseMethods)
+      end
+    }
+      
+    # DataObjects uses it's own internal connection pooling in addition to the
+    # pooling that Sequel uses.  You should make sure that you don't set
+    # the connection pool size to more than 8 for a
+    # Sequel::DataObjects::Database object, or hack DataObjects (or Extlib) to
+    # use a pool size at least as large as the pool size being used by Sequel.
+    class Database < Sequel::Database
+      set_adapter_scheme :do
+      
+      # Convert the given exceptions to Sequel:Errors, necessary
+      # because DO raises errors specific to database types in
+      # certain cases.
+      attr_accessor :converted_exceptions
+      
+      # Call the DATABASE_SETUP proc directly after initialization,
+      # so the object always uses sub adapter specific code.  Also,
+      # raise an error immediately if the connection doesn't have a
+      # uri, since DataObjects requires one.
+      def initialize(opts)
+        @opts = opts
+        @converted_exceptions = []
+        raise(Error, "No connection string specified") unless uri
+        if prok = DATABASE_SETUP[subadapter.to_sym]
+          prok.call(self)
+        end
+        super(opts)
+      end
+      
+      # Setup a DataObjects::Connection to the database.
+      def connect(server)
+        setup_connection(::DataObjects::Connection.new(uri(server_opts(server))))
+      end
+      
+      # Return a Sequel::DataObjects::Dataset object for this database.
+      def dataset(opts = nil)
+        DataObjects::Dataset.new(self, opts)
+      end
+    
+      # Execute the given SQL.  If a block is given, the DataObjects::Reader
+      # created is yielded to it. A block should not be provided unless a
+      # a SELECT statement is being used (or something else that returns rows).
+      # Otherwise, the return value is the insert id if opts[:type] is :insert,
+      # or the number of affected rows, otherwise.
+      def execute(sql, opts={})
+        log_info(sql)
+        synchronize(opts[:server]) do |conn|
+          begin
+            command = conn.create_command(sql)
+            res = block_given? ? command.execute_reader : command.execute_non_query
+          rescue Exception => e
+            raise_error(e, :classes=>@converted_exceptions)
+          end
+          if block_given?
+            begin
+              yield(res)
+            ensure
+             res.close if res
+            end
+          elsif opts[:type] == :insert
+            res.insert_id
+          else
+            res.affected_rows
+          end
+        end
+      end
+      
+      # Execute the SQL on the this database, returning the number of affected
+      # rows.
+      def execute_dui(sql, opts={})
+        execute(sql, opts)
+      end
+      
+      # Execute the SQL on this database, returning the primary key of the
+      # table being inserted to.
+      def execute_insert(sql, opts={})
+        execute(sql, opts.merge(:type=>:insert))
+      end
+      
+      # Return the subadapter type for this database, i.e. sqlite3 for
+      # do:sqlite3::memory:.
+      def subadapter
+        uri.split(":").first
+      end
+      
+      # Use DataObject's transaction support for transactions.  This
+      # only supports single level transactions, and it always prepares
+      # transactions and commits them immediately after.  It's wasteful,
+      # but required by DataObject's API.
+      def transaction(server=nil)
+        th = Thread.current
+        synchronize(server) do |conn|
+          return yield(conn) if @transactions.include?(th)
+          t = ::DataObjects::Transaction.create_for_uri(uri)
+          t.instance_variable_get(:@connection).close
+          t.instance_variable_set(:@connection, conn)
+          begin
+            log_info("Transaction.begin")
+            t.begin
+            @transactions << th
+            yield(conn)
+          rescue Exception => e
+            log_info("Transaction.rollback")
+            t.rollback
+            transaction_error(e)
+          ensure
+            unless e
+              log_info("Transaction.commit")
+              t.prepare
+              t.commit 
+            end
+            @transactions.delete(th)
+          end
+        end
+      end
+      
+      # Return the DataObjects URI for the Sequel URI, removing the do:
+      # prefix.
+      def uri(opts={})
+        opts = @opts.merge(opts)
+        (opts[:uri] || opts[:url]).sub(/\Ado:/, '')
+      end
+
+      private
+
+      # Close the given database connection.
+      def disconnect_connection(c)
+        c.close
+      end
+      
+      # Allow extending the given connection when it is first created.
+      # By default, just returns the connection.
+      def setup_connection(conn)
+        conn
+      end
+      
+      # The DataObjects adapter should convert exceptions by default.
+      def connection_pool_default_options
+        super.merge(:pool_convert_exceptions=>false)
+      end
+    end
+    
+    # Dataset class for Sequel::DataObjects::Database objects.
+    class Dataset < Sequel::Dataset
+      # Handle the usual time class overrides.
+      def literal(v)
+        case v
+        when Time
+          literal(v.iso8601)
+        when Date, DateTime
+          literal(v.to_s)
+        else
+          super
+        end
+      end
+      
+      # Execute the SQL on the database and yield the rows as hashes
+      # with symbol keys.
+      def fetch_rows(sql)
+        execute(sql) do |reader|
+          cols = @columns = reader.fields.map{|f| output_identifier(f)}
+          while(reader.next!) do
+            h = {}
+            cols.zip(reader.values).each{|k, v| h[k] = v}
+            yield h
+          end
+        end
+        self
+      end
+    end
+  end
+end