sequel 3.0.0 → 3.1.0

data/lib/sequel/database/schema_generator.rb

@@ -223,6 +223,7 @@ module Sequel
         @operations << {:op => :add_constraint, :name => name, :type => :check, :check => block || args}
       end
 
+      # Add a unique constraint to the given column(s)
       def add_unique_constraint(columns, opts = {})
         @operations << {:op => :add_constraint, :type => :unique, :columns => Array(columns)}.merge(opts)
       end

data/lib/sequel/database/schema_methods.rb

@@ -16,9 +16,18 @@ module Sequel
     #   DB.add_index :posts, :title
     #   DB.add_index :posts, [:author, :title], :unique => true
     #
+    #
+    # Options:
+    # * :ignore_errors - Ignore any DatabaseErrors that are raised
+    #
     # See alter_table.
-    def add_index(table, *args)
-      alter_table(table) {add_index(*args)}
+    def add_index(table, columns, options={})
+      e = options[:ignore_errors]
+      begin
+        alter_table(table){add_index(columns, options)}
+      rescue DatabaseError
+        raise unless e
+      end
     end
     
     # Alters the given table with the specified block. Example:
@@ -55,13 +64,14 @@ module Sequel
     #
     # Options:
     # * :temp - Create the table as a temporary table.
+    # * :ignore_index_errors - Ignore any errors when creating indexes.
     #
     # See Schema::Generator.
     def create_table(name, options={}, &block)
       options = {:generator=>options} if options.is_a?(Schema::Generator)
       generator = options[:generator] || Schema::Generator.new(self, &block)
-      execute_ddl(create_table_sql(name, generator, options))
-      index_sql_list(name, generator.indexes).each{|sql| execute_ddl(sql)}
+      create_table_from_generator(name, generator, options)
+      create_table_indexes_from_generator(name, generator, options)
     end
     
     # Forcibly creates a table, attempting to drop it unconditionally (and catching any errors), then creating it.
@@ -70,6 +80,11 @@ module Sequel
       create_table(name, options, &block)
     end
     
+    # Creates the table unless the table already exists
+    def create_table?(name, options={}, &block)
+      create_table(name, options, &block) unless table_exists?(name)
+    end
+    
     # Creates a view, replacing it if it already exists:
     #
     #   DB.create_or_replace_view(:cheap_items, "SELECT * FROM items WHERE price < 100")
@@ -165,5 +180,24 @@ module Sequel
     def set_column_type(table, *args)
       alter_table(table) {set_column_type(*args)}
     end
+
+    private
+
+    # Execute the create table statements using the generator.
+    def create_table_from_generator(name, generator, options)
+      execute_ddl(create_table_sql(name, generator, options))
+    end
+
+    # Execute the create index statements using the generator.
+    def create_table_indexes_from_generator(name, generator, options)
+      e = options[:ignore_index_errors]
+      index_sql_list(name, generator.indexes).each do |sql|
+        begin
+          execute_ddl(sql)
+        rescue DatabaseError
+          raise unless e
+        end
+      end
+    end
   end
 end

data/lib/sequel/dataset.rb

@@ -259,6 +259,12 @@ module Sequel
       !(@opts.collect{|k,v| k unless v.nil?}.compact & opts).empty?
     end
 
+    # Whether this dataset is a simple SELECT * FROM table.
+    def simple_select_all?
+      o = @opts.reject{|k,v| v.nil?}
+      o.length == 1 && o[:from] && o[:from].length == 1
+    end
+
     private
     
     # Set the server to use to :default unless it is already set in the passed opts

data/lib/sequel/dataset/convenience.rb

@@ -11,7 +11,7 @@ module Sequel
     #
     #   ds[:id=>1] => {:id=1}
     def [](*conditions)
-      raise(Error, ARRAY_ACCESS_ERROR_MSG) if (conditions.length == 1 and conditions.is_a?(Integer)) or conditions.length == 0
+      raise(Error, ARRAY_ACCESS_ERROR_MSG) if (conditions.length == 1 and conditions.first.is_a?(Integer)) or conditions.length == 0
       first(*conditions)
     end
 
@@ -109,7 +109,7 @@ module Sequel
     #   # this will commit every 50 records
     #   dataset.import([:x, :y], [[1, 2], [3, 4], ...], :slice => 50)
     def import(columns, values, opts={})
-      return @db.transaction{execute_dui("INSERT INTO #{quote_schema_table(@opts[:from].first)} (#{identifier_list(columns)}) VALUES #{literal(values)}")} if values.is_a?(Dataset)
+      return @db.transaction{execute_dui("#{insert_sql_base}#{quote_schema_table(@opts[:from].first)} (#{identifier_list(columns)}) VALUES #{literal(values)}")} if values.is_a?(Dataset)
 
       return if values.empty?
       raise(Error, IMPORT_ERROR_MSG) if columns.empty?

data/lib/sequel/dataset/graph.rb

@@ -69,7 +69,7 @@ module Sequel
       raise_alias_error.call if @opts[:graph] && @opts[:graph][:table_aliases] && @opts[:graph][:table_aliases].include?(table_alias)
 
       # Join the table early in order to avoid cloning the dataset twice
-      ds = join_table(options[:join_type] || :left_outer, table, join_conditions, :table_alias=>table_alias, :implicit_qualifier=>options[:implicit_qualifier], &block)
+      ds = join_table(options[:join_type] || :left_outer, dataset.simple_select_all? ? table : dataset, join_conditions, :table_alias=>table_alias, :implicit_qualifier=>options[:implicit_qualifier], &block)
       opts = ds.opts
 
       # Whether to include the table in the result set
@@ -167,7 +167,7 @@ module Sequel
     # #set_graph_aliases.
     def add_graph_aliases(graph_aliases)
       ds = select_more(*graph_alias_columns(graph_aliases))
-      ds.opts[:graph_aliases] = (ds.opts[:graph_aliases] || {}).merge(graph_aliases)
+      ds.opts[:graph_aliases] = (ds.opts[:graph_aliases] || ds.opts[:graph][:column_aliases] || {}).merge(graph_aliases)
       ds
     end
 

data/lib/sequel/dataset/prepared_statements.rb

@@ -90,14 +90,9 @@ module Sequel
       # Changes the values of symbols if they start with $ and
       # prepared_args is present.  If so, they are considered placeholders,
       # and they are substituted using prepared_arg.
-      def literal(v)
-        case v
-        when Symbol
-          if match = PLACEHOLDER_RE.match(v.to_s) and @prepared_args
-            super(prepared_arg(match[1].to_sym))
-          else
-            super
-          end
+      def literal_symbol(v)
+        if match = PLACEHOLDER_RE.match(v.to_s) and @prepared_args
+          literal(prepared_arg(match[1].to_sym))
         else
           super
         end

data/lib/sequel/dataset/sql.rb

@@ -7,10 +7,12 @@ module Sequel
     COLUMN_REF_RE2 = /\A([\w ]+)___([\w ]+)\z/.freeze
     COLUMN_REF_RE3 = /\A([\w ]+)__([\w ]+)\z/.freeze
     COUNT_FROM_SELF_OPTS = [:distinct, :group, :sql, :limit, :compounds]
+    INSERT_SQL_BASE="INSERT INTO ".freeze
     IS_LITERALS = {nil=>'NULL'.freeze, true=>'TRUE'.freeze, false=>'FALSE'.freeze}.freeze
     IS_OPERATORS = ::Sequel::SQL::ComplexExpression::IS_OPERATORS
     N_ARITY_OPERATORS = ::Sequel::SQL::ComplexExpression::N_ARITY_OPERATORS
     NULL = "NULL".freeze
+    QUALIFY_KEYS = [:select, :where, :having, :order, :group]
     QUESTION_MARK = '?'.freeze
     STOCK_COUNT_OPTS = {:select => [SQL::AliasedExpression.new(LiteralString.new("COUNT(*)").freeze, :count)], :order => nil}.freeze
     SELECT_CLAUSE_ORDER = %w'distinct columns from join where group having compounds order limit'.freeze
@@ -317,7 +319,7 @@ module Sequel
         if values.empty?
           insert_default_values_sql
         else
-          "INSERT INTO #{from} VALUES #{literal(values)}"
+          "#{insert_sql_base}#{from} VALUES #{literal(values)}"
         end
       when Hash
         values = @opts[:defaults].merge(values) if @opts[:defaults]
@@ -330,10 +332,10 @@ module Sequel
             fl << literal(String === k ? k.to_sym : k)
             vl << literal(v)
           end
-          "INSERT INTO #{from} (#{fl.join(COMMA_SEPARATOR)}) VALUES (#{vl.join(COMMA_SEPARATOR)})"
+          "#{insert_sql_base}#{from} (#{fl.join(COMMA_SEPARATOR)}) VALUES (#{vl.join(COMMA_SEPARATOR)})"
         end
       when Dataset
-        "INSERT INTO #{from} #{literal(values)}"
+        "#{insert_sql_base}#{from} #{literal(values)}"
       end
     end
     
@@ -532,7 +534,7 @@ module Sequel
     # This method should be overridden by descendants if the support
     # inserting multiple records in a single SQL statement.
     def multi_insert_sql(columns, values)
-      s = "INSERT INTO #{source_list(@opts[:from])} (#{identifier_list(columns)}) VALUES "
+      s = "#{insert_sql_base}#{source_list(@opts[:from])} (#{identifier_list(columns)}) VALUES "
       values.map{|r| s + literal(r)}
     end
     
@@ -595,6 +597,30 @@ module Sequel
       [qcr.table, qcr.column].map{|x| [SQL::QualifiedIdentifier, SQL::Identifier, Symbol].any?{|c| x.is_a?(c)} ? literal(x) : quote_identifier(x)}.join('.')
     end
 
+    # Return a copy of the dataset with unqualified identifiers in the
+    # SELECT, WHERE, GROUP, HAVING, and ORDER clauses qualified by the
+    # given table. If no columns are currently selected, select all
+    # columns of the given table.
+    def qualify_to(table)
+      o = @opts
+      return clone if o[:sql]
+      h = {}
+      (o.keys & QUALIFY_KEYS).each do |k|
+        h[k] = qualified_expression(o[k], table)
+      end
+      h[:select] = [SQL::ColumnAll.new(table)] if !o[:select] || o[:select].empty?
+      clone(h)
+    end
+    
+    # Qualify the dataset to its current first source.  This is useful
+    # if you have unqualified identifiers in the query that all refer to
+    # the first source, and you want to join to another table which
+    # has columns with the same name as columns in the current dataset.
+    # See qualify_to.
+    def qualify_to_first_source
+      qualify_to(first_source)
+    end
+
     # Adds quoting to identifiers (columns and tables). If identifiers are not
     # being quoted, returns name as a string.  If identifiers are being quoted
     # quote the name with quoted_identifier.
@@ -654,7 +680,11 @@ module Sequel
     #   dataset.select{|o| o.a, o.sum(:b)} # SELECT a, sum(b) FROM items
     def select(*columns, &block)
       columns += Array(virtual_row_block_call(block)) if block
-      clone(:select => columns)
+      m = []
+      columns.map do |i|
+        i.is_a?(Hash) ? m.concat(i.map{|k, v| SQL::AliasedExpression.new(k,v)}) : m << i
+      end
+      clone(:select => m)
     end
     
     # Returns a copy of the dataset selecting the wildcard.
@@ -690,7 +720,7 @@ module Sequel
 
     # SQL fragment for specifying subscripts (SQL arrays)
     def subscript_sql(s)
-      "#{literal(s.f)}[#{s.sub.join(COMMA_SEPARATOR)}]"
+      "#{literal(s.f)}[#{expression_list(s.sub)}]"
     end
 
     # Returns a copy of the dataset with no filters (HAVING or WHERE clause) applied.
@@ -778,6 +808,12 @@ module Sequel
 
     protected
 
+    # Return a from_self dataset if an order or limit is specified, so it works as expected
+    # with UNION, EXCEPT, and INTERSECT clauses.
+    def compound_from_self
+      (@opts[:limit] || @opts[:order]) ? from_self : self
+    end
+    
     # 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)
@@ -803,21 +839,14 @@ module Sequel
     # 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)
-      if columns.nil? || columns.empty?
-        WILDCARD
-      else
-        m = columns.map do |i|
-          i.is_a?(Hash) ? i.map{|k, v| as_sql(literal(k), v)} : literal(i)
-        end
-        m.join(COMMA_SEPARATOR)
-      end
+      (columns.nil? || columns.empty?) ? WILDCARD : expression_list(columns)
     end
     
     # Add the dataset to the list of compounds
     def compound_clone(type, dataset, all)
-      clone(:compounds=>Array(@opts[:compounds]).map{|x| x.dup} + [[type, dataset, all]])
+      compound_from_self.clone(:compounds=>Array(@opts[:compounds]).map{|x| x.dup} + [[type, dataset.compound_from_self, all]]).from_self
     end
-    
+
     # Converts an array of expressions into a comma separated string of
     # expressions.
     def expression_list(columns)
@@ -863,9 +892,14 @@ module Sequel
       columns.map{|i| quote_identifier(i)}.join(COMMA_SEPARATOR)
     end
 
+    # SQL statement for the beginning of an INSERT statement
+    def insert_sql_base
+      INSERT_SQL_BASE
+    end
+
     # SQL statement for formatting an insert statement with default values
     def insert_default_values_sql
-      "INSERT INTO #{source_list(@opts[:from])} DEFAULT VALUES"
+      "#{insert_sql_base}#{source_list(@opts[:from])} DEFAULT VALUES"
     end
 
     # Inverts the given order by breaking it into a list of column references
@@ -1003,6 +1037,47 @@ module Sequel
         column
       end
     end
+    
+    # Qualify the given expression e to the given table.
+    def qualified_expression(e, table)
+      case e
+      when Symbol
+        t, column, aliaz = split_symbol(e)
+        if t
+          e
+        elsif aliaz
+          SQL::AliasedExpression.new(SQL::QualifiedIdentifier.new(table, SQL::Identifier.new(column)), aliaz)
+        else
+          SQL::QualifiedIdentifier.new(table, e)
+        end
+      when Array
+        e.map{|a| qualified_expression(a, table)}
+      when Hash
+        h = {}
+        e.each{|k,v| h[qualified_expression(k, table)] = qualified_expression(v, table)}
+        h
+      when SQL::Identifier
+        SQL::QualifiedIdentifier.new(table, e)
+      when SQL::OrderedExpression
+        SQL::OrderedExpression.new(qualified_expression(e.expression, table), e.descending)
+      when SQL::AliasedExpression
+        SQL::AliasedExpression.new(qualified_expression(e.expression, table), e.aliaz)
+      when SQL::CaseExpression
+        SQL::CaseExpression.new(qualified_expression(e.conditions, table), qualified_expression(e.default, table), qualified_expression(e.expression, table))
+      when SQL::Cast
+        SQL::Cast.new(qualified_expression(e.expr, table), e.type)
+      when SQL::Function
+        SQL::Function.new(e.f, *qualified_expression(e.args, table))
+      when SQL::ComplexExpression 
+        SQL::ComplexExpression.new(e.op, *qualified_expression(e.args, table))
+      when SQL::SQLArray 
+        SQL::SQLArray.new(qualified_expression(e.array, table))
+      when SQL::Subscript 
+        SQL::Subscript.new(qualified_expression(e.f, table), qualified_expression(e.sub, table))
+      else
+        e
+      end
+    end
 
     # The order of methods to call to build the SELECT SQL statement
     def select_clause_order
@@ -1028,8 +1103,7 @@ module Sequel
       return unless @opts[:compounds]
       @opts[:compounds].each do |type, dataset, all|
         compound_sql = subselect_sql(dataset)
-        compound_sql = "SELECT * FROM (#{compound_sql})" if dataset.opts[:compounds]
-        sql.replace("#{sql} #{type.to_s.upcase}#{' ALL' if all} #{compound_sql}")
+        sql << " #{type.to_s.upcase}#{' ALL' if all} #{compound_sql}"
       end
     end
 

data/lib/sequel/extensions/blank.rb

@@ -1,3 +1,5 @@
+# The blank extension adds the blank? method to all objects (e.g. Object#blank?).
+
 class FalseClass
   # false is always blank
   def blank?
@@ -5,7 +7,6 @@ class FalseClass
   end
 end
 
-# Helpers from Metaid and a bit more
 class Object
   # Objects are blank if they respond true to empty?
   def blank?

data/lib/sequel/extensions/inflector.rb

@@ -1,6 +1,7 @@
-# Add inflection methods to String, which allows the easy transformation of
-# words from singular to plural,class names to table names, modularized class
-# names to ones without, and class names to foreign keys.
+# The inflector extension adds inflection instance methods to String, which allows the easy transformation of
+# words from singular to plural, class names to table names, modularized class
+# names to ones without, and class names to foreign keys.  It exists for 
+# backwards compatibility to legacy Sequel code.
 
 class String
   # This module acts as a singleton returned/yielded by String.inflections,

data/lib/sequel/extensions/migration.rb

@@ -1,3 +1,7 @@
+# Adds the Sequel::Migration and Sequel::Migrator classes, which allow
+# the user to easily group schema changes and migrate the database
+# to a newer version or revert to a previous version.
+
 module Sequel
   # The Migration class describes a database migration that can be reversed.
   # The migration looks very similar to ActiveRecord (Rails) migrations, e.g.:
@@ -128,6 +132,7 @@ module Sequel
   #   Sequel::Migrator.apply(DB, '.', 5, 1)
   module Migrator
     MIGRATION_FILE_PATTERN = /\A\d+_.+\.rb\z/.freeze
+    MIGRATION_SPLITTER = '_'.freeze
 
     # Migrates the supplied database in the specified directory from the
     # current version to the target version. If no current version is
@@ -162,7 +167,7 @@ module Sequel
     # Returns the latest version available in the specified directory.
     def self.latest_migration_version(directory)
       l = migration_files(directory).last
-      l ? File.basename(l).to_i : nil
+      l ? migration_version_from_file(File.basename(l)) : nil
     end
 
     # Returns a list of migration classes filtered for the migration range and
@@ -190,7 +195,7 @@ module Sequel
     def self.migration_files(directory, range = nil)
       files = []
       Dir.new(directory).each do |file|
-        files[file.to_i] = File.join(directory, file) if MIGRATION_FILE_PATTERN.match(file)
+        files[migration_version_from_file(file)] = File.join(directory, file) if MIGRATION_FILE_PATTERN.match(file)
       end
       filtered = range ? files[range] : files
       filtered ? filtered.compact : []
@@ -208,5 +213,11 @@ module Sequel
       dataset = schema_info_dataset(db)
       dataset.send(dataset.first ? :update : :<<, :version => version)
     end
+
+    # Return the integer migration version based on the filename.
+    def self.migration_version_from_file(filename)
+      filename.split(MIGRATION_SPLITTER, 2).first.to_i
+    end
+    private_class_method :migration_version_from_file
   end
 end

data/lib/sequel/extensions/pagination.rb

@@ -1,3 +1,7 @@
+# The pagination extension adds the Sequel::Dataset#paginate and #each_page methods,
+# which return paginated (limited and offset) datasets with some helpful methods
+# that make creating a paginated display easier.
+
 module Sequel
   class Dataset
     # Returns a paginated dataset. The returned dataset is limited to

data/lib/sequel/extensions/pretty_table.rb

@@ -1,3 +1,7 @@
+# The pretty_table extension adds Sequel::Dataset#print and the
+# Sequel::PrettyTable class for creating nice-looking plain-text
+# tables.
+
 module Sequel
   class Dataset
     # Pretty prints the records in the dataset as plain-text table.

data/lib/sequel/extensions/query.rb

@@ -1,3 +1,7 @@
+# The query extension adds Sequel::Dataset#query which allows
+# a different way to construct queries instead of the usual
+# method chaining.
+
 module Sequel
   class Database
     # Return a dataset modified by the query block