sequel 0.4.0 → 0.4.1

data/lib/sequel/dbi.rb

@@ -1,130 +1,2 @@
-if !Object.const_defined?('Sequel')
-  require File.join(File.dirname(__FILE__), '../sequel')
-end
-
-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 array_tuples_fetch_rows(sql, &block)
-        @db.synchronize do
-          s = @db.execute sql
-          begin
-            @columns = s.column_names.map {|c| c.to_sym}
-            s.fetch {|r| r.keys = @columns; yield 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(values, opts = nil)
-        @db.do update_sql(values, opts)
-        self
-      end
-    
-      def delete(opts = nil)
-        @db.do delete_sql(opts)
-      end
-    end
-  end
-end
+warn "Requiring 'sequel/dbi' is deprecated. Please modify your code to require 'sequel' instead."
+require File.join(File.dirname(__FILE__), 'adapters/dbi')

data/lib/sequel/informix.rb

@@ -1,78 +1,2 @@
-if !Object.const_defined?('Sequel')
-  require File.join(File.dirname(__FILE__), '../sequel')
-end
-
-require 'informix'
-
-module Sequel
-  module Informix
-    class Database < Sequel::Database
-      set_adapter_scheme :informix
-      
-      # AUTO_INCREMENT = 'IDENTITY(1,1)'.freeze
-      # 
-      # def auto_increment_sql
-      #   AUTO_INCREMENT
-      # end
-      
-      def connect
-        ::Informix.connect(@opts[:database], @opts[:user], @opts[:password])
-      end
-      
-      def disconnect
-        @pool.disconnect {|c| c.close}
-      end
-    
-      def dataset(opts = nil)
-        Sequel::Informix::Dataset.new(self, opts)
-      end
-      
-      # Returns number of rows affected
-      def execute(sql)
-        @logger.info(sql) if @logger
-        @pool.hold {|c| c.do(sql)}
-      end
-      alias_method :do, :execute
-      
-      def query(sql, &block)
-        @logger.info(sql) if @logger
-        @pool.hold {|c| block[c.cursor(sql)]}
-      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
-          @db.query(sql) do |cursor|
-            begin
-              cursor.open.each_hash {|r| block[r]}
-            ensure
-              cursor.drop
-            end
-          end
-        end
-        self
-      end
-      
-      def insert(*values)
-        @db.do insert_sql(*values)
-      end
-    
-      def update(values, opts = nil)
-        @db.do update_sql(values, opts)
-      end
-    
-      def delete(opts = nil)
-        @db.do delete_sql(opts)
-      end
-    end
-  end
-end
+warn "Requiring 'sequel/informix' is deprecated. Please modify your code to require 'sequel' instead."
+require File.join(File.dirname(__FILE__), 'adapters/informix')

data/lib/sequel/mysql.rb

@@ -1,256 +1,2 @@
-if !Object.const_defined?('Sequel')
-  require File.join(File.dirname(__FILE__), '../sequel')
-end
-
-require 'mysql'
-
-# Monkey patch Mysql::Result to yield hashes with symbol keys
-class Mysql::Result
-  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_time,  # MYSQL_TYPE_TIMESTAMP
-    8   => :to_i,     # MYSQL_TYPE_LONGLONG
-    9   => :to_i,     # MYSQL_TYPE_INT24
-    10  => :to_time,  # MYSQL_TYPE_DATE
-    11  => :to_time,  # MYSQL_TYPE_TIME
-    12  => :to_time,  # MYSQL_TYPE_DATETIME
-    13  => :to_i,     # MYSQL_TYPE_YEAR
-    14  => :to_time,  # 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_s,     # MYSQL_TYPE_TINY_BLOB
-    # 250 => :to_s,     # MYSQL_TYPE_MEDIUM_BLOB
-    # 251 => :to_s,     # MYSQL_TYPE_LONG_BLOB
-    # 252 => :to_s,     # MYSQL_TYPE_BLOB
-    # 253 => :to_s,     # MYSQL_TYPE_VAR_STRING
-    # 254 => :to_s,     # MYSQL_TYPE_STRING
-    # 255 => :to_s      # MYSQL_TYPE_GEOMETRY
-  }
-  
-  def convert_type(v, type)
-    v ? ((t = MYSQL_TYPES[type]) ? v.send(t) : v) : nil
-  end
-  
-  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
-  
-  def each_array(with_table = nil)
-    c = columns
-    while row = fetch_row
-      c.each_with_index do |f, i|
-        if (t = MYSQL_TYPES[@column_types[i]]) && (v = row[i])
-          row[i] = v.send(t)
-        end
-      end
-      row.keys = c
-      yield row
-    end
-  end
-  
-  def 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
-end
-
-module Sequel
-  module MySQL
-    class Database < Sequel::Database
-      set_adapter_scheme :mysql
-    
-      def serial_primary_key_options
-        {:primary_key => true, :type => :integer, :auto_increment => true}
-      end
-      
-      AUTO_INCREMENT = 'AUTO_INCREMENT'.freeze
-      
-      def auto_increment_sql
-        AUTO_INCREMENT
-      end
-
-      def connect
-        conn = Mysql.real_connect(@opts[:host], @opts[:user], @opts[:password], 
-          @opts[:database], @opts[:port], nil, Mysql::CLIENT_MULTI_RESULTS)
-        conn.query_with_result = false
-        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_results = '#{encoding}'")
-        end
-        conn.reconnect = true
-        conn
-      end
-      
-      def disconnect
-        @pool.disconnect {|c| c.close}
-      end
-      
-      def tables
-        @pool.hold do |conn|
-          conn.list_tables.map {|t| t.to_sym}
-        end
-      end
-    
-      def dataset(opts = nil)
-        MySQL::Dataset.new(self, opts)
-      end
-      
-      def execute(sql)
-        @logger.info(sql) if @logger
-        @pool.hold do |conn|
-          conn.query(sql)
-        end
-      end
-      
-      def execute_select(sql)
-        @logger.info(sql) if @logger
-        @pool.hold do |conn|
-          conn.query(sql)
-          conn.use_result
-        end
-      end
-      
-      def execute_insert(sql)
-        @logger.info(sql) if @logger
-        @pool.hold do |conn|
-          conn.query(sql)
-          conn.insert_id
-        end
-      end
-    
-      def execute_affected(sql)
-        @logger.info(sql) if @logger
-        @pool.hold do |conn|
-          conn.query(sql)
-          conn.affected_rows
-        end
-      end
-
-      def transaction
-        @pool.hold do |conn|
-          @transactions ||= []
-          if @transactions.include? Thread.current
-            return yield(conn)
-          end
-          conn.query(SQL_BEGIN)
-          begin
-            @transactions << Thread.current
-            result = yield(conn)
-            conn.query(SQL_COMMIT)
-            result
-          rescue => e
-            conn.query(SQL_ROLLBACK)
-            raise e unless SequelRollbackError === e
-          ensure
-            @transactions.delete(Thread.current)
-          end
-        end
-      end
-    end
-    
-    class Dataset < Sequel::Dataset
-      def quote_column_ref(c); "`#{c}`"; end
-      
-      TRUE = '1'
-      FALSE = '0'
-      
-      def literal(v)
-        case v
-        when LiteralString: v
-        when String: "'#{v.gsub(/'|\\/, '\&\&')}'"
-        when true: TRUE
-        when false: FALSE
-        else
-          super
-        end
-      end
-      
-      def match_expr(l, r)
-        case r
-        when Regexp:
-          r.casefold? ? \
-            "(#{literal(l)} REGEXP #{literal(r.source)})" :
-            "(#{literal(l)} REGEXP BINARY #{literal(r.source)})"
-        else
-          super
-        end
-      end
-      
-      # MySQL supports ORDER and LIMIT clauses in UPDATE statements.
-      def update_sql(values, opts = nil)
-        sql = super
-
-        opts = opts ? @opts.merge(opts) : @opts
-        
-        if order = opts[:order]
-          sql << " ORDER BY #{column_list(order)}"
-        end
-
-        if limit = opts[:limit]
-          sql << " LIMIT #{limit}"
-        end
-
-        sql
-      end
-
-      def insert(*values)
-        @db.execute_insert(insert_sql(*values))
-      end
-    
-      def update(values, opts = nil)
-        @db.execute_affected(update_sql(values, opts))
-      end
-    
-      def delete(opts = nil)
-        @db.execute_affected(delete_sql(opts))
-      end
-      
-      def fetch_rows(sql)
-        @db.synchronize do
-          r = @db.execute_select(sql)
-          begin
-            @columns = r.columns
-            r.each_hash {|row| yield row}
-          ensure
-            r.free
-          end
-        end
-        self
-      end
-
-      def array_tuples_fetch_rows(sql, &block)
-        @db.synchronize do
-          r = @db.execute_select(sql)
-          begin
-            @columns = r.columns
-            r.each_array(&block)
-          ensure
-            r.free
-          end
-        end
-        self
-      end
-    end
-  end
-end
+warn "Requiring 'sequel/mysql' is deprecated. Please modify your code to require 'sequel' instead."
+require File.join(File.dirname(__FILE__), 'adapters/mysql')