sequel 4.3.0 → 4.4.0

data/doc/schema_modification.rdoc

@@ -586,7 +586,7 @@ the table if the table already exists.  On some databases, it uses
 <tt>IF NOT EXISTS</tt>, on others it does a separate query to check for
 existence.
 
-This should not be used inside migrations, as if the the tbale does not
+This should not be used inside migrations, as if the table does not
 exist, it may mess up the migration.
 
 === +rename_table+

data/doc/security.rdoc

@@ -79,7 +79,7 @@ in which case Sequel automatically literalizes the input:
 Sequel generally treats ruby strings as SQL strings (escaping them correctly), and
 not as raw SQL.  However, you can convert a ruby string to a literal string, and
 Sequel will then treat it as raw SQL.  This is typically done through String#lit
-if the {core_extensions}[link:files/doc/core_extensions_rdoc.html] are in use,
+if the {core_extensions}[rdoc-ref:doc/core_extensions.rdoc] are in use,
 or Sequel.lit[rdoc-ref:Sequel::SQL::Builders#lit] if they are not in use.
 
   'a'.lit
@@ -308,7 +308,7 @@ practice, though being explicit on a per-call basis is still recommended:
   Album.set_allowed_columns(:name, :copies_sold)
   Album.create(params[:album]) # Only name and copies_sold set
 
-For more details on the mass assignment methods, see the {Mass Assignment Guide}[link:files/doc/mass_assignment_rdoc.html].
+For more details on the mass assignment methods, see the {Mass Assignment Guide}[rdoc-ref:doc/mass_assignment.rdoc].
 
 == General Parameter Handling
 

data/doc/sql.rdoc

@@ -78,7 +78,7 @@ Almost everywhere in Sequel, you can drop down to literal SQL by providing a lit
   DB[:albums].select('name') # SELECT 'name' FROM albums
   DB[:albums].select(Sequel.lit('name')) # SELECT name FROM albums
 
-For a simpler way of creating literal strings, you can also use the {core_extensions extension}[link:files/doc/core_extensions_rdoc.html], which adds the <tt>String#lit</tt> method, and other methods that integrate Sequel's DSL with the ruby language:
+For a simpler way of creating literal strings, you can also use the {core_extensions extension}[rdoc-ref:doc/core_extensions.rdoc], which adds the <tt>String#lit</tt> method, and other methods that integrate Sequel's DSL with the ruby language:
 
   DB[:albums].select('name'.lit)
 
@@ -137,7 +137,7 @@ The other way to qualify an identifier is to use the <tt>Sequel.qualify</tt> wit
 
   Sequel.qualify(:table, :column) # "table"."column"
 
-Another way to generate identifiers is to use Sequel's {virtual row support}[link:files/doc/virtual_rows_rdoc.html]:
+Another way to generate identifiers is to use Sequel's {virtual row support}[rdoc-ref:doc/virtual_rows.rdoc]:
 
   DB[:albums].select{name} # SELECT "name" FROM "albums"
   DB[:albums].select{albums__name} # SELECT "albums"."name" FROM "albums"
@@ -573,4 +573,4 @@ Note how +update+ and +delete+ used the +where+ argument, but that +insert+ did
 
 === Methods Used for Each SQL Clause
 
-To see which methods exist that affect each SQL clause, see the {"Dataset Basics" guide}[link:files/doc/dataset_basics_rdoc.html].
+To see which methods exist that affect each SQL clause, see the {"Dataset Basics" guide}[rdoc-ref:doc/dataset_basics.rdoc].

data/doc/thread_safety.rdoc

@@ -4,7 +4,7 @@ Most Sequel usage (and all common Sequel usage) is thread safe by default.  Spec
 
 == Connection Pool
 
-In order to allow multiple threads to operate on the same database at the same time, Sequel uses a connection pool.  The connection pool is designed so that a thread uses a connection for the minimum amount of time, returning the connection to the pool as soon as it is done using the connection.  If a thread requests a connection and the pool does not have an available connection, a new connection will be created.  If the maximum number of connections in the pool has already been reached, the thread will block (actually busy-wait) until a connection is available or the the connection pool timeout has elapsed (in which case a PoolTimeout error will be raised).
+In order to allow multiple threads to operate on the same database at the same time, Sequel uses a connection pool.  The connection pool is designed so that a thread uses a connection for the minimum amount of time, returning the connection to the pool as soon as it is done using the connection.  If a thread requests a connection and the pool does not have an available connection, a new connection will be created.  If the maximum number of connections in the pool has already been reached, the thread will block (actually busy-wait) until a connection is available or the connection pool timeout has elapsed (in which case a PoolTimeout error will be raised).
 
 == Exceptions
 

data/doc/validations.rdoc

@@ -299,7 +299,7 @@ Additionally, you can also include an optional options hash as the last argument
 :message :: The message to use
 :only_if_modified :: Only check the uniqueness if the object is new or one of the columns has been modified.
 
-+validates_unique+ is the only method in +validation_helpers+ that checks with the database.  Attempting to validate uniqueness outside of the database suffers from a race condition, so any time you want to add a uniqueness validation, you should make sure to add a uniqueness constraint or unique index on the underlying database table.  See the {"Migrations and Schema Modification" guide}[link:files/doc/migration_rdoc.html] for details on how to do that.  
++validates_unique+ is the only method in +validation_helpers+ that checks with the database.  Attempting to validate uniqueness outside of the database suffers from a race condition, so any time you want to add a uniqueness validation, you should make sure to add a uniqueness constraint or unique index on the underlying database table.  See the {"Migrations and Schema Modification" guide}[rdoc-ref:doc/migration.rdoc] for details on how to do that.  
 
 == +validation_helpers+ Options
 

data/doc/virtual_rows.rdoc

@@ -68,7 +68,7 @@ inside the proc.  If that doesn't make sense, maybe this example will help:
   # WHERE c > (a - 32)
   
 There are two related differences here.  First is the usage of <tt>o.c</tt> vs +c+,
-and second is the difference between the the use of +a+.  In the regular proc,
+and second is the difference between the use of +a+.  In the regular proc,
 you couldn't call +c+ without an explicit receiver in the proc, unless the self of the
 surrounding scope responded to it.  For +a+, note how ruby calls the method on
 the receiver of the surrounding scope in the regular proc, which returns an integer,

data/lib/sequel/adapters/jdbc.rb

@@ -143,6 +143,25 @@ module Sequel
         db.extend(Sequel::JDBC::Cubrid::DatabaseMethods)
         db.extend_datasets Sequel::Cubrid::DatasetMethods
         Java::cubrid.jdbc.driver.CUBRIDDriver
+      end,
+      :sqlanywhere=>proc do |db|
+        drv = [
+          lambda{Java::sybase.jdbc4.sqlanywhere.IDriver},
+          lambda{Java::ianywhere.ml.jdbcodbc.jdbc4.IDriver},
+          lambda{Java::sybase.jdbc.sqlanywhere.IDriver},
+          lambda{Java::ianywhere.ml.jdbcodbc.jdbc.IDriver},
+          lambda{Java::com.sybase.jdbc4.jdbc.Sybdriver},
+          lambda{Java::com.sybase.jdbc3.jdbc.Sybdriver}
+        ].each do |class_proc|
+          begin
+            break class_proc.call
+          rescue NameError
+          end
+        end
+        Sequel.require 'adapters/jdbc/sqlanywhere'
+        db.extend(Sequel::JDBC::SqlAnywhere::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::SqlAnywhere::Dataset
+        drv
       end
     }
     
@@ -286,15 +305,31 @@ module Sequel
       def execute_insert(sql, opts=OPTS)
         execute(sql, {:type=>:insert}.merge(opts))
       end
-      
+
+      # Use the JDBC metadata to get a list of foreign keys for the table.
+      def foreign_key_list(table, opts=OPTS)
+        m = output_identifier_meth
+        schema, table = metadata_schema_and_table(table, opts)
+        foreign_keys = {}
+        metadata(:getImportedKeys, nil, schema, table) do |r|
+          if fk = foreign_keys[r[:fk_name]]
+            fk[:columns] << [r[:key_seq], m.call(r[:fkcolumn_name])]
+            fk[:key] << [r[:key_seq], m.call(r[:pkcolumn_name])]
+          elsif r[:fk_name]
+            foreign_keys[r[:fk_name]] = {:name=>m.call(r[:fk_name]), :columns=>[[r[:key_seq], m.call(r[:fkcolumn_name])]], :table=>m.call(r[:pktable_name]), :key=>[[r[:key_seq], m.call(r[:pkcolumn_name])]]}
+          end
+        end
+        foreign_keys.values.each do |fk|
+          [:columns, :key].each do |k|
+            fk[k] = fk[k].sort.map{|_, v| v}
+          end
+        end
+      end
+
       # Use the JDBC metadata to get the index information for the table.
       def indexes(table, opts=OPTS)
         m = output_identifier_meth
-        im = input_identifier_meth
-        schema, table = schema_and_table(table)
-        schema ||= opts[:schema]
-        schema = im.call(schema) if schema
-        table = im.call(table)
+        schema, table = metadata_schema_and_table(table, opts)
         indexes = {}
         metadata(:getIndexInfo, nil, schema, table, false, true) do |r|
           next unless name = r[:column_name]
@@ -511,6 +546,16 @@ module Sequel
         end
       end
 
+      # Return the schema and table suitable for use with metadata queries.
+      def metadata_schema_and_table(table, opts)
+        im = input_identifier_meth(opts[:dataset])
+        schema, table = schema_and_table(table)
+        schema ||= opts[:schema]
+        schema = im.call(schema) if schema
+        table = im.call(table)
+        [schema, table]
+      end
+      
       # Created a JDBC prepared statement on the connection with the given SQL.
       def prepare_jdbc_statement(conn, sql, opts)
         conn.prepareStatement(sql)
@@ -563,12 +608,8 @@ module Sequel
       # Parse the table schema for the given table.
       def schema_parse_table(table, opts=OPTS)
         m = output_identifier_meth(opts[:dataset])
-        im = input_identifier_meth(opts[:dataset])
         ds = dataset
-        schema, table = schema_and_table(table)
-        schema ||= opts[:schema]
-        schema = im.call(schema) if schema
-        table = im.call(table)
+        schema, table = metadata_schema_and_table(table, opts)
         pks, ts = [], []
         metadata(:getPrimaryKeys, nil, schema, table) do |h|
           next if schema_parse_table_skip?(h, schema)
@@ -742,7 +783,7 @@ module Sequel
       # Return a callable object that will convert any value of <tt>v</tt>'s
       # class to a ruby object.  If no callable object can handle <tt>v</tt>'s
       # class, return false so that the negative lookup is cached.
-      def convert_type_proc(v)
+      def convert_type_proc(v, ctn=nil)
         case v
         when JAVA_BIG_DECIMAL
           DECIMAL_METHOD
@@ -768,6 +809,16 @@ module Sequel
           false
         end
       end
+
+      # The generic JDBC support does not use column info when deciding on conversion procs.
+      def convert_type_proc_uses_column_info?
+        false
+      end
+
+      # By default, if using column info, assume the info needed is the column's type name.
+      def convert_type_proc_column_info(meta, i)
+        meta.column_type_name(i)
+      end
       
       # Extend the dataset with the JDBC stored procedure methods.
       def prepare_extend_sproc(ds)
@@ -781,14 +832,29 @@ module Sequel
         meta = result.getMetaData
         cols = []
         i = 0
-        meta.getColumnCount.times{cols << [output_identifier(meta.getColumnLabel(i+=1)), i]}
-        columns = cols.map{|c| c.at(0)}
-        @columns = columns
         ct = @convert_types
-        if (ct.nil? ? db.convert_types : ct)
-          cols.each{|c| c << nil}
+        ct = db.convert_types if ct.nil?
+
+        if ct
+          use_column_info = convert_type_proc_uses_column_info?
+          # When converting types, four values are associated with every column:
+          # 1) column name symbol
+          # 2) index (starting at 1, as JDBC does)
+          # 3) database-specific value usable by convert_type_proc to determine the conversion proc to use for column
+          # 4) nil (later updated with the actual conversion proc during the lookup process)
+          meta.getColumnCount.times do
+            i += 1
+            cols << [output_identifier(meta.getColumnLabel(i)), i, (convert_type_proc_column_info(meta, i) if use_column_info), nil]
+          end
+          @columns = cols.map{|c| c.at(0)}
           process_result_set_convert(cols, result, &block)
         else
+          # When not converting types, only the type name and the index are used.
+          meta.getColumnCount.times do
+            i += 1
+            cols << [output_identifier(meta.getColumnLabel(i)), i]
+          end
+          @columns = cols.map{|c| c.at(0)}
           process_result_set_no_convert(cols, result, &block)
         end
       ensure
@@ -816,13 +882,13 @@ module Sequel
       def process_result_set_convert(cols, result)
         while result.next
           row = {}
-          cols.each do |n, i, p|
+          cols.each do |n, i, ctn, p|
             v = result.getObject(i)
             row[n] = if v
               if p
                 p.call(v)
               elsif p.nil?
-                cols[i-1][2] = p = convert_type_proc(v)
+                cols[i-1][3] = p = convert_type_proc(v, ctn)
                 if p
                   p.call(v)
                 else

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

@@ -65,7 +65,7 @@ module Sequel
         private
 
         # Return clob as blob if use_clob_as_blob is true
-        def convert_type_proc(v)
+        def convert_type_proc(v, ctn=nil)
           case v
           when JAVA_SQL_CLOB
             ::Sequel::DB2::use_clob_as_blob ? DB2_CLOB_METHOD : super

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

@@ -255,7 +255,7 @@ module Sequel
         DERBY_CLOB_METHOD = TYPE_TRANSLATOR_INSTANCE.method(:derby_clob)
       
         # Handle clobs on Derby as strings.
-        def convert_type_proc(v)
+        def convert_type_proc(v, ctn=nil)
           if v.is_a?(JAVA_SQL_CLOB)
             DERBY_CLOB_METHOD
           else

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

@@ -62,7 +62,7 @@ module Sequel
           when :add_column
             if (pk = op.delete(:primary_key)) || (ref = op.delete(:table))
               sqls = [super(table, op)]
-              sqls << "ALTER TABLE #{quote_schema_table(table)} ADD PRIMARY KEY (#{quote_identifier(op[:name])})" if pk
+              sqls << "ALTER TABLE #{quote_schema_table(table)} ADD PRIMARY KEY (#{quote_identifier(op[:name])})" if pk && op[:type] != :identity
               if ref
                 op[:table] = ref
                 sqls << "ALTER TABLE #{quote_schema_table(table)} ADD FOREIGN KEY (#{quote_identifier(op[:name])}) #{column_references_sql(op)}"
@@ -202,7 +202,7 @@ module Sequel
         H2_CLOB_METHOD = TYPE_TRANSLATOR_INSTANCE.method(:h2_clob)
       
         # Handle H2 specific clobs as strings.
-        def convert_type_proc(v)
+        def convert_type_proc(v, ctn=nil)
           if v.is_a?(Java::OrgH2Jdbc::JdbcClob)
             H2_CLOB_METHOD
           else

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

@@ -37,6 +37,13 @@ module Sequel
         # HSQLDB specific SQL for renaming columns, and changing column types and/or nullity.
         def alter_table_sql(table, op)
           case op[:op]
+          when :add_column
+            if op[:table]
+              [super(table, op.merge(:table=>nil)),
+               alter_table_sql(table, op.merge(:op=>:add_constraint, :type=>:foreign_key, :name=>op[:foreign_key_name], :columns=>[op[:name]], :table=>op[:table]))]
+            else
+              super
+            end
           when :rename_column
             "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} RENAME TO #{quote_identifier(op[:new_name])}"
           when :set_column_type

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

@@ -33,7 +33,7 @@ module Sequel
         JTDS_CLOB_METHOD = TYPE_TRANSLATOR_INSTANCE.method(:jtds_clob)
       
         # Handle CLOB types retrieved via JTDS.
-        def convert_type_proc(v)
+        def convert_type_proc(v, ctn=nil)
           if v.is_a?(Java::NetSourceforgeJtdsJdbc::ClobImpl)
             JTDS_CLOB_METHOD
           else

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

@@ -112,7 +112,7 @@ module Sequel
           convert_type_oracle_timestamp(db.synchronize(@opts[:server]){|c| v.timestampValue(c)})
         end
       
-        def convert_type_proc(v)
+        def convert_type_proc(v, ctn=nil)
           case v
           when JAVA_BIG_DECIMAL
             ORACLE_DECIMAL_METHOD

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

@@ -168,17 +168,48 @@ module Sequel
         # 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)
+        def convert_type_proc(v, ctn=nil)
           case v
           when Java::OrgPostgresqlJdbc4::Jdbc4Array
-            PGArrayConverter.new(method(:convert_type_proc))
+            if pr = db.conversion_procs[ctn]
+              lambda{|x| pr.call(PG_OBJECT_METHOD.call(x))}
+            else
+              PGArrayConverter.new(method(:convert_type_proc))
+            end
           when Java::OrgPostgresqlUtil::PGobject
-            PG_OBJECT_METHOD
+            if pr = db.conversion_procs[ctn]
+              lambda{|x| pr.call(PG_OBJECT_METHOD.call(x))}
+            else
+              PG_OBJECT_METHOD
+            end
+          when String
+            if pr = db.conversion_procs[ctn]
+              pr
+            else
+              false
+            end
+          when JAVA_HASH_MAP
+            if Sequel.respond_to?(:hstore)
+              lambda{|x| Sequel.hstore(HASH_MAP_METHOD.call(x))}
+            else
+              HASH_MAP_METHOD
+            end
           else
             super
           end
         end
         
+        # The jdbc/postgresql adapter uses column type oids when determining
+        # conversion procs.
+        def convert_type_proc_uses_column_info?
+          true
+        end
+
+        # Use the column type oid as the database specific column info value.
+        def convert_type_proc_column_info(meta, i)
+          meta.field(i).oid
+        end
+      
         # Literalize strings similar to the native postgres adapter
         def literal_string_append(sql, v)
           sql << APOS << db.synchronize(@opts[:server]){|c| c.escape_string(v)} << APOS

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

@@ -0,0 +1,57 @@
+Sequel.require 'adapters/shared/sqlanywhere'
+Sequel.require 'adapters/jdbc/transactions'
+
+module Sequel
+  module JDBC
+    module SqlAnywhere
+      # Database instance methods for Sybase databases accessed via JDBC.
+      module DatabaseMethods
+        extend Sequel::Database::ResetIdentifierMangling
+        include Sequel::SqlAnywhere::DatabaseMethods
+        include Sequel::JDBC::Transactions
+
+        LAST_INSERT_ID = 'SELECT @@IDENTITY'.freeze
+
+        private
+
+        # Get the last inserted id.
+        def last_insert_id(conn, opts=OPTS)
+          statement(conn) do |stmt|
+            sql = LAST_INSERT_ID
+            rs = log_yield(sql){stmt.executeQuery(sql)}
+            rs.next
+            rs.getInt(1)
+          end
+        end
+      end
+
+      #Dataset class for Sybase datasets accessed via JDBC.
+      class Dataset < JDBC::Dataset
+        include Sequel::SqlAnywhere::DatasetMethods
+
+        private
+
+        class ::Sequel::JDBC::Dataset::TYPE_TRANSLATOR
+          def sqla_boolean(i) i != 0 end
+        end
+
+        BOOLEAN_METHOD =  TYPE_TRANSLATOR_INSTANCE.method(:sqla_boolean)
+
+        def convert_type_proc(v, ctn=nil)
+          case
+          when ctn && ctn =~ SqlAnywhere::DatabaseMethods::SMALLINT_RE
+            BOOLEAN_METHOD
+          else
+            super(v, ctn)
+          end
+        end
+
+        # SQLAnywhere needs the column info if it is converting smallint to bool,
+        # since the JDBC adapter always returns smallint as integer.
+        def convert_type_proc_uses_column_info?
+          convert_smallint_to_bool
+        end
+      end
+    end
+  end
+end

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

@@ -22,13 +22,13 @@ module Sequel
           def process_result_set_convert(cols, result)
             while result.next
               row = {}
-              cols.each do |n, i, p|
+              cols.each do |n, i, ctn, p|
                 v = (n == :is_autoincrement ? result.getString(i) : result.getObject(i))
                 row[n] = if v
                   if p
                     p.call(v)
                   elsif p.nil?
-                    cols[i-1][2] = p = convert_type_proc(v)
+                    cols[i-1][3] = p = convert_type_proc(v, ctn)
                     if p
                       p.call(v)
                     else