sequel 0.5.0.2 → 1.0

data/bin/sequel

@@ -1,41 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'rubygems'
-require 'sequel'
-
-usage = <<END
-Usage: sequel <connection URI>
-Sequel: Lightweight ORM library for Ruby
-
-Examples:
-  sequel sqlite:///blog.db
-  sequel postgres://localhost/my_blog
-
-For more information see http://code.google.com/p/ruby-sequel
-END
-
-db = ARGV.shift
-
-if db.nil? || db.empty?
-  puts usage
-  exit
-end
-
-begin
-  DB = Sequel.connect db
-rescue => e
-  puts e.message
-  exit
-end
-
-begin
-  DB.test_connection
-rescue => e
-  puts e.message
-  puts e.backtrace.first
-  exit
-end
-
-require 'irb'
-puts "Your database is stored in DB..."
-IRB.start

data/lib/sequel/adapters/adapter_skeleton.rb

@@ -1,68 +0,0 @@
-# require 'adapter_lib'
-
-module Sequel
-  module Adapter
-    class Database < Sequel::Database
-      set_adapter_scheme :adapter
-      
-      def connect
-        AdapterDB.new(@opts[:database], @opts[:user], @opts[:password])
-      end
-      
-      def disconnect
-        @pool.disconnect {|c| c.disconnect}
-      end
-    
-      def dataset(opts = nil)
-        Adapter::Dataset.new(self, opts)
-      end
-    
-      def execute(sql)
-        @logger.info(sql) if @logger
-        @pool.hold {|conn| conn.exec(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
-          cursor = @db.execute sql
-          begin
-            @columns = cursor.get_col_names.map {|c| c.to_sym}
-            while r = cursor.fetch
-              row = {}
-              r.each_with_index {|v, i| row[@columns[i]] = v}
-              yield row
-            end
-          ensure
-            cursor.close
-          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

data/lib/sequel/adapters/ado.rb

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

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

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