sequel 2.6.0 → 2.7.0

data/lib/sequel_core/adapters/shared/postgres.rb

@@ -10,32 +10,35 @@ module Sequel
       
       SELECT_CURRVAL = "SELECT currval('%s')".freeze
       SELECT_CUSTOM_SEQUENCE = <<-end_sql
-        SELECT CASE  
+        SELECT '"' || name.nspname || '"."' || CASE  
             WHEN split_part(def.adsrc, '''', 2) ~ '.' THEN  
               substr(split_part(def.adsrc, '''', 2),  
                      strpos(split_part(def.adsrc, '''', 2), '.')+1) 
             ELSE split_part(def.adsrc, '''', 2)  
-          END
+          END || '"'
         FROM pg_class t
         JOIN pg_namespace  name ON (t.relnamespace = name.oid)
         JOIN pg_attribute  attr ON (t.oid = attrelid)
         JOIN pg_attrdef    def  ON (adrelid = attrelid AND adnum = attnum)
         JOIN pg_constraint cons ON (conrelid = adrelid AND adnum = conkey[1])
-        WHERE t.oid = '%s'::regclass
-          AND cons.contype = 'p'
+        WHERE cons.contype = 'p'
           AND def.adsrc ~* 'nextval'
+          AND name.nspname = '%s'
+          AND t.relname = '%s'
       end_sql
       SELECT_PK = <<-end_sql
         SELECT pg_attribute.attname
-        FROM pg_class, pg_attribute, pg_index
-        WHERE pg_class.oid = pg_attribute.attrelid AND
-          pg_class.oid = pg_index.indrelid AND
-          pg_index.indkey[0] = pg_attribute.attnum AND
-          pg_index.indisprimary = 't' AND
-          pg_class.relname = '%s'
+        FROM pg_class, pg_attribute, pg_index, pg_namespace
+        WHERE pg_class.oid = pg_attribute.attrelid
+          AND pg_class.relnamespace  = pg_namespace.oid
+          AND pg_class.oid = pg_index.indrelid
+          AND pg_index.indkey[0] = pg_attribute.attnum
+          AND pg_index.indisprimary = 't'
+          AND pg_namespace.nspname = '%s'
+          AND pg_class.relname = '%s'
       end_sql
       SELECT_SERIAL_SEQUENCE = <<-end_sql
-        SELECT seq.relname
+        SELECT  '"' || name.nspname || '"."' || seq.relname || '"'
         FROM pg_class seq, pg_attribute attr, pg_depend dep,
           pg_namespace name, pg_constraint cons
         WHERE seq.oid = dep.objid
@@ -46,7 +49,8 @@ module Sequel
           AND attr.attrelid = cons.conrelid
           AND attr.attnum = cons.conkey[1]
           AND cons.contype = 'p'
-          AND dep.refobjid = '%s'::regclass
+          AND name.nspname = '%s'
+          AND seq.relname = '%s'
       end_sql
       
       # Depth of the current transaction on this connection, used
@@ -64,15 +68,15 @@ module Sequel
       end
       
       # Get the primary key and sequence for the given table.
-      def sequence(table)
-        sql = SELECT_SERIAL_SEQUENCE % table
+      def sequence(schema, table)
+        sql = SELECT_SERIAL_SEQUENCE % [schema, table]
         @db.log_info(sql)
         execute(sql) do |r|
           seq = single_value(r)
           return seq if seq
         end
         
-        sql = SELECT_CUSTOM_SEQUENCE % table
+        sql = SELECT_CUSTOM_SEQUENCE % [schema, table]
         @db.log_info(sql)
         execute(sql) do |r|
           return single_value(r)
@@ -80,8 +84,8 @@ module Sequel
       end
       
       # Get the primary key for the given table.
-      def primary_key(table)
-        sql = SELECT_PK % table
+      def primary_key(schema, table)
+        sql = SELECT_PK % [schema, table]
         @db.log_info(sql)
         execute(sql) do |r|
           return single_value(r)
@@ -93,8 +97,6 @@ module Sequel
     module DatabaseMethods
       PREPARED_ARG_PLACEHOLDER = '$'.lit.freeze
       RE_CURRVAL_ERROR = /currval of sequence "(.*)" is not yet defined in this session|relation "(.*)" does not exist/.freeze
-      RELATION_QUERY = {:from => [:pg_class], :select => [:relname]}.freeze
-      RELATION_FILTER = "(relkind = 'r') AND (relname !~ '^pg|sql')".freeze
       SQL_BEGIN = 'BEGIN'.freeze
       SQL_SAVEPOINT = 'SAVEPOINT autopoint_%d'.freeze
       SQL_COMMIT = 'COMMIT'.freeze
@@ -103,19 +105,29 @@ module Sequel
       SQL_RELEASE_SAVEPOINT = 'RELEASE SAVEPOINT autopoint_%d'.freeze
       SYSTEM_TABLE_REGEXP = /^pg|sql/.freeze
       
+      # The default schema to use if none is specified (default: public)
+      def default_schema
+        @default_schema ||= :public
+      end
+      
+      # Set a new default schema to use.
+      def default_schema=(schema)
+        @default_schema = schema
+      end
+      
       # Remove the cached entries for primary keys and sequences when dropping a table.
       def drop_table(*names)
         names.each do |name|
-          s = name.to_sym
-          @primary_keys.delete(s)
-          @primary_key_sequences.delete(s)
+          name = quote_schema_table(name)
+          @primary_keys.delete(name)
+          @primary_key_sequences.delete(name)
         end
         super
       end
 
       # Always CASCADE the table drop
       def drop_table_sql(name)
-        "DROP TABLE #{name} CASCADE"
+        "DROP TABLE #{quote_schema_table(name)} CASCADE"
       end
       
       # PostgreSQL specific index SQL.
@@ -128,9 +140,8 @@ module Sequel
         filter = " WHERE #{filter_expr(filter)}" if filter
         case index_type
         when :full_text
-          lang = "#{literal(index[:language] || 'simple')}, "
-          cols = index[:columns].map {|c| literal(c)}.join(" || ")
-          expr = "(to_tsvector(#{lang}#{cols}))"
+          cols = Array(index[:columns]).map{|x| :COALESCE[x, '']}.sql_string_join(' ')
+          expr = "(to_tsvector(#{literal(index[:language] || 'simple')}, #{literal(cols)}))"
           index_type = :gin
         when :spatial
           index_type = :gist
@@ -152,17 +163,8 @@ module Sequel
 
       # Support :schema__table format for table
       def schema(table_name=nil, opts={})
-        case table_name
-        when Symbol
-          t, c, a = dataset.send(:split_symbol, table_name)
-          opts[:schema] ||= t
-          table_name = c
-        when SQL::QualifiedIdentifier
-          opts[:schema] ||= table_name.table
-          table_name = table_name.column
-        when SQL::Identifier
-          table_name = table_name.value
-        end
+        schema, table_name = schema_and_table(table_name) if table_name
+        opts[:schema] = schema if schema
         super(table_name, opts)
       end
 
@@ -185,9 +187,27 @@ module Sequel
         @server_version
       end
       
+      # Whether the given table exists in the database
+      #
+      # Options:
+      # * :schema - The schema to search (default_schema by default)
+      # * :server - The server to use
+      def table_exists?(table, opts={})
+        schema, table = schema_and_table(table)
+        opts[:schema] ||= schema
+        tables(opts){|ds| !ds.first(:relname=>table.to_s).nil?}
+      end
+      
       # Array of symbols specifying table names in the current database.
-      def tables
-        dataset(RELATION_QUERY).filter(RELATION_FILTER).map{|r| r[:relname].to_sym}
+      # The dataset used is yielded to the block if one is provided,
+      # otherwise, an array of symbols of table names is returned.  
+      #
+      # Options:
+      # * :schema - The schema to search (default_schema by default)
+      # * :server - The server to use
+      def tables(opts={})
+        ds = self[:pg_class].join(:pg_namespace, :oid=>:relnamespace, 'r'=>:relkind, :nspname=>(opts[:schema]||default_schema).to_s).select(:relname).exclude(:relname.like(SYSTEM_TABLE_REGEXP)).server(opts[:server])
+        block_given? ? yield(ds) : ds.map{|r| r[:relname].to_sym}
       end
       
       # PostgreSQL supports multi-level transactions using save points.
@@ -273,14 +293,14 @@ module Sequel
       # cached, and if the primary key for a table is changed, the
       # @primary_keys instance variable should be reset manually.
       def primary_key_for_table(conn, table)
-        @primary_keys.include?(table) ? @primary_keys[table] : (@primary_keys[table] = conn.primary_key(table))
+        @primary_keys[quote_schema_table(table)] ||= conn.primary_key(*schema_and_table(table))
       end
       
       # Returns primary key for the given table.  This information is
       # cached, and if the primary key for a table is changed, the
       # @primary_keys instance variable should be reset manually.
       def primary_key_sequence_for_table(conn, table)
-        @primary_key_sequences.include?(table) ? @primary_key_sequences[table] : (@primary_key_sequences[table] = conn.sequence(table))
+        @primary_key_sequences[quote_schema_table(table)] ||= conn.sequence(*schema_and_table(table))
       end
       
       # Set the default of the row to NULL if it is blank, and set
@@ -330,7 +350,7 @@ module Sequel
         else
           ds.select_more!(:pg_class__relname___table)
         end
-        ds.join!(:pg_namespace, :oid=>:pg_class__relnamespace, :nspname=>opts[:schema] || 'public') if opts[:schema] || !opts.include?(:schema)
+        ds.join!(:pg_namespace, :oid=>:pg_class__relnamespace, :nspname=>(opts[:schema] || default_schema).to_s) if opts[:schema] || !opts.include?(:schema)
         ds
       end
     end
@@ -401,10 +421,9 @@ module Sequel
       # PostgreSQL specific full text search syntax, using tsearch2 (included
       # in 8.3 by default, and available for earlier versions as an add-on).
       def full_text_search(cols, terms, opts = {})
-        lang = opts[:language] ? "#{literal(opts[:language])}, " : ""
-        cols = cols.is_a?(Array) ? cols.map {|c| literal(c)}.join(" || ") : literal(cols)
-        terms = terms.is_a?(Array) ? literal(terms.join(" | ")) : literal(terms)
-        filter("to_tsvector(#{lang}#{cols}) @@ to_tsquery(#{lang}#{terms})")
+        lang = opts[:language] || 'simple'
+        cols =  Array(cols).map{|x| :COALESCE[x, '']}.sql_string_join(' ')
+        filter("to_tsvector(#{literal(lang)}, #{literal(cols)}) @@ to_tsquery(#{literal(lang)}, #{literal(Array(terms).join(' | '))})")
       end
       
       # Insert given values into the database.

data/lib/sequel_core/core_ext.rb

@@ -52,6 +52,16 @@ class Module
 
   private
 
+  # Define instance method(s) that calls class method(s) of the
+  # same name, caching the result in an instance variable.  Define
+  # standard attr_writer method for modifying that instance variable
+  def class_attr_overridable(*meths)
+    meths.each{|meth| class_eval("def #{meth}; @#{meth}.nil? ? (@#{meth} = self.class.#{meth}) : @#{meth} end")}
+    attr_writer(*meths) 
+    public(*meths) 
+    public(*meths.collect{|m|"#{m}="}) 
+  end
+
   # Define instance method(s) that calls class method(s) of the
   # same name. Replaces the construct:
   #

data/lib/sequel_core/core_sql.rb

@@ -11,6 +11,13 @@ class Array
     ::Sequel::SQL::CaseExpression.new(self, default, expression)
   end
 
+  # Return a Sequel::SQL::Array created from this array.  Used if this array contains
+  # all two pairs and you want it treated as an SQL array instead of a ordered hash-like
+  # conditions.
+  def sql_array
+    ::Sequel::SQL::SQLArray.new(self)
+  end
+
   # Return a Sequel::SQL::BooleanExpression created from this array, matching all of the
   # conditions.
   def sql_expr

data/lib/sequel_core/database.rb

@@ -495,6 +495,11 @@ module Sequel
     def connection_pool_default_options
       {}
     end
+    
+    # Sequel doesn't use database schema's by default.
+    def default_schema
+      nil
+    end
 
     # SQL to ROLLBACK a transaction.
     def rollback_transaction_sql
@@ -512,6 +517,23 @@ module Sequel
         raise exception
       end
     end
+    
+    # Split the schema information from the table
+    def schema_and_table(table_name)
+      case table_name
+      when Symbol
+        s, t, a = dataset.send(:split_symbol, table_name)
+        [s||default_schema, t]
+      when SQL::QualifiedIdentifier
+        [table_name.table, table_name.column]
+      when SQL::Identifier
+        [default_schema, table_name.value]
+      when String
+        [default_schema, table_name]
+      else
+        raise Error, 'table_name should be a Symbol, SQL::QualifiedIdentifier, SQL::Identifier, or String'
+      end
+    end
 
     # Return the options for the given server by merging the generic
     # options for all server with the specific options for the given

data/lib/sequel_core/database/schema.rb

@@ -109,7 +109,7 @@ module Sequel
     #   DB.drop_table(:posts, :comments)
     def drop_table(*names)
       names.each do |n|
-        @schemas.delete(n.to_sym) if @schemas
+        @schemas.delete(n.is_a?(String) ? n.to_sym : n) if @schemas
         execute_ddl(drop_table_sql(n))
       end
     end

data/lib/sequel_core/dataset.rb

@@ -48,7 +48,8 @@ module Sequel
 
     # All methods that should have a ! method added that modifies
     # the receiver.
-    MUTATION_METHODS = %w'and distinct exclude exists filter from from_self full_outer_join graph
+    MUTATION_METHODS = %w'add_graph_aliases and distinct exclude exists
+    filter from from_self full_outer_join graph
     group group_and_count group_by having inner_join intersect invert join
     left_outer_join limit naked or order order_by order_more paginate query reject
     reverse reverse_order right_outer_join select select_all select_more
@@ -190,18 +191,18 @@ module Sequel
       execute_dui(delete_sql(*args))
     end
     
-    # Iterates over the records in the dataset.
+    # Iterates over the records in the dataset and returns set.  If opts
+    # have been passed that modify the columns, reset the column information.
     def each(opts = nil, &block)
-      if @opts[:graph] and !(opts && opts[:graph] == false)
-        graph_each(opts, &block)
-      else
-        row_proc = @row_proc unless opts && opts[:naked]
-        transform = @transform
-        fetch_rows(select_sql(opts)) do |r|
-          r = transform_load(r) if transform
-          r = row_proc[r] if row_proc
-          yield r
+      if opts && opts.keys.any?{|o| COLUMN_CHANGE_OPTS.include?(o)}
+        prev_columns = @columns
+        begin
+          _each(opts, &block)
+        ensure
+          @columns = prev_columns
         end
+      else
+        _each(opts, &block)
       end
       self
     end
@@ -432,6 +433,23 @@ module Sequel
 
     private
     
+    # Runs #graph_each if graphing.  Otherwise, iterates through the records
+    # yielded by #fetch_rows, applying any row_proc or transform if necessary,
+    # and yielding the result.
+    def _each(opts, &block)
+      if @opts[:graph] and !(opts && opts[:graph] == false)
+        graph_each(opts, &block)
+      else
+        row_proc = @row_proc unless opts && opts[:naked]
+        transform = @transform
+        fetch_rows(select_sql(opts)) do |r|
+          r = transform_load(r) if transform
+          r = row_proc[r] if row_proc
+          yield r
+        end
+      end
+    end
+
     # Execute the given SQL on the database using execute.
     def execute(sql, opts={}, &block)
       @db.execute(sql, {:server=>@opts[:server] || :read_only}.merge(opts), &block)

data/lib/sequel_core/dataset/sql.rb

@@ -29,6 +29,11 @@ module Sequel
       as_sql(literal(ae.expression), ae.aliaz)
     end
 
+    # SQL fragment for the SQL array.
+    def array_sql(a)
+      a.empty? ? '(NULL)' : "(#{expression_list(a)})"     
+    end
+
     # SQL fragment for specifying given CaseExpression.
     def case_expression_sql(ce)
       sql = '(CASE '
@@ -363,7 +368,8 @@ module Sequel
     #   * String, Symbol: table
     # * expr - specifies conditions, depends on type:
     #   * Hash, Array with all two pairs - Assumes key (1st arg) is column of joined table (unless already
-    #     qualified), and value (2nd arg) is column of the last joined or primary table.
+    #     qualified), and value (2nd arg) is column of the last joined or primary table (or the
+    #     :implicit_qualifier option).
     #     To specify multiple conditions on a single joined table column, you must use an array.
     #     Uses a JOIN with an ON clause.
     #   * Array - If all members of the array are symbols, considers them as columns and 
@@ -374,13 +380,23 @@ module Sequel
     #   * Everything else - pretty much the same as a using the argument in a call to filter,
     #     so strings are considered literal, symbols specify boolean columns, and blockless
     #     filter expressions can be used. Uses a JOIN with an ON clause.
-    # * table_alias - the name of the table's alias when joining, necessary for joining
-    #   to the same table more than once.  No alias is used by default.
+    # * options - a hash of options, with any of the following keys:
+    #   * :table_alias - the name of the table's alias when joining, necessary for joining
+    #     to the same table more than once.  No alias is used by default.
+    #   * :implicit_qualifer - The name to use for qualifying implicit conditions.  By default,
+    #     the last joined or primary table is used.
     # * block - The block argument should only be given if a JOIN with an ON clause is used,
     #   in which case it yields the table alias/name for the table currently being joined,
     #   the table alias/name for the last joined (or first table), and an array of previous
     #   SQL::JoinClause.
-    def join_table(type, table, expr=nil, table_alias=nil, &block)
+    def join_table(type, table, expr=nil, options={}, &block)
+      if options.is_one_of?(Symbol, String)
+        table_alias = options
+        last_alias = nil 
+      else
+        table_alias = options[:table_alias]
+        last_alias = options[:implicit_qualifier]
+      end
       if Dataset === table
         if table_alias.nil?
           table_alias_num = (@opts[:num_dataset_sources] || 0) + 1
@@ -398,7 +414,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.is_a?(Dataset) ? 't1' : 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)
@@ -470,7 +486,7 @@ module Sequel
       when ::Sequel::SQL::Expression
         v.to_s(self)
       when Array
-        v.all_two_pairs? ? literal(v.sql_expr) : (v.empty? ? '(NULL)' : "(#{expression_list(v)})")
+        v.all_two_pairs? ? literal(v.sql_expr) : array_sql(v)
       when Hash
         literal(v.sql_expr)
       when Time, DateTime
@@ -653,7 +669,11 @@ module Sequel
 
       sql
     end
-    alias_method :sql, :select_sql
+
+    # Same as select_sql, not aliased directly to make subclassing simpler.
+    def sql(*args)
+      select_sql(*args)
+    end
 
     # SQL fragment for specifying subscripts (SQL arrays)
     def subscript_sql(s)

data/lib/sequel_core/migration.rb

@@ -13,7 +13,22 @@ module Sequel
   #     end
   # 
   #     def down
-  #       execute 'DROP TABLE sessions'
+  #       # You can use raw SQL if you need to
+  #       self << 'DROP TABLE sessions'
+  #     end
+  #   end
+  #
+  #   class AlterItems < Sequel::Migration
+  #     def up
+  #       alter_table :items do
+  #         add_column :category, :text, :default => 'ruby'
+  #       end
+  #     end
+  # 
+  #     def down
+  #       alter_table :items do
+  #         drop_column :category
+  #       end  
   #     end
   #   end
   #
@@ -25,7 +40,10 @@ module Sequel
   #
   # See Sequel::Schema::Generator for the syntax to use for creating tables,
   # and Sequel::Schema::AlterTableGenerator for the syntax to use when
-  # altering existing tables.
+  # altering existing tables.  Migrations act as a proxy for the database
+  # given in #apply, so inside #down and #up, you can act as though self
+  # refers to the database.  So you can use any of the Sequel::Database
+  # instance methods directly.
   class Migration
     # Creates a new instance of the migration and sets the @db attribute.
     def initialize(db)