sequel 3.21.0 → 3.39.0

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

@@ -6,16 +6,10 @@ module Sequel
       def database_type
         :progress
       end
-
-      def dataset(opts = nil)
-        ds = super
-        ds.extend(DatasetMethods)
-        ds
-      end
     end
   
     module DatasetMethods
-      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'limit distinct columns from join where group order having compounds')
+      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'select limit distinct columns from join where group order having compounds')
 
       # Progress requires SQL standard datetimes
       def requires_sql_standard_datetimes?
@@ -37,7 +31,10 @@ module Sequel
       # The Progress adapter targets Progress 9, so it silently ignores the option.
       def select_limit_sql(sql)
         raise(Error, "OFFSET not supported") if @opts[:offset]
-        #sql << " TOP #{@opts[:limit]}" if @opts[:limit]
+        # if l = @opts[:limit]
+        #   sql << " TOP "
+        #   literal_append(sql, l)
+        # end
       end
     end
   end

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

@@ -7,16 +7,13 @@ module Sequel
       AUTO_VACUUM = [:none, :full, :incremental].freeze
       PRIMARY_KEY_INDEX_RE = /\Asqlite_autoindex_/.freeze
       SYNCHRONOUS = [:off, :normal, :full].freeze
-      TABLES_FILTER = "type = 'table' AND NOT name = 'sqlite_sequence'"
+      TABLES_FILTER = "type = 'table' AND NOT name = 'sqlite_sequence'".freeze
       TEMP_STORE = [:default, :file, :memory].freeze
-      
-      # Run all alter_table commands in a transaction.  This is technically only
-      # needed for drop column.
-      def alter_table(name, generator=nil, &block)
-        remove_cached_schema(name)
-        generator ||= Schema::AlterTableGenerator.new(self, &block)
-        transaction{generator.operations.each{|op| alter_table_sql_list(name, [op]).flatten.each{|sql| execute_ddl(sql)}}}
-      end
+      VIEWS_FILTER = "type = 'view'".freeze
+
+      # Whether to use integers for booleans in the database.  SQLite recommends
+      # booleans be stored as integers, but historically Sequel has used 't'/'f'.
+      attr_accessor :integer_booleans
 
       # A symbol signifying the value of the auto_vacuum PRAGMA.
       def auto_vacuum
@@ -30,7 +27,14 @@ module Sequel
         value = AUTO_VACUUM.index(value) || (raise Error, "Invalid value for auto_vacuum option. Please specify one of :none, :full, :incremental.")
         pragma_set(:auto_vacuum, value)
       end
-      
+
+      # Set the case_sensitive_like PRAGMA using the given boolean value, if using
+      # SQLite 3.2.3+.  If not using 3.2.3+, no error is raised. See pragma_set.
+      # Consider using the :case_sensitive_like Database option instead.
+      def case_sensitive_like=(value)
+        pragma_set(:case_sensitive_like, !!value ? 'on' : 'off') if sqlite_version >= 30203
+      end
+
       # SQLite uses the :sqlite database type.
       def database_type
         :sqlite
@@ -49,22 +53,33 @@ module Sequel
         pragma_set(:foreign_keys, !!value ? 'on' : 'off') if sqlite_version >= 30619
       end
 
+      # Return the array of foreign key info hashes using the foreign_key_list PRAGMA,
+      # including information for the :on_update and :on_delete entries.
+      def foreign_key_list(table, opts={})
+        m = output_identifier_meth
+        h = {}
+        metadata_dataset.with_sql("PRAGMA foreign_key_list(?)", input_identifier_meth.call(table)).each do |row|
+          if r = h[row[:id]]
+            r[:columns] << m.call(row[:from])
+            r[:key] << m.call(row[:to]) if r[:key]
+          else
+            h[row[:id]] = {:columns=>[m.call(row[:from])], :table=>m.call(row[:table]), :key=>([m.call(row[:to])] if row[:to]), :on_update=>on_delete_sql_to_sym(row[:on_update]), :on_delete=>on_delete_sql_to_sym(row[:on_delete])}
+          end
+        end
+        h.values
+      end
+
       # Use the index_list and index_info PRAGMAs to determine the indexes on the table.
       def indexes(table, opts={})
         m = output_identifier_meth
         im = input_identifier_meth
         indexes = {}
-        begin
-          metadata_dataset.with_sql("PRAGMA index_list(?)", im.call(table)).each do |r|
-            next if r[:name] =~ PRIMARY_KEY_INDEX_RE
-            indexes[m.call(r[:name])] = {:unique=>r[:unique].to_i==1}
-          end
-        rescue Sequel::DatabaseError
-          nil
-        else
-          indexes.each do |k, v|
-            v[:columns] = metadata_dataset.with_sql("PRAGMA index_info(?)", im.call(k)).map(:name).map{|x| m.call(x)}
-          end
+        metadata_dataset.with_sql("PRAGMA index_list(?)", im.call(table)).each do |r|
+          next if r[:name] =~ PRIMARY_KEY_INDEX_RE
+          indexes[m.call(r[:name])] = {:unique=>r[:unique].to_i==1}
+        end
+        indexes.each do |k, v|
+          v[:columns] = metadata_dataset.with_sql("PRAGMA index_info(?)", im.call(k)).map(:name).map{|x| m.call(x)}
         end
         indexes
       end
@@ -83,6 +98,11 @@ module Sequel
       def pragma_set(name, value)
         execute_ddl("PRAGMA #{name} = #{value}")
       end
+
+      # Set the integer_booleans option using the passed in :integer_boolean option.
+      def set_integer_booleans
+        @integer_booleans = typecast_value_boolean(@opts[:integer_booleans])
+      end
       
       # The version of the server as an integer, where 3.6.19 = 30619.
       # If the server version can't be determined, 0 is used.
@@ -96,11 +116,29 @@ module Sequel
         end
       end
       
+      # SQLite supports CREATE TABLE IF NOT EXISTS syntax since 3.3.0.
+      def supports_create_table_if_not_exists?
+        sqlite_version >= 30300
+      end
+      
       # SQLite 3.6.8+ supports savepoints. 
       def supports_savepoints?
         sqlite_version >= 30608
       end
 
+      # Override the default setting for whether to use timezones in timestamps.
+      # For backwards compatibility, it is set to +true+ by default.
+      # Anyone wanting to use SQLite's datetime functions should set it to +false+
+      # using this method.  It's possible that the default will change in a future version,
+      # so anyone relying on timezones in timestamps should set this to +true+.
+      attr_writer :use_timestamp_timezones
+
+      # SQLite supports timezones in timestamps, since it just stores them as strings,
+      # but it breaks the usage of SQLite's datetime functions.
+      def use_timestamp_timezones?
+        defined?(@use_timestamp_timezones) ? @use_timestamp_timezones : (@use_timestamp_timezones = true)
+      end
+
       # A symbol signifying the value of the synchronous PRAGMA.
       def synchronous
         SYNCHRONOUS[pragma_get(:synchronous).to_i]
@@ -118,8 +156,7 @@ module Sequel
       # Options:
       # * :server - Set the server to use.
       def tables(opts={})
-        m = output_identifier_meth
-        metadata_dataset.from(:sqlite_master).server(opts[:server]).filter(TABLES_FILTER).map{|r| m.call(r[:name])}
+        tables_and_views(TABLES_FILTER, opts)
       end
       
       # A symbol signifying the value of the temp_store PRAGMA.
@@ -134,8 +171,35 @@ module Sequel
         pragma_set(:temp_store, value)
       end
       
+      # Array of symbols specifying the view names in the current database.
+      #
+      # Options:
+      # * :server - Set the server to use.
+      def views(opts={})
+        tables_and_views(VIEWS_FILTER, opts)
+      end
+
       private
 
+      # Run all alter_table commands in a transaction.  This is technically only
+      # needed for drop column.
+      def apply_alter_table(table, ops)
+        fks = foreign_keys
+        self.foreign_keys = false if fks
+        transaction do 
+          if ops.length > 1 && ops.all?{|op| op[:op] == :add_constraint}
+            # If you are just doing constraints, apply all of them at the same time,
+            # as otherwise all but the last one get lost.
+            alter_table_sql_list(table, [{:op=>:add_constraints, :ops=>ops}]).flatten.each{|sql| execute_ddl(sql)}
+          else
+            # Run each operation separately, as later operations may depend on the
+            # results of earlier operations.
+            ops.each{|op| alter_table_sql_list(table, [op]).flatten.each{|sql| execute_ddl(sql)}}
+          end
+        end
+        self.foreign_keys = true if fks
+      end
+
       # SQLite supports limited table modification.  You can add a column
       # or an index.  Dropping columns is supported by copying the table into
       # a temporary table, dropping the table, and creating a new table without
@@ -161,13 +225,26 @@ module Sequel
         when :set_column_null
           duplicate_table(table){|columns| columns.each{|s| s[:null] = op[:null] if s[:name].to_s == op[:name].to_s}}
         when :set_column_type
-          duplicate_table(table){|columns| columns.each{|s| s[:type] = op[:type] if s[:name].to_s == op[:name].to_s}}
+          duplicate_table(table){|columns| columns.each{|s| s.merge!(op) if s[:name].to_s == op[:name].to_s}}
+        when :drop_constraint
+          case op[:type]
+          when :primary_key
+            duplicate_table(table){|columns| columns.each{|s| s[:primary_key] = nil}}
+          when :foreign_key
+            duplicate_table(table, :no_foreign_keys=>true)
+          else
+            duplicate_table(table)
+          end
+        when :add_constraint
+          duplicate_table(table, :constraints=>[op])
+        when :add_constraints
+          duplicate_table(table, :constraints=>op[:ops])
         else
-          raise Error, "Unsupported ALTER TABLE operation"
+          raise Error, "Unsupported ALTER TABLE operation: #{op[:op].inspect}"
         end
       end
-      
-      # The array of column symbols in the table, except for ones given in opts[:except]
+
+      # A name to use for the backup table
       def backup_table_name(table, opts={})
         table = table.gsub('`', '')
         (opts[:times]||1000).times do |i|
@@ -176,17 +253,19 @@ module Sequel
         end
       end
 
-      # Allow use without a generator, needed for the alter table hackery that Sequel allows.
-      def column_list_sql(generator)
-        generator.is_a?(Schema::Generator) ? super : generator.map{|c| column_definition_sql(c)}.join(', ')
+      # Surround default with parens to appease SQLite
+      def column_definition_default_sql(sql, column)
+        sql << " DEFAULT (#{literal(column[:default])})" if column.include?(:default)
       end
-
+    
       # Array of PRAGMA SQL statements based on the Database options that should be applied to
       # new connections.
       def connection_pragmas
         ps = []
         v = typecast_value_boolean(opts.fetch(:foreign_keys, 1))
         ps << "PRAGMA foreign_keys = #{v ? 1 : 0}"
+        v = typecast_value_boolean(opts.fetch(:case_sensitive_like, 1))
+        ps << "PRAGMA case_sensitive_like = #{v ? 1 : 0}"
         [[:auto_vacuum, AUTO_VACUUM], [:synchronous, SYNCHRONOUS], [:temp_store, TEMP_STORE]].each do |prag, con|
           if v = opts[prag]
             raise(Error, "Value for PRAGMA #{prag} not supported, should be one of #{con.join(', ')}") unless v = con.index(v.to_sym)
@@ -196,28 +275,13 @@ module Sequel
         ps
       end
 
-      # The array of column schema hashes, except for the ones given in opts[:except]
-      def defined_columns_for(table, opts={})
+      # The array of column schema hashes for the current columns in the table
+      def defined_columns_for(table)
         cols = parse_pragma(table, {})
         cols.each do |c|
           c[:default] = LiteralString.new(c[:default]) if c[:default]
           c[:type] = c[:db_type]
         end
-        if opts[:except]
-          nono= Array(opts[:except]).compact.map{|n| n.to_s}
-          cols.reject!{|c| nono.include? c[:name] }
-        end
-
-        if foreign_keys
-          metadata_dataset.with_sql("PRAGMA foreign_key_list(?)", input_identifier_meth.call(table)).each do |row|
-            c = cols.find {|co| co[:name] == row[:from] } or next
-            c[:table] = row[:table]
-            c[:key] = row[:to]
-            c[:on_update] = on_delete_sql_to_sym(row[:on_update])
-            c[:on_delete] = on_delete_sql_to_sym(row[:on_delete])
-            # is there any way to get deferrable status?
-          end
-        end
         cols
       end
 
@@ -231,17 +295,40 @@ module Sequel
         opts[:old_columns_proc].call(old_columns) if opts[:old_columns_proc]
 
         yield def_columns if block_given?
-        def_columns_str = column_list_sql(def_columns)
+
+        constraints = (opts[:constraints] || []).dup
+        pks = []
+        def_columns.each{|c| pks << c[:name] if c[:primary_key]}
+        if pks.length > 1
+          constraints << {:type=>:primary_key, :columns=>pks}
+          def_columns.each{|c| c[:primary_key] = false if c[:primary_key]}
+        end
+
+        # If dropping a foreign key constraint, drop all foreign key constraints,
+        # as there is no way to determine which one to drop.
+        unless opts[:no_foreign_keys]
+          fks = foreign_key_list(table)
+
+          # If dropping a column, if there is a foreign key with that
+          # column, don't include it when building a copy of the table.
+          if ocp = opts[:old_columns_proc]
+            fks.delete_if{|c| ocp.call(c[:columns].dup) != c[:columns]}
+          end
+
+          constraints.concat(fks.each{|h| h[:type] = :foreign_key})
+        end
+
+        def_columns_str = (def_columns.map{|c| column_definition_sql(c)} + constraints.map{|c| constraint_definition_sql(c)}).join(', ')
         new_columns = old_columns.dup
         opts[:new_columns_proc].call(new_columns) if opts[:new_columns_proc]
 
         qt = quote_schema_table(table)
         bt = quote_identifier(backup_table_name(qt))
         a = [
-           "CREATE TABLE #{bt}(#{def_columns_str})",
-           "INSERT INTO #{bt}(#{dataset.send(:identifier_list, new_columns)}) SELECT #{dataset.send(:identifier_list, old_columns)} FROM #{qt}",
-           "DROP TABLE #{qt}",
-           "ALTER TABLE #{bt} RENAME TO #{qt}"
+           "ALTER TABLE #{qt} RENAME TO #{bt}",
+           "CREATE TABLE #{qt}(#{def_columns_str})",
+           "INSERT INTO #{qt}(#{dataset.send(:identifier_list, new_columns)}) SELECT #{dataset.send(:identifier_list, old_columns)} FROM #{bt}",
+           "DROP TABLE #{bt}"
         ]
         indexes(table).each do |name, h|
           if (h[:columns].map{|x| x.to_s} - new_columns).empty?
@@ -280,7 +367,7 @@ module Sequel
 
       # Parse the output of the table_info pragma
       def parse_pragma(table_name, opts)
-        metadata_dataset.with_sql("PRAGMA table_info(?)", input_identifier_meth.call(table_name)).map do |row|
+        metadata_dataset.with_sql("PRAGMA table_info(?)", input_identifier_meth(opts[:dataset]).call(table_name)).map do |row|
           row.delete(:cid)
           row[:allow_null] = row.delete(:notnull).to_i == 0
           row[:default] = row.delete(:dflt_value)
@@ -294,65 +381,123 @@ module Sequel
       
       # SQLite treats integer primary keys as autoincrementing (alias of rowid).
       def schema_autoincrementing_primary_key?(schema)
-        super and schema[:db_type].downcase == 'integer'
+        super && schema[:db_type].downcase == 'integer'
       end
 
       # SQLite supports schema parsing using the table_info PRAGMA, so
       # parse the output of that into the format Sequel expects.
       def schema_parse_table(table_name, opts)
-        m = output_identifier_meth
+        m = output_identifier_meth(opts[:dataset])
         parse_pragma(table_name, opts).map do |row|
           [m.call(row.delete(:name)), row]
         end
       end
       
-      # SQLite uses the integer data type even for bignums.  This is because they
-      # are both stored internally as text, and converted when returned from
-      # the database.  Using an integer type instead of bigint makes it more likely
-      # that software will automatically return the column as an integer.
+      # Backbone of the tables and views support.
+      def tables_and_views(filter, opts)
+        m = output_identifier_meth
+        metadata_dataset.from(:sqlite_master).server(opts[:server]).filter(filter).map{|r| m.call(r[:name])}
+      end
+
+      # SQLite only supports AUTOINCREMENT on integer columns, not
+      # bigint columns, so use integer instead of bigint for those
+      # columns.
       def type_literal_generic_bignum(column)
-        :integer
+        column[:auto_increment] ? :integer : super
       end
     end
     
     # Instance methods for datasets that connect to an SQLite database
     module DatasetMethods
-      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'distinct columns from join where group having compounds order limit')
-      COMMA_SEPARATOR = ', '.freeze
+      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'select distinct columns from join where group having compounds order limit')
       CONSTANT_MAP = {:CURRENT_DATE=>"date(CURRENT_TIMESTAMP, 'localtime')".freeze, :CURRENT_TIMESTAMP=>"datetime(CURRENT_TIMESTAMP, 'localtime')".freeze, :CURRENT_TIME=>"time(CURRENT_TIMESTAMP, 'localtime')".freeze}
-    
-      # SQLite does not support pattern matching via regular expressions.
-      # SQLite is case insensitive (depending on pragma), so use LIKE for
-      # ILIKE.
-      def complex_expression_sql(op, args)
+      EMULATED_FUNCTION_MAP = {:char_length=>'length'.freeze}
+      EXTRACT_MAP = {:year=>"'%Y'", :month=>"'%m'", :day=>"'%d'", :hour=>"'%H'", :minute=>"'%M'", :second=>"'%f'"}
+      NOT_SPACE = Dataset::NOT_SPACE
+      COMMA = Dataset::COMMA
+      PAREN_CLOSE = Dataset::PAREN_CLOSE
+      AS = Dataset::AS
+      APOS = Dataset::APOS
+      EXTRACT_OPEN = "CAST(strftime(".freeze
+      EXTRACT_CLOSE = ') AS '.freeze
+      NUMERIC = 'NUMERIC'.freeze
+      INTEGER = 'INTEGER'.freeze
+      BACKTICK = '`'.freeze
+      BACKTICK_RE = /`/.freeze
+      DOUBLE_BACKTICK = '``'.freeze
+      BLOB_START = "X'".freeze
+      HSTAR = "H*".freeze
+      DATE_OPEN = "date(".freeze
+      DATETIME_OPEN = "datetime(".freeze
+
+      def cast_sql_append(sql, expr, type)
+        if type == Time or type == DateTime
+          sql << DATETIME_OPEN
+          literal_append(sql, expr)
+          sql << PAREN_CLOSE
+        elsif type == Date
+          sql << DATE_OPEN
+          literal_append(sql, expr)
+          sql << PAREN_CLOSE
+        else
+          super
+        end
+      end
+
+      # SQLite is case insensitive (depending on pragma), so use LIKE for ILIKE.
+      # It also doesn't support a NOT LIKE b, you need to use NOT (a LIKE b).
+      # It doesn't support xor or the extract function natively, so those have to be emulated.
+      def complex_expression_sql_append(sql, op, args)
         case op
-        when :~, :'!~', :'~*', :'!~*'
-          raise Error, "SQLite does not support pattern matching via regular expressions"
-        when :LIKE, :'NOT LIKE', :ILIKE, :'NOT ILIKE'
-          # SQLite is case insensitive for ASCII, and non case sensitive for other character sets
-          "#{'NOT ' if [:'NOT LIKE', :'NOT ILIKE'].include?(op)}(#{literal(args.at(0))} LIKE #{literal(args.at(1))})"
+        when :ILIKE
+          super(sql, :LIKE, args.map{|a| SQL::Function.new(:upper, a)})
+        when :"NOT LIKE", :"NOT ILIKE"
+          sql << NOT_SPACE
+          complex_expression_sql_append(sql, (op == :"NOT ILIKE" ? :ILIKE : :LIKE), args)
+        when :^
+          sql << complex_expression_arg_pairs(args) do |a, b|
+            a = literal(a)
+            b = literal(b)
+            "((~(#{a} & #{b})) & (#{a} | #{b}))"
+          end
+        when :extract
+          part = args.at(0)
+          raise(Sequel::Error, "unsupported extract argument: #{part.inspect}") unless format = EXTRACT_MAP[part]
+          sql << EXTRACT_OPEN << format << COMMA
+          literal_append(sql, args.at(1))
+          sql << EXTRACT_CLOSE << (part == :second ? NUMERIC : INTEGER) << PAREN_CLOSE
         else
-          super(op, args)
+          super
         end
       end
       
-      # MSSQL doesn't support the SQL standard CURRENT_DATE or CURRENT_TIME
-      def constant_sql(constant)
-        CONSTANT_MAP[constant] || super
+      # SQLite has CURRENT_TIMESTAMP and related constants in UTC instead
+      # of in localtime, so convert those constants to local time.
+      def constant_sql_append(sql, constant)
+        if c = CONSTANT_MAP[constant]
+          sql << c
+        else
+          super
+        end
       end
       
       # SQLite performs a TRUNCATE style DELETE if no filter is specified.
       # Since we want to always return the count of records, add a condition
       # that is always true and then delete.
       def delete
-        @opts[:where] ? super : filter(1=>1).delete
+        @opts[:where] ? super : where(1=>1).delete
       end
       
       # Return an array of strings specifying a query explanation for a SELECT of the
-      # current dataset.
-      def explain
-        db.send(:metadata_dataset).clone(:sql=>"EXPLAIN #{select_sql}").
-          map{|x| "#{x[:addr]}|#{x[:opcode]}|#{(1..5).map{|i| x[:"p#{i}"]}.join('|')}|#{x[:comment]}"}
+      # current dataset. Currently, the options are ignore, but it accepts options
+      # to be compatible with other adapters.
+      def explain(opts=nil)
+        # Load the PrettyTable class, needed for explain output
+        Sequel.extension(:_pretty_table) unless defined?(Sequel::PrettyTable)
+
+        ds = db.send(:metadata_dataset).clone(:sql=>"EXPLAIN #{select_sql}")
+        rows = ds.all
+        Sequel::PrettyTable.string(rows, ds.columns)
       end
       
       # HAVING requires GROUP BY on SQLite
@@ -362,8 +507,20 @@ module Sequel
       end
       
       # SQLite uses the nonstandard ` (backtick) for quoting identifiers.
-      def quoted_identifier(c)
-        "`#{c}`"
+      def quoted_identifier_append(sql, c)
+        sql << BACKTICK << c.to_s.gsub(BACKTICK_RE, DOUBLE_BACKTICK) << BACKTICK
+      end
+      
+      # When a qualified column is selected on SQLite and the qualifier
+      # is a subselect, the column name used is the full qualified name
+      # (including the qualifier) instead of just the column name.  To
+      # get correct column names, you must use an alias.
+      def select(*cols)
+        if ((f = @opts[:from]) && f.any?{|t| t.is_a?(Dataset) || (t.is_a?(SQL::AliasedExpression) && t.expression.is_a?(Dataset))}) || ((j = @opts[:join]) && j.any?{|t| t.table.is_a?(Dataset)})
+          super(*cols.map{|c| alias_qualified_column(c)})
+        else
+          super
+        end
       end
       
       # SQLite does not support INTERSECT ALL or EXCEPT ALL
@@ -382,31 +539,63 @@ module Sequel
       end
       
       # SQLite supports timezones in literal timestamps, since it stores them
-      # as text.
+      # as text.  But using timezones in timestamps breaks SQLite datetime
+      # functions, so we allow the user to override the default per database.
       def supports_timestamp_timezones?
-        true
+        db.use_timestamp_timezones?
       end
 
+      # SQLite cannot use WHERE 't'.
+      def supports_where_true?
+        false
+      end
+      
       private
       
       # SQLite uses string literals instead of identifiers in AS clauses.
-      def as_sql(expression, aliaz)
+      def as_sql_append(sql, aliaz)
         aliaz = aliaz.value if aliaz.is_a?(SQL::Identifier)
-        "#{expression} AS #{literal(aliaz.to_s)}"
+        sql << AS
+        literal_append(sql, aliaz.to_s)
       end
-      
+
+      # If col is a qualified column, alias it to the same as the column name
+      def alias_qualified_column(col)
+        case col
+        when Symbol
+          t, c, a = split_symbol(col)
+          if t && !a
+            alias_qualified_column(SQL::QualifiedIdentifier.new(t, c))
+          else
+            col
+          end
+        when SQL::QualifiedIdentifier
+          SQL::AliasedExpression.new(col, col.column)
+        else
+          col
+        end
+      end
+
       # SQL fragment specifying a list of identifiers
       def identifier_list(columns)
-        columns.map{|i| quote_identifier(i)}.join(COMMA_SEPARATOR)
+        columns.map{|i| quote_identifier(i)}.join(COMMA)
       end
     
       # SQLite uses a preceding X for hex escaping strings
-      def literal_blob(v)
-        blob = ''
-        v.each_byte{|x| blob << sprintf('%02x', x)}
-        "X'#{blob}'"
+      def literal_blob_append(sql, v)
+        sql << BLOB_START << v.unpack(HSTAR).first << APOS
       end
-      
+
+      # Respect the database integer_booleans setting, using 0 or 'f'.
+      def literal_false
+        @db.integer_booleans ? '0' : "'f'"
+      end
+
+      # Respect the database integer_booleans setting, using 1 or 't'.
+      def literal_true
+        @db.integer_booleans ? '1' : "'t'"
+      end
+
       # SQLite does not support the SQL WITH clause
       def select_clause_methods
         SELECT_CLAUSE_METHODS
@@ -416,7 +605,7 @@ module Sequel
       def select_lock_sql(sql)
         super unless @opts[:lock] == :update
       end
-      
+
       # SQLite treats a DELETE with no WHERE clause as a TRUNCATE
       def _truncate_sql(table)
         "DELETE FROM #{table}"