epugh-sequel 0.0.0

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 0
+:major: 0
+:minor: 0

data/bin/sequel

@@ -0,0 +1,104 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'optparse'
+require 'sequel'
+
+db_opts = {}
+echo = nil
+env = nil
+logfile = nil
+migrate_dir = nil
+migrate_ver = nil
+load_dir = nil
+
+opts = OptionParser.new do |opts|
+  opts.banner = "Sequel: The Database Toolkit for Ruby"
+  opts.define_head "Usage: sequel <uri|path> [options]"
+  opts.separator ""
+  opts.separator "Examples:"
+  opts.separator "  sequel sqlite://blog.db"
+  opts.separator "  sequel postgres://localhost/my_blog"
+  opts.separator "  sequel config/database.yml"
+  opts.separator ""
+  opts.separator "For more information see http://sequel.rubyforge.org"
+  opts.separator ""
+  opts.separator "Options:"
+
+  opts.on_tail("-?", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+
+  opts.on("-e", "--env ENV", "use environment config for database") do |v|
+    env = v
+  end
+  
+  opts.on("-E", "--echo", "echo SQL statements") do
+    echo = true
+  end
+  
+  opts.on("-l", "--log logfile", "log SQL statements to log file") do |v|
+    logfile = v
+  end
+  
+  opts.on("-L", "--load-dir DIR", "loads all *.rb from specifed directory") do |v|
+    load_dir = v
+  end
+  
+  opts.on("-m", "--migrate-directory DIR", "run the migrations in directory") do |v|
+    migrate_dir = v
+  end
+  
+  opts.on("-M", "--migrate-version VER", "migrate the database to version given") do |v|
+    migrate_ver = Integer(v)
+  end
+
+  opts.on_tail("-v", "--version", "Show version") do
+    puts "sequel #{Sequel.version}"
+    exit
+  end
+end
+opts.parse!
+
+db = ARGV.shift
+
+if db.blank?
+  puts opts
+  exit 1
+end
+
+if logfile || echo
+  require 'logger'
+  db_opts[:loggers] = []
+  db_opts[:loggers] << Logger.new(logfile) if logfile
+  db_opts[:loggers] << Logger.new($stdout) if echo
+end
+
+if File.exist?(db)
+  require 'yaml'
+  env ||= "development"
+  db_config = YAML.load_file(db)
+  db_config = db_config[env] || db_config[env.to_sym] || db_config
+  db_config.each{|(k,v)| db_config[k.to_sym] = db_config.delete(k)}
+  db_config.merge!(db_opts)
+end
+
+begin
+  DB = Sequel.connect(*(db_config ? [db_config] : [db, db_opts]))
+  DB.test_connection
+  if migrate_dir
+    Sequel::Migrator.apply(DB, migrate_dir, migrate_ver)
+    exit
+  end
+rescue => e
+  puts "#{e.class}: #{e.message}"
+  puts e.backtrace.first
+  exit 1
+end
+
+Dir["#{load_dir}/**/*.rb"].each{|f| load(f)} if load_dir
+
+require 'irb'
+puts "Your database is stored in DB..."
+IRB.start

data/lib/sequel.rb

@@ -0,0 +1 @@
+require 'sequel/model'

data/lib/sequel/adapters/ado.rb

@@ -0,0 +1,85 @@
+Sequel.require 'adapters/utils/date_format'
+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.connect('ado://mydb')
+  # 
+  # or using the Sequel.ado method:
+  #
+  #   DB = Sequel.ado('mydb')
+  #
+  module ADO
+    class Database < Sequel::Database
+      set_adapter_scheme :ado
+
+      def initialize(opts)
+        super(opts)
+        opts[:driver] ||= 'SQL Server'
+        case opts[:driver]
+        when 'SQL Server'
+          Sequel.require 'adapters/shared/mssql'
+          extend Sequel::MSSQL::DatabaseMethods
+        end
+      end
+
+      def connect(server)
+        opts = server_opts(server)
+        s = "driver=#{opts[:driver]};server=#{opts[:host]};database=#{opts[:database]}#{";uid=#{opts[:user]};pwd=#{opts[:password]}" if opts[:user]}"
+        handle = WIN32OLE.new('ADODB.Connection')
+        handle.Open(s)
+        handle
+      end
+      
+      def dataset(opts = nil)
+        ADO::Dataset.new(self, opts)
+      end
+    
+      def execute(sql, opts={})
+        log_info(sql)
+        synchronize(opts[:server]) do |conn|
+          r = conn.Execute(sql)
+          yield(r) if block_given?
+          r
+        end
+      end
+      alias_method :do, :execute
+
+      private
+
+      def disconnect_connection(conn)
+        conn.Close
+      end
+    end
+    
+    class Dataset < Sequel::Dataset
+      include Dataset::SQLStandardDateFormat
+
+      def fetch_rows(sql)
+        execute(sql) do |s|
+          @columns = s.Fields.extend(Enumerable).map do |column|
+            name = column.Name.empty? ? '(no column name)' : column.Name
+            output_identifier(name)
+          end
+          
+          unless s.eof
+            s.moveFirst
+            s.getRows.transpose.each {|r| yield hash_row(r)}
+          end
+        end
+        self
+      end
+      
+      private
+      
+      def hash_row(row)
+        @columns.inject({}) do |m, c|
+          m[c] = row.shift
+          m
+        end
+      end
+    end
+  end
+end

data/lib/sequel/adapters/db2.rb

@@ -0,0 +1,132 @@
+require 'db2/db2cli'
+
+module Sequel
+  module DB2
+    class Database < Sequel::Database
+      set_adapter_scheme :db2
+      include DB2CLI
+      
+      rc, @@env = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE)
+      #check_error(rc, "Could not allocate DB2 environment")
+
+      def connect(server)
+        opts = server_opts(server)
+        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 test_connection(server=nil)
+        synchronize(server){|conn|}
+        true
+      end
+
+      def dataset(opts = nil)
+        DB2::Dataset.new(self, opts)
+      end
+      
+      def execute(sql, opts={})
+        log_info(sql)
+        synchronize(opts[:server]) 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")
+            
+            yield(sth) if block_given?
+
+            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
+      
+      private
+      
+      def check_error(rc, msg)
+        case rc
+        when SQL_SUCCESS, SQL_SUCCESS_WITH_INFO
+          nil
+        else
+          raise DatabaseError, msg
+        end
+      end
+
+      def disconnect_connection(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
+    
+    class Dataset < Sequel::Dataset
+      MAX_COL_SIZE = 256
+      
+      def fetch_rows(sql)
+        execute(sql) do |sth|
+          @column_info = get_column_info(sth)
+          @columns = @column_info.map {|c| output_identifier(c[:name])}
+          while (rc = SQLFetch(@handle)) != SQL_NO_DATA_FOUND
+            @db.check_error(rc, "Could not fetch row")
+            yield hash_row(sth)
+          end
+        end
+        self
+      end
+      
+      private
+
+      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[output_identifier(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
+    end
+  end
+end

data/lib/sequel/adapters/dbi.rb

@@ -0,0 +1,101 @@
+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) # :nodoc:
+        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
+
+      private_class_method :uri_to_options
+      
+      def connect(server)
+        opts = server_opts(server)
+        dbname = opts[:database]
+        if dbname !~ /^DBI:/ then
+          dbname = "DBI:#{dbname}"
+          [:host, :port].each{|sym| dbname += ";#{sym}=#{opts[sym]}" unless blank_object?(opts[sym])}
+        end
+        ::DBI.connect(dbname, opts[:user], opts[:password])
+      end
+      
+      def dataset(opts = nil)
+        DBI::Dataset.new(self, opts)
+      end
+    
+      def execute(sql, opts={})
+        log_info(sql)
+        synchronize(opts[:server]) do |conn|
+          r = conn.execute(sql)
+          yield(r) if block_given?
+          r
+        end
+      end
+      
+      def do(sql, opts={})
+        log_info(sql)
+        synchronize(opts[:server]){|conn| conn.do(sql)}
+      end
+      alias_method :execute_dui, :do
+
+      private
+
+      def disconnect_connection(c)
+        c.disconnect
+      end
+    end
+    
+    class Dataset < Sequel::Dataset
+      def fetch_rows(sql, &block)
+        execute(sql) do |s|
+          begin
+            @columns = s.column_names.map{|c| output_identifier(c)}
+            s.fetch{|r| yield hash_row(s, r)}
+          ensure
+            s.finish rescue nil
+          end
+        end
+        self
+      end
+      
+      private
+      
+      def hash_row(stmt, row)
+        @columns.inject({}) do |m, c|
+          m[c] = row.shift
+          m
+        end
+      end
+    end
+  end
+end

data/lib/sequel/adapters/do.rb

@@ -0,0 +1,197 @@
+require 'data_objects'
+
+module Sequel
+  # Module holding the DataObjects support for Sequel.  DataObjects is a
+  # ruby library with a standard API for accessing databases.
+  #
+  # The DataObjects adapter currently supports PostgreSQL, MySQL, and
+  # SQLite:
+  #
+  # *  Sequel.connect('do:sqlite3::memory:')
+  # *  Sequel.connect('do:postgres://user:password@host/database')
+  # *  Sequel.connect('do:mysql://user:password@host/database')
+  module DataObjects
+    # Contains procs keyed on sub adapter type that extend the
+    # given database object so it supports the correct database type.
+    DATABASE_SETUP = {:postgres=>proc do |db|
+        require 'do_postgres'
+        Sequel.require 'adapters/do/postgres'
+        db.converted_exceptions << PostgresError
+        db.extend(Sequel::DataObjects::Postgres::DatabaseMethods)
+      end,
+      :mysql=>proc do |db|
+        require 'do_mysql'
+        Sequel.require 'adapters/do/mysql'
+        db.converted_exceptions << MysqlError
+        db.extend(Sequel::DataObjects::MySQL::DatabaseMethods)
+      end,
+      :sqlite3=>proc do |db|
+        require 'do_sqlite3'
+        Sequel.require 'adapters/do/sqlite'
+        db.converted_exceptions << Sqlite3Error
+        db.extend(Sequel::DataObjects::SQLite::DatabaseMethods)
+      end
+    }
+      
+    # DataObjects uses it's own internal connection pooling in addition to the
+    # pooling that Sequel uses.  You should make sure that you don't set
+    # the connection pool size to more than 8 for a
+    # Sequel::DataObjects::Database object, or hack DataObjects (or Extlib) to
+    # use a pool size at least as large as the pool size being used by Sequel.
+    class Database < Sequel::Database
+      set_adapter_scheme :do
+      
+      # Convert the given exceptions to Sequel:Errors, necessary
+      # because DO raises errors specific to database types in
+      # certain cases.
+      attr_accessor :converted_exceptions
+      
+      # Call the DATABASE_SETUP proc directly after initialization,
+      # so the object always uses sub adapter specific code.  Also,
+      # raise an error immediately if the connection doesn't have a
+      # uri, since DataObjects requires one.
+      def initialize(opts)
+        @opts = opts
+        @converted_exceptions = []
+        raise(Error, "No connection string specified") unless uri
+        if prok = DATABASE_SETUP[subadapter.to_sym]
+          prok.call(self)
+        end
+        super(opts)
+      end
+      
+      # Setup a DataObjects::Connection to the database.
+      def connect(server)
+        setup_connection(::DataObjects::Connection.new(uri(server_opts(server))))
+      end
+      
+      # Return a Sequel::DataObjects::Dataset object for this database.
+      def dataset(opts = nil)
+        DataObjects::Dataset.new(self, opts)
+      end
+    
+      # Execute the given SQL.  If a block is given, the DataObjects::Reader
+      # created is yielded to it. A block should not be provided unless a
+      # a SELECT statement is being used (or something else that returns rows).
+      # Otherwise, the return value is the insert id if opts[:type] is :insert,
+      # or the number of affected rows, otherwise.
+      def execute(sql, opts={})
+        log_info(sql)
+        synchronize(opts[:server]) do |conn|
+          begin
+            command = conn.create_command(sql)
+            res = block_given? ? command.execute_reader : command.execute_non_query
+          rescue Exception => e
+            raise_error(e, :classes=>@converted_exceptions)
+          end
+          if block_given?
+            begin
+              yield(res)
+            ensure
+             res.close if res
+            end
+          elsif opts[:type] == :insert
+            res.insert_id
+          else
+            res.affected_rows
+          end
+        end
+      end
+      
+      # Execute the SQL on the this database, returning the number of affected
+      # rows.
+      def execute_dui(sql, opts={})
+        execute(sql, opts)
+      end
+      
+      # Execute the SQL on this database, returning the primary key of the
+      # table being inserted to.
+      def execute_insert(sql, opts={})
+        execute(sql, opts.merge(:type=>:insert))
+      end
+      
+      # Return the subadapter type for this database, i.e. sqlite3 for
+      # do:sqlite3::memory:.
+      def subadapter
+        uri.split(":").first
+      end
+      
+      # Use DataObject's transaction support for transactions.  This
+      # only supports single level transactions, and it always prepares
+      # transactions and commits them immediately after.  It's wasteful,
+      # but required by DataObject's API.
+      def transaction(opts={})
+        unless opts.is_a?(Hash)
+          Deprecation.deprecate('Passing an argument other than a Hash to Database#transaction', "Use DB.transaction(:server=>#{opts.inspect})") 
+          opts = {:server=>opts}
+        end
+        th = Thread.current
+        synchronize(opts[:server]) do |conn|
+          return yield(conn) if @transactions.include?(th)
+          t = ::DataObjects::Transaction.create_for_uri(uri)
+          t.instance_variable_get(:@connection).close
+          t.instance_variable_set(:@connection, conn)
+          begin
+            log_info("Transaction.begin")
+            t.begin
+            @transactions << th
+            yield(conn)
+          rescue Exception => e
+            log_info("Transaction.rollback")
+            t.rollback
+            transaction_error(e)
+          ensure
+            unless e
+              log_info("Transaction.commit")
+              t.prepare
+              t.commit 
+            end
+            @transactions.delete(th)
+          end
+        end
+      end
+      
+      # Return the DataObjects URI for the Sequel URI, removing the do:
+      # prefix.
+      def uri(opts={})
+        opts = @opts.merge(opts)
+        (opts[:uri] || opts[:url]).sub(/\Ado:/, '')
+      end
+
+      private
+
+      # Close the given database connection.
+      def disconnect_connection(c)
+        c.close
+      end
+      
+      # Allow extending the given connection when it is first created.
+      # By default, just returns the connection.
+      def setup_connection(conn)
+        conn
+      end
+      
+      # The DataObjects adapter should convert exceptions by default.
+      def connection_pool_default_options
+        super.merge(:pool_convert_exceptions=>false)
+      end
+    end
+    
+    # Dataset class for Sequel::DataObjects::Database objects.
+    class Dataset < Sequel::Dataset
+      # Execute the SQL on the database and yield the rows as hashes
+      # with symbol keys.
+      def fetch_rows(sql)
+        execute(sql) do |reader|
+          cols = @columns = reader.fields.map{|f| output_identifier(f)}
+          while(reader.next!) do
+            h = {}
+            cols.zip(reader.values).each{|k, v| h[k] = v}
+            yield h
+          end
+        end
+        self
+      end
+    end
+  end
+end