sequel 3.21.0 → 3.36.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
@@ -72,11 +118,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)
@@ -103,11 +144,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 +167,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 +209,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 +222,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
@@ -204,6 +259,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 +274,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 +283,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 +349,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 +375,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 +388,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,22 +20,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

@@ -7,27 +7,6 @@ module Sequel
     # 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
@@ -41,69 +20,25 @@ 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|
-            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
-        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
+          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

@@ -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,17 +15,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,
     }
       
@@ -59,11 +63,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,11 +133,13 @@ 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)
+          res.each{|h| yield h}
         end
         self
       end