sequel_core 1.0

data/lib/sequel_core/adapters/ado.rb

@@ -0,0 +1,100 @@
+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(*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/db2.rb

@@ -0,0 +1,158 @@
+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 Error, 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(*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/dbi.rb

@@ -0,0 +1,126 @@
+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(*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

@@ -0,0 +1,87 @@
+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 select_sql(opts = nil)
+        limit = opts.delete(:limit)
+        offset = opts.delete(:offset)
+        sql = super
+        if limit
+          limit = "FIRST #{limit}"
+          offset = offset ? "SKIP #{offset}" : ""
+          sql.sub!(/^select /i,"SELECT #{offset} #{limit} ")
+        end
+        sql
+      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(*args, &block)
+        @db.do update_sql(*args, &block)
+      end
+    
+      def delete(opts = nil)
+        @db.do delete_sql(opts)
+      end
+    end
+  end
+end