sequel 3.33.0 → 3.34.0

data/doc/schema_modification.rdoc

@@ -143,9 +143,10 @@ as it's third argument.  A simple example is:
         on most databases.
 :on_delete :: Specify the behavior of this foreign key column when the row with the primary key
               it references is deleted , can be :restrict, :cascade, :set_null, or :set_default.
+              You can also use a string, which is used literally.
 :on_update :: Specify the behavior of this foreign key column when the row with the primary key
-              it references modifies the value of the primary key, can be
-              :restrict, :cascade, :set_null, or :set_default.
+              it references modifies the value of the primary key.  Takes the same options as
+              :on_delete.
 
 Like +primary_key+, if you provide +foreign_key+ with an array of symbols, it will not create a
 column, but create a foreign key constraint:
@@ -253,6 +254,21 @@ and it creates an unnamed constraint
     check{char_length(name) > 2}
   end
   
+== +create_join_table+
+
++create_join_table+ is a shortcut that you can use to create simple many-to-many join tables:
+
+  create_join_table(:artist_id=>:artists, :album_id=>:albums)
+
+which expands to:
+
+  create_table(:albums_artists) do
+    foreign_key :album_id, :albums, :null=>false
+    foreign_key :artist_id, :artists, :null=>false
+    primary_key [:album_id, :artist_id]
+    index [:artist_id, :album_id]
+  end
+
 == +alter_table+
 
 +alter_table+ is used to alter existing tables, changing their columns, indexes,

data/doc/virtual_rows.rdoc

@@ -205,6 +205,55 @@ call, with an optional hash as the second argument: Here are some examples of us
   ds.select{sum(:over, :args=>col1, :partition=>col2, :order=>col3){}}
   # SELECT sum(col1) OVER (PARTITION BY col2 ORDER BY col3)
 
+== Operators
+
+VirtualRows use method_missing to handle almost all method calls.  However, they
+have special handling of some operator methods to make certain things easier. The
+operators all use a prefix form.
+
+=== Math Operators
+
+The standard +, -, *, and / mathematical operators are defined:
+
+  ds.select{|o| o.-(1, o.a).as(b)}
+  ds.select{self.-(1, a).as(b)}
+  # SELECT (1 - a) AS b
+
+=== Boolean Operators
+
+The & and | methods are defined to use AND and OR:
+
+  ds.where{|o| o.&({:a=>:b}, :c)}
+  ds.where{self.&({:a=>:b}, :c)}
+  # WHERE ((a = b) AND c)
+
+The ~ method is defined to do inversion:
+
+  ds.where{|o| o.~({:a=>1, :b=>2})}
+  ds.where{self.~({:a=>1, :b=>2})}
+  # WHERE ((a != 1) OR (b != 2))
+
+=== Inequality Operators
+
+The standard >, <, >=, and <= inequality operators are defined:
+
+  ds.where{|o| o.>(1, :c)}
+  ds.where{self.>(1, :c)}
+  # WHERE (1 > c)
+
+== Literal Strings
+
+The backtick operator can be used inside an instance-evaled
+virtual row block to create a literal string:
+
+  ds.where{a > `some SQL`}
+  # WHERE (a > some SQL)
+
+You can use this on a regular virtual row block too, but it
+doesn't look as nice:
+
+  ds.where{|o| o.>(:a, o.`('some SQL')}
+
 == Returning multiple values
 
 It's common when using select and order virtual row blocks to want to

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

@@ -36,11 +36,6 @@ module Sequel
           false
         end
       
-        # Use execute_insert to execute the replace_sql.
-        def replace(*args)
-          execute_insert(replace_sql(*args))
-        end
-        
         private
         
         # do_mysql sets NO_BACKSLASH_ESCAPES, so use standard SQL string escaping

data/lib/sequel/adapters/ibmdb.rb

@@ -174,7 +174,7 @@ module Sequel
       # REORG the related table whenever it is altered.  This is not always
       # required, but it is necessary for compatibilty with other Sequel
       # code in many cases.
-      def alter_table(name, generator=nil, &block)
+      def alter_table(name, generator=nil)
         res = super
         reorg(name)
         res
@@ -231,11 +231,16 @@ module Sequel
         sql = ps.prepared_sql
         synchronize(opts[:server]) do |conn|
           unless conn.prepared_statements.fetch(ps_name, []).first == sql
-            log_yield("Preparing #{ps_name}: #{sql}"){conn.prepare(sql, ps_name)}
+            log_yield("PREPARE #{ps_name}: #{sql}"){conn.prepare(sql, ps_name)}
           end
           args = args.map{|v| v.nil? ? nil : prepared_statement_arg(v)}
-          stmt = log_yield("Executing #{ps_name}: #{args.inspect}"){conn.execute_prepared(ps_name, *args)}
-
+          log_sql = "EXECUTE #{ps_name}"
+          if ps.log_sql
+            log_sql << " ("
+            log_sql << sql
+            log_sql << ")"
+          end
+          stmt = log_yield(log_sql, args){conn.execute_prepared(ps_name, *args)}
           if block_given?
             begin
               yield(stmt)

data/lib/sequel/adapters/jdbc.rb

@@ -343,13 +343,18 @@ module Sequel
           if name and cps = conn.prepared_statements[name] and cps[0] == sql
             cps = cps[1]
           else
-            log_yield("Closing #{name}"){cps[1].close} if cps
-            cps = log_yield("Preparing#{" #{name}:" if name} #{sql}"){conn.prepareStatement(sql)}
+            log_yield("CLOSE #{name}"){cps[1].close} if cps
+            cps = log_yield("PREPARE#{" #{name}:" if name} #{sql}"){conn.prepareStatement(sql)}
             conn.prepared_statements[name] = [sql, cps] if name
           end
           i = 0
           args.each{|arg| set_ps_arg(cps, arg, i+=1)}
-          msg = "Executing#{" #{name}" if name}"
+          msg = "EXECUTE#{" #{name}" if name}"
+          if ps.log_sql
+            msg << " ("
+            msg << sql
+            msg << ")"
+          end
           begin
             if block_given?
               yield log_yield(msg, args){cps.executeQuery}
@@ -623,7 +628,7 @@ module Sequel
       # Handle type conversions for common Java types.
       class TYPE_TRANSLATOR
         LF = "\n".freeze
-        def time(v) Sequel.string_to_time(v.to_string) end
+        def time(v) Sequel.string_to_time(v.to_string) + v.getTime.divmod(1000).last/1000.0 end
         def date(v) Date.civil(v.getYear + 1900, v.getMonth + 1, v.getDate) end
         def decimal(v) BigDecimal.new(v.to_string) end
         def byte_array(v) Sequel::SQL::Blob.new(String.from_java_bytes(v)) end

data/lib/sequel/adapters/jdbc/h2.rb

@@ -25,7 +25,7 @@ module Sequel
 
         # H2 uses an IDENTITY type
         def serial_primary_key_options
-          {:primary_key => true, :type => :identity}
+          {:primary_key => true, :type => :identity, :identity=>true}
         end
 
         # H2 supports CREATE TABLE IF NOT EXISTS syntax.
@@ -114,6 +114,12 @@ module Sequel
         def schema_column_type(db_type)
           db_type == 'clob' ? :string : super
         end
+
+        # Use BIGINT IDENTITY for identity columns that use bigint, fixes
+        # the case where primary_key :column, :type=>Bignum is used.
+        def type_literal_generic_bignum(column)
+          column[:identity] ? 'BIGINT IDENTITY' : super
+        end
       end
       
       # Dataset class for H2 datasets accessed via JDBC.
@@ -124,7 +130,7 @@ module Sequel
         HSTAR = "H*".freeze
         BITCOMP_OPEN = "((0 - ".freeze
         BITCOMP_CLOSE = ") - 1)".freeze
-        ILIKE_PLACEHOLDER = "CAST(? AS VARCHAR_IGNORECASE)".freeze
+        ILIKE_PLACEHOLDER = ["CAST(".freeze, " AS VARCHAR_IGNORECASE)".freeze].freeze
         TIME_FORMAT = "'%H:%M:%S'".freeze
         
         # Emulate the case insensitive LIKE operator and the bitwise operators.

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

@@ -66,11 +66,6 @@ module Sequel
       # Dataset class for MySQL datasets accessed via JDBC.
       class Dataset < JDBC::Dataset
         include Sequel::MySQL::DatasetMethods
-        
-        # Use execute_insert to execute the replace_sql.
-        def replace(*args)
-          execute_insert(replace_sql(*args))
-        end
       end
     end
   end

data/lib/sequel/adapters/jdbc/postgresql.rb

@@ -75,6 +75,49 @@ module Sequel
         include Sequel::Postgres::DatasetMethods
         APOS = Dataset::APOS
 
+        class ::Sequel::JDBC::Dataset::TYPE_TRANSLATOR
+          # Convert Java::OrgPostgresqlJdbc4::Jdbc4Array to ruby arrays
+          def pg_array(v)
+            _pg_array(v.array)
+          end
+
+          # Convert Java::OrgPostgresqlUtil::PGobject to ruby strings
+          def pg_object(v)
+            v.to_string
+          end
+
+          private
+
+          # Handle multi-dimensional Java arrays by recursively mapping them
+          # to ruby arrays.
+          def _pg_array(v)
+            v.to_ary.map do |i|
+              if i.respond_to?(:to_ary)
+                _pg_array(i)
+              else
+                i
+              end
+            end
+          end
+        end
+
+        PG_ARRAY_METHOD = TYPE_TRANSLATOR_INSTANCE.method(:pg_array)
+        PG_OBJECT_METHOD = TYPE_TRANSLATOR_INSTANCE.method(:pg_object)
+      
+        # Handle PostgreSQL array and object types. Object types are just
+        # turned into strings, similarly to how the native adapter treats
+        # the types.
+        def convert_type_proc(v)
+          case v
+          when Java::OrgPostgresqlJdbc4::Jdbc4Array
+            PG_ARRAY_METHOD
+          when Java::OrgPostgresqlUtil::PGobject
+            PG_OBJECT_METHOD
+          else
+            super
+          end
+        end
+        
         # Add the shared PostgreSQL prepared statement methods
         def prepare(*args)
           ps = super

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

@@ -8,7 +8,26 @@ module Sequel
       module DatabaseMethods
         include Sequel::SQLite::DatabaseMethods
         LAST_INSERT_ROWID = 'SELECT last_insert_rowid()'.freeze
+        FOREIGN_KEY_ERROR_RE = /query does not return ResultSet/.freeze
         
+        # Swallow pointless exceptions when the foreign key list pragma
+        # doesn't return any rows.
+        def foreign_key_list(table, opts={})
+          super
+        rescue Sequel::DatabaseError => e
+          raise unless e.message =~ FOREIGN_KEY_ERROR_RE
+          []
+        end
+
+        # Swallow pointless exceptions when the index list pragma
+        # doesn't return any rows.
+        def indexes(table, opts={})
+          super
+        rescue Sequel::DatabaseError => e
+          raise unless e.message =~ FOREIGN_KEY_ERROR_RE
+          {}
+        end
+
         private
         
         # Use last_insert_rowid() to get the last inserted id.

data/lib/sequel/adapters/mock.rb

@@ -44,6 +44,21 @@ module Sequel
         'sqlite'=>'SQLite'
       }
 
+      # Procs to run for specific database types to get the mock adapter
+      # to work with the shared adapter
+      SHARED_ADAPTER_SETUP = {
+        'postgres' => lambda do |db|
+          db.instance_eval do
+            @server_version = 90103
+            @primary_keys = {}
+            @primary_key_sequences = {}
+            def primary_key(table)
+              :id
+            end
+          end
+        end
+      }
+
       # Set the autogenerated primary key integer
       # to be returned when running an insert query.
       # Argument types supported:
@@ -98,6 +113,9 @@ module Sequel
       #          instance an raise it wrapped in a DatabaseError.
       attr_writer :numrows
 
+      # Mock the server version, useful when using the shared adapters
+      attr_accessor :server_version
+
       # Additional options supported:
       #
       # :autoid :: Call #autoid= with the value
@@ -114,6 +132,9 @@ module Sequel
           require "sequel/adapters/shared/#{opts[:host]}"
           extend Sequel.const_get(mod_name)::DatabaseMethods
           extend_datasets Sequel.const_get(mod_name)::DatasetMethods
+          if pr = SHARED_ADAPTER_SETUP[opts[:host]]
+            pr.call(self)
+          end
         end
         self.autoid = opts[:autoid]
         self.columns = opts[:columns]
@@ -186,12 +207,12 @@ module Sequel
         begin
           if block
             columns(ds, sql) if ds
-            _fetch(sql, ds._fetch || @fetch, &block)
+            _fetch(sql, (ds._fetch if ds) || @fetch, &block)
           elsif meth = opts[:meth]
             if meth == :numrows
-              _numrows(sql, ds.numrows || @numrows)
+              _numrows(sql, (ds.numrows if ds) || @numrows)
             else
-              v = ds.autoid
+              v = ds.autoid if ds
               _autoid(sql, v || @autoid, (ds if v))
             end
           end

data/lib/sequel/adapters/mysql.rb

@@ -43,6 +43,10 @@ module Sequel
       
       # Mysql::Error messages that indicate the current connection should be disconnected
       MYSQL_DATABASE_DISCONNECT_ERRORS = /\A(Commands out of sync; you can't run this command now|Can't connect to local MySQL server through socket|MySQL server has gone away|Lost connection to MySQL server during query)/
+       
+      # Regular expression used for getting accurate number of rows
+      # matched by an update statement.
+      AFFECTED_ROWS_RE = /Rows matched:\s+(\d+)\s+Changed:\s+\d+\s+Warnings:\s+\d+/.freeze
       
       set_adapter_scheme :mysql
 
@@ -155,6 +159,16 @@ module Sequel
         @convert_tinyint_to_bool = v
       end
 
+      # Return the number of matched rows when executing a delete/update statement.
+      def execute_dui(sql, opts={})
+        execute(sql, opts){|c| return affected_rows(c)}
+      end
+
+      # Return the last inserted id when executing an insert statement.
+      def execute_insert(sql, opts={})
+        execute(sql, opts){|c| return c.insert_id}
+      end
+
       # Return the version of the MySQL server two which we are connecting.
       def server_version(server=nil)
         @server_version ||= (synchronize(server){|conn| conn.server_version if conn.respond_to?(:server_version)} || super)
@@ -167,7 +181,7 @@ module Sequel
       # yield the connection if a block is given.
       def _execute(conn, sql, opts)
         begin
-          r = log_yield(sql){conn.query(sql)}
+          r = log_yield((log_sql = opts[:log_sql]) ? sql + log_sql : sql){conn.query(sql)}
           if opts[:type] == :select
             yield r if r
           elsif block_given?
@@ -209,6 +223,18 @@ module Sequel
         end
       end
       
+      # Try to get an accurate number of rows matched using the query
+      # info.  Fall back to affected_rows if there was no match, but
+      # that may be inaccurate.
+      def affected_rows(conn)
+        s = conn.info
+        if s && s =~ AFFECTED_ROWS_RE
+          $1.to_i
+        else
+          conn.affected_rows
+        end
+      end
+
       # MySQL connections use the query method to execute SQL without a result
       def connection_execute_method
         :query
@@ -269,19 +295,10 @@ module Sequel
 
       Database::DatasetClass = self
 
-      # Regular expression used for getting accurate number of rows
-      # matched by an update statement.
-      AFFECTED_ROWS_RE = /Rows matched:\s+(\d+)\s+Changed:\s+\d+\s+Warnings:\s+\d+/.freeze
-      
-      # Delete rows matching this dataset
-      def delete
-        execute_dui(delete_sql){|c| return c.affected_rows}
-      end
-      
       # Yield all rows matching this dataset.  If the dataset is set to
       # split multiple statements, yield arrays of hashes one per statement
       # instead of yielding results for all statements as hashes.
-      def fetch_rows(sql, &block)
+      def fetch_rows(sql)
         execute(sql) do |r|
           i = -1
           cps = db.conversion_procs
@@ -298,7 +315,7 @@ module Sequel
             yield_rows(r, cols){|h| s << h}
             yield s
           else
-            yield_rows(r, cols, &block)
+            yield_rows(r, cols){|h| yield h}
           end
         end
         self
@@ -310,22 +327,6 @@ module Sequel
         super
       end
       
-      # Insert a new value into this dataset
-      def insert(*values)
-        execute_dui(insert_sql(*values)){|c| return c.insert_id}
-      end
-      
-      # You can parse out the correct number of rows matched using the query info,
-      # even though affected_rows doesn't provide an accurate number.
-      def provides_accurate_rows_matched?
-        true
-      end
-
-      # Replace (update or insert) the matching row.
-      def replace(*args)
-        execute_dui(replace_sql(*args)){|c| return c.insert_id}
-      end
-      
       # Makes each yield arrays of rows, with each array containing the rows
       # for a given result set.  Does not work with graphing.  So you can submit
       # SQL with multiple statements and easily determine which statement
@@ -342,35 +343,13 @@ module Sequel
         ds
       end
       
-      # Update the matching rows.
-      def update(values={})
-        execute_dui(update_sql(values)){|c| return affected_rows(c)}
-      end
-      
       private
       
-      # Try to get an accurate number of rows matched using the query
-      # info.  Fall back to affected_rows if there was no match, but
-      # that may be inaccurate.
-      def affected_rows(conn)
-        s = conn.info
-        if s && s =~ AFFECTED_ROWS_RE
-          $1.to_i
-        else
-          conn.affected_rows
-        end
-      end
-
       # Set the :type option to :select if it hasn't been set.
       def execute(sql, opts={}, &block)
         super(sql, {:type=>:select}.merge(opts), &block)
       end
       
-      # Set the :type option to :dui if it hasn't been set.
-      def execute_dui(sql, opts={}, &block)
-        super(sql, {:type=>:dui}.merge(opts), &block)
-      end
-      
       # Handle correct quoting of strings using ::MySQL.quote.
       def literal_string_append(sql, v)
         sql << "'"