sequel 2.11.0 → 2.12.0

data/doc/schema.rdoc

@@ -8,7 +8,7 @@ The format of the individual migration files themselves is explained in the Sequ
 
 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:
+Sequel has 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
@@ -27,3 +27,5 @@ Also, new in Sequel 2.10 is the ability to have database independent migrations
     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.
+
+Note that if you use a ruby class, you shouldn't use a :size option.  Using a ruby class means that you want Sequel to pick the database type to use.  If you want to specify the size, you are no longer in database independent territory, and you need to specify the type as well, using a lowercase method, symbol, or string.

data/doc/sharding.rdoc

@@ -1,17 +1,17 @@
 = Read-Only Slaves/Writable Master and Database Sharding
 
-Starting with version 2.4.0, Sequel has support for read only slave databases
+Sequel has support for read only slave databases
 with a writable master database, as well as database sharding (where you can
-pick a database connection to use for a given dataset).  Support for both
+pick a server to use for a given dataset).  Support for both
 features is database independent, and should work for all database adapters
 included with Sequel.
 
 == The :servers Database option
 
-Both features use the new :servers Database option.  The :servers option should
+Both features use the :servers Database option.  The :servers option should
 be a hash with symbol keys and values that are either hashes or procs that
-return hashes.  Note that all servers should have the same schema, unless you
-really know what you are doing.
+return hashes.  Note that all servers should have the same schema for all
+tables you are accessing, unless you really know what you are doing.
 
 == Master and Slave Database Configurations
 
@@ -23,7 +23,7 @@ is the simplest configuration:
   DB=Sequel.connect('postgres://master_server/database', \
     :servers=>{:read_only=>{:host=>'slave_server'}})
 
-This will use the host slave_server for SELECT queries and master_server for
+This will use the slave_server for SELECT queries and master_server for
 other queries.
 
 === Multiple Read-Only Slaves, Single Master
@@ -67,7 +67,7 @@ There is specific support in Sequel for handling master/slave database
 combinations, with the only necessary setup being the database configuration.
 However, since sharding is always going to be implementation dependent, Sequel
 supplies the basic infrastructure, but you have to tell it which server to use
-for each dataset.  Let's assume the simple scenario, a distributed rainbow
+for each dataset.  Let's assume a simple scenario, a distributed rainbow
 table for SHA-1 hashes, sharding based on the first hex character (for a total
 of 16 shards).  First, you need to configure the database:
 
@@ -89,7 +89,7 @@ since it considers the default server and shard servers independent.  Note that
 if you always set the shard on a dataset before using it in queries, it will
 not attempt to connect to the default server.  Sequel may use the default
 server in queries it generates itself, such as to get column names or table
-schemas, so it is always good to have a default server that works.
+schemas, so you should always have a default server that works.
 
 To set the shard for a given query, you use the Dataset#server method:
 

data/doc/virtual_rows.rdoc

@@ -0,0 +1,65 @@
+= Virtual Row Blocks
+
+Dataset methods filter, order, and select all take blocks that yield
+instances of Sequel::SQL::VirtualRow.  These are referred to as
+virtual row blocks.  Many other dataset methods pass the blocks
+they are given into one of those three methods, so there are actually
+many Sequel methods that take virtual row blocks.
+
+VirtualRow is a class that returns SQL::Indentifiers,
+SQL::QualifiedIdentifiers, or SQL::Functions depending on how it is
+called.  This is best shown by example:
+
+  ds = DB[:items]
+  ds.filter{|o| o.column > 1}        # column > 1
+  ds.filter{|o| o.table__column > 1} # table.column > 1
+  ds.filter{|o| o.function(1) > 1}   # function(1) > 1
+  
+Basically, the rules are:
+
+* If there are arguments, an SQL::Function is returned with the
+  name of the method used and the arguments given.
+
+* If there are no arguments and the method contains a double
+  underscore, split on the double underscore and return an
+  SQL::QualifiedIdentifier with the table and column.
+  
+* Otherwise, create an SQL::Identifier with the name of the
+  method.
+  
+One of the consequences of these rules is that you cannot
+create an SQL::Function that takes no arguments using a VirtualRow
+instance.
+  
+In Sequel 2.12, the following is deprecated by default, as
+virtual row blocks are required to accept an argument:
+
+  ds.filter{:column > 1}                     # column > 1
+  ds.filter{:table__column > 1}              # table.column > 1
+  ds.filter{:function.sql_function(1) > 1}   # function(1) > 1
+  
+This is to keep backwards compatibility while notifying people
+to change their code.  In Sequel 3.0, you will be able to
+do:
+
+  ds.filter{column > 1}        # column > 1
+  ds.filter{table__column > 1} # table.column > 1
+  ds.filter{function(1) > 1}   # function(1) > 1
+
+Sequel 3.0 will change the virtual row block support to use
+instance_eval if the block doesn't take an argument.  This
+breaks backward compatibility because instance methods called
+inside the block will now have a virtual row instance as a
+receiver instead of the receiver where the block was defined.
+You can still use local variables in the enclosing scope
+inside the block, as they take on their usual meaning.
+
+If you find yourself needing to call instance methods for the
+current receiver inside a virtual row block, you should change
+the block to accept an argument, and use that argument whenever
+you need the virtual row support.
+
+You can get the Sequel 3.0 behavior in Sequel 2.12 using the
+following method:
+
+  Sequel.virtual_row_instance_eval = true

data/lib/sequel.rb

@@ -1 +1 @@
-require 'sequel_model'
+require 'sequel/model'

data/lib/{sequel_core → sequel}/adapters/ado.rb

@@ -1,11 +1,11 @@
-require 'sequel_core/adapters/utils/date_format'
+Sequel.require 'adapters/utils/date_format'
 require 'win32ole'
 
 module Sequel
   # The ADO adapter provides connectivity to ADO databases in Windows. ADO
   # databases can be opened using a URL with the ado schema:
   #
-  #   DB = Sequel.open('ado://mydb')
+  #   DB = Sequel.connect('ado://mydb')
   # 
   # or using the Sequel.ado method:
   #
@@ -20,7 +20,7 @@ module Sequel
         opts[:driver] ||= 'SQL Server'
         case opts[:driver]
         when 'SQL Server'
-          require 'sequel_core/adapters/shared/mssql'
+          Sequel.require 'adapters/shared/mssql'
           extend Sequel::MSSQL::DatabaseMethods
         end
       end

data/lib/{sequel_core → sequel}/adapters/dbi.rb

@@ -44,7 +44,7 @@ module Sequel
         dbname = opts[:database]
         if dbname !~ /^DBI:/ then
           dbname = "DBI:#{dbname}"
-          [:host, :port].each{|sym| dbname += ";#{sym}=#{opts[sym]}" unless opts[sym].blank?}
+          [:host, :port].each{|sym| dbname += ";#{sym}=#{opts[sym]}" unless blank_object?(opts[sym])}
         end
         ::DBI.connect(dbname, opts[:user], opts[:password])
       end

data/lib/{sequel_core → sequel}/adapters/do.rb

@@ -15,19 +15,19 @@ module Sequel
     # 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'
+        Sequel.require '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'
+        Sequel.require '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'
+        Sequel.require 'adapters/do/sqlite'
         db.converted_exceptions << Sqlite3Error
         db.extend(Sequel::DataObjects::SQLite::DatabaseMethods)
       end
@@ -120,9 +120,13 @@ module Sequel
       # 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)
+      def transaction(opts={})
+        unless opts.is_a?(Hash)
+          Deprecation.deprecate('Passing an argument other than a Hash to Database#transaction', "Use DB.transaction(:server=>#{opts.inspect})") 
+          opts = {:server=>opts}
+        end
         th = Thread.current
-        synchronize(server) do |conn|
+        synchronize(opts[:server]) do |conn|
           return yield(conn) if @transactions.include?(th)
           t = ::DataObjects::Transaction.create_for_uri(uri)
           t.instance_variable_get(:@connection).close

data/lib/{sequel_core → sequel}/adapters/do/mysql.rb

@@ -1,4 +1,4 @@
-require 'sequel_core/adapters/shared/mysql'
+Sequel.require 'adapters/shared/mysql'
 
 module Sequel
   module DataObjects

data/lib/{sequel_core → sequel}/adapters/do/postgres.rb

@@ -1,4 +1,4 @@
-require 'sequel_core/adapters/shared/postgres'
+Sequel.require 'adapters/shared/postgres'
 
 module Sequel
   Postgres::CONVERTED_EXCEPTIONS << PostgresError

data/lib/{sequel_core → sequel}/adapters/do/sqlite.rb

@@ -1,4 +1,4 @@
-require 'sequel_core/adapters/shared/sqlite'
+Sequel.require 'adapters/shared/sqlite'
 
 module Sequel
   module DataObjects

data/lib/{sequel_core → sequel}/adapters/firebird.rb

@@ -1,5 +1,5 @@
 require 'fb'
-require 'sequel_core/adapters/utils/unsupported'
+Sequel.require 'adapters/utils/unsupported'
 
 module Sequel
   # The Sequel Firebird adapter requires the ruby fb driver located at
@@ -18,26 +18,6 @@ module Sequel
         @primary_key_sequences = {}
       end
 
-      # Use Firebird specific syntax for add column
-      def alter_table_sql(table, op)
-        case op[:op]
-        when :add_column
-          "ALTER TABLE #{quote_schema_table(table)} ADD #{column_definition_sql(op)}"
-        when :drop_column
-          "ALTER TABLE #{quote_schema_table(table)} DROP #{column_definition_sql(op)}"
-        when :rename_column
-          "ALTER TABLE #{quote_schema_table(table)} ALTER #{quote_identifier(op[:name])} TO #{quote_identifier(op[:new_name])}"
-        when :set_column_type
-          "ALTER TABLE #{quote_schema_table(table)} ALTER #{quote_identifier(op[:name])} TYPE #{type_literal(op)}"
-        else
-          super(table, op)
-        end
-      end
-
-      def auto_increment_sql()
-        AUTO_INCREMENT
-      end
-      
       def connect(server)
         opts = server_opts(server)
 
@@ -50,10 +30,6 @@ module Sequel
         conn
       end
 
-      def create_sequence_sql(name, opts={})
-        "CREATE SEQUENCE #{quote_identifier(name)}"
-      end
-
       # Creates a table with the columns given in the provided block:
       #
       #   DB.create_table :posts do
@@ -77,52 +53,10 @@ module Sequel
         statements[0].flatten.each {|sql| execute_ddl(sql)}
       end
 
-      def create_table_sql_list(name, columns, indexes = nil, options={})
-        statements = super
-        drop_seq_statement = nil
-        columns.each do |c|
-          if c[:auto_increment]
-            c[:sequence_name] ||= "seq_#{name}_#{c[:name]}"
-            unless c[:create_sequence] == false
-              drop_seq_statement = drop_sequence_sql(c[:sequence_name])
-              statements << create_sequence_sql(c[:sequence_name])
-              statements << restart_sequence_sql(c[:sequence_name], {:restart_position => c[:sequence_start_position]}) if c[:sequence_start_position]
-            end
-            unless c[:create_trigger] == false
-              c[:trigger_name] ||= "BI_#{name}_#{c[:name]}"
-              c[:quoted_name] = quote_identifier(c[:name])
-              trigger_definition = <<-END
-              begin
-                if ((new.#{c[:quoted_name]} is null) or (new.#{c[:quoted_name]} = 0)) then
-                begin
-                  new.#{c[:quoted_name]} = next value for #{c[:sequence_name]};
-                end
-              end
-              END
-              statements << create_trigger_sql(name, c[:trigger_name], trigger_definition, {:events => [:insert]})
-            end
-          end
-        end
-        [statements, drop_seq_statement]
-      end
-
       def create_trigger(*args)
         self << create_trigger_sql(*args)
       end
 
-      def create_trigger_sql(table, name, definition, opts={})
-        events = opts[:events] ? Array(opts[:events]) : [:insert, :update, :delete]
-        whence = opts[:after] ? 'AFTER' : 'BEFORE'
-        inactive = opts[:inactive] ? 'INACTIVE' : 'ACTIVE'
-        position = opts[:position] ? opts[:position] : 0
-        sql = <<-end_sql
-          CREATE TRIGGER #{quote_identifier(name)} for #{quote_identifier(table)}
-          #{inactive} #{whence} #{events.map{|e| e.to_s.upcase}.join(' OR ')} position #{position}
-          as #{definition}
-        end_sql
-        sql
-      end
-
       def dataset(opts = nil)
         Firebird::Dataset.new(self, opts)
       end
@@ -131,10 +65,6 @@ module Sequel
         self << drop_sequence_sql(name)
       end
 
-      def drop_sequence_sql(name)
-        "DROP SEQUENCE #{quote_identifier(name)}"
-      end
-
       def execute(sql, opts={})
         log_info(sql)
         begin
@@ -165,11 +95,6 @@ module Sequel
         self << restart_sequence_sql(*args)
       end
 
-      def restart_sequence_sql(name, opts={})
-        seq_name = quote_identifier(name)
-        "ALTER SEQUENCE #{seq_name} RESTART WITH #{opts[:restart_position]}"
-      end
-
       def sequences(opts={})
         ds = self[:"rdb$generators"].server(opts[:server]).filter(:"rdb$system_flag" => 0).select(:"rdb$generator_name")
         block_given? ? yield(ds) : ds.map{|r| ds.send(:output_identifier, r[:"rdb$generator_name"])}
@@ -180,8 +105,12 @@ module Sequel
         block_given? ? yield(ds) : ds.map{|r| ds.send(:output_identifier, r[:"rdb$relation_name"])}
       end
 
-      def transaction(server=nil)
-        synchronize(server) do |conn|
+      def transaction(opts={})
+        unless opts.is_a?(Hash)
+          Deprecation.deprecate('Passing an argument other than a Hash to Database#transaction', "Use DB.transaction(:server=>#{opts.inspect})") 
+          opts = {:server=>opts}
+        end
+        synchronize(opts[:server]) do |conn|
           return yield(conn) if @transactions.include?(Thread.current)
           log_info("Transaction.begin")
           conn.transaction
@@ -204,9 +133,84 @@ module Sequel
 
       private
 
+      # Use Firebird specific syntax for add column
+      def alter_table_sql(table, op)
+        case op[:op]
+        when :add_column
+          "ALTER TABLE #{quote_schema_table(table)} ADD #{column_definition_sql(op)}"
+        when :drop_column
+          "ALTER TABLE #{quote_schema_table(table)} DROP #{column_definition_sql(op)}"
+        when :rename_column
+          "ALTER TABLE #{quote_schema_table(table)} ALTER #{quote_identifier(op[:name])} TO #{quote_identifier(op[:new_name])}"
+        when :set_column_type
+          "ALTER TABLE #{quote_schema_table(table)} ALTER #{quote_identifier(op[:name])} TYPE #{type_literal(op)}"
+        else
+          super(table, op)
+        end
+      end
+
+      def auto_increment_sql()
+        AUTO_INCREMENT
+      end
+      
+      def create_sequence_sql(name, opts={})
+        "CREATE SEQUENCE #{quote_identifier(name)}"
+      end
+
+      def create_table_sql_list(name, columns, indexes = nil, options={})
+        statements = super
+        drop_seq_statement = nil
+        columns.each do |c|
+          if c[:auto_increment]
+            c[:sequence_name] ||= "seq_#{name}_#{c[:name]}"
+            unless c[:create_sequence] == false
+              drop_seq_statement = drop_sequence_sql(c[:sequence_name])
+              statements << create_sequence_sql(c[:sequence_name])
+              statements << restart_sequence_sql(c[:sequence_name], {:restart_position => c[:sequence_start_position]}) if c[:sequence_start_position]
+            end
+            unless c[:create_trigger] == false
+              c[:trigger_name] ||= "BI_#{name}_#{c[:name]}"
+              c[:quoted_name] = quote_identifier(c[:name])
+              trigger_definition = <<-END
+              begin
+                if ((new.#{c[:quoted_name]} is null) or (new.#{c[:quoted_name]} = 0)) then
+                begin
+                  new.#{c[:quoted_name]} = next value for #{c[:sequence_name]};
+                end
+              end
+              END
+              statements << create_trigger_sql(name, c[:trigger_name], trigger_definition, {:events => [:insert]})
+            end
+          end
+        end
+        [statements, drop_seq_statement]
+      end
+
+      def create_trigger_sql(table, name, definition, opts={})
+        events = opts[:events] ? Array(opts[:events]) : [:insert, :update, :delete]
+        whence = opts[:after] ? 'AFTER' : 'BEFORE'
+        inactive = opts[:inactive] ? 'INACTIVE' : 'ACTIVE'
+        position = opts[:position] ? opts[:position] : 0
+        sql = <<-end_sql
+          CREATE TRIGGER #{quote_identifier(name)} for #{quote_identifier(table)}
+          #{inactive} #{whence} #{events.map{|e| e.to_s.upcase}.join(' OR ')} position #{position}
+          as #{definition}
+        end_sql
+        sql
+      end
+
       def disconnect_connection(c)
         c.close
       end
+
+      def drop_sequence_sql(name)
+        "DROP SEQUENCE #{quote_identifier(name)}"
+      end
+
+      def restart_sequence_sql(name, opts={})
+        seq_name = quote_identifier(name)
+        "ALTER SEQUENCE #{seq_name} RESTART WITH #{opts[:restart_position]}"
+      end
     end
 
     # Dataset class for Firebird datasets
@@ -241,7 +245,7 @@ module Sequel
       # Insert given values into the database.
       def insert(*values)
         if !@opts[:sql]
-          single_value(default_server_opts(:sql=>insert_returning_pk_sql(*values)))
+          clone(default_server_opts(:sql=>insert_returning_pk_sql(*values))).single_value
         else
           execute_insert(insert_sql(*values), :table=>opts[:from].first,
             :values=>values.size == 1 ? values.first : values)
@@ -261,7 +265,7 @@ module Sequel
 
       # Insert a record returning the record inserted
       def insert_select(*values)
-        single_record(default_server_opts(:naked=>true, :sql=>insert_returning_sql(nil, *values)))
+        naked.clone(default_server_opts(:sql=>insert_returning_sql(nil, *values))).single_record
       end
 
       # The order of clauses in the SELECT SQL statement