sequel 2.5.0 → 2.6.0

data/lib/sequel_core/adapters/sqlite.rb

@@ -8,6 +8,7 @@ module Sequel
     # Database class for PostgreSQL databases used with Sequel and the
     # ruby-sqlite3 driver.
     class Database < Sequel::Database
+      UNIX_EPOCH_TIME_FORMAT = /\A\d+\z/.freeze
       include ::Sequel::SQLite::DatabaseMethods
       
       set_adapter_scheme :sqlite
@@ -30,10 +31,13 @@ module Sequel
         db = ::SQLite3::Database.new(opts[:database])
         db.busy_timeout(opts.fetch(:timeout, 5000))
         db.type_translation = true
-        # fix for timestamp translation
-        db.translator.add_translator("timestamp") do |t, v|
-          v =~ /^\d+$/ ? Time.at(v.to_i) : Time.parse(v) 
-        end 
+        # Handle datetime's with Sequel.datetime_class
+        prok = proc do |t,v|
+          v = Time.at(v.to_i).iso8601 if UNIX_EPOCH_TIME_FORMAT.match(v)
+          v.to_sequel_time
+        end
+        db.translator.add_translator("timestamp", &prok)
+        db.translator.add_translator("datetime", &prok)
         db
       end
       

data/lib/sequel_core/core_sql.rb

@@ -7,8 +7,8 @@ class Array
 
   # Return a Sequel::SQL::CaseExpression with this array as the conditions and the given
   # default value.
-  def case(default)
-    ::Sequel::SQL::CaseExpression.new(self, default)
+  def case(default, expression = nil)
+    ::Sequel::SQL::CaseExpression.new(self, default, expression)
   end
 
   # Return a Sequel::SQL::BooleanExpression created from this array, matching all of the
@@ -87,8 +87,8 @@ class Hash
   # Return a Sequel::SQL::CaseExpression with this hash as the conditions and the given
   # default value.  Note that the order of the conditions will be arbitrary, so all
   # conditions should be orthogonal.
-  def case(default)
-    ::Sequel::SQL::CaseExpression.new(to_a, default)
+  def case(default, expression = nil)
+    ::Sequel::SQL::CaseExpression.new(to_a, default, expression)
   end
 
   # Return a Sequel::SQL::BooleanExpression created from this hash, matching all of the

data/lib/sequel_core/database.rb

@@ -355,7 +355,7 @@ module Sequel
       synchronize(server){|conn|}
       true
     end
-    
+
     # A simple implementation of SQL transactions. Nested transactions are not 
     # supported - calling #transaction within a transaction will reuse the 
     # current transaction. Should be overridden for databases that support nested 
@@ -363,19 +363,19 @@ module Sequel
     def transaction(server=nil)
       synchronize(server) do |conn|
         return yield(conn) if @transactions.include?(Thread.current)
-        log_info(SQL_BEGIN)
-        conn.execute(SQL_BEGIN)
+        log_info(begin_transaction_sql)
+        conn.execute(begin_transaction_sql)
         begin
           @transactions << Thread.current
           yield(conn)
         rescue Exception => e
-          log_info(SQL_ROLLBACK)
-          conn.execute(SQL_ROLLBACK)
+          log_info(rollback_transaction_sql)
+          conn.execute(rollback_transaction_sql)
           transaction_error(e)
         ensure
           unless e
-            log_info(SQL_COMMIT)
-            conn.execute(SQL_COMMIT)
+            log_info(commit_transaction_sql)
+            conn.execute(commit_transaction_sql)
           end
           @transactions.delete(Thread.current)
         end
@@ -384,15 +384,25 @@ module Sequel
     
     # Typecast the value to the given column_type. Can be overridden in
     # adapters to support database specific column types.
+    # This method should raise Sequel::Error::InvalidValue if assigned value
+    # is invalid.
     def typecast_value(column_type, value)
       return nil if value.nil?
       case column_type
       when :integer
-        Integer(value)
+        begin
+          Integer(value)
+        rescue ArgumentError => e
+          raise Sequel::Error::InvalidValue, e.message.inspect
+        end
       when :string
         value.to_s
       when :float
-        Float(value)
+        begin
+          Float(value)
+        rescue ArgumentError => e
+          raise Sequel::Error::InvalidValue, e.message.inspect
+        end
       when :decimal
         case value
         when BigDecimal
@@ -402,7 +412,7 @@ module Sequel
         when Integer
           value.to_s.to_d
         else
-          raise ArgumentError, "invalid value for BigDecimal: #{value.inspect}"
+          raise Sequel::Error::InvalidValue, "invalid value for BigDecimal: #{value.inspect}"
         end
       when :boolean
         case value
@@ -420,7 +430,7 @@ module Sequel
         when String
           value.to_date
         else
-          raise ArgumentError, "invalid value for Date: #{value.inspect}"
+          raise Sequel::Error::InvalidValue, "invalid value for Date: #{value.inspect}"
         end
       when :time
         case value
@@ -429,10 +439,10 @@ module Sequel
         when String
           value.to_time
         else
-          raise ArgumentError, "invalid value for Time: #{value.inspect}"
+          raise Sequel::Error::InvalidValue, "invalid value for Time: #{value.inspect}"
         end
       when :datetime
-        raise(ArgumentError, "invalid value for #{tc}: #{value.inspect}") unless value.is_one_of?(DateTime, Date, Time, String)
+        raise(Sequel::Error::InvalidValue, "invalid value for Datetime: #{value.inspect}") unless value.is_one_of?(DateTime, Date, Time, String)
         if Sequel.datetime_class === value
           # Already the correct class, no need to convert
           value
@@ -446,7 +456,7 @@ module Sequel
       else
         value
       end
-    end 
+    end
 
     # Returns the URI identifying the database.
     # This method can raise an error if the database used options
@@ -471,6 +481,38 @@ module Sequel
     
     private
     
+    # SQL to BEGIN a transaction.
+    def begin_transaction_sql
+      SQL_BEGIN
+    end
+
+    # SQL to COMMIT a transaction.
+    def commit_transaction_sql
+      SQL_COMMIT
+    end
+
+    # The default options for the connection pool.
+    def connection_pool_default_options
+      {}
+    end
+
+    # SQL to ROLLBACK a transaction.
+    def rollback_transaction_sql
+      SQL_ROLLBACK
+    end
+    
+    # Convert the given exception to a DatabaseError, keeping message
+    # and traceback.
+    def raise_error(exception, opts={})
+      if !opts[:classes] || exception.is_one_of?(*opts[:classes])
+        e = DatabaseError.new("#{exception.class} #{exception.message}")
+        e.set_backtrace(exception.backtrace)
+        raise e
+      else
+        raise exception
+      end
+    end
+
     # Return the options for the given server by merging the generic
     # options for all server with the specific options for the given
     # server specified in the :servers option.
@@ -491,23 +533,6 @@ module Sequel
       opts
     end
 
-    # The default options for the connection pool.
-    def connection_pool_default_options
-      {}
-    end
-
-    # Convert the given exception to a DatabaseError, keeping message
-    # and traceback.
-    def raise_error(exception, opts={})
-      if !opts[:classes] || exception.is_one_of?(*opts[:classes])
-        e = DatabaseError.new("#{exception.class} #{exception.message}")
-        e.set_backtrace(exception.backtrace)
-        raise e
-      else
-        raise exception
-      end
-    end
-
     # Raise a database error unless the exception is an Error::Rollback.
     def transaction_error(e, *classes)
       raise_error(e, :classes=>classes) unless Error::Rollback === e

data/lib/sequel_core/database/schema.rb

@@ -40,6 +40,7 @@ module Sequel
     #
     # See Schema::AlterTableGenerator.
     def alter_table(name, generator=nil, &block)
+      @schemas.delete(name.to_sym) if @schemas
       generator ||= Schema::AlterTableGenerator.new(self, &block)
       alter_table_sql_list(name, generator.operations).flatten.each {|sql| execute_ddl(sql)}
     end
@@ -70,8 +71,9 @@ module Sequel
     #   DB.create_or_replace_view(:cheap_items, "SELECT * FROM items WHERE price < 100")
     #   DB.create_or_replace_view(:ruby_items, DB[:items].filter(:category => 'ruby'))
     def create_or_replace_view(name, source)
+      @schemas.delete(name.to_sym) if @schemas
       source = source.sql if source.is_a?(Dataset)
-      execute_ddl("CREATE OR REPLACE VIEW #{name} AS #{source}")
+      execute_ddl("CREATE OR REPLACE VIEW #{quote_identifier(name)} AS #{source}")
     end
     
     # Creates a view based on a dataset or an SQL string:
@@ -80,7 +82,7 @@ module Sequel
     #   DB.create_view(:ruby_items, DB[:items].filter(:category => 'ruby'))
     def create_view(name, source)
       source = source.sql if source.is_a?(Dataset)
-      execute_ddl("CREATE VIEW #{name} AS #{source}")
+      execute_ddl("CREATE VIEW #{quote_identifier(name)} AS #{source}")
     end
     
     # Removes a column from the specified table:
@@ -106,14 +108,20 @@ module Sequel
     #
     #   DB.drop_table(:posts, :comments)
     def drop_table(*names)
-      names.each {|n| execute_ddl(drop_table_sql(n))}
+      names.each do |n|
+        @schemas.delete(n.to_sym) if @schemas
+        execute_ddl(drop_table_sql(n))
+      end
     end
     
     # Drops a view:
     #
     #   DB.drop_view(:cheap_items)
-    def drop_view(name)
-      execute_ddl("DROP VIEW #{name}")
+    def drop_view(*names)
+      names.each do |n|
+        @schemas.delete(n.to_sym) if @schemas
+        execute_ddl("DROP VIEW #{quote_identifier(n)}")
+      end
     end
 
     # Renames a table:

data/lib/sequel_core/dataset/convenience.rb

@@ -135,7 +135,7 @@ module Sequel
       elsif args[0].is_a?(Array) && args[1].is_a?(Dataset)
         table = @opts[:from].first
         columns, dataset = *args
-        sql = "INSERT INTO #{quote_identifier(table)} #{literal(columns)} VALUES #{literal(dataset)}"
+        sql = "INSERT INTO #{quote_identifier(table)} (#{identifier_list(columns)}) VALUES #{literal(dataset)}"
         return @db.transaction{execute_dui(sql)}
       else
         # we assume that an array of hashes is given

data/lib/sequel_core/dataset/sql.rb

@@ -26,12 +26,17 @@ module Sequel
 
     # SQL fragment for the aliased expression
     def aliased_expression_sql(ae)
-      "#{literal(ae.expression)} AS #{quote_identifier(ae.aliaz)}"
+      as_sql(literal(ae.expression), ae.aliaz)
     end
 
     # SQL fragment for specifying given CaseExpression.
     def case_expression_sql(ce)
-      "(CASE #{ce.conditions.collect{|c,r| "WHEN #{literal(c)} THEN #{literal(r)} "}.join}ELSE #{literal(ce.default)} END)"
+      sql = '(CASE '
+      sql << "#{literal(ce.expression)} " if ce.expression
+      ce.conditions.collect{ |c,r|
+        sql << "WHEN #{literal(c)} THEN #{literal(r)} "
+      }
+      sql << "ELSE #{literal(ce.default)} END)"
     end
 
     # SQL fragment for specifying all columns in a given table.
@@ -335,8 +340,8 @@ module Sequel
       table = jc.table
       table_alias = jc.table_alias
       table_alias = nil if table == table_alias
-      " #{join_type_sql(jc.join_type)} #{table_ref(table)}" \
-        "#{" AS #{quote_identifier(jc.table_alias)}" if table_alias}"
+      tref = table_ref(table)
+      " #{join_type_sql(jc.join_type)} #{table_alias ? as_sql(tref, table_alias) : tref}"
     end
 
     # SQL fragment specifying a JOIN clause with ON.
@@ -393,7 +398,7 @@ module Sequel
         raise(Sequel::Error, "can't use a block if providing an array of symbols as expr") if block_given?
         SQL::JoinUsingClause.new(expr, type, table, table_alias)
       else
-        last_alias = @opts[:last_joined_table] || first_source
+        last_alias = @opts[:last_joined_table] || (first_source.is_a?(Dataset) ? 't1' : first_source)
         if Hash === expr or (Array === expr and expr.all_two_pairs?)
           expr = expr.collect do |k, v|
             k = qualified_column_name(k, table_name) if k.is_a?(Symbol)
@@ -465,7 +470,7 @@ module Sequel
       when ::Sequel::SQL::Expression
         v.to_s(self)
       when Array
-        v.all_two_pairs? ? literal(v.sql_expr) : (v.empty? ? '(NULL)' : "(#{v.collect{|i| literal(i)}.join(COMMA_SEPARATOR)})")
+        v.all_two_pairs? ? literal(v.sql_expr) : (v.empty? ? '(NULL)' : "(#{expression_list(v)})")
       when Hash
         literal(v.sql_expr)
       when Time, DateTime
@@ -487,9 +492,9 @@ module Sequel
     # inserting multiple records in a single SQL statement.
     def multi_insert_sql(columns, values)
       table = quote_identifier(@opts[:from].first)
-      columns = literal(columns)
+      columns = identifier_list(columns)
       values.map do |r|
-        "INSERT INTO #{table} #{columns} VALUES #{literal(r)}"
+        "INSERT INTO #{table} (#{columns}) VALUES #{literal(r)}"
       end
     end
     
@@ -667,7 +672,8 @@ module Sequel
     #
     def symbol_to_column_ref(sym)
       c_table, column, c_alias = split_symbol(sym)
-      "#{"#{quote_identifier(c_table)}." if c_table}#{quote_identifier(column)}#{" AS #{quote_identifier(c_alias)}" if c_alias}"
+      qc = "#{"#{quote_identifier(c_table)}." if c_table}#{quote_identifier(column)}"
+      c_alias ? as_sql(qc, c_alias) : qc
     end
 
     # Returns a copy of the dataset with no filters (HAVING or WHERE clause) applied.
@@ -724,9 +730,7 @@ module Sequel
         # get values from hash
         values = transform_save(values) if @transform
         values.map do |k, v|
-          # convert string key into symbol
-          k = k.to_sym if String === k
-          "#{literal(k)} = #{literal(v)}"
+          "#{k.is_one_of?(String, Symbol) ? quote_identifier(k) : literal(k)} = #{literal(v)}"
         end.join(COMMA_SEPARATOR)
       else
         # copy values verbatim
@@ -750,11 +754,17 @@ module Sequel
     # Returns a table reference for use in the FROM clause.  Returns an SQL subquery
     # frgament with an optional table alias.
     def to_table_reference(table_alias=nil)
-      "(#{sql})#{" #{quote_identifier(table_alias)}" if table_alias}"
+      s = "(#{sql})"
+      table_alias ? as_sql(s, table_alias) : s
     end
 
     private
 
+    # SQL fragment for specifying an alias.  expression should already be literalized.
+    def as_sql(expression, aliaz)
+      "#{expression} AS #{quote_identifier(aliaz)}"
+    end
+
     # Converts an array of column names into a comma seperated string of 
     # column names. If the array is empty, a wildcard (*) is returned.
     def column_list(columns)
@@ -762,7 +772,7 @@ module Sequel
         WILDCARD
       else
         m = columns.map do |i|
-          i.is_a?(Hash) ? i.map{|k, v| "#{literal(k)} AS #{quote_identifier(v)}"} : literal(i)
+          i.is_a?(Hash) ? i.map{|k, v| as_sql(literal(k), v)} : literal(i)
         end
         m.join(COMMA_SEPARATOR)
       end
@@ -806,6 +816,11 @@ module Sequel
       end
     end
 
+    # SQL fragment specifying a list of identifiers
+    def identifier_list(columns)
+      columns.map{|i| quote_identifier(i)}.join(COMMA_SEPARATOR)
+    end
+
     # SQL statement for formatting an insert statement with default values
     def insert_default_values_sql
       "INSERT INTO #{source_list(@opts[:from])} DEFAULT VALUES"
@@ -891,7 +906,7 @@ module Sequel
       when Dataset
         t.to_table_reference
       when Hash
-        t.map {|k, v| "#{table_ref(k)} #{table_ref(v)}"}.join(COMMA_SEPARATOR)
+        t.map{|k, v| as_sql(table_ref(k), v)}.join(COMMA_SEPARATOR)
       when Symbol
         symbol_to_column_ref(t)
       when String

data/lib/sequel_core/migration.rb

@@ -85,6 +85,13 @@ module Sequel
   # The migration files should contain one or more migration classes based
   # on Sequel::Migration.
   #
+  # Migrations are generally run via the sequel command line tool,
+  # using the -m and -M switches.  The -m switch specifies the migration
+  # directory, and the -M switch specifies the version to which to migrate.
+  # 
+  # You can apply migrations using the Migrator API, as well (this is necessary
+  # if you want to specify the version from which to migrate in addition to the version
+  # to which to migrate).
   # To apply a migration, the #apply method must be invoked with the database
   # instance, the directory of migration files and the target version. If
   # no current version is supplied, it is read from the database. The migrator

data/lib/sequel_core/schema/generator.rb

@@ -145,9 +145,8 @@ module Sequel
         index(columns, opts.merge(:type => :spatial))
       end
 
-      # Add a unique index on the given columns to the DDL.
+      # Add a unique constraint on the given columns to the DDL.
       def unique(columns, opts = {})
-        index(columns, opts.merge(:unique => true))
         @columns << {:type => :check, :constraint_type => :unique,
                      :name => nil, :columns => Array(columns)}.merge(opts)
       end
@@ -200,6 +199,13 @@ module Sequel
 
       # Add a foreign key with the given name and referencing the given table
       # to the DDL for the table.  See Generator#column for the available options.
+      #
+      # You can also pass an array of column names for creating composite foreign
+      # keys. In this case, it will assume the columns exists and will only add
+      # the constraint.
+      #
+      # NOTE: If you need to add a foreign key constraint to an existing column
+      # use the composite key syntax even if it is only one column.
       def add_foreign_key(name, table, opts = {})
         return add_composite_foreign_key(name, table, opts) if name.is_a?(Array)
         add_column(name, :integer, {:table=>table}.merge(opts))
@@ -260,6 +266,11 @@ module Sequel
       def set_column_type(name, type)
         @operations << {:op => :set_column_type, :name => name, :type => type}
       end
+      
+      # Modify a column's NOT NULL constraint.
+      def set_column_allow_null(name, allow_null)
+        @operations << {:op => :set_column_null, :name => name, :null => allow_null}
+      end
 
       private
 

data/lib/sequel_core/schema/sql.rb

@@ -33,6 +33,8 @@ module Sequel
           "ALTER COLUMN #{quoted_name} TYPE #{op[:type]}"
         when :set_column_default
           "ALTER COLUMN #{quoted_name} SET DEFAULT #{literal(op[:default])}"
+        when :set_column_null
+          "ALTER COLUMN #{quoted_name} #{op[:null] ? 'DROP' : 'SET'} NOT NULL"
         when :add_index
           return index_definition_sql(table, op)
         when :drop_index
@@ -100,7 +102,8 @@ module Sequel
         when :unique
           sql << "UNIQUE #{literal(constraint[:columns])}"
         else
-          sql << "CHECK #{filter_expr(constraint[:check])}"
+          check = constraint[:check]
+          sql << "CHECK #{filter_expr((check.is_a?(Array) && check.length == 1) ? check.first : check)}"
         end
         sql
       end
@@ -205,6 +208,7 @@ module Sequel
       #   table_name, otherwise you may only getting the schemas for tables
       #   that have been requested explicitly.
       def schema(table_name = nil, opts={})
+        table_name = table_name.to_sym if table_name
         if opts[:reload] && @schemas
           if table_name
             @schemas.delete(table_name)
@@ -213,17 +217,30 @@ module Sequel
           end
         end
 
-        if table_name
-          return @schemas[table_name] if @schemas && @schemas[table_name]
-        else
-          return @schemas if @schemas
+        if @schemas
+          if table_name
+            return @schemas[table_name] if @schemas[table_name]
+          else
+            return @schemas
+          end
         end
 
         if table_name
           @schemas ||= {}
-          @schemas[table_name] ||= schema_parse_table(table_name, opts)
+          if respond_to?(:schema_parse_table, true)
+            @schemas[table_name] ||= schema_parse_table(table_name, opts)
+          else
+            raise Error, 'schema parsing is not implemented on this database'
+          end
         else
-          @schemas = schema_parse_tables(opts)
+          if respond_to?(:schema_parse_tables, true)
+            @schemas = schema_parse_tables(opts)
+          elsif respond_to?(:schema_parse_table, true) and respond_to?(:tables, true)
+            tables.each{|t| schema(t, opts)}
+            @schemas
+          else
+            raise Error, 'schema parsing is not implemented on this database'
+          end
         end
       end
       
@@ -240,11 +257,11 @@ module Sequel
       # integer, string, date, datetime, boolean, and float.
       def schema_column_type(db_type)
         case db_type
-        when 'tinyint'
+        when /\Atinyint/
           Sequel.convert_tinyint_to_bool ? :boolean : :integer
-        when /\A(int(eger)?|bigint|smallint)\z/
+        when /\A(int(eger)?|bigint|smallint)/
           :integer
-        when /\A(character( varying)?|varchar|text)\z/
+        when /\A(character( varying)?|varchar|text)/
           :string
         when /\Adate\z/
           :date
@@ -263,77 +280,6 @@ module Sequel
         end
       end
 
-      # The final dataset used by the schema parser, after all
-      # options have been applied.
-      def schema_ds(table_name, opts)
-        schema_ds_dataset.from(*schema_ds_from(table_name, opts)) \
-          .select(*schema_ds_select(table_name, opts)) \
-          .join(*schema_ds_join(table_name, opts)) \
-          .filter(*schema_ds_filter(table_name, opts))
-      end
-
-      # The blank dataset used by the schema parser.
-      def schema_ds_dataset
-        schema_utility_dataset
-      end
-
-      # Argument array for the schema dataset's filter method.
-      def schema_ds_filter(table_name, opts)
-        if table_name
-          [{:c__table_name=>table_name.to_s}]
-        else
-          [{:t__table_type=>'BASE TABLE'}]
-        end
-      end
-
-      # Argument array for the schema dataset's from method.
-      def schema_ds_from(table_name, opts)
-        [:information_schema__tables___t]
-      end
-
-      # Argument array for the schema dataset's join method.
-      def schema_ds_join(table_name, opts)
-        [:information_schema__columns, [:table_catalog, :table_schema, :table_name], :c]
-      end
-
-      # Argument array for the schema dataset's select method.
-      def schema_ds_select(table_name, opts)
-        cols = [:column_name___column, :data_type___db_type, :character_maximum_length___max_chars, \
-          :numeric_precision, :column_default___default, :is_nullable___allow_null]
-        cols << :c__table_name unless table_name
-        cols
-      end
-
-      # Parse the schema for a given table.
-      def schema_parse_table(table_name, opts)
-        schema_parse_rows(schema_ds(table_name, opts))
-      end
-
-      # Parse the schema all tables in the database.
-      def schema_parse_tables(opts)
-        schemas = {}
-        schema_ds(nil, opts).each do |row|
-          (schemas[row.delete(:table_name).to_sym] ||= []) << row
-        end
-        schemas.each do |table, rows|
-          schemas[table] = schema_parse_rows(rows)
-        end
-        schemas
-      end
-
-      # Parse the output of the information schema columns into
-      # the hash used by Sequel.
-      def schema_parse_rows(rows)
-        schema = []
-        rows.each do |row| 
-          row[:allow_null] = row[:allow_null] == 'YES' ? true : false
-          row[:default] = nil if row[:default].blank?
-          row[:type] = schema_column_type(row[:db_type])
-          schema << [row.delete(:column).to_sym, row]
-        end
-        schema
-      end
-
       # SQL fragment specifying the type of a given column.
       def type_literal(column)
         column[:size] ||= 255 if column[:type] == :varchar