sequel 3.21.0 → 3.41.0

data/lib/sequel/adapters/sqlite.rb

@@ -1,9 +1,4 @@
 require 'sqlite3'
-begin
-  SQLite3::Database.instance_method(:type_translation)
-rescue
-  raise(Sequel::Error, "SQLite3::Database#type_translation is not defined.  If you are using the sqlite3 gem, please install the sqlite3-ruby gem.")
-end
 Sequel.require 'adapters/shared/sqlite'
 
 module Sequel
@@ -11,21 +6,62 @@ module Sequel
   # for Sequel.
   module SQLite
     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
+      FALSE_VALUES = (%w'0 false f no n' + [0]).freeze
+
+      def blob(s)
+        Sequel::SQL::Blob.new(s.to_s)
+      end
+
+      def boolean(s)
+        s = s.downcase if s.is_a?(String)
+        !FALSE_VALUES.include?(s)
+      end
+
+      def date(s)
+        case s
+        when String
+          Sequel.string_to_date(s)
+        when Integer
+          Date.jd(s)
+        when Float
+          Date.jd(s.to_i)
+        else
+          raise Sequel::Error, "unhandled type when converting to date: #{s.inspect} (#{s.class.inspect})"
+        end
+      end
+
+      def integer(s)
+        s.to_i
+      end
+
+      def float(s)
+        s.to_f
+      end
+
+      def numeric(s)
+        s = s.to_s unless s.is_a?(String)
+        ::BigDecimal.new(s) rescue s
+      end
+
+      def time(s)
+        case s
+        when String
+          Sequel.string_to_time(s)
+        when Integer
+          Sequel::SQLTime.create(s/3600, (s % 3600)/60, s % 60)
+        when Float
+          s, f = s.divmod(1)
+          Sequel::SQLTime.create(s/3600, (s % 3600)/60, s % 60, (f*1000000).round)
+        else
+          raise Sequel::Error, "unhandled type when converting to date: #{s.inspect} (#{s.class.inspect})"
+        end
+      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'bit bool boolean' => tt.method(:boolean),
@@ -51,6 +87,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['datetime'] = @conversion_procs['timestamp'] = method(:to_application_timestamp)
+        set_integer_booleans
+      end
       
       # Connect to the database.  Since SQLite is a file based database,
       # the only options available are :database (to specify the database
@@ -71,10 +117,11 @@ module Sequel
         
         db
       end
-      
-      # Return instance of Sequel::SQLite::Dataset with the given options.
-      def dataset(opts = nil)
-        SQLite::Dataset.new(self, opts)
+
+      # Disconnect given connections from the database.
+      def disconnect_connection(c)
+        c.prepared_statements.each_value{|v| v.first.close}
+        c.close
       end
       
       # Run the given SQL with the given arguments and yield each row.
@@ -103,11 +150,20 @@ module Sequel
         _execute(:insert, sql, opts)
       end
       
-      # Run the given SQL with the given arguments and return the first value of the first row.
-      def single_value(sql, opts={})
-        _execute(:single_value, sql, opts)
+      # Handle Integer and Float arguments, since SQLite can store timestamps as integers and floats.
+      def to_application_timestamp(s)
+        case s
+        when String
+          super
+        when Integer
+          super(Time.at(s).to_s)
+        when Float
+          super(DateTime.jd(s).to_s)
+        else
+          raise Sequel::Error, "unhandled type when converting to : #{s.inspect} (#{s.class.inspect})"
+        end
       end
-      
+
       private
       
       # Yield an available connection.  Rescue
@@ -117,12 +173,11 @@ 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)}
-            when :single_value
-              log_yield(sql, log_args){conn.get_first_value(sql, args)}
             when :insert
               log_yield(sql, log_args){conn.execute(sql, args)}
               conn.last_insert_row_id
@@ -160,7 +215,7 @@ module Sequel
 
       # Execute a prepared statement on the database using the given name.
       def execute_prepared_statement(conn, type, name, opts, &block)
-        ps = prepared_statements[name]
+        ps = prepared_statement(name)
         sql = ps.prepared_sql
         args = opts[:arguments]
         ps_args = {}
@@ -173,13 +228,19 @@ module Sequel
           end
         end
         unless cps
-          cps = conn.prepare(sql)
+          cps = log_yield("PREPARE #{name}: #{sql}"){conn.prepare(sql)}
           conn.prepared_statements[name] = [cps, sql]
         end
+        log_sql = "EXECUTE #{name}"
+        if ps.log_sql
+          log_sql << " ("
+          log_sql << sql
+          log_sql << ")"
+        end
         if block
-          log_yield("Executing prepared statement #{name}", args){cps.execute(ps_args, &block)}
+          log_yield(log_sql, args){cps.execute(ps_args, &block)}
         else
-          log_yield("Executing prepared statement #{name}", args){cps.execute!(ps_args){|r|}}
+          log_yield(log_sql, args){cps.execute!(ps_args){|r|}}
           case type
           when :insert
             conn.last_insert_row_id
@@ -189,21 +250,18 @@ module Sequel
         end
       end
       
-      # The main error class that SQLite3 raises
+      # SQLite3 raises ArgumentError in addition to SQLite3::Exception in
+      # some cases, such as operations on a closed database.
       def database_error_classes
-        [SQLite3::Exception]
-      end
-
-      # Disconnect given connections from the database.
-      def disconnect_connection(c)
-        c.prepared_statements.each_value{|v| v.first.close}
-        c.close
+        [SQLite3::Exception, ArgumentError]
       end
     end
     
     # 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 +275,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 +284,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,14 +350,15 @@ 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|
             row = {}
             cols.each do |name,i,type_proc|
               v = values[i]
-              if type_proc && v.is_a?(String)
+              if type_proc && v
                 v = type_proc.call(v)
               end
               row[name] = v
@@ -312,9 +376,8 @@ module Sequel
         ps.extend(PreparedStatementMethods)
         if name
           ps.prepared_statement_name = name
-          db.prepared_statements[name] = ps
+          db.set_prepared_statement(name, ps)
         end
-        ps.prepared_sql
         ps
       end
       
@@ -326,8 +389,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

@@ -1,3 +1,4 @@
+require 'swift/db/mysql'
 Sequel.require 'adapters/shared/mysql'
 
 module Sequel
@@ -9,11 +10,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,22 +21,24 @@ module Sequel
         def schema_column_type(db_type)
           db_type == 'tinyint(1)' ? :boolean : super
         end
+      
+        # Apply the connectiong setting SQLs for every new connection.
+        def setup_connection(conn)
+          mysql_connection_setting_sqls.each{|sql| log_yield(sql){conn.execute(sql)}}
+          super
+        end
       end
       
       # Dataset class for MySQL datasets accessed via Swift.
       class Dataset < Swift::Dataset
         include Sequel::MySQL::DatasetMethods
-        
-        # Use execute_insert to execute the replace_sql.
-        def replace(*args)
-          execute_insert(replace_sql(*args))
-        end
+        APOS = Dataset::APOS
         
         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

@@ -1,33 +1,13 @@
+require 'swift/db/postgres'
 Sequel.require 'adapters/shared/postgres'
 
 module Sequel
-  Postgres::CONVERTED_EXCEPTIONS << ::SwiftError
+  Postgres::CONVERTED_EXCEPTIONS << ::Swift::Error
   
   module Swift
     # Adapter, Database, and Dataset support for accessing a PostgreSQL
     # database via Swift.
     module Postgres
-      # Methods to add to the Swift adapter/connection to allow it to work
-      # with the shared PostgreSQL code.
-      module AdapterMethods
-        include Sequel::Postgres::AdapterMethods
-        
-        # Log all SQL that goes through the execute method to the related
-        # database object.
-        def execute(sql, *args)
-          @db.log_yield(sql){super}
-        rescue SwiftError => e
-          @db.send(:raise_error, e)
-        end
-        
-        private
-        
-        # Swift specific method of getting specific values from a result set.
-        def single_value(row)
-          row.values.at(0)
-        end
-      end
-    
       # Methods to add to Database instances that access PostgreSQL via Swift.
       module DatabaseMethods
         include Sequel::Postgres::DatabaseMethods
@@ -35,75 +15,29 @@ module Sequel
         # Add the primary_keys and primary_key_sequences instance variables,
         # so we can get the correct return values for inserted rows.
         def self.extended(db)
-          db.instance_eval do
-            @primary_keys = {}
-            @primary_key_sequences = {}
-          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|
-            begin
-              res = conn.execute(sql)
-              yield res if block_given?
-              nil
-            rescue SwiftError => e
-              raise_error(e)
-            end
-          end
-        end
-        
-        # Run the DELETE/UPDATE SQL on the database and return the number
-        # of matched rows.
-        def execute_dui(sql, opts={})
-          synchronize(opts[:server]) do |conn|
-            begin
-              conn.execute(sql).rows
-            rescue SwiftError => e
-              raise_error(e)
-            end
-          end
-        end
-      
-        # Run the INSERT SQL on the database and return the primary key
-        # for the record.
-        def execute_insert(sql, opts={})
-          synchronize(opts[:server]) do |conn|
-            begin
-              conn.execute(sql)
-              insert_result(conn, opts[:table], opts[:values])
-            rescue SwiftError => e
-              raise_error(e)
-            end
-          end
+          db.send(:initialize_postgres_adapter)
         end
         
         private
         
-        # Execute SQL on the connection.
-        def log_connection_execute(conn, sql)
-          conn.execute(sql)
+        # Remove all other options except for ones specifically handled, as
+        # otherwise swift passes them to dbic++ which passes them to PostgreSQL
+        # which can raise an error.
+        def server_opts(o)
+          o = super
+          so = {}
+          [:db, :user, :password, :host, :port].each{|s| so[s] = o[s] if o.has_key?(s)}
+          so
         end
       
         # Extend the adapter with the Swift PostgreSQL AdapterMethods.
         def setup_connection(conn)
           conn = super(conn)
-          conn.extend(Sequel::Swift::Postgres::AdapterMethods)
-          conn.db = self
-          conn.apply_connection_settings
+          conn.native_bind_format = true
+          connection_configuration_sqls.each{|sql| log_yield(sql){conn.execute(sql)}}
           conn
         end
       end
-      
-      class Dataset < Swift::Dataset
-        include Sequel::Postgres::DatasetMethods
-      end
     end
   end
 end

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

@@ -1,3 +1,4 @@
+require 'swift/db/sqlite3'
 Sequel.require 'adapters/shared/sqlite'
 
 module Sequel
@@ -8,10 +9,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 +25,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.rb

@@ -1,11 +1,8 @@
-require 'swift'
-
 module Sequel
-  # Module holding the Swift support for Sequel.  Swift is a
-  # ruby front-end for dbic++, a fast database access library
-  # written in C++.
+  # Module holding the Swift DB support for Sequel.  Swift DB is a
+  # collection of drivers used in Swift ORM.
   #
-  # The Swift adapter currently supports PostgreSQL and MySQL:
+  # The Swift adapter currently supports PostgreSQL, MySQL and SQLite3
   #
   #   Sequel.connect('swift://user:password@host/database?db_type=postgres')
   #   Sequel.connect('swift://user:password@host/database?db_type=mysql')
@@ -15,17 +12,21 @@ module Sequel
     DATABASE_SETUP = {:postgres=>proc do |db|
         Sequel.ts_require 'adapters/swift/postgres'
         db.extend(Sequel::Swift::Postgres::DatabaseMethods)
+        db.extend_datasets Sequel::Postgres::DatasetMethods
         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
+        db.set_integer_booleans
       end,
     }
       
@@ -56,14 +57,11 @@ module Sequel
       
       # Create an instance of swift_class for the given options.
       def connect(server)
-        setup_connection(swift_class.new(server_opts(server)))
+        opts = server_opts(server)
+        opts[:pass] = opts[:password]
+        setup_connection(swift_class.new(opts))
       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|
@@ -71,7 +69,7 @@ module Sequel
             res = log_yield(sql){conn.execute(sql)}
             yield res if block_given?
             nil
-          rescue SwiftError => e
+          rescue ::Swift::Error => e
             raise_error(e)
           end
         end
@@ -82,8 +80,8 @@ module Sequel
       def execute_dui(sql, opts={})
         synchronize(opts[:server]) do |conn|
           begin
-            log_yield(sql){conn.execute(sql).rows}
-          rescue SwiftError => e
+            log_yield(sql){conn.execute(sql).affected_rows}
+          rescue ::Swift::Error => e
             raise_error(e)
           end
         end
@@ -95,7 +93,7 @@ module Sequel
         synchronize(opts[:server]) do |conn|
           begin
             log_yield(sql){conn.execute(sql).insert_id}
-          rescue SwiftError => e
+          rescue ::Swift::Error => e
             raise_error(e)
           end
         end
@@ -109,15 +107,10 @@ module Sequel
         :execute
       end
       
-      # Close the given database connection.
-      def disconnect_connection(c)
-      end
-      
-      # Execute SQL on the connection
-      def log_connection_execute(conn, sql)
-        log_yield(sql){conn.execute(sql)}
+      def database_error_classes
+        [::Swift::Error]
       end
-      
+
       # Set the :db entry to the same as the :database entry, since
       # Swift uses :db.
       def server_opts(o)
@@ -134,11 +127,22 @@ 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)
+      def fetch_rows(sql)
         execute(sql) do |res|
-          @columns = res.fields
-          res.each(&block)
+          col_map = {}
+          @columns = res.fields.map do |c|
+            col_map[c] = output_identifier(c)
+          end
+          res.each do |r|
+            h = {}
+            r.each do |k, v|
+              h[col_map[k]] = v.is_a?(StringIO) ? SQL::Blob.new(v.read) : v
+            end
+            yield h
+          end
         end
         self
       end