sequel 2.10.0 → 2.11.0

data/lib/sequel_core/adapters/sqlite.rb

@@ -52,6 +52,9 @@ module Sequel
         db.translator.add_translator("real", &prok)
         db.translator.add_translator("double precision", &prok)
         
+        # Handle blob values with Sequel::SQL::Blob
+        db.translator.add_translator("blob"){|t,v| ::Sequel::SQL::Blob.new(v)}
+        
         db
       end
       
@@ -156,7 +159,7 @@ module Sequel
         # SQLite uses a : before the name of the argument for named
         # arguments.
         def prepared_arg(k)
-          "#{prepared_arg_placeholder}#{k}".lit
+          LiteralString.new("#{prepared_arg_placeholder}#{k}")
         end
       end
       
@@ -211,23 +214,6 @@ module Sequel
         end
       end
       
-      # Use the ISO format for dates and timestamps, and quote strings
-      # using the ::SQLite3::Database.quote method.
-      def literal(v)
-        case v
-        when LiteralString
-          v
-        when String
-          "'#{::SQLite3::Database.quote(v)}'"
-        when Time
-          literal(v.iso8601)
-        when Date, DateTime
-          literal(v.to_s)
-        else
-          super
-        end
-      end
-      
       # Prepare the given type of query with the given name and store
       # it in the database.  Note that a new native prepared statement is
       # created on each call to this prepared statement.
@@ -240,6 +226,10 @@ module Sequel
       
       private
       
+      def literal_string(v)
+        "'#{::SQLite3::Database.quote(v)}'"
+      end
+
       # SQLite uses a : before the name of the argument as a placeholder.
       def prepared_arg_placeholder
         PREPARED_ARG_PLACEHOLDER

data/lib/sequel_core/adapters/utils/date_format.rb

@@ -0,0 +1,21 @@
+# Module containing overrides for Sequel's standard date/time literalization
+# to use the SQL standrd.  The SQL standard is used by fewer databases than
+# the defacto standard (which is just a normal string).
+module Sequel::Dataset::SQLStandardDateFormat
+  private
+
+  # Use SQL standard syntax for Date
+  def literal_date(v)
+    v.strftime("DATE '%Y-%m-%d'") 
+  end
+    
+  # Use SQL standard syntax for DateTime
+  def literal_datetime(v)
+    v.strftime("TIMESTAMP '%Y-%m-%d %H:%M:%S'")
+  end
+
+  # Use SQL standard syntax for Time
+  def literal_time(v)
+    v.strftime("TIMESTAMP '%Y-%m-%d %H:%M:%S'")
+  end
+end

data/lib/sequel_core/core_ext.rb

@@ -56,7 +56,7 @@ class Module
   # 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")}
+    meths.each{|meth| class_eval("def #{meth}; !defined?(@#{meth}) ? (@#{meth} = self.class.#{meth}) : @#{meth} end")}
     attr_writer(*meths) 
     public(*meths) 
     public(*meths.collect{|m|"#{m}="}) 

data/lib/sequel_core/core_sql.rb

@@ -121,7 +121,7 @@ class String
   include Sequel::SQL::AliasMethods
   include Sequel::SQL::CastMethods
 
-  # Converts a string into an LiteralString, in order to override string
+  # Converts a string into a Sequel::LiteralString, in order to override string
   # literalization, e.g.:
   #
   #   DB[:items].filter(:abc => 'def').sql #=>
@@ -130,8 +130,12 @@ class String
   #   DB[:items].filter(:abc => 'def'.lit).sql #=>
   #     "SELECT * FROM items WHERE (abc = def)"
   #
-  def lit
-    Sequel::LiteralString.new(self)
+  # You can also provide arguments, to create a Sequel::SQL::PlaceholderLiteralString:
+  #
+  #    DB[:items].select{|o| o.count('DISTINCT ?'.lit(:a))}.sql #=>
+  #      "SELECT count(DISTINCT a) FROM items"
+  def lit(*args)
+    args.empty? ? Sequel::LiteralString.new(self) : Sequel::SQL::PlaceholderLiteralString.new(self, args)
   end
   alias_method :expr, :lit
   
@@ -149,9 +153,10 @@ class String
 
   # Returns a Blob that holds the same data as this string. Blobs provide proper
   # escaping of binary data.
-  def to_blob
+  def to_sequel_blob
     ::Sequel::SQL::Blob.new self
   end
+  alias to_blob to_sequel_blob
 end
 
 class Symbol

data/lib/sequel_core/database.rb

@@ -75,6 +75,9 @@ module Sequel
       @default_schema = opts.include?(:default_schema) ? opts[:default_schema] : default_schema_default
       @prepared_statements = {}
       @transactions = []
+      @identifier_input_method = nil
+      @identifier_output_method = nil
+      @quote_identifiers = nil
       if opts.include?(:upcase_identifiers)
         @identifier_input_method = opts[:upcase_identifiers] ? :upcase : ""
       end
@@ -492,73 +495,71 @@ module Sequel
     # is invalid.
     def typecast_value(column_type, value)
       return nil if value.nil?
-      case column_type
-      when :integer
-        begin
+      begin
+        case column_type
+        when :integer
           Integer(value)
-        rescue ArgumentError => e
-          raise Sequel::Error::InvalidValue, e.message.inspect
-        end
-      when :string
-        value.to_s
-      when :float
-        begin
+        when :string
+          value.to_s
+        when :float
           Float(value)
-        rescue ArgumentError => e
-          raise Sequel::Error::InvalidValue, e.message.inspect
-        end
-      when :decimal
-        case value
-        when BigDecimal
-          value
-        when String, Float
-          value.to_d
-        when Integer
-          value.to_s.to_d
-        else
-          raise Sequel::Error::InvalidValue, "invalid value for BigDecimal: #{value.inspect}"
-        end
-      when :boolean
-        case value
-        when false, 0, "0", /\Af(alse)?\z/i
-          false
-        else
-          value.blank? ? nil : true
-        end
-      when :date
-        case value
-        when Date
-          value
-        when DateTime, Time
-          Date.new(value.year, value.month, value.day)
-        when String
-          value.to_date
-        else
-          raise Sequel::Error::InvalidValue, "invalid value for Date: #{value.inspect}"
-        end
-      when :time
-        case value
-        when Time
-          value
-        when String
-          value.to_time
+        when :decimal
+          case value
+          when BigDecimal
+            value
+          when String, Float
+            value.to_d
+          when Integer
+            value.to_s.to_d
+          else
+            raise Sequel::Error::InvalidValue, "invalid value for BigDecimal: #{value.inspect}"
+          end
+        when :boolean
+          case value
+          when false, 0, "0", /\Af(alse)?\z/i
+            false
+          else
+            value.blank? ? nil : true
+          end
+        when :date
+          case value
+          when Date
+            value
+          when DateTime, Time
+            Date.new(value.year, value.month, value.day)
+          when String
+            value.to_date
+          else
+            raise Sequel::Error::InvalidValue, "invalid value for Date: #{value.inspect}"
+          end
+        when :time
+          case value
+          when Time
+            value
+          when String
+            value.to_time
+          else
+            raise Sequel::Error::InvalidValue, "invalid value for Time: #{value.inspect}"
+          end
+        when :datetime
+          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
+          else
+            # First convert it to standard ISO 8601 time, then
+            # parse that string using the time class.
+            (Time === value ? value.iso8601 : value.to_s).to_sequel_time
+          end
+        when :blob
+          ::Sequel::SQL::Blob.new(value)
         else
-          raise Sequel::Error::InvalidValue, "invalid value for Time: #{value.inspect}"
-        end
-      when :datetime
-        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
-        else
-          # First convert it to standard ISO 8601 time, then
-          # 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
+      rescue ArgumentError => exp
+        e = Sequel::Error::InvalidValue.new("#{exp.class} #{exp.message}")
+        e.set_backtrace(exp.backtrace)
+        raise e
       end
     end
     

data/lib/sequel_core/dataset.rb

@@ -1,4 +1,4 @@
-%w'callback convenience pagination prepared_statements query schema sql unsupported'.each do |f|
+%w'callback convenience pagination prepared_statements query schema sql'.each do |f|
   require "sequel_core/dataset/#{f}"
 end
 
@@ -54,7 +54,7 @@ module Sequel
     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
     set_defaults set_graph_aliases set_model set_overrides sort sort_by
-    unfiltered union unordered where'.collect{|x| x.to_sym}
+    unfiltered union unordered where with_sql'.collect{|x| x.to_sym}
 
     NOTIMPL_MSG = "This method must be overridden in Sequel adapters".freeze
     STOCK_TRANSFORMS = {
@@ -467,6 +467,11 @@ module Sequel
       end
     end
 
+    # Set the server to use to :default unless it is already set in the passed opts
+    def default_server_opts(opts)
+      {:server=>@opts[:server] || :default}.merge(opts)
+    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)
@@ -474,12 +479,12 @@ module Sequel
     
     # Execute the given SQL on the database using execute_dui.
     def execute_dui(sql, opts={}, &block)
-      @db.execute_dui(sql, {:server=>@opts[:server] || :default}.merge(opts), &block)
+      @db.execute_dui(sql, default_server_opts(opts), &block)
     end
     
     # Execute the given SQL on the database using execute_insert.
     def execute_insert(sql, opts={}, &block)
-      @db.execute_insert(sql, {:server=>@opts[:server] || :default}.merge(opts), &block)
+      @db.execute_insert(sql, default_server_opts(opts), &block)
     end
     
     # Modify the identifier returned from the database based on the

data/lib/sequel_core/dataset/convenience.rb

@@ -1,7 +1,7 @@
 module Sequel
   class Dataset
     COMMA_SEPARATOR = ', '.freeze
-    COUNT_OF_ALL_AS_COUNT = SQL::Function.new(:count, '*'.lit).as(:count)
+    COUNT_OF_ALL_AS_COUNT = SQL::Function.new(:count, LiteralString.new('*'.freeze)).as(:count)
 
     # Returns the first record matching the conditions.
     def [](*conditions)
@@ -16,7 +16,7 @@ module Sequel
 
     # Returns the average value for the given column.
     def avg(column)
-      get(SQL::Function.new(:avg, column))
+      get{|o| o.avg(column)}
     end
     
     # Returns true if no records exists in the dataset
@@ -61,8 +61,9 @@ module Sequel
     end
 
     # Return the column value for the first matching record in the dataset.
-    def get(column)
-      select(column).single_value
+    def get(column=nil, &block)
+      raise(Error, 'must provide argument or block to Dataset#get, not both') if column && block
+      (column ? select(column) : select(&block)).single_value
     end
 
     # Returns a dataset grouped by the given column with count by group.
@@ -73,7 +74,7 @@ module Sequel
     # Returns the interval between minimum and maximum values for the given 
     # column.
     def interval(column)
-      get("(max(#{literal(column)}) - min(#{literal(column)}))".lit)
+      get{|o| o.max(column) - o.min(column)}
     end
 
     # Reverses the order and then runs first.  Note that this
@@ -97,12 +98,12 @@ module Sequel
 
     # Returns the maximum value for the given column.
     def max(column)
-      get(SQL::Function.new(:max, column))
+      get{|o| o.max(column)}
     end
 
     # Returns the minimum value for the given column.
     def min(column)
-      get(SQL::Function.new(:min, column))
+      get{|o| o.min(column)}
     end
 
     # Inserts multiple records into the associated table. This method can be
@@ -170,7 +171,7 @@ module Sequel
     # Returns a Range object made from the minimum and maximum values for the
     # given column.
     def range(column)
-      if r = select(SQL::Function.new(:min, column).as(:v1), SQL::Function.new(:max, column).as(:v2)).first
+      if r = select{|o| [o.min(column).as(:v1), o.max(column).as(:v2)]}.first
         (r[:v1]..r[:v2])
       end
     end
@@ -191,7 +192,7 @@ module Sequel
     
     # Returns the sum for the given column.
     def sum(column)
-      get(SQL::Function.new(:sum, column))
+      get{|o| o.sum(column)}
     end
 
     # Returns true if the table exists.  Will raise an error

data/lib/sequel_core/dataset/prepared_statements.rb

@@ -1,6 +1,6 @@
 module Sequel 
   class Dataset
-    PREPARED_ARG_PLACEHOLDER = '?'.lit.freeze
+    PREPARED_ARG_PLACEHOLDER = LiteralString.new('?').freeze
     
     # Default implementation of the argument mapper to allow
     # native database support for bind variables and prepared

data/lib/sequel_core/dataset/sql.rb

@@ -7,13 +7,11 @@ 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]
-    DATE_FORMAT = "DATE '%Y-%m-%d'".freeze
     N_ARITY_OPERATORS = ::Sequel::SQL::ComplexExpression::N_ARITY_OPERATORS
     NULL = "NULL".freeze
     QUESTION_MARK = '?'.freeze
-    STOCK_COUNT_OPTS = {:select => ["COUNT(*)".lit], :order => nil}.freeze
+    STOCK_COUNT_OPTS = {:select => [LiteralString.new("COUNT(*)").freeze], :order => nil}.freeze
     SELECT_CLAUSE_ORDER = %w'distinct columns from join where group having compounds order limit'.freeze
-    TIMESTAMP_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S'".freeze
     TWO_ARITY_OPERATORS = ::Sequel::SQL::ComplexExpression::TWO_ARITY_OPERATORS
     WILDCARD = '*'.freeze
 
@@ -45,6 +43,11 @@ module Sequel
       sql << "ELSE #{literal(ce.default)} END)"
     end
 
+    # SQL fragment for the SQL CAST expression.
+    def cast_sql(expr, type)
+      "CAST(#{literal(expr)} AS #{db.send(:type_literal_base, :type=>type)})"
+    end
+
     # SQL fragment for specifying all columns in a given table.
     def column_all_sql(ca)
       "#{quote_schema_table(ca.table)}.*"
@@ -126,7 +129,7 @@ module Sequel
     #   DB.select(1).where(DB[:items].exists).sql
     #   #=> "SELECT 1 WHERE EXISTS (SELECT * FROM items)"
     def exists(opts = nil)
-      "EXISTS (#{select_sql(opts)})".lit
+      LiteralString.new("EXISTS (#{select_sql(opts)})")
     end
 
     # Returns a copy of the dataset with the given conditions imposed upon it.  
@@ -184,8 +187,7 @@ module Sequel
     alias_method :where, :filter
 
     # The first source (primary table) for this dataset.  If the dataset doesn't
-    # have a table, raises an error.  If the table is aliased, returns the actual
-    # table name, not the alias.
+    # have a table, raises an error.  If the table is aliased, returns the aliased name.
     def first_source
       source = @opts[:from]
       if source.nil? || source.empty?
@@ -464,38 +466,39 @@ module Sequel
     # If an unsupported object is given, an exception is raised.
     def literal(v)
       case v
-      when LiteralString
-        v
       when String
-        "'#{v.gsub(/\\/, "\\\\\\\\").gsub(/'/, "''")}'"
-      when Integer, Float
-        v.to_s
+        return v if v.is_a?(LiteralString)
+        v.is_a?(SQL::Blob) ? literal_blob(v) : literal_string(v)
+      when Symbol
+        literal_symbol(v)
+      when Integer
+        literal_integer(v)
+      when Hash
+        literal_hash(v)
+      when SQL::Expression
+        literal_expression(v)
+      when Float
+        literal_float(v)
       when BigDecimal
-        d = v.to_s("F")
-        d = "'#{d}'" if v.nan? || v.infinite?
-        d
+        literal_big_decimal(v)
       when NilClass
         NULL
       when TrueClass
-        BOOL_TRUE
+        literal_true
       when FalseClass
-        BOOL_FALSE
-      when Symbol
-        symbol_to_column_ref(v)
-      when ::Sequel::SQL::Expression
-        v.to_s(self)
+        literal_false
       when Array
-        v.all_two_pairs? ? literal(v.sql_expr) : array_sql(v)
-      when Hash
-        literal(v.sql_expr)
-      when Time, DateTime
-        v.strftime(TIMESTAMP_FORMAT)
+        literal_array(v)
+      when Time
+        literal_time(v)
+      when DateTime
+        literal_datetime(v)
       when Date
-        v.strftime(DATE_FORMAT)
+        literal_date(v)
       when Dataset
-        "(#{subselect_sql(v)})"
+        literal_dataset(v)
       else
-        raise Error, "can't express #{v.inspect} as a SQL literal"
+        literal_other(v)
       end
     end
 
@@ -537,15 +540,17 @@ module Sequel
     #   ds.order(:name.asc).sql #=> 'SELECT * FROM items ORDER BY name ASC'
     #   ds.order(:arr|1).sql #=> 'SELECT * FROM items ORDER BY arr[1]'
     #   ds.order(nil).sql #=> 'SELECT * FROM items'
-    def order(*order)
-      clone(:order => (order.compact.empty?) ? nil : order)
+    def order(*columns)
+      columns += Array((yield SQL::VirtualRow.new)) if block_given?
+      clone(:order => (columns.compact.empty?) ? nil : columns)
     end
     alias_method :order_by, :order
     
     # Returns a copy of the dataset with the order columns added
     # to the existing order.
-    def order_more(*order)
-      order(*((@opts[:order] || []) + order))
+    def order_more(*columns)
+      columns += Array((yield SQL::VirtualRow.new)) if block_given?
+      order(*((@opts[:order] || []) + columns))
     end
     
     # SQL fragment for the ordered expression, used in the ORDER BY
@@ -621,6 +626,7 @@ module Sequel
     # Returns a copy of the dataset with the columns selected changed
     # to the given columns.
     def select(*columns)
+      columns += Array((yield SQL::VirtualRow.new)) if block_given?
       clone(:select => columns)
     end
     
@@ -632,6 +638,7 @@ module Sequel
     # Returns a copy of the dataset with the given columns added
     # to the existing selected columns.
     def select_more(*columns)
+      columns += Array((yield SQL::VirtualRow.new)) if block_given?
       select(*((@opts[:select] || []) + columns))
     end
     
@@ -666,9 +673,7 @@ module Sequel
     #   :items__abc___a.to_column_ref(ds) #=> "items.abc AS a"
     #
     def symbol_to_column_ref(sym)
-      c_table, column, c_alias = split_symbol(sym)
-      qc = "#{"#{quote_identifier(c_table)}." if c_table}#{quote_identifier(column)}"
-      c_alias ? as_sql(qc, c_alias) : qc
+      literal_symbol(sym)
     end
 
     # Returns a copy of the dataset with no filters (HAVING or WHERE clause) applied.
@@ -737,6 +742,12 @@ module Sequel
       sql
     end
 
+    # Returns a copy of the dataset with the static SQL used.  This is useful if you want
+    # to keep the same row_proc/transform/graph, but change the SQL used to custom SQL.
+    def with_sql(sql)
+      clone(:sql=>sql)
+    end
+
     [:inner, :full_outer, :right_outer, :left_outer].each do |jtype|
       class_eval("def #{jtype}_join(*args, &block); join_table(:#{jtype}, *args, &block) end")
     end
@@ -808,7 +819,7 @@ module Sequel
       when TrueClass, FalseClass
         SQL::BooleanExpression.new(:NOOP, expr)
       when String
-        "(#{expr})".lit
+        LiteralString.new("(#{expr})")
       else
         raise(Error, 'Invalid filter argument')
       end
@@ -849,6 +860,89 @@ module Sequel
       "#{join_type.to_s.gsub('_', ' ').upcase} JOIN"
     end
 
+    # SQL fragment for Array.  Treats as an expression if an array of all two pairs, or as a SQL array otherwise.
+    def literal_array(v)
+      v.all_two_pairs? ? literal_expression(v.sql_expr) : array_sql(v)
+    end
+
+    # SQL fragment for BigDecimal
+    def literal_big_decimal(v)
+      d = v.to_s("F")
+      v.nan? || v.infinite? ?  "'#{d}'" : d
+    end
+
+    # SQL fragment for SQL::Blob
+    def literal_blob(v)
+      literal_string(v)
+    end
+
+    # SQL fragment for Dataset.  Does a subselect inside parantheses.
+    def literal_dataset(v)
+      "(#{subselect_sql(v)})"
+    end
+
+    # SQL fragment for Date, using the ISO8601 format.
+    def literal_date(v)
+      "'#{v}'"
+    end
+
+    # SQL fragment for DateTime, using the ISO8601 format.
+    def literal_datetime(v)
+      "'#{v}'"
+    end
+
+    # SQL fragment for SQL::Expression, result depends on the specific type of expression.
+    def literal_expression(v)
+      v.to_s(self)
+    end
+
+    # SQL fragment for false
+    def literal_false
+      BOOL_FALSE
+    end
+
+    # SQL fragment for Float
+    def literal_float(v)
+      v.to_s
+    end
+
+    # SQL fragment for Hash, treated as an expression
+    def literal_hash(v)
+      literal_expression(v.sql_expr)
+    end
+
+    # SQL fragment for Integer
+    def literal_integer(v)
+      v.to_s
+    end
+
+    # SQL fragmento for a type of object not handled by Dataset#literal.  Raises an error.  If a database specific type is allowed, this should be overriden in a subclass.
+    def literal_other(v)
+      raise Error, "can't express #{v.inspect} as a SQL literal"
+    end
+
+    # SQL fragment for String.  Doubles \ and ' by default.
+    def literal_string(v)
+      "'#{v.gsub(/\\/, "\\\\\\\\").gsub(/'/, "''")}'"
+    end
+
+    # SQL fragment for Symbol, treated as an identifier, possibly aliased and/or qualified.
+    def literal_symbol(v)
+      c_table, column, c_alias = split_symbol(v)
+      qc = "#{"#{quote_identifier(c_table)}." if c_table}#{quote_identifier(column)}"
+      c_alias ? as_sql(qc, c_alias) : qc
+    end
+
+    # SQL fragment for Time, uses the ISO8601 format.
+    def literal_time(v)
+      "'#{v.iso8601}'"
+    end
+
+    # SQL fragment for true.
+    def literal_true
+      BOOL_TRUE
+    end
+
     # Returns a qualified column name (including a table name) if the column
     # name isn't already qualified.
     def qualified_column_name(column, table)