sequel 2.10.0 → 2.11.0

data/lib/sequel_core/adapters/openbase.rb

@@ -37,17 +37,6 @@ module Sequel
     end
     
     class Dataset < Sequel::Dataset
-      def literal(v)
-        case v
-        when Time
-          literal(v.iso8601)
-        when Date, DateTime
-          literal(v.to_s)
-        else
-          super
-        end
-      end
-
       def fetch_rows(sql)
         execute(sql) do |result|
           begin

data/lib/sequel_core/adapters/oracle.rb

@@ -78,15 +78,6 @@ module Sequel
     class Dataset < Sequel::Dataset
       include DatasetMethods
 
-      def literal(v)
-        case v
-        when OraDate
-          literal(Time.local(*v.to_a))
-        else
-          super
-        end
-      end
-
       def fetch_rows(sql, &block)
         execute(sql) do |cursor|
           begin
@@ -102,6 +93,17 @@ module Sequel
         end
         self
       end
+
+      private
+
+      def literal_other(v)
+        case v
+        when OraDate
+          literal_time(Time.local(*v.to_a))
+        else
+          super
+        end
+      end
     end
   end
 end

data/lib/sequel_core/adapters/postgres.rb

@@ -85,7 +85,7 @@ module Sequel
     # Hash with integer keys and proc values for converting PostgreSQL types.
     PG_TYPES = {
       16 => lambda{ |s| s == 't' }, # boolean
-      17 => lambda{ |s| Adapter.unescape_bytea(s).to_blob }, # bytea
+      17 => lambda{ |s| ::Sequel::SQL::Blob.new(Adapter.unescape_bytea(s)) }, # bytea
       20 => lambda{ |s| s.to_i }, # int8
       21 => lambda{ |s| s.to_i }, # int2
       22 => lambda{ |s| s.to_i }, # int2vector
@@ -326,23 +326,9 @@ module Sequel
         end
       end
 
-      # Literalize strings and blobs using code from the native adapter.
-      def literal(v)
-        case v
-        when LiteralString
-          v
-        when SQL::Blob
-          db.synchronize{|c| "'#{c.escape_bytea(v)}'"}
-        when String
-          db.synchronize{|c| "'#{c.escape_string(v)}'"}
-        else
-          super
-        end
-      end
-      
       if SEQUEL_POSTGRES_USES_PG
         
-        PREPARED_ARG_PLACEHOLDER = '$'.lit.freeze
+        PREPARED_ARG_PLACEHOLDER = LiteralString.new('$').freeze
         
         # PostgreSQL specific argument mapper used for mapping the named
         # argument hash to a array with numbered arguments.  Only used with
@@ -373,7 +359,7 @@ module Sequel
               @prepared_args << y
               i = @prepared_args.length
             end
-            "#{prepared_arg_placeholder}#{i}#{"::#{type}" if type}".lit
+            LiteralString.new("#{prepared_arg_placeholder}#{i}#{"::#{type}" if type}")
           end
         end
 
@@ -451,6 +437,17 @@ module Sequel
           PREPARED_ARG_PLACEHOLDER
         end
       end
+      
+      private
+
+      def literal_blob(v)
+        db.synchronize{|c| "'#{c.escape_bytea(v)}'"}
+      end
+
+      def literal_string(v)
+        db.synchronize{|c| "'#{c.escape_string(v)}'"}
+      end
+
     end
   end
 end

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

@@ -1,3 +1,5 @@
+require 'sequel_core/adapters/utils/unsupported'
+
 module Sequel
   module MSSQL
     module DatabaseMethods
@@ -52,21 +54,6 @@ module Sequel
         filter("CONTAINS (#{literal(cols)}, #{literal(terms)})")
       end
       
-      def literal(v)
-        case v
-        when LiteralString
-          v
-        when String
-          "N#{super}"
-        when Time
-          literal(v.iso8601)
-        when Date, DateTime
-          literal(v.to_s)
-        else
-          super
-        end
-      end
-
       def multi_insert_sql(columns, values)
         values = values.map {|r| "SELECT #{expression_list(r)}" }.join(" UNION ALL ")
         ["INSERT INTO #{source_list(@opts[:from])} (#{identifier_list(columns)}) #{values}"]
@@ -83,6 +70,10 @@ module Sequel
 
       private
 
+      def literal_string(v)
+        "N#{super}"
+      end
+
       def select_clause_order
         SELECT_CLAUSE_ORDER
       end

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

@@ -1,3 +1,5 @@
+require 'sequel_core/adapters/utils/unsupported'
+
 module Sequel
   module Schema
     module SQL
@@ -146,8 +148,15 @@ module Sequel
 
       BOOL_TRUE = '1'.freeze
       BOOL_FALSE = '0'.freeze
+      CAST_TYPES = {String=>:CHAR, Integer=>:SIGNED, Time=>:DATETIME, DateTime=>:DATETIME, Numeric=>:DECIMAL, BigDecimal=>:DECIMAL, File=>:BINARY}
+      TIMESTAMP_FORMAT = "'%Y-%m-%d %H:%M:%S'".freeze
       COMMA_SEPARATOR = ', '.freeze
       
+      # MySQL can't use the varchar type in a cast.
+      def cast_sql(expr, type)
+        "CAST(#{literal(expr)} AS #{CAST_TYPES[type] || db.send(:type_literal_base, :type=>type)})"
+      end
+
       # MySQL specific syntax for LIKE/REGEXP searches, as well as
       # string concatenation.
       def complex_expression_sql(op, args)
@@ -224,20 +233,6 @@ module Sequel
         end
       end
       
-      # Override the default boolean values.
-      def literal(v)
-        case v
-        when true
-          BOOL_TRUE
-        when false
-          BOOL_FALSE
-        when DateTime, Time
-          v.strftime("'%Y-%m-%d %H:%M:%S'")
-        else
-          super
-        end
-      end
-      
       # MySQL specific syntax for inserting multiple values at once.
       def multi_insert_sql(columns, values)
         values = values.map {|r| literal(Array(r))}.join(COMMA_SEPARATOR)
@@ -307,6 +302,26 @@ module Sequel
 
       private
 
+      # Use MySQL Timestamp format
+      def literal_datetime(v)
+        v.strftime(TIMESTAMP_FORMAT)
+      end
+
+      # Use 0 for false on MySQL
+      def literal_false
+        BOOL_FALSE
+      end
+
+      # Use MySQL Timestamp format
+      def literal_time(v)
+        v.strftime(TIMESTAMP_FORMAT)
+      end
+
+      # Use 1 for true on MySQL
+      def literal_true
+        BOOL_TRUE
+      end
+      
       # MySQL doesn't support DISTINCT ON
       def select_distinct_sql(sql, opts)
         if opts[:distinct]

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

@@ -1,3 +1,6 @@
+require 'sequel_core/adapters/utils/date_format'
+require 'sequel_core/adapters/utils/unsupported'
+
 module Sequel
   module Oracle
     module DatabaseMethods
@@ -13,6 +16,7 @@ module Sequel
     
     module DatasetMethods
       include Dataset::UnsupportedIntersectExceptAll
+      include Dataset::SQLStandardDateFormat
 
       SELECT_CLAUSE_ORDER = %w'distinct columns from join where group having compounds order limit'.freeze
 

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

@@ -161,7 +161,7 @@ module Sequel
     
     # Methods shared by Database instances that connect to PostgreSQL.
     module DatabaseMethods
-      PREPARED_ARG_PLACEHOLDER = '$'.lit.freeze
+      PREPARED_ARG_PLACEHOLDER = LiteralString.new('$').freeze
       RE_CURRVAL_ERROR = /currval of sequence "(.*)" is not yet defined in this session|relation "(.*)" does not exist/.freeze
       SQL_BEGIN = 'BEGIN'.freeze
       SQL_SAVEPOINT = 'SAVEPOINT autopoint_%d'.freeze
@@ -333,9 +333,7 @@ module Sequel
       
       # Dataset containing all current database locks 
       def locks
-        dataset.from(:pg_class, :pg_locks).
-          select(:pg_class__relname, :pg_locks.*).
-          filter(:pg_class__relfilenode=>:pg_locks__relation)
+        dataset.from(:pg_class).join(:pg_locks, :relation=>:relfilenode).select(:pg_class__relname, Sequel::SQL::ColumnAll.new(:pg_locks))
       end
       
       # Return primary key for the given table.
@@ -552,6 +550,7 @@ module Sequel
       FOR_SHARE = ' FOR SHARE'.freeze
       FOR_UPDATE = ' FOR UPDATE'.freeze
       LOCK = 'LOCK TABLE %s IN %s MODE'.freeze
+      NULL = LiteralString.new('NULL').freeze
       PG_TIMESTAMP_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S".freeze
       QUERY_PLAN = 'QUERY PLAN'.to_sym
       ROW_EXCLUSIVE = 'ROW EXCLUSIVE'.freeze
@@ -614,7 +613,7 @@ module Sequel
       # Insert given values into the database.
       def insert(*values)
         if !@opts[:sql] and server_version >= 80200
-          single_value(:sql=>insert_returning_pk_sql(*values))
+          single_value(default_server_opts(:sql=>insert_returning_pk_sql(*values)))
         else
           execute_insert(insert_sql(*values), :table=>opts[:from].first,
             :values=>values.size == 1 ? values.first : values)
@@ -628,32 +627,9 @@ module Sequel
 
       # Insert a record returning the record inserted
       def insert_select(*values)
-        single_record(:naked=>true, :sql=>insert_returning_sql(nil, *values)) if server_version >= 80200
+        single_record(default_server_opts(:naked=>true, :sql=>insert_returning_sql(nil, *values))) if server_version >= 80200
       end
 
-      # Handle microseconds for Time and DateTime values, as well as PostgreSQL
-      # specific boolean values and string escaping.
-      def literal(v)
-        case v
-        when LiteralString
-          v
-        when SQL::Blob
-          "'#{v.gsub(/[\000-\037\047\134\177-\377]/){|b| "\\#{("%o" % b[0..1].unpack("C")[0]).rjust(3, '0')}"}}'"
-        when String
-          "'#{v.gsub("'", "''")}'"
-        when Time
-          "#{v.strftime(PG_TIMESTAMP_FORMAT)}.#{sprintf("%06d",v.usec)}'"
-        when DateTime
-          "#{v.strftime(PG_TIMESTAMP_FORMAT)}.#{sprintf("%06d", (v.sec_fraction * 86400000000).to_i)}'"
-        when TrueClass
-          BOOL_TRUE
-        when FalseClass
-          BOOL_FALSE
-        else
-          super
-        end
-      end
-      
       # Locks the table with the specified mode.
       def lock(mode, server=nil)
         sql = LOCK % [source_list(@opts[:from]), mode]
@@ -678,17 +654,36 @@ module Sequel
       
       private
       
-      # Call execute_insert on the database object with the given values.
-      def execute_insert(sql, opts={})
-        @db.execute_insert(sql, {:server=>@opts[:server] || :default}.merge(opts))
-      end
-
       # Use the RETURNING clause to return the primary key of the inserted record, if it exists
       def insert_returning_pk_sql(*values)
         pk = db.primary_key(opts[:from].first)
-        insert_returning_sql(pk ? Sequel::SQL::Identifier.new(pk) : 'NULL'.lit, *values)
+        insert_returning_sql(pk ? Sequel::SQL::Identifier.new(pk) : NULL, *values)
       end
       
+      def literal_blob(v)
+        "'#{v.gsub(/[\000-\037\047\134\177-\377]/){|b| "\\#{("%o" % b[0..1].unpack("C")[0]).rjust(3, '0')}"}}'"
+      end
+
+      def literal_datetime(v)
+        "#{v.strftime(PG_TIMESTAMP_FORMAT)}.#{sprintf("%06d", (v.sec_fraction * 86400000000).to_i)}'"
+      end
+
+      def literal_false
+        BOOL_FALSE
+      end
+
+      def literal_string(v)
+        "'#{v.gsub("'", "''")}'"
+      end
+
+      def literal_true
+        BOOL_TRUE
+      end
+
+      def literal_time(v)
+        "#{v.strftime(PG_TIMESTAMP_FORMAT)}.#{sprintf("%06d",v.usec)}'"
+      end
+
       # PostgreSQL is smart and can use parantheses around all datasets to get
       # the correct answers.
       def select_compounds_sql(sql, opts)

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

@@ -1,3 +1,6 @@
+require 'sequel_core/adapters/utils/date_format'
+require 'sequel_core/adapters/utils/unsupported'
+
 module Sequel
   module Progress
     module DatabaseMethods
@@ -11,6 +14,7 @@ module Sequel
   
     module DatasetMethods
       include Dataset::UnsupportedIntersectExcept
+      include Dataset::SQLStandardDateFormat
 
       SELECT_CLAUSE_ORDER = %w'limit distinct columns from join where group order having compounds'.freeze
 

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

@@ -1,3 +1,5 @@
+require 'sequel_core/adapters/utils/unsupported'
+
 module Sequel
   module SQLite
     module DatabaseMethods
@@ -22,14 +24,45 @@ module Sequel
         when :add_column, :add_index, :drop_index
           super
         when :drop_column
-          columns_str = (schema_parse_table(table, {}).map{|c| c[0]} - Array(op[:name])).join(",")
-          defined_columns_str = column_list_sql parse_pragma(table, {}).reject{ |c| c[:name] == op[:name].to_s}
-          ["CREATE TEMPORARY TABLE #{table}_backup(#{defined_columns_str})",
-           "INSERT INTO #{table}_backup SELECT #{columns_str} FROM #{table}",
-           "DROP TABLE #{table}",
-           "CREATE TABLE #{table}(#{defined_columns_str})",
-           "INSERT INTO #{table} SELECT #{columns_str} FROM #{table}_backup",
-           "DROP TABLE #{table}_backup"]
+          qt = quote_schema_table(table)
+          bt = quote_identifier(backup_table_name(qt.gsub('`', '')))
+          columns_str = dataset.send(:identifier_list, columns_for(table, :except => op[:name]))
+          defined_columns_str = column_list_sql(defined_columns_for(table, :except => op[:name]))
+          ["CREATE TEMPORARY TABLE #{bt}(#{defined_columns_str})",
+           "INSERT INTO #{bt} SELECT #{columns_str} FROM #{qt}",
+           "DROP TABLE #{qt}",
+           "CREATE TABLE #{qt}(#{defined_columns_str})",
+           "INSERT INTO #{qt} SELECT #{columns_str} FROM #{bt}",
+           "DROP TABLE #{bt}"]
+        when :rename_column
+          qt = quote_schema_table(table)
+          bt = quote_identifier(backup_table_name(qt.gsub('`', '')))
+          old_columns = dataset.send(:identifier_list, columns_for(table))
+          new_columns_arr = columns_for(table)
+
+          # Replace the old column in place. This is extremely important.
+          new_columns_arr[new_columns_arr.index(op[:name])] = op[:new_name]
+          
+          new_columns = dataset.send(:identifier_list, new_columns_arr)
+          
+          def_old_columns = column_list_sql(defined_columns_for(table))
+
+          def_new_columns_arr = defined_columns_for(table).map do |c|
+            c[:name] = op[:new_name].to_s if c[:name] == op[:name].to_s
+            c
+          end
+          
+          def_new_columns = column_list_sql(def_new_columns_arr)
+
+          [
+           "CREATE TEMPORARY TABLE #{bt}(#{def_old_columns})",
+           "INSERT INTO #{bt}(#{old_columns}) SELECT #{old_columns} FROM #{qt}",
+           "DROP TABLE #{qt}",
+           "CREATE TABLE #{qt}(#{def_new_columns})",
+           "INSERT INTO #{qt}(#{new_columns}) SELECT #{old_columns} FROM #{bt}",
+           "DROP TABLE #{bt}"
+          ]
+
         else
           raise Error, "Unsupported ALTER TABLE operation"
         end
@@ -92,6 +125,32 @@ module Sequel
       end
       
       private
+
+      # The array of column symbols in the table, except for ones given in opts[:except]
+      def backup_table_name(table, opts={})
+        (opts[:times]||1000).times do |i|
+          table_name = "#{table}_backup#{i}"
+          return table_name unless table_exists?(table_name)
+        end
+      end
+
+      # The array of column symbols in the table, except for ones given in opts[:except]
+      def columns_for(table, opts={})
+        cols = schema_parse_table(table, {}).map{|c| c[0]}
+        cols = cols - Array(opts[:except])
+        cols
+      end
+
+      # The array of column schema hashes, except for the ones given in opts[:except]
+      def defined_columns_for(table, opts={})
+        cols = parse_pragma(table, {})
+        cols.each{|c| c[:default] = LiteralString.new(c[:default]) if c[:default]}
+        if opts[:except]
+          nono= Array(opts[:except]).compact.map{|n| n.to_s}
+          cols.reject!{|c| nono.include? c[:name] }
+        end
+        cols
+      end
       
       # SQLite folds unquoted identifiers to lowercase, so it shouldn't need to upcase identifiers on input.
       def identifier_input_method_default
@@ -183,16 +242,17 @@ module Sequel
       end
       
       private
+
+      def literal_blob(v)
+        blob = ''
+        v.each_byte{|x| blob << sprintf('%02x', x)}
+        "X'#{blob}'"
+      end
       
       # SQLite uses string literals instead of identifiers in AS clauses.
       def as_sql(expression, aliaz)
         "#{expression} AS #{literal(aliaz.to_s)}"
       end
-
-      # Call execute_insert on the database with the given SQL.
-      def execute_insert(sql, opts={})
-        @db.execute_insert(sql, {:server=>@opts[:server] || :default}.merge(opts))
-      end
     end
   end
 end