sequel 0.4.0 → 0.4.1

data/lib/sequel/adapters/sqlite.rb

@@ -0,0 +1,186 @@
+if !Object.const_defined?('Sequel')
+  require File.join(File.dirname(__FILE__), '../../sequel')
+end
+
+require 'sqlite3'
+
+module Sequel
+  module SQLite
+    class Database < Sequel::Database
+      set_adapter_scheme :sqlite
+    
+      def serial_primary_key_options
+        {:primary_key => true, :type => :integer, :auto_increment => true}
+      end
+
+      def connect
+        if @opts[:database].nil? || @opts[:database].empty?
+          @opts[:database] = ':memory:'
+        end
+        db = ::SQLite3::Database.new(@opts[:database])
+        db.type_translation = true
+        # fix for timestamp translation
+        db.translator.add_translator("timestamp") do |t, v|
+          v =~ /^\d+$/ ? Time.at(v.to_i) : Time.parse(v) 
+        end 
+        db
+      end
+      
+      def disconnect
+        @pool.disconnect {|c| c.close}
+      end
+    
+      def dataset(opts = nil)
+        SQLite::Dataset.new(self, opts)
+      end
+      
+      TABLES_FILTER = "type = 'table' AND NOT name = 'sqlite_sequence'"
+    
+      def tables
+        self[:sqlite_master].filter(TABLES_FILTER).map {|r| r[:name].to_sym}
+      end
+    
+      def execute(sql)
+        @logger.info(sql) if @logger
+        @pool.hold {|conn| conn.execute_batch(sql); conn.changes}
+      end
+      
+      def execute_insert(sql)
+        @logger.info(sql) if @logger
+        @pool.hold {|conn| conn.execute(sql); conn.last_insert_row_id}
+      end
+      
+      def single_value(sql)
+        @logger.info(sql) if @logger
+        @pool.hold {|conn| conn.get_first_value(sql)}
+      end
+      
+      def execute_select(sql, &block)
+        @logger.info(sql) if @logger
+        @pool.hold {|conn| conn.query(sql, &block)}
+      end
+      
+      def pragma_get(name)
+        single_value("PRAGMA #{name}")
+      end
+      
+      def pragma_set(name, value)
+        execute("PRAGMA #{name} = #{value}")
+      end
+      
+      AUTO_VACUUM = {'0' => :none, '1' => :full, '2' => :incremental}.freeze
+      
+      def auto_vacuum
+        AUTO_VACUUM[pragma_get(:auto_vacuum)]
+      end
+      
+      def auto_vacuum=(value)
+        value = AUTO_VACUUM.index(value) || (raise SequelError, "Invalid value for auto_vacuum option. Please specify one of :none, :full, :incremental.")
+        pragma_set(:auto_vacuum, value)
+      end
+      
+      SYNCHRONOUS = {'0' => :off, '1' => :normal, '2' => :full}.freeze
+      
+      def synchronous
+        SYNCHRONOUS[pragma_get(:synchronous)]
+      end
+      
+      def synchronous=(value)
+        value = SYNCHRONOUS.index(value) || (raise SequelError, "Invalid value for synchronous option. Please specify one of :off, :normal, :full.")
+        pragma_set(:synchronous, value)
+      end
+      
+      TEMP_STORE = {'0' => :default, '1' => :file, '2' => :memory}.freeze
+      
+      def temp_store
+        TEMP_STORE[pragma_get(:temp_store)]
+      end
+      
+      def temp_store=(value)
+        value = TEMP_STORE.index(value) || (raise SequelError, "Invalid value for temp_store option. Please specify one of :default, :file, :memory.")
+        pragma_set(:temp_store, value)
+      end
+      
+      def transaction(&block)
+        @pool.hold do |conn|
+          if conn.transaction_active?
+            return yield(conn)
+          end
+          begin
+            result = nil
+            conn.transaction {result = yield(conn)}
+            result
+          rescue => e
+            raise e unless SequelRollbackError === e
+          end
+        end
+      end
+    end
+    
+    class Dataset < Sequel::Dataset
+      def literal(v)
+        case v
+        when Time: literal(v.iso8601)
+        else
+          super
+        end
+      end
+
+      def insert_sql(*values)
+        if (values.size == 1) && values.first.is_a?(Sequel::Dataset)
+          "INSERT INTO #{@opts[:from]} #{values.first.sql};"
+        else
+          super(*values)
+        end
+      end
+
+      def fetch_rows(sql, &block)
+        @db.execute_select(sql) do |result|
+          @columns = result.columns.map {|c| c.to_sym}
+          column_count = @columns.size
+          result.each do |values|
+            row = {}
+            column_count.times {|i| row[@columns[i]] = values[i]}
+            block.call(row)
+          end
+        end
+      end
+      
+      def array_tuples_fetch_rows(sql, &block)
+        @db.execute_select(sql) do |result|
+          @columns = result.columns.map {|c| c.to_sym}
+          result.each {|r| r.keys = @columns; block[r]}
+        end
+      end
+    
+      def insert(*values)
+        @db.execute_insert insert_sql(*values)
+      end
+    
+      def update(values, opts = nil)
+        @db.execute update_sql(values, opts)
+      end
+    
+      def delete(opts = nil)
+        # check if no filter is specified
+        unless (opts && opts[:where]) || @opts[:where]
+          @db.transaction do
+            unfiltered_count = count
+            @db.execute delete_sql(opts)
+            unfiltered_count
+          end
+        else
+          @db.execute delete_sql(opts)
+        end
+      end
+      
+      EXPLAIN = 'EXPLAIN %s'.freeze
+
+      def explain
+        res = []
+        @db.result_set(EXPLAIN % select_sql(opts), nil) {|r| res << r}
+        res
+      end
+    end
+  end
+end

data/lib/sequel/ado.rb

@@ -1,104 +1,2 @@
-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
+warn "Requiring 'sequel/ado' is deprecated. Please modify your code to only require 'sequel' instead."
+require File.join(File.dirname(__FILE__), 'adapters/ado')

data/lib/{sequel-core → sequel}/database.rb

@@ -237,24 +237,6 @@ module Sequel
     def self.set_adapter_scheme(scheme)
       @scheme = scheme
       @@adapters[scheme.to_sym] = self
-      
-      # Define convenience method for this database class
-      db_class = self
-      Sequel.meta_def(scheme) do |*args|
-        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
-        db_class.new(opts)
-      end
     end
     
     # Returns the scheme for the Database class.
@@ -274,6 +256,15 @@ module Sequel
       }
     end
     
+    def self.adapter_class(scheme)
+      unless c = @@adapters[scheme.to_sym]
+        require File.join(File.dirname(__FILE__), "adapters/#{scheme}")
+        c = @@adapters[scheme.to_sym]
+      end
+      raise SequelError, "Invalid database scheme" unless c
+      c
+    end
+        
     # call-seq:
     #   Sequel::Database.connect(conn_string)
     #   Sequel.connect(conn_string)
@@ -287,8 +278,7 @@ module Sequel
       uri = URI.parse(conn_string)
       scheme = uri.scheme
       scheme = :dbi if scheme =~ /^dbi-(.+)/
-      c = @@adapters[scheme.to_sym]
-      raise SequelError, "Invalid database scheme" unless c
+      c = adapter_class(scheme)
       c.new(c.uri_to_options(uri).merge(more_opts || {}))
     end
     

data/lib/sequel/db2.rb

@@ -1,160 +1,2 @@
-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
+warn "Requiring 'sequel/db2' is deprecated. Please modify your code to require 'sequel' instead."
+require File.join(File.dirname(__FILE__), 'adapters/db2')