sequel 3.21.0 → 3.32.0

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

@@ -7,16 +7,9 @@ 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
 
       # A symbol signifying the value of the auto_vacuum PRAGMA.
       def auto_vacuum
@@ -30,7 +23,20 @@ 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
+
+      # Boolean signifying the value of the case_sensitive_likePRAGMA, or nil
+      # if not using SQLite 3.2.3+.
+      def case_sensitive_like
+        pragma_get(:case_sensitive_like).to_i == 1 if sqlite_version >= 30203
+      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
@@ -96,11 +102,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 +142,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 +157,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,12 +211,27 @@ 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){|columns| columns.each{|s| s[:table] = nil}}
+          when :unique
+            duplicate_table(table)
+          else
+            raise Error, "Unsupported :type option for drop_constraint: #{op[:type].inspect}"
+          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]
       def backup_table_name(table, opts={})
         table = table.gsub('`', '')
@@ -176,17 +241,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)
@@ -208,7 +275,7 @@ module Sequel
           cols.reject!{|c| nono.include? c[:name] }
         end
 
-        if foreign_keys
+        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]
@@ -217,6 +284,9 @@ module Sequel
             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
@@ -231,17 +301,26 @@ 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
+
+        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 +359,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)
@@ -300,12 +379,18 @@ module Sequel
       # 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
       
+      # 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 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
@@ -317,28 +402,59 @@ module Sequel
     
     # 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}
-    
+      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
+      BLOB_START = "X'".freeze
+      HSTAR = "H*".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)
+      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.
@@ -362,8 +478,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 << 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 +510,53 @@ 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
-      
+
       # SQLite does not support the SQL WITH clause
       def select_clause_methods
         SELECT_CLAUSE_METHODS
@@ -416,7 +566,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}"

data/lib/sequel/adapters/sqlite.rb

@@ -13,26 +13,21 @@ module Sequel
     TYPE_TRANSLATOR = tt = Class.new do
       FALSE_VALUES = %w'0 false f no n'.freeze
       def boolean(s) !FALSE_VALUES.include?(s.downcase) end
-      def blob(s) ::Sequel::SQL::Blob.new(s) end
       def integer(s) s.to_i end
       def float(s) s.to_f end
       def numeric(s) ::BigDecimal.new(s) rescue s end
-      def date(s) ::Sequel.string_to_date(s) end
-      def time(s) ::Sequel.string_to_time(s) end
-      def timestamp(s) ::Sequel.database_to_application_timestamp(s) end
     end.new
 
     # Hash with string keys and callable values for converting SQLite types.
     SQLITE_TYPES = {}
     {
-      %w'timestamp datetime' => tt.method(:timestamp),
-      %w'date' => tt.method(:date),
-      %w'time' => tt.method(:time),
+      %w'date' => ::Sequel.method(:string_to_date),
+      %w'time' => ::Sequel.method(:string_to_time),
       %w'bit bool boolean' => tt.method(:boolean),
       %w'integer smallint mediumint int bigint' => tt.method(:integer),
       %w'numeric decimal money' => tt.method(:numeric),
       %w'float double real dec fixed' + ['double precision'] => tt.method(:float),
-      %w'blob' => tt.method(:blob)
+      %w'blob' => ::Sequel::SQL::Blob.method(:new)
     }.each do |k,v|
       k.each{|n| SQLITE_TYPES[n] = v}
     end
@@ -51,6 +46,16 @@ module Sequel
       end
       
       private_class_method :uri_to_options
+
+      # The conversion procs to use for this database
+      attr_reader :conversion_procs
+
+      def initialize(opts={})
+        super
+        @conversion_procs = SQLITE_TYPES.dup
+        @conversion_procs['timestamp'] = method(:to_application_timestamp)
+        @conversion_procs['datetime'] = method(:to_application_timestamp)
+      end
       
       # Connect to the database.  Since SQLite is a file based database,
       # the only options available are :database (to specify the database
@@ -72,11 +77,6 @@ module Sequel
         db
       end
       
-      # Return instance of Sequel::SQLite::Dataset with the given options.
-      def dataset(opts = nil)
-        SQLite::Dataset.new(self, opts)
-      end
-      
       # Run the given SQL with the given arguments and yield each row.
       def execute(sql, opts={}, &block)
         _execute(:select, sql, opts, &block)
@@ -117,7 +117,8 @@ module Sequel
           synchronize(opts[:server]) do |conn|
             return execute_prepared_statement(conn, type, sql, opts, &block) if sql.is_a?(Symbol)
             log_args = opts[:arguments]
-            args = opts.fetch(:arguments, [])
+            args = {}
+            opts.fetch(:arguments, {}).each{|k, v| args[k] = prepared_statement_argument(v)}
             case type
             when :select
               log_yield(sql, log_args){conn.query(sql, args, &block)}
@@ -173,7 +174,7 @@ module Sequel
           end
         end
         unless cps
-          cps = conn.prepare(sql)
+          cps = log_yield("Preparing #{name}: #{sql}"){conn.prepare(sql)}
           conn.prepared_statements[name] = [cps, sql]
         end
         if block
@@ -204,6 +205,8 @@ module Sequel
     # Dataset class for SQLite datasets that use the ruby-sqlite3 driver.
     class Dataset < Sequel::Dataset
       include ::Sequel::SQLite::DatasetMethods
+
+      Database::DatasetClass = self
       
       PREPARED_ARG_PLACEHOLDER = ':'.freeze
       
@@ -217,7 +220,7 @@ module Sequel
         # but with the keys converted to strings.
         def map_to_prepared_args(hash)
           args = {}
-          hash.each{|k,v| args[k.to_s] = v}
+          hash.each{|k,v| args[k.to_s.gsub('.', '__')] = v}
           args
         end
         
@@ -226,7 +229,12 @@ module Sequel
         # SQLite uses a : before the name of the argument for named
         # arguments.
         def prepared_arg(k)
-          LiteralString.new("#{prepared_arg_placeholder}#{k}")
+          LiteralString.new("#{prepared_arg_placeholder}#{k.to_s.gsub('.', '__')}")
+        end
+
+        # Always assume a prepared argument.
+        def prepared_arg?(k)
+          true
         end
       end
       
@@ -287,7 +295,8 @@ module Sequel
       def fetch_rows(sql)
         execute(sql) do |result|
           i = -1
-          type_procs = result.types.map{|t| SQLITE_TYPES[base_type_name(t)]}
+          cps = db.conversion_procs
+          type_procs = result.types.map{|t| cps[base_type_name(t)]}
           cols = result.columns.map{|c| i+=1; [output_identifier(c), i, type_procs[i]]}
           @columns = cols.map{|c| c.first}
           result.each do |values|
@@ -314,7 +323,6 @@ module Sequel
           ps.prepared_statement_name = name
           db.prepared_statements[name] = ps
         end
-        ps.prepared_sql
         ps
       end
       
@@ -326,8 +334,8 @@ module Sequel
       end
 
       # Quote the string using the adapter class method.
-      def literal_string(v)
-        "'#{::SQLite3::Database.quote(v)}'"
+      def literal_string_append(sql, v)
+        sql << "'" << ::SQLite3::Database.quote(v) << "'"
       end
 
       # SQLite uses a : before the name of the argument as a placeholder.

data/lib/sequel/adapters/swift/mysql.rb

@@ -9,11 +9,6 @@ module Sequel
       module DatabaseMethods
         include Sequel::MySQL::DatabaseMethods
         
-        # Return instance of Sequel::Swift::MySQL::Dataset with the given opts.
-        def dataset(opts=nil)
-          Sequel::Swift::MySQL::Dataset.new(self, opts)
-        end
-        
         private
         
         # The database name for the given database.
@@ -25,11 +20,21 @@ module Sequel
         def schema_column_type(db_type)
           db_type == 'tinyint(1)' ? :boolean : super
         end
+      
+        # By default, MySQL 'where id is null' selects the last inserted id.
+        # Turn that off unless explicitly enabled.
+        def setup_connection(conn)
+          super
+          sql = "SET SQL_AUTO_IS_NULL=0"
+          log_yield(sql){conn.execute(sql)} unless opts[:auto_is_null]
+          conn
+        end
       end
       
       # Dataset class for MySQL datasets accessed via Swift.
       class Dataset < Swift::Dataset
         include Sequel::MySQL::DatasetMethods
+        APOS = Dataset::APOS
         
         # Use execute_insert to execute the replace_sql.
         def replace(*args)
@@ -39,8 +44,8 @@ module Sequel
         private
         
         # Use Swift's escape method for quoting.
-        def literal_string(s)
-          db.synchronize{|c| "'#{c.escape(s)}'"}
+        def literal_string_append(sql, s)
+          sql << APOS << db.synchronize{|c| c.escape(s)} << APOS
         end
       end
     end

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

@@ -41,11 +41,6 @@ module Sequel
           end
         end
         
-        # Return instance of Sequel::Swift::Postgres::Dataset with the given opts.
-        def dataset(opts=nil)
-          Sequel::Swift::Postgres::Dataset.new(self, opts)
-        end
-        
         # Run the SELECT SQL on the database and yield the rows
         def execute(sql, opts={})
           synchronize(opts[:server]) do |conn|

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

@@ -8,10 +8,12 @@ module Sequel
       # Database instance methods for SQLite databases accessed via Swift.
       module DatabaseMethods
         include Sequel::SQLite::DatabaseMethods
-        
-        # Return instance of Sequel::Swift::SQL::Dataset with the given opts.
-        def dataset(opts=nil)
-          Sequel::Swift::SQLite::Dataset.new(self, opts)
+
+        # Set the correct pragmas on the connection.
+        def connect(opts)
+          c = super
+          connection_pragmas.each{|s| log_yield(s){c.execute(s)}}
+          c
         end
       end
       
@@ -22,8 +24,8 @@ module Sequel
         private
         
         # Use Swift's escape method for quoting.
-        def literal_string(s)
-          db.synchronize{|c| "#{c.escape(s)}"}
+        def literal_string_append(sql, s)
+          sql << db.synchronize{|c| c.escape(s)}
         end
       end
     end

data/lib/sequel/adapters/swift.rb

@@ -15,16 +15,19 @@ module Sequel
     DATABASE_SETUP = {:postgres=>proc do |db|
         Sequel.ts_require 'adapters/swift/postgres'
         db.extend(Sequel::Swift::Postgres::DatabaseMethods)
+        db.dataset_class = Sequel::Swift::Postgres::Dataset
         db.swift_class = ::Swift::DB::Postgres
       end,
       :mysql=>proc do |db|
         Sequel.ts_require 'adapters/swift/mysql'
         db.extend(Sequel::Swift::MySQL::DatabaseMethods)
+        db.dataset_class = Sequel::Swift::MySQL::Dataset
         db.swift_class = ::Swift::DB::Mysql
       end,
       :sqlite=>proc do |db|
         Sequel.ts_require 'adapters/swift/sqlite'
         db.extend(Sequel::Swift::SQLite::DatabaseMethods)
+        db.dataset_class = Sequel::Swift::SQLite::Dataset
         db.swift_class = ::Swift::DB::Sqlite3
       end,
     }
@@ -59,11 +62,6 @@ module Sequel
         setup_connection(swift_class.new(server_opts(server)))
       end
       
-      # Return a Sequel::Swift::Dataset object for this database.
-      def dataset(opts = nil)
-        Swift::Dataset.new(self, opts)
-      end
-    
       # Execute the given SQL, yielding a Swift::Result if a block is given.
       def execute(sql, opts={})
         synchronize(opts[:server]) do |conn|
@@ -134,6 +132,8 @@ module Sequel
     end
     
     class Dataset < Sequel::Dataset
+      Database::DatasetClass = self
+
       # Set the columns and yield the hashes to the block.
       def fetch_rows(sql, &block)
         execute(sql) do |res|