sequel 0.5.0.2 → 1.0

data/lib/sequel/adapters/sqlite.rb

@@ -1,192 +0,0 @@
-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 Error, "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 Error, "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 Error, "Invalid value for temp_store option. Please specify one of :default, :file, :memory.")
-        pragma_set(:temp_store, value)
-      end
-      
-      def alter_table_sql(table, op)
-        case op[:op]
-        when :add_column
-          "ALTER TABLE #{table} ADD #{column_definition_sql(op)}"
-        else
-          raise Error, "Unsupported ALTER TABLE operation"
-        end
-      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 Error::Rollback === 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(*args, &block)
-        @db.execute update_sql(*args, &block)
-      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,6 +0,0 @@
-warn "Requiring 'sequel/ado' is deprecated. Please modify your code to only require 'sequel' instead."
-
-if !Object.const_defined?('Sequel')
-  require File.join(File.dirname(__FILE__), '../sequel')
-end
-require File.join(File.dirname(__FILE__), 'adapters/ado')

data/lib/sequel/array_keys.rb

@@ -1,296 +0,0 @@
-# ArrayKeys provide support for accessing array elements by keys. ArrayKeys are
-# based on the arrayfields gem by Ara Howard, and can be used as substitutes
-# for fetching records tuples as Ruby hashes.
-#
-# The main advantage offered by ArrayKeys over hashes is that the values are 
-# always ordered according to the column order in the query. Another purported
-# advantage is that they reduce the memory footprint, but this has turned out
-# to be a false claim.
-module ArrayKeys
-  # The KeySet module contains methods that extend an array of keys to return
-  # a key's position in the key set.
-  module KeySet
-    # Returns the key's position in the key set. Provides indifferent access
-    # for symbols and strings.
-    def key_pos(key)
-      @key_indexes ||= inject({}) {|h, k| h[k.to_sym] = h.size; h}
-      @key_indexes[key] || @key_indexes[key.to_sym] || @key_indexes[key.to_s]
-    end
- 
-    # Adds a key to the key set.
-    def add_key(key)
-      self << key
-      @key_indexes[key] = @key_indexes.size
-    end
-    
-    # Removes a key from the key set by its index.
-    def del_key(idx)
-      delete_at(idx)
-      @key_indexes = nil # reset key indexes
-    end
-  end
-  
-  # The KeyAccess provides a large part of the Hash API for arrays with keys.
-  module KeyAccess
-    # Returns a value referenced by an array index or a key.
-    def [](idx, *args)
-      if String === idx or Symbol === idx
-        (idx = @keys.key_pos(idx)) ? super(idx, *args) : nil
-      else
-        super
-      end
-    end
- 
-    # Sets the value referenced by an array index or a key.
-    def []=(idx,*args)
-      if String === idx or Symbol === idx
-        idx = @keys.key_pos(idx) || @keys.add_key(idx.to_sym)
-      end
-      super(idx, *args)
-    end
-    
-    # Stores a value by index or key.
-    def store(k, v); self[k] = v; end
-    
-    # Slices the array, and returns an array with its keys sliced accordingly.
-    def slice(*args)
-      s = super(*args)
-      s.keys = @keys.slice(*args)
-      s
-    end
-    
-    # Converts the array into a hash.
-    def to_hash
-      h = {}
-      each_with_index {|v, i| h[@keys[i].to_sym] = v}
-      h
-    end
-    alias_method :to_h, :to_hash
-    
-    # Iterates over each key-value pair in the array.
-    def each_pair
-      each_with_index {|v, i| yield @keys[i], v}
-    end
-    
-    # Iterates over the array's associated keys.
-    def each_key(&block)
-      @keys.each(&block)
-    end
-    
-    # Iterates over the array's values.
-    def each_value(&block)
-      each(&block)
-    end
-    
-    # Deletes a value by its key.
-    def delete(key, *args)
-      if (idx = @keys.key_pos(key))
-        delete_at(idx)
-      end
-    end
-    
-    # Deletes a value by its index.
-    def delete_at(idx)
-      super(idx)
-      @keys = @keys.clone
-      @keys.del_key(idx)
-    end
-    
-    # Returns true if the array's key set contains the given key.
-    def include?(k)
-      @keys.include?(k) || @keys.include?(k.to_sym) || @keys.include?(k.to_s)
-    end
-    
-    # Returns true if the array's key set contains the given key.
-    def has_key?(k)
-      @keys.include?(k) || @keys.include?(k.to_sym) || @keys.include?(k.to_s)
-    end
-    alias_method :member?, :has_key?
-    alias_method :key?, :has_key?
-    
-    # Returns true if the array contains the given value.
-    def has_value?(k); orig_include?(k); end
-    alias_method :value?, :has_value?
-    
-    # Fetches a value by its key and optionally passes it through the given
-    # block:
-    #
-    #   row.fetch(:name) {|v| v.to_sym}
-    #
-    # You can also give a default value
-    #
-    #   row.fetch(:name, 'untitled')
-    #
-    def fetch(k, *args, &block)
-      if idx = @keys.key_pos(k)
-        v = at idx
-      else
-        !args.empty? ? (v = args.first) : (raise IndexError, "key not found")
-      end
-      block ? block[v] : v
-    end
-    
-    # Returns self.
-    def values
-      self
-    end
-    
-    # Creates a copy of self with the same key set.
-    def dup
-      copy = super
-      copy.keys = @keys
-      copy
-    end
-    
-    # Creates a copy of self with a copy of the key set.
-    def clone
-      copy = super
-      copy.keys = @keys.clone
-      copy
-    end
-    
-    # Returns an array merged from self and the given array.
-    def merge(values, &block)
-      clone.merge!(values, &block)
-    end
-    
-    # Merges the given array with self, optionally passing the values from self
-    # through the given block:
-    #
-    #   row.merge!(new_values) {|k, old, new| (k == :name) ? old : new}
-    #
-    def merge!(values, &block)
-      values.each_pair do |k, v|
-        self[k] = (has_key?(k) && block) ? block[k, self[k], v] : v
-      end
-      self
-    end
-    alias_method :update, :merge!
-    alias_method :update!, :merge!
-  end
-  
-  # The ArrayExtensions module provides extensions for the Array class.
-  module ArrayExtensions
-    attr_reader :keys
-    
-    # Sets the key set for the array. Once a key set has been set for an array,
-    # it is extended with the KeyAccess API
-    def keys=(keys)
-      extend ArrayKeys::KeyAccess if keys
-      @keys = keys.frozen? ? keys.dup : keys
-      unless @keys.respond_to?(:key_pos)
-        @keys.extend(ArrayKeys::KeySet)
-      end
-    end
- 
-    alias_method :columns, :keys
-    alias_method :columns=, :keys=
-  end
-  
-  # The DatasetExtensions module provides extensions that modify
-  # a dataset to return Array tuples instead of Hash tuples.
-  module DatasetExtensions
-    # Fetches a dataset's records, converting each tuple into an array with 
-    # keys.
-    def array_tuples_each(opts = nil, &block)
-      fetch_rows(select_sql(opts)) {|h| block[Array.from_hash(h)]}
-    end
-
-    # Provides the corresponding behavior to Sequel::Dataset#update_each_method,
-    # using array tuples.
-    def array_tuples_update_each_method
-      # warning: ugly code generation ahead
-      if @row_proc && @transform
-        class << self
-          def each(opts = nil, &block)
-            if opts && opts[:naked]
-              fetch_rows(select_sql(opts)) {|r| block[transform_load(Array.from_hash(r))]}
-            else
-              fetch_rows(select_sql(opts)) {|r| block[@row_proc[transform_load(Array.from_hash(r))]]}
-            end
-            self
-          end
-        end
-      elsif @row_proc
-        class << self
-          def each(opts = nil, &block)
-            if opts && opts[:naked]
-              fetch_rows(select_sql(opts)) {|r| block[Array.from_hash(r)]}
-            else
-              fetch_rows(select_sql(opts)) {|r| block[@row_proc[Array.from_hash(r)]]}
-            end
-            self
-          end
-        end
-      elsif @transform
-        class << self
-          def each(opts = nil, &block)
-            fetch_rows(select_sql(opts)) {|r| block[transform_load(Array.from_hash(r))]}
-            self
-          end
-        end
-      else
-        class << self
-          def each(opts = nil, &block)
-            fetch_rows(select_sql(opts)) {|r| block[Array.from_hash(r)]}
-            self
-          end
-        end
-      end
-    end
-  end
-end
-
-# Array extensions.
-class Array
-  alias_method :orig_include?, :include?
-
-  include ArrayKeys::ArrayExtensions
-
-  # Converts a hash into an array with keys.
-  def self.from_hash(h)
-    a = []; a.keys = []
-    a.merge!(h)
-  end
-end
-
-module Sequel
-  # Modifies all dataset classes to fetch records as arrays with keys. By 
-  # default records are fetched as hashes.
-  def self.use_array_tuples
-    Dataset.dataset_classes.each do |c|
-      c.class_eval do
-        if method_defined?(:array_tuples_fetch_rows)
-          alias_method :hash_tuples_fetch_rows, :fetch_rows
-          alias_method :fetch_rows, :array_tuples_fetch_rows
-        else
-          alias_method :orig_each, :each
-          alias_method :orig_update_each_method, :update_each_method
-          include ArrayKeys::DatasetExtensions
-          alias_method :each, :array_tuples_each
-          alias_method :update_each_method, :array_tuples_update_each_method
-        end
-      end
-    end
-  end
-  
-  # Modifies all dataset classes to fetch records as hashes.
-  def self.use_hash_tuples
-    Dataset.dataset_classes.each do |c|
-      c.class_eval do
-        if method_defined?(:hash_tuples_fetch_rows)
-          alias_method :fetch_rows, :hash_tuples_fetch_rows
-        else
-          if method_defined?(:orig_each)
-            alias_method :each, :orig_each
-            undef_method :orig_each
-          end
-          if method_defined?(:orig_update_each_method)
-            alias_method :update_each_method, :orig_update_each_method
-            undef_method :orig_update_each_method
-          end
-        end
-      end
-    end
-  end
-end