sequel 0.4.0 → 0.4.1

data/CHANGELOG

@@ -1,3 +1,7 @@
+=== 0.4.1 (2007-11-25)
+
+* Put adapter files in lib/sequel/adapters. Requiring sequel/<adapter> is now deprecated. Users can now just require 'sequel' and adapters are automagically loaded (#93).
+
 === 0.4.0 (2007-11-24)
 
 * Reorganized lib directory structure.

data/README

@@ -79,14 +79,9 @@ Much of Sequel is still undocumented (especially the part relating to model clas
 
 === Connecting to a database
 
-Before connecting to a database, you should require the corresponding adaptor, for example:
-
-  require 'sequel/sqlite'
-
-Note: you don't need to require 'sequel' separately before that, as each adapter requires 'sequel' if it hasn't yet been required.
-
 To connect to a database you simply provide Sequel with a URL:
 
+  require 'sequel'
   DB = Sequel.open 'sqlite:///blog.db'
   
 The connection URL can also include such stuff as the user name and password:

data/Rakefile

@@ -6,7 +6,7 @@ require 'fileutils'
 include FileUtils
 
 NAME = "sequel"
-VERS = "0.4.0"
+VERS = "0.4.1"
 CLEAN.include ['**/.*.sw?', 'pkg/*', '.config', 'doc/*', 'coverage/*']
 RDOC_OPTS = ['--quiet', '--title', "Sequel: Concise ORM for Ruby",
   "--opname", "index.html",

data/bin/sequel

@@ -22,8 +22,7 @@ if db.nil? || db.empty?
 end
 
 begin
-  scheme = URI.parse(db).scheme
-  require File.join('sequel', scheme)
+  DB = Sequel.connect db
 rescue LoadError => e
   puts "Failed to load #{scheme} adapter: #{e.message}"
   exit
@@ -32,7 +31,6 @@ rescue => e
   exit
 end
 
-DB = Sequel.connect db
 begin
   DB.test_connection
 rescue => e

data/lib/sequel.rb

@@ -6,7 +6,7 @@ files = %w[
   core_ext core_sql array_keys error connection_pool pretty_table
   dataset migration model schema database worker
 ]
-dir = File.join(File.dirname(__FILE__), 'sequel-core')
+dir = File.join(File.dirname(__FILE__), 'sequel')
 files.each {|f| require(File.join(dir, f))}
 
 module Sequel #:nodoc:
@@ -29,6 +29,23 @@ module Sequel #:nodoc:
     def single_threaded=(value)
       Database.single_threaded = value
     end
+    
+    def method_missing(m, *args)
+      c = Database.adapter_class(m)
+      begin
+        case args.size
+        when 1: # Sequel.dbi(db_name)
+          opts = {:database => args[0]}
+        when 0 # Sequel.dbi
+          opts = {}
+        else # Sequel.dbi(db_name, opts)
+          opts = args[1].merge(:database => args[0])
+        end
+      rescue
+        raise SequelError, "Invalid parameters specified"
+      end
+      c.new(opts)
+    end
   end
 end
 

data/lib/sequel/adapters/ado.rb

@@ -0,0 +1,104 @@
+if !Object.const_defined?('Sequel')
+  require File.join(File.dirname(__FILE__), '../../sequel')
+end
+
+require 'win32ole'
+
+module Sequel
+  # The ADO adapter provides connectivity to ADO databases in Windows. ADO
+  # databases can be opened using a URL with the ado schema:
+  #
+  #   DB = Sequel.open('ado://mydb')
+  # 
+  # or using the Sequel.ado method:
+  #
+  #   DB = Sequel.ado('mydb')
+  #
+  module ADO
+    class Database < Sequel::Database
+      set_adapter_scheme :ado
+      
+      AUTO_INCREMENT = 'IDENTITY(1,1)'.freeze
+      
+      def auto_increment_sql
+        AUTO_INCREMENT
+      end
+      
+      def connect
+        dbname = @opts[:database]
+        handle = WIN32OLE.new('ADODB.Connection')
+        handle.Open(dbname)
+        handle
+      end
+      
+      def disconnect
+        # how do we disconnect? couldn't find anything in the docs
+      end
+    
+      def dataset(opts = nil)
+        ADO::Dataset.new(self, opts)
+      end
+    
+      def execute(sql)
+        @logger.info(sql) if @logger
+        @pool.hold {|conn| conn.Execute(sql)}
+      end
+      
+      alias_method :do, :execute
+    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
+          
+          @columns = s.Fields.extend(Enumerable).map {|x| x.Name.to_sym}
+          
+          s.moveFirst
+          s.getRows.transpose.each {|r| yield hash_row(r)}
+        end
+        self
+      end
+      
+      def hash_row(row)
+        @columns.inject({}) do |m, c|
+          m[c] = row.shift
+          m
+        end
+      end
+    
+      def array_tuples_fetch_rows(sql, &block)
+        @db.synchronize do
+          s = @db.execute sql
+          
+          @columns = s.Fields.extend(Enumerable).map {|x| x.Name.to_sym}
+          
+          s.moveFirst
+          s.getRows.transpose.each {|r| r.keys = @columns; yield r}
+        end
+        self
+      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

data/lib/sequel/adapters/db2.rb

@@ -0,0 +1,160 @@
+if !Object.const_defined?('Sequel')
+  require File.join(File.dirname(__FILE__), '../../sequel')
+end
+
+require 'db2/db2cli'
+
+module Sequel
+  module DB2
+    class Database < Sequel::Database
+      set_adapter_scheme :db2
+      include DB2CLI
+      
+      # AUTO_INCREMENT = 'IDENTITY(1,1)'.freeze
+      # 
+      # def auto_increment_sql
+      #   AUTO_INCREMENT
+      # end
+      
+      def check_error(rc, msg)
+        case rc
+        when SQL_SUCCESS, SQL_SUCCESS_WITH_INFO: nil
+        else
+          raise SequelError, msg
+        end
+      end
+      
+      rc, @@env = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE)
+      check_error(rc, "Could not allocate DB2 environment")
+
+      def connect
+        rc, dbc = SQLAllocHandle(SQL_HANDLE_DBC, @@env) 
+        check_error(rc, "Could not allocate database connection")
+        
+        rc = SQLConnect(dbc, @opts[:database], @opts[:user], @opts[:password]) 
+        check_error(rc, "Could not connect to database")
+        
+        dbc
+      end
+      
+      def disconnect
+        @pool.disconnect do |conn|
+          rc = SQLDisconnect(conn)
+          check_error(rc, "Could not disconnect from database")
+
+          rc = SQLFreeHandle(SQL_HANDLE_DBC, conn)
+          check_error(rc, "Could not free Database handle")
+        end
+      end
+    
+      def test_connection
+        @pool.hold {|conn|}
+        true
+      end
+
+      def dataset(opts = nil)
+        DB2::Dataset.new(self, opts)
+      end
+      
+      def execute(sql, &block)
+        @logger.info(sql) if @logger
+        @pool.hold do |conn|
+          rc, sth = SQLAllocHandle(SQL_HANDLE_STMT, @handle) 
+          check_error(rc, "Could not allocate statement")
+
+          begin
+            rc = SQLExecDirect(sth, sql) 
+            check_error(rc, "Could not execute statement")
+            
+            block[sth] if block
+
+            rc, rpc = SQLRowCount(sth)
+            check_error(rc, "Could not get RPC") 
+            rpc
+          ensure
+            rc = SQLFreeHandle(SQL_HANDLE_STMT, sth)
+            check_error(rc, "Could not free statement")
+          end
+        end
+      end
+      alias_method :do, :execute
+    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.execute(sql) do |sth|
+            @column_info = get_column_info(sth)
+            @columns = @column_info.map {|c| c[:name]}
+            while (rc = SQLFetch(@handle)) != SQL_NO_DATA_FOUND
+              @db.check_error(rc, "Could not fetch row")
+              yield hash_row(sth)
+            end
+          end
+        end
+        self
+      end
+      
+      MAX_COL_SIZE = 256
+
+      def get_column_info(sth)
+        rc, column_count = SQLNumResultCols(sth)
+        @db.check_error(rc, "Could not get number of result columns")
+
+        (1..column_count).map do |i| 
+          rc, name, buflen, datatype, size, digits, nullable = SQLDescribeCol(sth, i, MAX_COL_SIZE)
+          @b.check_error(rc, "Could not describe column")
+          
+          {:name => name, :db2_type => datatype, :precision => size}
+        end 
+      end
+      
+      def hash_row(sth)
+        row = {}
+        @column_info.each_with_index do |c, i|
+          rc, v = SQLGetData(sth, i+1, c[:db2_type], c[:precision]) 
+          @db.check_error(rc, "Could not get data")
+          
+          @row[c[:name]] = convert_type(v)
+        end
+        row
+      end
+      
+      def convert_type(v)
+        case v
+        when DB2CLI::Date 
+          DBI::Date.new(v.year, v.month, v.day)
+        when DB2CLI::Time
+          DBI::Time.new(v.hour, v.minute, v.second)
+        when DB2CLI::Timestamp 
+          DBI::Timestamp.new(v.year, v.month, v.day,
+            v.hour, v.minute, v.second, v.fraction)
+        when DB2CLI::Null
+          nil
+        else  
+          v
+        end
+      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

data/lib/sequel/adapters/dbi.rb

@@ -0,0 +1,130 @@
+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