sequel_core 2.1.0 → 2.2.0

data/lib/sequel_core/adapters/sqlite.rb

@@ -116,6 +116,18 @@ module Sequel
         case op[:op]
         when :add_column
           "ALTER TABLE #{table} ADD #{column_definition_sql(op)}"
+        when :add_index
+          index_definition_sql(table, op)
+        when :drop_column
+          columns_str = (schema_parse_table(table, {}).map {|c| c[0] } - (Array === op[:name] ? op[:name] : [op[:name]])).join(",")
+          sql  = "BEGIN TRANSACTION;\n"
+          sql += "CREATE TEMPORARY TABLE #{table}_backup(#{columns_str});\n"
+          sql += "INSERT INTO #{table}_backup SELECT #{columns_str} FROM #{table};\n"
+          sql += "DROP TABLE #{table};\n"
+          sql += "CREATE TABLE #{table}(#{columns_str});\n"
+          sql += "INSERT INTO #{table} SELECT #{columns_str} FROM #{table}_backup;\n"
+          sql += "DROP TABLE #{table}_backup;\n"
+          sql += "COMMIT;\n"
         else
           raise Error, "Unsupported ALTER TABLE operation"
         end

data/lib/sequel_core/core_sql.rb

@@ -139,10 +139,17 @@ class String
   def to_sql
     split("\n").to_sql
   end
+
+  # Returns a Blob that holds the same data as this string. Blobs provide proper
+  # escaping of binary data.
+  def to_blob
+    ::Sequel::SQL::Blob.new self
+  end
 end
 
 class Symbol
   include Sequel::SQL::QualifyingMethods
+  include Sequel::SQL::IdentifierMethods
   include Sequel::SQL::GenericExpressionMethods
 
   # If no argument is given, returns a Sequel::SQL::ColumnAll object specifying all

data/lib/sequel_core/database.rb

@@ -48,8 +48,8 @@ module Sequel
     def initialize(opts = {}, &block)
       @opts = opts
       
-      @quote_identifiers = opts[:quote_identifiers] || @@quote_identifiers
-      @single_threaded = opts[:single_threaded] || @@single_threaded
+      @quote_identifiers = opts.include?(:quote_identifiers) ? opts[:quote_identifiers] : @@quote_identifiers
+      @single_threaded = opts.include?(:single_threaded) ? opts[:single_threaded] : @@single_threaded
       @schemas = nil
       @pool = (@single_threaded ? SingleThreadedPool : ConnectionPool).new(connection_pool_default_options.merge(opts), &block)
       @pool.connection_proc = proc {connect} unless block
@@ -133,25 +133,21 @@ module Sequel
     # Converts a uri to an options hash. These options are then passed
     # to a newly created database object.
     def self.uri_to_options(uri)
-      if uri.is_a?(String)
-        uri = URI.parse(uri)
-      end
+      uri = URI.parse(uri) if uri.is_a?(String)
       # special case for sqlite
-      if uri.scheme == 'sqlite'
-        {
-          :user => uri.user,
+      opts = if uri.scheme == 'sqlite'
+        { :user => uri.user,
           :password => uri.password,
-          :database => (uri.host.nil? && uri.path == '/') ? nil : "#{uri.host}#{uri.path}"
-        }
+          :database => (uri.host.nil? && uri.path == '/') ? nil : "#{uri.host}#{uri.path}" }
       else
-        {
-          :user => uri.user,
+        { :user => uri.user,
           :password => uri.password,
           :host => uri.host,
           :port => uri.port,
-          :database => (m = /\/(.*)/.match(uri.path)) && (m[1])
-        }
+          :database => (m = /\/(.*)/.match(uri.path)) && (m[1]) }
       end
+      uri.query.split('&').collect{|s| s.split('=')}.each{|k,v| opts[k.to_sym] = v} unless uri.query.blank?
+      opts
     end
     
     ### Private Class Methods ###
@@ -427,6 +423,8 @@ module Sequel
           # parse that string using the time class.
           (Time === value ? value.iso8601 : value.to_s).to_sequel_time
         end
+      when :blob
+        value.to_blob
       else
         value
       end

data/lib/sequel_core/dataset.rb

@@ -1,4 +1,4 @@
-%w'callback convenience pagination query schema sequelizer sql'.each do |f|
+%w'callback convenience pagination query schema sql'.each do |f|
   require "sequel_core/dataset/#{f}"
 end
 
@@ -187,7 +187,7 @@ module Sequel
     def clone(opts = {})
       c = super()
       c.opts = @opts.merge(opts)
-      c.instance_variable_set(:@columns, nil) if c.options_overlap(COLUMN_CHANGE_OPTS)
+      c.instance_variable_set(:@columns, nil) if opts.keys.any?{|o| COLUMN_CHANGE_OPTS.include?(o)}
       c
     end
     
@@ -198,7 +198,10 @@ module Sequel
     # If the dataset does not have any rows, this will be an empty array.
     # If you are looking for all columns for a single table, see Schema::SQL#schema.
     def columns
-      single_record unless @columns
+      return @columns if @columns
+      ds = unfiltered.unordered.clone(:distinct => nil)
+      ds.single_record
+      @columns = ds.instance_variable_get(:@columns)
       @columns || []
     end
     

data/lib/sequel_core/dataset/sql.rb

@@ -6,7 +6,7 @@ module Sequel
     COLUMN_REF_RE1 = /\A([\w ]+)__([\w ]+)___([\w ]+)\z/.freeze
     COLUMN_REF_RE2 = /\A([\w ]+)___([\w ]+)\z/.freeze
     COLUMN_REF_RE3 = /\A([\w ]+)__([\w ]+)\z/.freeze
-    COUNT_FROM_SELF_OPTS = [:distinct, :group, :sql]
+    COUNT_FROM_SELF_OPTS = [:distinct, :group, :sql, :limit]
     DATE_FORMAT = "DATE '%Y-%m-%d'".freeze
     N_ARITY_OPERATORS = ::Sequel::SQL::ComplexExpression::N_ARITY_OPERATORS
     NULL = "NULL".freeze
@@ -134,8 +134,9 @@ module Sequel
     # * Sequel::SQL::BooleanExpression - an existing condition expression,
     #   probably created using the Sequel blockless filter DSL.
     #
-    # filter also takes a block, but use of this is discouraged as it requires
-    # ParseTree.  
+    # filter also takes a block, which should return one of the above argument
+    # types, and is treated the same way. If both a block and regular argument
+    # are provided, they get ANDed together.
     #
     # Examples:
     #
@@ -527,7 +528,7 @@ module Sequel
     # SQL fragment for the qualifed identifier, specifying
     # a table and a column (or schema and table).
     def qualified_identifier_sql(qcr)
-      "#{quote_identifier(qcr.table)}.#{quote_identifier(qcr.column)}"
+      [qcr.table, qcr.column].map{|x| x.is_one_of?(SQL::QualifiedIdentifier, SQL::Identifier) ? literal(x) : quote_identifier(x)}.join('.')
     end
 
     # Adds quoting to identifiers (columns and tables). If identifiers are not
@@ -588,7 +589,7 @@ module Sequel
       select_columns = columns ? column_list(columns) : WILDCARD
 
       if distinct = opts[:distinct]
-        distinct_clause = distinct.empty? ? "DISTINCT" : "DISTINCT ON (#{column_list(distinct)})"
+        distinct_clause = distinct.empty? ? "DISTINCT" : "DISTINCT ON (#{expression_list(distinct)})"
         sql = "SELECT #{distinct_clause} #{select_columns}"
       else
         sql = "SELECT #{select_columns}"
@@ -607,7 +608,7 @@ module Sequel
       end
 
       if group = opts[:group]
-        sql << " GROUP BY #{column_list(group)}"
+        sql << " GROUP BY #{expression_list(group)}"
       end
 
       if having = opts[:having]
@@ -615,7 +616,7 @@ module Sequel
       end
 
       if order = opts[:order]
-        sql << " ORDER BY #{column_list(order)}"
+        sql << " ORDER BY #{expression_list(order)}"
       end
 
       if limit = opts[:limit]
@@ -694,7 +695,7 @@ module Sequel
     #
     # Raises an error if the dataset is grouped or includes more
     # than one table.
-    def update_sql(values = {}, opts = nil, &block)
+    def update_sql(values = {}, opts = nil)
       opts = opts ? @opts.merge(opts) : @opts
 
       if opts[:group]
@@ -704,23 +705,19 @@ module Sequel
       end
       
       sql = "UPDATE #{source_list(@opts[:from])} SET "
-      if block
-        sql << block.to_sql(self, :comma_separated => true)
+      set = if values.is_a?(Hash)
+        # 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)}"
+        end.join(COMMA_SEPARATOR)
       else
-        set = if values.is_a?(Hash)
-          # 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)}"
-          end.join(COMMA_SEPARATOR)
-        else
-          # copy values verbatim
-          values
-        end
-        sql << set
+        # copy values verbatim
+        values
       end
+      sql << set
       if where = opts[:where]
         sql << " WHERE #{literal(where)}"
       end
@@ -750,12 +747,18 @@ module Sequel
         WILDCARD
       else
         m = columns.map do |i|
-          i.is_a?(Hash) ? i.map{|kv| "#{literal(kv[0])} AS #{quote_identifier(kv[1])}"} : literal(i)
+          i.is_a?(Hash) ? i.map{|k, v| "#{literal(k)} AS #{quote_identifier(v)}"} : literal(i)
         end
         m.join(COMMA_SEPARATOR)
       end
     end
     
+    # Converts an array of expressions into a comma separated string of
+    # expressions.
+    def expression_list(columns)
+      columns.map{|i| literal(i)}.join(COMMA_SEPARATOR)
+    end
+    
     # SQL fragment based on the expr type.  See #filter.
     def filter_expr(expr = nil, &block)
       expr = nil if expr == []
@@ -774,7 +777,7 @@ module Sequel
           SQL::BooleanExpression.from_value_pairs(expr)
         end
       when Proc
-        Sequel.use_parse_tree ? expr.to_sql(self).lit : filter_expr(expr.call)
+        filter_expr(expr.call(SQL::VirtualRow.new))
       when SQL::NumericExpression, SQL::StringExpression
         raise(Error, "Invalid SQL Expression type: #{expr.inspect}") 
       when Symbol, SQL::Expression

data/lib/sequel_core/object_graph.rb

@@ -31,7 +31,7 @@ module Sequel
     # Arguments:
     # * dataset -  Can be a symbol (specifying a table), another dataset,
     #   or an object that responds to .dataset and yields a symbol or a dataset
-    # * join_conditions - A conditions hash that is passed to the join_table method
+    # * join_conditions - Any condition(s) allowed by join_table.
     # * options -  A hash of graph options.  The following options are currently used:
     #   * :table_alias - The alias to use for the table.  If not specified, doesn't
     #     alias the table.  You will get an error if the the alias (or table) name is
@@ -43,7 +43,8 @@ module Sequel
     #     columns and is like simply joining the tables, though graph keeps
     #     some metadata about join that makes it important to use graph instead
     #     of join.
-    def graph(dataset, join_conditions, options = {})
+    # * block - A block that is passed to join_table.
+    def graph(dataset, join_conditions = nil, options = {}, &block)
       # Allow the use of a model, dataset, or symbol as the first argument
       # Find the table name/dataset based on the argument
       dataset = dataset.dataset if dataset.respond_to?(:dataset)
@@ -68,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)
+      ds = join_table(options[:join_type] || :left_outer, table, join_conditions, table_alias, &block)
       opts = ds.opts
 
       # Whether to include the table in the result set
@@ -87,15 +88,15 @@ module Sequel
         # Associates table alias (the master is never aliased)
         table_aliases = graph[:table_aliases] = {master=>self}
         # Keep track of the alias numbers used
-        ca_num = graph[:column_alias_num] = {}
+        ca_num = graph[:column_alias_num] = Hash.new(0)
         # All columns in the master table are never
         # aliased, but are not included if set_graph_aliases
         # has been used.
         if add_columns
-          select = (opts[:select] ||= [])
+          select = opts[:select] = []
           columns.each do |column|
             column_aliases[column] = [master, column]
-            select.push(:"#{master}__#{column}")
+            select.push(column.qualify(master))
           end
         end
       end
@@ -120,23 +121,19 @@ module Sequel
         # using the next value of N that we know hasn't been
         # used
         cols.each do |column|
-          col_alias, c = if column_aliases[column]
-            tc = :"#{table_alias}_#{column}"
-            if column_aliases[tc]
-              if can = ca_num[tc]
-                ca_num[tc] += 1
-                tc = :"#{tc}_#{can}"
-              else
-                ca_num[tc] = 1
-                tc = :"#{tc}_0"
-             end
+          col_alias, identifier = if column_aliases[column]
+            column_alias = :"#{table_alias}_#{column}"
+            if column_aliases[column_alias]
+              column_alias_num = ca_num[column_alias]
+              column_alias = :"#{column_alias}_#{column_alias_num}" 
+              ca_num[column_alias] += 1
             end
-            [tc, :"#{table_alias}__#{column}___#{tc}"]
+            [column_alias, column.qualify(table_alias).as(column_alias)]
           else
-            [column, :"#{table_alias}__#{column}"]
+            [column, column.qualify(table_alias)]
           end
           column_aliases[col_alias] = [table_alias, column]
-          select.push(c)
+          select.push(identifier)
         end
       end
       ds
@@ -158,8 +155,13 @@ module Sequel
     #   The first element of the array should be the table alias,
     #   and the second should be the actual column name.
     def set_graph_aliases(graph_aliases)
-      ds = select(*graph_aliases.collect{|col_alias, tc| :"#{tc[0]}__#{tc[1]}#{"___#{col_alias}" unless tc[1] == col_alias}"})
-      ds.opts[:graph_aliases]=graph_aliases
+      cols = graph_aliases.collect do |col_alias, tc| 
+        identifier = tc[1].qualify(tc[0])
+        identifier = identifier.as(col_alias) unless tc[1] == col_alias
+        identifier
+      end
+      ds = select(*cols)
+      ds.opts[:graph_aliases] = graph_aliases
       ds
     end
 

data/lib/sequel_core/schema/sql.rb

@@ -227,6 +227,8 @@ module Sequel
       # integer, string, date, datetime, boolean, and float.
       def schema_column_type(db_type)
         case db_type
+        when 'tinyint'
+          Sequel.convert_tinyint_to_bool ? :boolean : :integer
         when /\A(int(eger)?|bigint|smallint)\z/
           :integer
         when /\A(character( varying)?|varchar|text)\z/
@@ -237,12 +239,14 @@ module Sequel
           :datetime
         when /\Atime( with(out)? time zone)?\z/
           :time
-        when /\A(boolean|tinyint)\z/
+        when "boolean"
           :boolean
         when /\A(real|float|double( precision)?)\z/
           :float
         when /\A(numeric|decimal|money)\z/
           :decimal
+        when "bytea"
+          :blob
         end
       end
 

data/lib/sequel_core/sql.rb

@@ -197,6 +197,14 @@ module Sequel
       end
     end
     
+    # Includes a method that returns Identifiers.
+    module IdentifierMethods
+      # Return self wrapped as an identifier.
+      def identifier
+        Identifier.new(self)
+      end
+    end
+
     # This module includes the methods that are defined on objects that can be 
     # used in a numeric or string context in SQL (Symbol, LiteralString, 
     # SQL::Function, and SQL::StringExpression).
@@ -385,7 +393,7 @@ module Sequel
       # a keyword in ruby.
       attr_reader :aliaz
 
-      # default value.
+      # Create an object with the given expression and alias.
       def initialize(expression, aliaz)
         @expression, @aliaz = expression, aliaz
       end
@@ -397,13 +405,25 @@ module Sequel
       end
     end
 
+    # Blob is used to represent binary data in the Ruby environment that is
+    # stored as a blob type in the database. In PostgreSQL, the blob type is 
+    # called bytea. Sequel represents binary data as a Blob object because 
+    # certain database engines, such as PostgreSQL, require binary data to be 
+    # escaped.
+    class Blob < ::String
+      # return self.
+      def to_blob
+        self
+      end
+    end
+
     # Subclass of ComplexExpression where the expression results
     # in a boolean value in SQL.
     class BooleanExpression < ComplexExpression
       include BooleanMethods
       
       # Take pairs of values (e.g. a hash or array of arrays of two pairs)
-      # and converts it to a ComplexExpression.  The operator and args
+      # and converts it to a BooleanExpression.  The operator and args
       # used depends on the case of the right (2nd) argument:
       #
       # * 0..10 - left >= 0 AND left <= 10
@@ -531,6 +551,27 @@ module Sequel
       end
     end
     
+    # Represents an identifier (column or table). Can be used
+    # to specify a Symbol with multiple underscores should not be
+    # split, or for creating an identifier without using a symbol.
+    class Identifier < GenericExpression
+      include QualifyingMethods
+
+      # The table and column to reference
+      attr_reader :value
+
+      # Set the value to the given argument
+      def initialize(value)
+        @value = value
+      end
+      
+      # Delegate the creation of the resulting SQL to the given dataset,
+      # since it may be database dependent.
+      def to_s(ds)
+        ds.quote_identifier(@value)
+      end 
+    end
+    
     # IrregularFunction is used for the SQL EXTRACT and CAST functions,
     # which don't use regular function calling syntax. The IrregularFunction
     # replaces the commas the regular function uses with a custom
@@ -637,10 +678,10 @@ module Sequel
       # The expression to order the result set by.
       attr_reader :expression
 
-      # Whether the expression should order the result set in a descening manner
+      # Whether the expression should order the result set in a descending manner
       attr_reader :descending
 
-      # default value.
+      # Set the expression and descending attributes to the given values.
       def initialize(expression, descending = true)
         @expression, @descending = expression, descending
       end
@@ -727,9 +768,39 @@ module Sequel
         ds.subscript_sql(self)
       end
     end
+
+    # An instance of this class is yielded to the block supplied to filter.
+    # Useful if another library also defines the operator methods that
+    # Sequel defines for symbols.
+    #
+    # Examples:
+    #
+    #   ds = DB[:t]
+    #   ds.filter{|r| r.name < 2} # SELECT * FROM t WHERE (name < 2)
+    #   ds.filter{|r| r.table__column + 1 < 2} # SELECT * FROM t WHERE ((table.column + 1) < 2)
+    #   ds.filter{|r| r.is_active(1, 'arg2')} # SELECT * FROM t WHERE is_active(1, 'arg2')
+    class VirtualRow
+      (instance_methods - %w"__id__ __send__").each{|m| undef_method(m)}
+
+      # Can return Identifiers, QualifiedIdentifiers, or Functions:
+      #
+      # * Function - returned if any arguments are supplied, using the method name
+      #   as the function name, and the arguments as the function arguments.
+      # * QualifiedIdentifier - returned if the method name contains __, with the
+      #   table being the part before __, and the column being the part after.
+      # * Identifier - returned otherwise, using the method name.
+      def method_missing(m, *args)
+        if args.empty?
+          table, column = m.to_s.split('__', 2)
+          column ? QualifiedIdentifier.new(table, column) : Identifier.new(m)
+        else
+          Function.new(m, *args)
+        end
+      end
+    end
   end
 
-  # LiteralString is used to represent literal SQL expressions. An 
+  # LiteralString is used to represent literal SQL expressions. A 
   # LiteralString is copied verbatim into an SQL statement. Instances of
   # LiteralString can be created by calling String#lit.
   # LiteralStrings can use all of the SQL::ColumnMethods and the