sequel 2.9.0 → 2.10.0

data/lib/sequel_core/adapters/informix.rb

@@ -53,7 +53,16 @@ module Sequel
       def fetch_rows(sql, &block)
         execute(sql) do |cursor|
           begin
-            cursor.open.each_hash(&block)
+            col_map = nil
+            cursor.open.each_hash do |h|
+              unless col_map
+                col_map = {}
+                @columns = h.keys.map{|k| col_map[k] = output_identifier(k)}
+              end
+              h2 = {}
+              h.each{|k,v| h2[col_map[k]||k] = v}
+              yield h2
+            end
           ensure
             cursor.drop
           end

data/lib/sequel_core/adapters/jdbc.rb

@@ -61,6 +61,12 @@ module Sequel
         require 'sequel_core/adapters/shared/mssql'
         db.extend(Sequel::MSSQL::DatabaseMethods)
         com.microsoft.sqlserver.jdbc.SQLServerDriver
+      end,
+      :h2=>proc do |db|
+        require 'sequel_core/adapters/jdbc/h2'
+        db.extend(Sequel::JDBC::H2::DatabaseMethods)
+        JDBC.load_gem('h2')
+        org.h2.Driver
       end
     }
     
@@ -87,11 +93,12 @@ module Sequel
       # raise an error immediately if the connection doesn't have a
       # uri, since JDBC requires one.
       def initialize(opts)
-        super(opts)
+        @opts = opts
         raise(Error, "No connection string specified") unless uri
         if match = /\Ajdbc:([^:]+)/.match(uri) and prok = DATABASE_SETUP[match[1].to_sym]
           prok.call(self)
         end
+        super(opts)
       end
       
       # Execute the given stored procedure with the give name. If a block is
@@ -178,6 +185,14 @@ module Sequel
         execute(sql, {:type=>:insert}.merge(opts))
       end
       
+      # All tables in this database
+      def tables
+        ts = []
+        ds = dataset
+        metadata(:getTables, nil, nil, nil, ['TABLE'].to_java(:string)){|h| ts << ds.send(:output_identifier, h[:table_name])}
+        ts
+      end
+      
       # Default transaction method that should work on most JDBC
       # databases.  Does not use the JDBC transaction methods, uses
       # SQL BEGIN/ROLLBACK/COMMIT statements instead.
@@ -214,10 +229,14 @@ module Sequel
         ur = opts[:uri] || opts[:url] || opts[:database]
         ur =~ /^\Ajdbc:/ ? ur : "jdbc:#{ur}"
       end
-      alias url uri
       
       private
       
+      # The JDBC adapter should not need the pool to convert exceptions.
+      def connection_pool_default_options
+        super.merge(:pool_convert_exceptions=>false)
+      end
+      
       # Close given adapter connections
       def disconnect_connection(c)
         c.close
@@ -283,6 +302,13 @@ module Sequel
         nil
       end
       
+      # Yield the metadata for this database
+      def metadata(*args, &block)
+        ds = dataset
+        ds.identifier_output_method = :downcase
+        synchronize{|c| ds.send(:process_result_set, c.getMetaData.send(*args), &block)}
+      end
+      
       # Java being java, you need to specify the type of each argument
       # for the prepared statement, and bind it individually.  This
       # guesses which JDBC method to use, and hopefully JRuby will convert
@@ -313,9 +339,20 @@ module Sequel
         conn
       end
       
-      # The JDBC adapter should not need the pool to convert exceptions.
-      def connection_pool_default_options
-        super.merge(:pool_convert_exceptions=>false)
+      # All tables in this database
+      def schema_parse_table(table, opts={})
+        ds = dataset
+        schema, table = schema_and_table(table)
+        schema = ds.send(:input_identifier, schema) if schema
+        table = ds.send(:input_identifier, table)
+        pks, ts = [], []
+        metadata(:getPrimaryKeys, nil, schema, table) do |h|
+          pks << h[:column_name]
+        end
+        metadata(:getColumns, nil, schema, table, nil) do |h|
+          ts << [ds.send(:output_identifier, h[:column_name]), {:type=>schema_column_type(h[:type_name]), :db_type=>h[:type_name], :default=>(h[:column_def] == '' ? nil : h[:column_def]), :allow_null=>(h[:nullable] != 0), :primary_key=>pks.include?(h[:column_name])}]
+        end
+        ts
       end
     end
     
@@ -373,20 +410,7 @@ module Sequel
       
       # Correctly return rows from the database and return them as hashes.
       def fetch_rows(sql, &block)
-        execute(sql) do |result|
-          # get column names
-          meta = result.getMetaData
-          column_count = meta.getColumnCount
-          @columns = []
-          column_count.times {|i| @columns << meta.getColumnName(i+1).to_sym}
-
-          # get rows
-          while result.next
-            row = {}
-            @columns.each_with_index {|v, i| row[v] = result.getObject(i+1)}
-            yield row
-          end
-        end
+        execute(sql){|result| process_result_set(result, &block)}
         self
       end
       
@@ -416,10 +440,45 @@ module Sequel
       
       private
       
+      # Convert the type.  Used for converting Java types to ruby types.
+      def convert_type(v)
+        case v
+        when Java::JavaSQL::Timestamp, Java::JavaSQL::Time
+          v.to_string.to_sequel_time
+        when Java::JavaSQL::Date
+          v.to_string.to_date
+        when Java::JavaIo::BufferedReader
+          lines = []
+          while(line = v.read_line) do lines << line end
+          lines.join("\n")
+        when Java::JavaMath::BigDecimal
+          BigDecimal.new(v.to_string)
+        else
+          v
+        end
+      end
+      
       # Extend the dataset with the JDBC stored procedure methods.
       def prepare_extend_sproc(ds)
         ds.extend(StoredProcedureMethods)
       end
+      
+      # Split out from fetch rows to allow processing of JDBC result sets
+      # that don't come from issuing an SQL string.
+      def process_result_set(result)
+        # get column names
+        meta = result.getMetaData
+        column_count = meta.getColumnCount
+        @columns = []
+        column_count.times{|i| @columns << output_identifier(meta.getColumnName(i+1))}
+
+        # get rows
+        while result.next
+          row = {}
+          @columns.each_with_index{|v, i| row[v] = convert_type(result.getObject(i+1))}
+          yield row
+        end
+      end
     end
   end
 end

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

@@ -0,0 +1,69 @@
+module Sequel
+  module JDBC
+    # Database and Dataset support for H2 databases accessed via JDBC.
+    module H2
+      # Instance methods for H2 Database objects accessed via JDBC.
+      module DatabaseMethods
+        # H2 needs to add a primary key column as a constraint
+        def alter_table_sql(table, op)
+          case op[:op]
+          when :add_column
+            if op.delete(:primary_key)
+              sql = super(table, op)
+              [sql, "ALTER TABLE #{quote_schema_table(table)} ADD PRIMARY KEY (#{quote_identifier(op[:name])})"]
+            else
+              super(table, op)
+            end
+          else
+            super(table, op)
+          end
+        end
+      
+        # Return Sequel::JDBC::H2::Dataset object with the given opts.
+        def dataset(opts=nil)
+          Sequel::JDBC::H2::Dataset.new(self, opts)
+        end
+        
+        # H2 uses an IDENTITY type
+        def serial_primary_key_options
+          {:primary_key => true, :type => :identity}
+        end
+        
+        private
+        
+        # Use IDENTITY() to get the last inserted id.
+        def last_insert_id(conn, opts={})
+          stmt = conn.createStatement
+          begin
+            rs = stmt.executeQuery('SELECT IDENTITY();')
+            rs.next
+            rs.getInt(1)
+          ensure
+            stmt.close
+          end 
+        end
+        
+        # Default to a single connection for a memory database.
+        def connection_pool_default_options
+          o = super
+          uri == 'jdbc:h2:mem:' ? o.merge(:max_connections=>1) : o
+        end
+      end
+      
+      # Dataset class for H2 datasets accessed via JDBC.
+      class Dataset < JDBC::Dataset
+        # Use H2 syntax for Date, DateTime, and Time types.
+        def literal(v)
+          case v
+          when Date
+            v.strftime("DATE '%Y-%m-%d'") 
+          when DateTime, Time
+            v.strftime("TIMESTAMP '%Y-%m-%d %H:%M:%S'")
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -46,6 +46,16 @@ module Sequel
           execute_insert(insert_sql(*values))
         end
         
+        # Handle time types correctly
+        def literal(v)
+          case v
+          when Time, DateTime
+            v.strftime("'%Y-%m-%d %H:%M:%S'")
+          else
+            super
+          end
+        end
+        
         # Use execute_insert to execute the replace_sql.
         def replace(*args)
           execute_insert(replace_sql(*args))

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

@@ -91,12 +91,16 @@ module Sequel
           ps
         end
         
-        # Convert Java::JavaSql::Timestamps correctly, and handle SQL::Blobs
-        # correctly.
+        # Convert Java::JavaSql::Timestamps correctly, and handle Strings
+        # similar to the native postgres adapter.
         def literal(v)
           case v
+          when LiteralString
+            v
           when SQL::Blob
-            "'#{v.gsub(/[\000-\037\047\134\177-\377]/){|b| "\\#{ b[0].to_s(8).rjust(3, '0') }"}}'"
+            super
+          when String
+            db.synchronize{|c| "'#{c.escape_string(v)}'"}
           when Java::JavaSql::Timestamp
             "TIMESTAMP #{literal(v.to_s)}"
           else

data/lib/sequel_core/adapters/mysql.rb

@@ -2,84 +2,40 @@ require 'mysql'
 require 'sequel_core/adapters/shared/mysql'
 require 'sequel_core/dataset/stored_procedures'
 
-# Add methods to get columns, yield hashes with symbol keys, and do
-# type conversion.
-class Mysql::Result
-  # Mapping of type numbers to conversion methods.
-  MYSQL_TYPES = {
-    0   => :to_d,     # MYSQL_TYPE_DECIMAL
-    1   => :to_i,     # MYSQL_TYPE_TINY
-    2   => :to_i,     # MYSQL_TYPE_SHORT
-    3   => :to_i,     # MYSQL_TYPE_LONG
-    4   => :to_f,     # MYSQL_TYPE_FLOAT
-    5   => :to_f,     # MYSQL_TYPE_DOUBLE
-    # 6   => ??,        # MYSQL_TYPE_NULL
-    7   => :to_sequel_time,  # MYSQL_TYPE_TIMESTAMP
-    8   => :to_i,     # MYSQL_TYPE_LONGLONG
-    9   => :to_i,     # MYSQL_TYPE_INT24
-    10  => :to_date,  # MYSQL_TYPE_DATE
-    11  => :to_time,  # MYSQL_TYPE_TIME
-    12  => :to_sequel_time,  # MYSQL_TYPE_DATETIME
-    13  => :to_i,     # MYSQL_TYPE_YEAR
-    14  => :to_date,  # MYSQL_TYPE_NEWDATE
-    # 15  => :to_s      # MYSQL_TYPE_VARCHAR
-    # 16  => :to_s,     # MYSQL_TYPE_BIT
-    246 => :to_d,     # MYSQL_TYPE_NEWDECIMAL
-    247 => :to_i,     # MYSQL_TYPE_ENUM
-    248 => :to_i,      # MYSQL_TYPE_SET
-    249 => :to_blob,     # MYSQL_TYPE_TINY_BLOB
-    250 => :to_blob,     # MYSQL_TYPE_MEDIUM_BLOB
-    251 => :to_blob,     # MYSQL_TYPE_LONG_BLOB
-    252 => :to_blob,     # MYSQL_TYPE_BLOB
-    # 253 => :to_s,     # MYSQL_TYPE_VAR_STRING
-    # 254 => :to_s,     # MYSQL_TYPE_STRING
-    # 255 => :to_s      # MYSQL_TYPE_GEOMETRY
-  }
-  
-  # Return an array of column name symbols for this result set.
-  def columns(with_table = nil)
-    unless @columns
-      @column_types = []
-      @columns = fetch_fields.map do |f|
-        @column_types << f.type
-        (with_table ? "#{f.table}.#{f.name}" : f.name).to_sym
-      end
-    end
-    @columns
-  end
-
-  # yield a hash with symbol keys and type converted values.
-  def sequel_each_hash(with_table = nil)
-    c = columns
-    while row = fetch_row
-      h = {}
-      c.each_with_index {|f, i| h[f] = convert_type(row[i], @column_types[i])}
-      yield h
-    end
-  end
-  
-  private
-  
-  # Convert the type of v using the method in MYSQL_TYPES[type].
-  def convert_type(v, type)
-    if v
-      if type == 1 && Sequel.convert_tinyint_to_bool
-        # We special case tinyint here to avoid adding
-        # a method to an ancestor of Fixnum
-        v.to_i == 0 ? false : true
-      else
-        (t = MYSQL_TYPES[type]) ? v.send(t) : v
-      end
-    else
-      nil
-    end
-  end
-  
-end
-
 module Sequel
   # Module for holding all MySQL-related classes and modules for Sequel.
   module MySQL
+    # Mapping of type numbers to conversion methods.
+    MYSQL_TYPES = {
+      0   => :to_d,     # MYSQL_TYPE_DECIMAL
+      1   => :to_i,     # MYSQL_TYPE_TINY
+      2   => :to_i,     # MYSQL_TYPE_SHORT
+      3   => :to_i,     # MYSQL_TYPE_LONG
+      4   => :to_f,     # MYSQL_TYPE_FLOAT
+      5   => :to_f,     # MYSQL_TYPE_DOUBLE
+      # 6   => ??,        # MYSQL_TYPE_NULL
+      7   => :to_sequel_time,  # MYSQL_TYPE_TIMESTAMP
+      8   => :to_i,     # MYSQL_TYPE_LONGLONG
+      9   => :to_i,     # MYSQL_TYPE_INT24
+      10  => :to_date,  # MYSQL_TYPE_DATE
+      11  => :to_time,  # MYSQL_TYPE_TIME
+      12  => :to_sequel_time,  # MYSQL_TYPE_DATETIME
+      13  => :to_i,     # MYSQL_TYPE_YEAR
+      14  => :to_date,  # MYSQL_TYPE_NEWDATE
+      # 15  => :to_s      # MYSQL_TYPE_VARCHAR
+      # 16  => :to_s,     # MYSQL_TYPE_BIT
+      246 => :to_d,     # MYSQL_TYPE_NEWDECIMAL
+      247 => :to_i,     # MYSQL_TYPE_ENUM
+      248 => :to_i,      # MYSQL_TYPE_SET
+      249 => :to_blob,     # MYSQL_TYPE_TINY_BLOB
+      250 => :to_blob,     # MYSQL_TYPE_MEDIUM_BLOB
+      251 => :to_blob,     # MYSQL_TYPE_LONG_BLOB
+      252 => :to_blob,     # MYSQL_TYPE_BLOB
+      # 253 => :to_s,     # MYSQL_TYPE_VAR_STRING
+      # 254 => :to_s,     # MYSQL_TYPE_STRING
+      # 255 => :to_s      # MYSQL_TYPE_GEOMETRY
+    }
+  
     # Database class for MySQL databases used with Sequel.
     class Database < Sequel::Database
       include Sequel::MySQL::DatabaseMethods
@@ -316,8 +272,13 @@ module Sequel
       # Yield all rows matching this dataset
       def fetch_rows(sql)
         execute(sql) do |r|
-          @columns = r.columns
-          r.sequel_each_hash {|row| yield row}
+          column_types = []
+          @columns = r.fetch_fields.map{|f| column_types << f.type; output_identifier(f.name)}
+          while row = r.fetch_row
+            h = {}
+            @columns.each_with_index {|f, i| h[f] = convert_type(row[i], column_types[i])}
+            yield h
+          end
         end
         self
       end
@@ -363,6 +324,21 @@ module Sequel
       
       private
       
+      # Convert the type of v using the method in MYSQL_TYPES[type].
+      def convert_type(v, type)
+        if v
+          if type == 1 && Sequel.convert_tinyint_to_bool
+            # We special case tinyint here to avoid adding
+            # a method to an ancestor of Fixnum
+            v.to_i == 0 ? false : true
+          else
+            (t = MYSQL_TYPES[type]) ? v.send(t) : v
+          end
+        else
+          nil
+        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)

data/lib/sequel_core/adapters/odbc.rb

@@ -129,7 +129,7 @@ module Sequel
               if (n = c.name).empty?
                 n = UNTITLED_COLUMN % (untitled_count += 1)
               end
-              n.to_sym
+              output_identifier(n)
             end
             rows = s.fetch_all
             rows.each {|row| yield hash_row(row)} if rows