sequel 3.33.0 → 3.34.0

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

@@ -50,6 +50,7 @@ module Sequel
             end
             i = 0
             _execute(conn, "SET " + args.map {|arg| "@sequel_arg_#{i+=1} = #{literal(arg)}"}.join(", "), opts) unless args.empty?
+            opts = opts.merge(:log_sql=>" (#{sql})") if ps.log_sql
             _execute(conn, "EXECUTE #{ps_name}#{" USING #{(1..i).map{|j| "@sequel_arg_#{j}"}.join(', ')}" unless i == 0}", opts, &block)
           end
         end
@@ -94,6 +95,11 @@ module Sequel
           def execute_dui(sql, opts={}, &block)
             super(prepared_statement_name, {:arguments=>bind_arguments}.merge(opts), &block)
           end
+          
+          # Same as execute, explicit due to intricacies of alias and super.
+          def execute_insert(sql, opts={}, &block)
+            super(prepared_statement_name, {:arguments=>bind_arguments}.merge(opts), &block)
+          end
         end
         
         # Methods for MySQL stored procedures using the native driver.

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

@@ -179,7 +179,7 @@ module Sequel
       include EmulateOffsetWithRowNumber
 
       SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'with select distinct columns from join where group having compounds order lock')
-      ROW_NUMBER_EXPRESSION = 'ROWNUM'.lit.freeze
+      ROW_NUMBER_EXPRESSION = LiteralString.new('ROWNUM').freeze
       SPACE = Dataset::SPACE
       APOS = Dataset::APOS
       APOS_RE = Dataset::APOS_RE

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

@@ -57,7 +57,7 @@ module Sequel
       attr_writer :db
 
       SELECT_CURRVAL = "SELECT currval('%s')".freeze
-      SELECT_CUSTOM_SEQUENCE = proc do |schema, table| <<-end_sql
+      SELECT_CUSTOM_SEQUENCE_SQL = (<<-end_sql
         SELECT '"' || name.nspname || '".' || CASE
             WHEN split_part(def.adsrc, '''', 2) ~ '.' THEN
               substr(split_part(def.adsrc, '''', 2),
@@ -71,11 +71,10 @@ module Sequel
         JOIN pg_constraint cons ON (conrelid = adrelid AND adnum = conkey[1])
         WHERE cons.contype = 'p'
           AND def.adsrc ~* 'nextval'
-          #{"AND name.nspname = '#{schema}'" if schema}
-          AND t.relname = '#{table}'
       end_sql
-      end
-      SELECT_PK = proc do |schema, table| <<-end_sql
+      ).strip.gsub(/\s+/, ' ').freeze
+
+      SELECT_PK_SQL = (<<-end_sql
         SELECT pg_attribute.attname
         FROM pg_class, pg_attribute, pg_index, pg_namespace
         WHERE pg_class.oid = pg_attribute.attrelid
@@ -83,11 +82,10 @@ module Sequel
           AND pg_class.oid = pg_index.indrelid
           AND pg_index.indkey[0] = pg_attribute.attnum
           AND pg_index.indisprimary = 't'
-          #{"AND pg_namespace.nspname = '#{schema}'" if schema}
-          AND pg_class.relname = '#{table}'
       end_sql
-      end
-      SELECT_SERIAL_SEQUENCE = proc do |schema, table| <<-end_sql
+      ).strip.gsub(/\s+/, ' ').freeze
+
+      SELECT_SERIAL_SEQUENCE_SQL = (<<-end_sql
         SELECT  '"' || name.nspname || '".' || seq.relname || ''
         FROM pg_class seq, pg_attribute attr, pg_depend dep,
           pg_namespace name, pg_constraint cons
@@ -99,10 +97,8 @@ module Sequel
           AND attr.attrelid = cons.conrelid
           AND attr.attnum = cons.conkey[1]
           AND cons.contype = 'p'
-          #{"AND name.nspname = '#{schema}'" if schema}
-          AND seq.relname = '#{table}'
       end_sql
-      end
+      ).strip.gsub(/\s+/, ' ').freeze
 
       # Depth of the current transaction on this connection, used
       # to implement multi-level transactions with savepoints.
@@ -132,23 +128,30 @@ module Sequel
         end
       end
 
-      # Get the primary key for the given table.
+      # Get the primary key for the given table and schema.  Both
+      # should be provided as literal SQL strings, with schema
+      # optionally nil.
       def primary_key(schema, table)
-        sql = SELECT_PK[schema, table]
+        sql = "#{SELECT_PK_SQL} AND pg_class.relname = #{table}"
+        sql << "AND pg_namespace.nspname = #{schema}" if schema
         execute(sql) do |r|
           return single_value(r)
         end
       end
 
-      # Get the primary key and sequence for the given table.
+      # Get the primary key and sequence for the given table and schema.
+      # Both should be provided as literal SQL strings, with schema
+      # optionally nil.
       def sequence(schema, table)
-        sql = SELECT_SERIAL_SEQUENCE[schema, table]
+        sql = "#{SELECT_SERIAL_SEQUENCE_SQL} AND seq.relname = #{table}"
+        sql << " AND name.nspname = #{schema}" if schema
         execute(sql) do |r|
           seq = single_value(r)
           return seq if seq
         end
 
-        sql = SELECT_CUSTOM_SEQUENCE[schema, table]
+        sql = "#{SELECT_CUSTOM_SEQUENCE_SQL} AND t.relname = #{table}"
+        sql << " AND name.nspname = #{schema}" if schema
         execute(sql) do |r|
           return single_value(r)
         end
@@ -161,6 +164,7 @@ module Sequel
       PREPARED_ARG_PLACEHOLDER = LiteralString.new('$').freeze
       RE_CURRVAL_ERROR = /currval of sequence "(.*)" is not yet defined in this session|relation "(.*)" does not exist/.freeze
       SYSTEM_TABLE_REGEXP = /^pg|sql/.freeze
+      FOREIGN_KEY_LIST_ON_DELETE_MAP = {'a'.freeze=>:no_action, 'r'.freeze=>:restrict, 'c'.freeze=>:cascade, 'n'.freeze=>:set_null, 'd'.freeze=>:set_default}.freeze
 
       # Commit an existing prepared transaction with the given transaction
       # identifier string.
@@ -266,6 +270,64 @@ module Sequel
         self << drop_trigger_sql(table, name, opts)
       end
 
+      # Return full foreign key information using the pg system tables, including
+      # :name, :on_delete, :on_update, and :deferrable entries in the hashes.
+      def foreign_key_list(table, opts={})
+        m = output_identifier_meth
+        im = input_identifier_meth
+        schema, table = schema_and_table(table)
+        range = 0...32
+
+        base_ds = metadata_dataset.
+          where(:cl__relkind=>'r', :co__contype=>'f', :cl__relname=>im.call(table)).
+          from(:pg_constraint___co).
+          join(:pg_class___cl, :oid=>:conrelid)
+
+        # We split the parsing into two separate queries, which are merged manually later.
+        # This is because PostgreSQL stores both the referencing and referenced columns in
+        # arrays, and I don't know a simple way to not create a cross product, as PostgreSQL
+        # doesn't appear to have a function that takes an array and element and gives you
+        # the index of that element in the array.
+
+        ds = base_ds.
+          join(:pg_attribute___att, :attrelid=>:oid, :attnum=>SQL::Function.new(:ANY, :co__conkey)).
+          order(:co__conname, SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(:co__conkey, [x]), x]}, 32, :att__attnum)).
+          select(:co__conname___name, :att__attname___column, :co__confupdtype___on_update, :co__confdeltype___on_delete,
+                 SQL::BooleanExpression.new(:AND, :co__condeferrable, :co__condeferred).as(:deferrable))
+
+        ref_ds = base_ds.
+          join(:pg_class___cl2, :oid=>:co__confrelid).
+          join(:pg_attribute___att2, :attrelid=>:oid, :attnum=>SQL::Function.new(:ANY, :co__confkey)).
+          order(:co__conname, SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(:co__conkey, [x]), x]}, 32, :att2__attnum)).
+          select(:co__conname___name, :cl2__relname___table, :att2__attname___refcolumn)
+
+        # If a schema is given, we only search in that schema, and the returned :table
+        # entry is schema qualified as well.
+        if schema
+          ds.join!(:pg_namespace___nsp, :oid=>:cl__relnamespace).
+            where(:nsp___nspname=>im.call(schema))
+          ref_ds.join!(:pg_namespace___nsp2, :oid=>:cl2__relnamespace).
+            select_more(:nsp2__nspname___schema)
+        end
+
+        h = {}
+        fklod_map = FOREIGN_KEY_LIST_ON_DELETE_MAP 
+        ds.each do |row|
+          if r = h[row[:name]]
+            r[:columns] << m.call(row[:column])
+          else
+            h[row[:name]] = {:name=>m.call(row[:name]), :columns=>[m.call(row[:column])], :on_update=>fklod_map[row[:on_update]], :on_delete=>fklod_map[row[:on_delete]], :deferrable=>row[:deferrable]}
+          end
+        end
+        ref_ds.each do |row|
+          r = h[row[:name]]
+          r[:table] ||= m.call(schema ? SQL::QualifiedIdentifier.new(row[:schema], row[:table]) : row[:table])
+          r[:key] ||= []
+          r[:key] << m.call(row[:refcolumn])
+        end
+        h.values
+      end
+
       # Use the pg_* system tables to determine indexes on a table
       def indexes(table, opts={})
         m = output_identifier_meth
@@ -279,7 +341,7 @@ module Sequel
           join(:pg_class___indc, :oid=>:indexrelid).
           join(:pg_attribute___att, :attrelid=>:tab__oid, :attnum=>attnums).
           filter(:indc__relkind=>'i', :ind__indisprimary=>false, :indexprs=>nil, :indpred=>nil).
-          order(:indc__relname, range.map{|x| [SQL::Subscript.new(:ind__indkey, [x]), x]}.case(32, :att__attnum)).
+          order(:indc__relname, SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(:ind__indkey, [x]), x]}, 32, :att__attnum)).
           select(:indc__relname___name, :ind__indisunique___unique, :att__attname___column)
 
         ds.join!(:pg_namespace___nsp, :oid=>:tab__relnamespace, :nspname=>schema.to_s) if schema
@@ -314,9 +376,9 @@ module Sequel
         quoted_table = quote_schema_table(table)
         return @primary_keys[quoted_table] if @primary_keys.include?(quoted_table)
         @primary_keys[quoted_table] = if conn = opts[:conn]
-          conn.primary_key(*schema_and_table(table))
+          conn.primary_key(*schema_and_table_quoted_strings(table))
         else
-          synchronize(opts[:server]){|con| con.primary_key(*schema_and_table(table))}
+          synchronize(opts[:server]){|con| con.primary_key(*schema_and_table_quoted_strings(table))}
         end
       end
 
@@ -325,9 +387,9 @@ module Sequel
         quoted_table = quote_schema_table(table)
         return @primary_key_sequences[quoted_table] if @primary_key_sequences.include?(quoted_table)
         @primary_key_sequences[quoted_table] = if conn = opts[:conn]
-          conn.sequence(*schema_and_table(table))
+          conn.sequence(*schema_and_table_quoted_strings(table))
         else
-          synchronize(opts[:server]){|con| con.sequence(*schema_and_table(table))}
+          synchronize(opts[:server]){|con| con.sequence(*schema_and_table_quoted_strings(table))}
         end
       end
 
@@ -337,7 +399,7 @@ module Sequel
         pk = SQL::Identifier.new(primary_key(table))
         return unless seq = primary_key_sequence(table)
         db = self
-        seq_ds = db.from(seq.lit)
+        seq_ds = db.from(LiteralString.new(seq))
         get{setval(seq, db[table].select{coalesce(max(pk)+seq_ds.select{:increment_by}, seq_ds.select(:min_value))}, false)}
       end
 
@@ -366,6 +428,7 @@ module Sequel
             0
           end
         end
+        warn 'Sequel support for PostgreSQL <8.2 is deprecated and will be removed in 3.35.0' if @server_version < 80200
         @server_version
       end
 
@@ -381,6 +444,11 @@ module Sequel
         server_version >= 90100
       end
 
+      # PostgreSQL supports DROP TABLE IF EXISTS on 8.2+
+      def supports_drop_table_if_exists?
+        server_version >= 80200
+      end
+
       # PostgreSQL supports savepoints
       def supports_savepoints?
         true
@@ -402,6 +470,13 @@ module Sequel
         pg_class_relname('r', opts, &block)
       end
 
+      # Check whether the given type name string/symbol (e.g. :hstore) is supported by
+      # the database.
+      def type_supported?(type)
+        @supported_types ||= {}
+        @supported_types.fetch(type){@supported_types[type] = (from(:pg_type).filter(:typtype=>'b', :typname=>type.to_s).count > 0)}
+      end
+
       # Array of symbols specifying view names in the current database.
       #
       # Options:
@@ -521,7 +596,7 @@ module Sequel
         filter = " WHERE #{filter_expr(filter)}" if filter
         case index_type
         when :full_text
-          expr = "(to_tsvector(#{literal(index[:language] || 'simple')}, #{literal(dataset.send(:full_text_string_join, cols))}))"
+          expr = "(to_tsvector(#{literal(index[:language] || 'simple')}::regconfig, #{literal(dataset.send(:full_text_string_join, cols))}))"
           index_type = :gin
         when :spatial
           index_type = :gist
@@ -591,6 +666,13 @@ module Sequel
         "ALTER TABLE #{quote_schema_table(name)} RENAME TO #{quote_identifier(schema_and_table(new_name).last)}"
       end
 
+      # Split the table into a schema and table, and return the values as quoted strings for usage
+      # in querying the system tables.
+      def schema_and_table_quoted_strings(table)
+        schema, table = schema_and_table(table)
+        [(literal(schema) if schema), literal(table)]
+      end
+
       # PostgreSQL's autoincrementing primary keys are of type integer or bigint
       # using a nextval function call as a default.
       def schema_autoincrementing_primary_key?(schema)
@@ -677,6 +759,7 @@ module Sequel
       BOOL_TRUE = 'true'.freeze
       COMMA_SEPARATOR = ', '.freeze
       DELETE_CLAUSE_METHODS = Dataset.clause_methods(:delete, %w'delete from using where')
+      DELETE_CLAUSE_METHODS_82 = Dataset.clause_methods(:delete, %w'delete from using where returning')
       DELETE_CLAUSE_METHODS_91 = Dataset.clause_methods(:delete, %w'with delete from using where returning')
       EXCLUSIVE = 'EXCLUSIVE'.freeze
       EXPLAIN = 'EXPLAIN '.freeze
@@ -698,6 +781,7 @@ module Sequel
       SHARE_UPDATE_EXCLUSIVE = 'SHARE UPDATE EXCLUSIVE'.freeze
       SQL_WITH_RECURSIVE = "WITH RECURSIVE ".freeze
       UPDATE_CLAUSE_METHODS = Dataset.clause_methods(:update, %w'update table set from where')
+      UPDATE_CLAUSE_METHODS_82 = Dataset.clause_methods(:update, %w'update table set from where returning')
       UPDATE_CLAUSE_METHODS_91 = Dataset.clause_methods(:update, %w'with update table set from where returning')
       SPACE = Dataset::SPACE
       FROM = Dataset::FROM
@@ -717,7 +801,7 @@ module Sequel
       # Shared methods for prepared statements when used with PostgreSQL databases.
       module PreparedStatementMethods
         # Override insert action to use RETURNING if the server supports it.
-        def run(&block)
+        def run
           if @prepared_type == :insert && supports_insert_select?
             fetch_rows(prepared_sql){|r| return r.values.first}
           else
@@ -743,7 +827,7 @@ module Sequel
         mod.def_mutation_method(:disable_insert_returning)
       end
 
-      # Return the results of an ANALYZE query as a string
+      # Return the results of an EXPLAIN ANALYZE query as a string
       def analyze
         explain(:analyze=>true)
       end
@@ -767,6 +851,7 @@ module Sequel
 
       # Disable the use of INSERT RETURNING, even if the server supports it
       def disable_insert_returning
+        warn("disable_insert_returning is deprecated and will be removed in Sequel 3.35.0")
         clone(:disable_insert_returning=>true)
       end
 
@@ -785,11 +870,11 @@ module Sequel
       def full_text_search(cols, terms, opts = {})
         lang = opts[:language] || 'simple'
         terms = terms.join(' | ') if terms.is_a?(Array)
-        filter("to_tsvector(?, ?) @@ to_tsquery(?, ?)", lang, full_text_string_join(cols), lang, terms)
+        filter("to_tsvector(?::regconfig, ?) @@ to_tsquery(?::regconfig, ?)", lang, full_text_string_join(cols), lang, terms)
       end
 
       # Insert given values into the database.
-      def insert(*values, &block)
+      def insert(*values)
         if @opts[:returning]
           super
         elsif !@opts[:sql] && supports_insert_select?
@@ -904,7 +989,13 @@ module Sequel
 
       # PostgreSQL allows deleting from joined datasets
       def delete_clause_methods
-        server_version >= 90100 ? DELETE_CLAUSE_METHODS_91 : DELETE_CLAUSE_METHODS
+        if (sv = server_version) >= 90100
+          DELETE_CLAUSE_METHODS_91
+        elsif sv >= 80200
+          DELETE_CLAUSE_METHODS_82
+        else
+          DELETE_CLAUSE_METHODS
+        end
       end
 
       # Only include the primary table in the main delete clause
@@ -1035,7 +1126,13 @@ module Sequel
 
       # PostgreSQL splits the main table from the joined tables
       def update_clause_methods
-        server_version >= 90100 ? UPDATE_CLAUSE_METHODS_91 : UPDATE_CLAUSE_METHODS
+        if (sv = server_version) >= 90100
+          UPDATE_CLAUSE_METHODS_91
+        elsif sv >= 80200
+          UPDATE_CLAUSE_METHODS_82
+        else
+          UPDATE_CLAUSE_METHODS
+        end
       end
 
       # Use FROM to specify additional tables in an update query

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

@@ -59,22 +59,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
@@ -226,7 +237,7 @@ module Sequel
           when :primary_key
             duplicate_table(table){|columns| columns.each{|s| s[:primary_key] = nil}}
           when :foreign_key
-            duplicate_table(table){|columns| columns.each{|s| s[:table] = nil}}
+            duplicate_table(table, :no_foreign_keys=>true)
           when :unique
             duplicate_table(table)
           else
@@ -283,20 +294,6 @@ module Sequel
           nono= Array(opts[:except]).compact.map{|n| n.to_s}
           cols.reject!{|c| nono.include? c[:name] }
         end
-
-        begin
-          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
-        rescue Sequel::DatabaseError
-          # Doesn't work correctly on some versions of JDBC SQLite,
-          # giving a "query does not return ResultSet" error.
-        end
         cols
       end
 
@@ -319,6 +316,20 @@ module Sequel
           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]
@@ -399,13 +410,12 @@ module Sequel
         m = output_identifier_meth
         metadata_dataset.from(:sqlite_master).server(opts[:server]).filter(filter).map{|r| m.call(r[:name])}
       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.
+
+      # 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
     
@@ -424,6 +434,8 @@ module Sequel
       NUMERIC = 'NUMERIC'.freeze
       INTEGER = 'INTEGER'.freeze
       BACKTICK = '`'.freeze
+      BACKTICK_RE = /`/.freeze
+      DOUBLE_BACKTICK = '``'.freeze
       BLOB_START = "X'".freeze
       HSTAR = "H*".freeze
 
@@ -470,14 +482,19 @@ module Sequel
       # 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
@@ -488,7 +505,7 @@ module Sequel
       
       # SQLite uses the nonstandard ` (backtick) for quoting identifiers.
       def quoted_identifier_append(sql, c)
-        sql << BACKTICK << c.to_s << BACKTICK
+        sql << BACKTICK << c.to_s.gsub(BACKTICK_RE, DOUBLE_BACKTICK) << BACKTICK
       end
       
       # When a qualified column is selected on SQLite and the qualifier