sequel_core 1.5.1 → 2.0.0

data/lib/sequel_core/adapters/dbi.rb

@@ -1,113 +1,127 @@
-require 'dbi'
-
-module Sequel
-  module DBI
-    class Database < Sequel::Database
-      set_adapter_scheme :dbi
-      
-      DBI_ADAPTERS = {
-        :ado => "ADO",
-        :db2 => "DB2",
-        :frontbase => "FrontBase",
-        :interbase => "InterBase",
-        :msql => "Msql",
-        :mysql => "Mysql",
-        :odbc => "ODBC",
-        :oracle => "Oracle",
-        :pg => "Pg",
-        :proxy => "Proxy",
-        :sqlite => "SQLite",
-        :sqlrelay => "SQLRelay"
-      }
-
-      # Converts a uri to an options hash. These options are then passed
-      # to a newly created database object.
-      def self.uri_to_options(uri)
-        database = (uri.path =~ /\/(.*)/) && ($1)
-        if uri.scheme =~ /dbi-(.+)/
-          adapter = DBI_ADAPTERS[$1.to_sym] || $1
-          database = "#{adapter}:#{database}"
-        end
-        {
-          :user => uri.user,
-          :password => uri.password,
-          :host => uri.host,
-          :port => uri.port,
-          :database => database
-        }
-      end
-
-    
-      def connect
-        dbname = @opts[:database]
-        dbname = 'DBI:' + dbname unless dbname =~ /^DBI:/
-        ::DBI.connect(dbname, @opts[:user], @opts[:password])
-      end
-      
-      def disconnect
-        @pool.disconnect {|c| c.disconnect}
-      end
-    
-      def dataset(opts = nil)
-        DBI::Dataset.new(self, opts)
-      end
-    
-      def execute(sql)
-        @logger.info(sql) if @logger
-        @pool.hold do |conn|
-          conn.execute(sql)
-        end
-      end
-      
-      def do(sql)
-        @logger.info(sql) if @logger
-        @pool.hold do |conn|
-          conn.do(sql)
-        end
-      end
-    end
-    
-    class Dataset < Sequel::Dataset
-      def literal(v)
-        case v
-        when Time
-          literal(v.iso8601)
-        else
-          super
-        end
-      end
-
-      def fetch_rows(sql, &block)
-        @db.synchronize do
-          s = @db.execute sql
-          begin
-            @columns = s.column_names.map {|c| c.to_sym}
-            s.fetch {|r| yield hash_row(s, r)}
-          ensure
-            s.finish rescue nil
-          end
-        end
-        self
-      end
-      
-      def hash_row(stmt, row)
-        @columns.inject({}) do |m, c|
-          m[c] = row.shift
-          m
-        end
-      end
-    
-      def insert(*values)
-        @db.do insert_sql(*values)
-      end
-    
-      def update(*args, &block)
-        @db.do update_sql(*args, &block)
-      end
-    
-      def delete(opts = nil)
-        @db.do delete_sql(opts)
-      end
-    end
-  end
-end
+require 'dbi'
+
+module Sequel
+  module DBI
+    class Database < Sequel::Database
+      attr_writer :lowercase
+      
+      set_adapter_scheme :dbi
+      
+      DBI_ADAPTERS = {
+        :ado => "ADO",
+        :db2 => "DB2",
+        :frontbase => "FrontBase",
+        :interbase => "InterBase",
+        :msql => "Msql",
+        :mysql => "Mysql",
+        :odbc => "ODBC",
+        :oracle => "Oracle",
+        :pg => "pg",
+        :proxy => "Proxy",
+        :sqlite => "SQLite",
+        :sqlrelay => "SQLRelay"
+      }
+
+      # Converts a uri to an options hash. These options are then passed
+      # to a newly created database object.
+      def self.uri_to_options(uri)
+        database = (m = /\/(.*)/.match(uri.path)) && (m[1])
+        if m = /dbi-(.+)/.match(uri.scheme)
+          adapter = DBI_ADAPTERS[m[1].to_sym] || m[1]
+          database = "#{adapter}:dbname=#{database}"
+        end
+        {
+          :user => uri.user,
+          :password => uri.password,
+          :host => uri.host,
+          :port => uri.port,
+          :database => database
+        }
+      end
+
+      
+      def connect
+        dbname = @opts[:database]
+        if dbname !~ /^DBI:/ then
+          dbname = "DBI:#{dbname}"
+          [:host, :port].each{|sym| dbname += ";#{sym}=#{@opts[sym]}" unless @opts[sym].blank?}
+        end
+        ::DBI.connect(dbname, @opts[:user], @opts[:password])
+      end
+      
+      def disconnect
+        @pool.disconnect {|c| c.disconnect}
+      end
+    
+      def dataset(opts = nil)
+        DBI::Dataset.new(self, opts)
+      end
+    
+      def execute(sql)
+        log_info(sql)
+        @pool.hold do |conn|
+          conn.execute(sql)
+        end
+      end
+      
+      def do(sql)
+        log_info(sql)
+        @pool.hold do |conn|
+          conn.do(sql)
+        end
+      end
+      
+      # Converts all column names to lowercase
+      def lowercase
+        @lowercase ||= false
+      end
+    end
+    
+    class Dataset < Sequel::Dataset
+      def literal(v)
+        case v
+        when Time
+          literal(v.iso8601)
+        when Date, DateTime
+          literal(v.to_s)
+        else
+          super
+        end
+      end
+
+      def fetch_rows(sql, &block)
+        @db.synchronize do
+          s = @db.execute sql
+          begin
+            @columns = s.column_names.map do |c|
+              @db.lowercase ? c.downcase.to_sym : c.to_sym
+            end
+            s.fetch {|r| yield hash_row(s, r)}
+          ensure
+            s.finish rescue nil
+          end
+        end
+        self
+      end
+      
+      def hash_row(stmt, row)
+        @columns.inject({}) do |m, c|
+          m[c] = row.shift
+          m
+        end
+      end
+    
+      def insert(*values)
+        @db.do insert_sql(*values)
+      end
+    
+      def update(*args, &block)
+        @db.do update_sql(*args, &block)
+      end
+    
+      def delete(opts = nil)
+        @db.do delete_sql(opts)
+      end
+    end
+  end
+end

data/lib/sequel_core/adapters/informix.rb

@@ -25,13 +25,13 @@ module Sequel
       
       # Returns number of rows affected
       def execute(sql)
-        @logger.info(sql) if @logger
+        log_info(sql)
         @pool.hold {|c| c.immediate(sql)}
       end
       alias_method :do, :execute
       
       def query(sql, &block)
-        @logger.info(sql) if @logger
+        log_info(sql)
         @pool.hold {|c| block[c.cursor(sql)]}
       end
     end
@@ -41,6 +41,8 @@ module Sequel
         case v
         when Time
           literal(v.iso8601)
+        when Date, DateTime
+          literal(v.to_s)
         else
           super
         end

data/lib/sequel_core/adapters/jdbc.rb

@@ -38,7 +38,7 @@ module Sequel
       end
       
       def execute_and_forget(sql)
-        @logger.info(sql) if @logger
+        log_info(sql)
         @pool.hold do |conn|
           stmt = conn.createStatement
           begin
@@ -50,7 +50,7 @@ module Sequel
       end
       
       def execute(sql)
-        @logger.info(sql) if @logger
+        log_info(sql)
         @pool.hold do |conn|
           stmt = conn.createStatement
           begin
@@ -67,6 +67,8 @@ module Sequel
         case v
         when Time
           literal(v.iso8601)
+        when Date, DateTime
+          literal(v.to_s)
         else
           super
         end
@@ -105,4 +107,4 @@ module Sequel
       end
     end
   end
-end
+end

data/lib/sequel_core/adapters/mysql.rb

@@ -4,7 +4,7 @@ require 'mysql'
 class Mysql::Result
   MYSQL_TYPES = {
     0   => :to_d,     # MYSQL_TYPE_DECIMAL
-    1   => :to_i,     # MYSQL_TYPE_TINY
+    #1   => :to_i,     # MYSQL_TYPE_TINY
     2   => :to_i,     # MYSQL_TYPE_SHORT
     3   => :to_i,     # MYSQL_TYPE_LONG
     4   => :to_f,     # MYSQL_TYPE_FLOAT
@@ -33,7 +33,17 @@ class Mysql::Result
   }
 
   def convert_type(v, type)
-    v ? ((t = MYSQL_TYPES[type]) ? v.send(t) : v) : nil
+    if v
+      if type == 1
+        # 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
 
   def columns(with_table = nil)
@@ -55,7 +65,6 @@ class Mysql::Result
           row[i] = v.send(t)
         end
       end
-      row.keys = c
       yield row
     end
   end
@@ -80,8 +89,8 @@ module Sequel
           if conn.respond_to?(:server_version)
             pool.hold {|c| c.server_version}
           else
-            get(:version[]) =~ /(\d+)\.(\d+)\.(\d+)/
-            ($1.to_i * 10000) + ($2.to_i * 100) + $3.to_i
+            m = /(\d+)\.(\d+)\.(\d+)/.match(get(:version[]))
+            (m[1].to_i * 10000) + (m[2].to_i * 100) + m[3].to_i
           end
         end
       end
@@ -114,6 +123,8 @@ module Sequel
         if encoding = @opts[:encoding] || @opts[:charset]
           conn.query("set character_set_connection = '#{encoding}'")
           conn.query("set character_set_client = '#{encoding}'")
+          conn.query("set character_set_database = '#{encoding}'")
+          conn.query("set character_set_server = '#{encoding}'")
           conn.query("set character_set_results = '#{encoding}'")
         end
         conn.reconnect = true
@@ -135,10 +146,14 @@ module Sequel
       end
 
       def execute(sql, &block)
-        @logger.info(sql) if @logger
-        @pool.hold do |conn|
-          conn.query(sql)
-          block[conn] if block
+        begin
+          log_info(sql)
+          @pool.hold do |conn|
+            conn.query(sql)
+            block[conn] if block
+          end
+        rescue Mysql::Error => e
+          raise Error.new(e.message)
         end
       end
 
@@ -175,7 +190,7 @@ module Sequel
         sql = "#{literal(column[:name].to_sym)} #{TYPES[column[:type]]}"
         column[:size] ||= 255 if column[:type] == :varchar
         elements = column[:size] || column[:elements]
-        sql << "(#{literal(elements)})" if elements
+        sql << literal(Array(elements)) if elements
         sql << UNSIGNED if column[:unsigned]
         sql << UNIQUE if column[:unique]
         sql << NOT_NULL if column[:null] == false
@@ -185,7 +200,7 @@ module Sequel
         sql << " #{auto_increment_sql}" if column[:auto_increment]
         if column[:table]
           sql << ", FOREIGN KEY (#{literal(column[:name].to_sym)}) REFERENCES #{column[:table]}"
-          sql << "(#{literal(column[:key])})" if column[:key]
+          sql << literal(Array(column[:key])) if column[:key]
           sql << " ON DELETE #{on_delete_clause(column[:on_delete])}" if column[:on_delete]
         end
         sql
@@ -196,13 +211,13 @@ module Sequel
         unique = "UNIQUE " if index[:unique]
         case index[:type]
         when :full_text
-          "CREATE FULLTEXT INDEX #{index_name} ON #{table_name} (#{literal(index[:columns])})"
+          "CREATE FULLTEXT INDEX #{index_name} ON #{table_name} #{literal(index[:columns])}"
         when :spatial
-          "CREATE SPATIAL INDEX #{index_name} ON #{table_name} (#{literal(index[:columns])})"
+          "CREATE SPATIAL INDEX #{index_name} ON #{table_name} #{literal(index[:columns])}"
         when nil
-          "CREATE #{unique}INDEX #{index_name} ON #{table_name} (#{literal(index[:columns])})"
+          "CREATE #{unique}INDEX #{index_name} ON #{table_name} #{literal(index[:columns])}"
         else
-          "CREATE #{unique}INDEX #{index_name} ON #{table_name} (#{literal(index[:columns])}) USING #{index[:type]}"
+          "CREATE #{unique}INDEX #{index_name} ON #{table_name} #{literal(index[:columns])} USING #{index[:type]}"
         end
       end
     
@@ -212,16 +227,20 @@ module Sequel
           if @transactions.include? Thread.current
             return yield(conn)
           end
+          log_info(SQL_BEGIN)
           conn.query(SQL_BEGIN)
           begin
             @transactions << Thread.current
-            result = yield(conn)
-            conn.query(SQL_COMMIT)
-            result
-          rescue => e
+            yield(conn)
+          rescue ::Exception => e
+            log_info(SQL_ROLLBACK)
             conn.query(SQL_ROLLBACK)
-            raise e unless Error::Rollback === e
+            raise (Mysql::Error === e ? Error.new(e.message) : e) unless Error::Rollback === e
           ensure
+            unless e
+              log_info(SQL_COMMIT)
+              conn.query(SQL_COMMIT)
+            end
             @transactions.delete(Thread.current)
           end
         end
@@ -231,12 +250,37 @@ module Sequel
       def use(db_name)
         disconnect
         @opts[:database] = db_name if self << "USE #{db_name}"
+        @schemas = nil
         self
       end
+
+      private
+      def connection_pool_default_options
+        super.merge(:pool_reuse_connections=>:last_resort, :pool_convert_exceptions=>false)
+      end
+
+      def schema_ds_dataset
+        ds = schema_utility_dataset.clone
+        ds.quote_identifiers = true
+        ds
+      end
+
+      def schema_ds_filter(table_name, opts)
+        filt = super
+        # Restrict it to the given or current database, unless specifically requesting :database = nil
+        filt = SQL::ComplexExpression.new(:AND, filt, {:c__table_schema=>opts[:database] || self.opts[:database]}) if opts[:database] || !opts.include?(:database)
+        filt
+      end
+
+      def schema_ds_join(table_name, opts)
+        [:information_schema__columns, {:table_schema => :table_schema, :table_name => :table_name}, :c]
+      end
     end
 
     class Dataset < Sequel::Dataset
-      def quote_column_ref(c); "`#{c}`"; end
+      def quoted_identifier(c)
+        "`#{c}`"
+      end
 
       TRUE = '1'
       FALSE = '0'
@@ -268,7 +312,7 @@ module Sequel
         when LiteralString
           v
         when String
-          "'#{v.gsub(/'|\\/, '\&\&')}'"
+          "'#{::Mysql.quote(v)}'"
         when true
           TRUE
         when false
@@ -293,27 +337,44 @@ module Sequel
       #
       # === Example
       #   @ds = MYSQL_DB[:nodes]
-      #   @ds.join_expr(:natural_left_outer, :nodes)
-      #   # 'NATURAL LEFT OUTER JOIN nodes'
-      #
-      def join_expr(type, table, expr = nil, options = {})
-        raise Error::InvalidJoinType, "Invalid join type: #{type}" unless join_type = JOIN_TYPES[type || :inner]
-        
-        server_version = @opts[:server_version] ||= @db.server_version
-        type = :inner if type == :cross && !expr.nil?
-
-        if (server_version >= 50014) && /\Anatural|cross|straight\z/.match(type.to_s)
-          table = "( #{literal(table)} )" if table.is_a?(Array)
-          "#{join_type} #{table}"
+      #   @ds.join_table(:natural_left_outer, :nodes)
+      #   # join SQL is 'NATURAL LEFT OUTER JOIN nodes'
+      def join_table(type, table, expr=nil, table_alias=nil)
+        raise(Error::InvalidJoinType, "Invalid join type: #{type}") unless join_type = JOIN_TYPES[type || :inner]
+
+        server_version = (@opts[:server_version] ||= @db.server_version)
+        type = :inner if (type == :cross) && !expr.nil?
+        return super(type, table, expr, table_alias) unless (server_version >= 50014) && /natural|cross|straight/.match(type.to_s)
+  
+        table = if Array === table
+          "( #{table.collect{|t| quote_identifier(t)}.join(', ')} )"
         else
-          super
+          quote_identifier(table)
         end
+        clone(:join => "#{@opts[:join]} #{join_type} #{table}")
       end
 
       def insert_default_values_sql
         "INSERT INTO #{source_list(@opts[:from])} () VALUES ()"
       end
 
+      def complex_expression_sql(op, args)
+        case op
+        when :~, :'!~'
+          "#{'NOT ' if op == :'!~'}(#{literal(args.at(0))} REGEXP BINARY #{literal(args.at(1))})"
+        when :'~*', :'!~*'
+          "#{'NOT ' if op == :'!~*'}(#{literal(args.at(0))} REGEXP #{literal(args.at(1))})"
+        when :'||'
+          if args.length > 1
+            "CONCAT(#{args.collect{|a| literal(a)}.join(', ')})"
+          else
+            literal(args.at(0))
+          end
+        else
+          super(op, args)
+        end
+      end
+
       def match_expr(l, r)
         case r
         when Regexp
@@ -352,7 +413,7 @@ module Sequel
         end
 
         if where = opts[:where]
-          sql << " WHERE #{where}"
+          sql << " WHERE #{literal(where)}"
         end
 
         if group = opts[:group]
@@ -360,7 +421,7 @@ module Sequel
         end
 
         if having = opts[:having]
-          sql << " HAVING #{having}"
+          sql << " HAVING #{literal(having)}"
         end
 
         if order = opts[:order]
@@ -391,13 +452,22 @@ module Sequel
       
       def full_text_search(cols, terms, opts = {})
         mode = opts[:boolean] ? " IN BOOLEAN MODE" : ""
-        filter("MATCH (#{literal(cols)}) AGAINST (#{literal(terms)}#{mode})")
+        s = if Array === terms
+          if mode.blank?
+            "MATCH #{literal(Array(cols))} AGAINST #{literal(terms)}"
+          else
+            "MATCH #{literal(Array(cols))} AGAINST (#{literal(terms)[1...-1]}#{mode})"
+          end
+        else
+          "MATCH #{literal(Array(cols))} AGAINST (#{literal(terms)}#{mode})"
+        end
+        filter(s)
       end
 
       # MySQL allows HAVING clause on ungrouped datasets.
       def having(*cond, &block)
         @opts[:having] = {}
-        filter(*cond, &block)
+        x = filter(*cond, &block)
       end
 
       # MySQL supports ORDER and LIMIT clauses in UPDATE statements.
@@ -431,12 +501,8 @@ module Sequel
           when Array
             if values.empty?
               "REPLACE INTO #{from} DEFAULT VALUES"
-            elsif values.keys
-              fl = values.keys.map {|f| literal(f.is_a?(String) ? f.to_sym : f)}
-              vl = values.values.map {|v| literal(v)}
-              "REPLACE INTO #{from} (#{fl.join(COMMA_SEPARATOR)}) VALUES (#{vl.join(COMMA_SEPARATOR)})"
             else
-              "REPLACE INTO #{from} VALUES (#{literal(values)})"
+              "REPLACE INTO #{from} VALUES #{literal(values)}"
             end
           when Hash
             if values.empty?
@@ -498,8 +564,8 @@ module Sequel
       end
 
       def multi_insert_sql(columns, values)
-        columns = literal(columns)
-        values = values.map {|r| "(#{literal(r)})"}.join(COMMA_SEPARATOR)
+        columns = column_list(columns)
+        values = values.map {|r| literal(Array(r))}.join(COMMA_SEPARATOR)
         ["INSERT INTO #{source_list(@opts[:from])} (#{columns}) VALUES #{values}"]
       end
     end

data/lib/sequel_core/adapters/odbc.rb

@@ -46,14 +46,14 @@ module Sequel
       # fetch_rows method source code for an example of how to drop
       # the statements.
       def execute(sql)
-        @logger.info(sql) if @logger
+        log_info(sql)
         @pool.hold do |conn|
           conn.run(sql)
         end
       end
       
       def do(sql)
-        @logger.info(sql) if @logger
+        log_info(sql)
         @pool.hold do |conn|
           conn.do(sql)
         end
@@ -74,12 +74,10 @@ module Sequel
           BOOL_TRUE
         when false
           BOOL_FALSE
-        when Time
+        when Time, DateTime
           formatted = v.strftime(ODBC_TIMESTAMP_FORMAT)
-          if v.usec >= 1000
-            msec = ( v.usec.to_f / 1000 ).round
-            formatted.insert ODBC_TIMESTAMP_AFTER_SECONDS, ".#{msec}"
-          end
+          usec = (Time === v ? v.usec : (v.sec_fraction * 86400000000))
+          formatted.insert(ODBC_TIMESTAMP_AFTER_SECONDS, ".#{(usec.to_f/1000).round}") if usec >= 1000
           formatted
         when Date
           v.strftime(ODBC_DATE_FORMAT)

data/lib/sequel_core/adapters/odbc_mssql.rb

@@ -58,7 +58,7 @@ module Sequel
           end
 
           if where = opts[:where]
-            sql << " WHERE #{where}"
+            sql << " WHERE #{literal(where)}"
           end
 
           if group = opts[:group]
@@ -70,7 +70,7 @@ module Sequel
           end
 
           if having = opts[:having]
-            sql << " HAVING #{having}"
+            sql << " HAVING #{literal(having)}"
           end
 
           if union = opts[:union]
@@ -91,7 +91,16 @@ module Sequel
         def full_text_search(cols, terms, opts = {})
           filter("CONTAINS (#{literal(cols)}, #{literal(terms)})")
         end
+
+        def complex_expression_sql(op, args)
+          case op
+          when :'||'
+            super(:+, args)
+          else
+            super(op, args)
+          end
+        end
       end
     end
   end
-end
+end