sequel 0.1.1 → 0.1.2

data/CHANGELOG

@@ -1,3 +1,25 @@
+*0.1.2*
+
+* The first opened database is automatically assigned to to Model.db.
+
+* Removed SequelConnectionError. Exception class errors are converted to RuntimeError.
+
+* Added support for UNION, INTERSECT and EXCEPT set operations.
+
+* Fixed Dataset#single_record to return nil if no record is found.
+
+* Updated specs to conform to RSpec 1.0.
+
+* Added Model#find_or_create method.
+
+* Fixed MySQL::Dataset#query_single (thanks Dries Harnie.)
+
+* Added Model.subset method. Fixed Model.filter and Model.exclude to accept blocks.
+
+* Added Database#uri method.
+
+* Refactored and removed deprecated code in postgres adapter.
+
 *0.1.1*
 
 * More documentation for Dataset.

data/Rakefile

@@ -6,7 +6,7 @@ require 'fileutils'
 include FileUtils
 
 NAME = "sequel"
-VERS = "0.1.1"
+VERS = "0.1.2"
 CLEAN.include ['**/.*.sw?', 'pkg/*', '.config', 'doc/*', 'coverage/*']
 RDOC_OPTS = ['--quiet', '--title', "Sequel: Concise ORM for Ruby",
   "--opname", "index.html",

data/lib/sequel/connection_pool.rb

@@ -50,8 +50,6 @@ module Sequel
     #
     # If no connection is available, Pool#hold will block until a connection
     # is available.
-    #
-    # Errors raised inside a hold call are wrapped in a SequelConnectionError.
     def hold
       t = Thread.current
       if (conn = owned_connection(t))
@@ -65,10 +63,9 @@ module Sequel
       ensure
         release(t)
       end
-    rescue SequelConnectionError => e
-      raise e
     rescue Exception => e
-      raise SequelConnectionError.new(e)
+      # if the error is not a StandardError it is converted into RuntimeError.
+      raise e.is_a?(StandardError) ? e : e.message
     end
     
     private

data/lib/sequel/database.rb

@@ -2,6 +2,7 @@ require 'uri'
 
 require File.join(File.dirname(__FILE__), 'schema')
 require File.join(File.dirname(__FILE__), 'dataset')
+require File.join(File.dirname(__FILE__), 'model')
 
 module Sequel
   # A Database object represents a virtual connection to a database.
@@ -15,11 +16,30 @@ module Sequel
     #
     # Sequel::Database is an abstract class that is not useful by itself.
     def initialize(opts = {}, &block)
+      Model.database_opened(self)
       @opts = opts
       @pool = ConnectionPool.new(@opts[:max_connections] || 4, &block)
       @logger = opts[:logger]
     end
     
+    def uri
+      uri = URI::Generic.new(
+        self.class.adapter_scheme.to_s,
+        nil,
+        @opts[:host],
+        @opts[:port],
+        nil,
+        "/#{@opts[:database]}",
+        nil,
+        nil,
+        nil
+      )
+      uri.user = @opts[:user]
+      uri.password = @opts[:password]
+      uri.to_s
+    end
+    alias url uri # Because I don't care much for the semantic difference.
+    
     # Returns a blank dataset
     def dataset
       Dataset.new(self)
@@ -114,7 +134,7 @@ module Sequel
     
     @@adapters = Hash.new
     
-    # Sets the adapter scheme for the database class. Call this method in
+    # Sets the adapter scheme for the Database class. Call this method in
     # descendnants of Database to allow connection using a URL. For example the
     # following:
     #   class DB2::Database < Sequel::Database
@@ -124,9 +144,15 @@ module Sequel
     # would allow connection using:
     #   Sequel.open('db2://user:password@dbserver/mydb')
     def self.set_adapter_scheme(scheme)
+      @scheme = scheme
       @@adapters[scheme.to_sym] = self
     end
     
+    # Returns the scheme for the Database class.
+    def self.adapter_scheme
+      @scheme
+    end
+    
     # Converts a uri to an options hash. These options are then passed
     # to a newly created database object.
     def self.uri_to_options(uri)

data/lib/sequel/dataset.rb

@@ -343,8 +343,20 @@ module Sequel
         raise SequelError, "Can only specify a HAVING clause on a grouped dataset"
       else
         filter(*cond, &block)
-       end
-     end
+      end
+    end
+    
+    def union(dataset, all = false)
+      dup_merge(:union => dataset, :union_all => all)
+    end
+
+    def intersect(dataset, all = false)
+      dup_merge(:intersect => dataset, :intersect_all => all)
+    end
+
+    def except(dataset, all = false)
+      dup_merge(:except => dataset, :except_all => all)
+    end
     
     LEFT_OUTER_JOIN = 'LEFT OUTER JOIN'.freeze
     INNER_JOIN = 'INNER JOIN'.freeze
@@ -437,6 +449,17 @@ module Sequel
         end
       end
       
+      if union = opts[:union]
+        sql << (opts[:union_all] ? \
+          " UNION ALL #{union.sql}" : " UNION #{union.sql}")
+      elsif intersect = opts[:intersect]
+        sql << (opts[:intersect_all] ? \
+          " INTERSECT ALL #{intersect.sql}" : " INTERSECT #{intersect.sql}")
+      elsif except = opts[:except]
+        sql << (opts[:except_all] ? \
+          " EXCEPT ALL #{except.sql}" : " EXCEPT #{except.sql}")
+      end
+      
       sql
     end
     alias sql select_sql
@@ -516,6 +539,7 @@ module Sequel
     # Returns the first record in the dataset.
     def single_record(opts = nil)
       each(opts) {|r| return r}
+      nil
     end
     
     # Returns the first value of the first reecord in the dataset.

data/lib/sequel/error.rb

@@ -1,20 +1,2 @@
 class SequelError < StandardError
-end
-
-# This error class is used to wrap exceptions occuring inside calls to
-# ConnectionPool#hold. Sequel wraps any exception raised by the database
-# connection and provides it as a SequelConnectionError. The original
-# exception is provided through SequelConnectionError#original_exception.
-class SequelConnectionError < SequelError
-  attr_reader :original_error
-
-  def initialize(original_error)
-    @original_error = original_error
-  end
-  
-  def message
-    "#{@original_error.class}: #{@original_error.message}"
-  end
-  
-  alias_method :to_s, :message
-end
+end

data/lib/sequel/model.rb

@@ -9,6 +9,9 @@ module Sequel
       @db ||= ((superclass != Object) && (superclass.db)) || nil
     end
     def self.db=(db); @db = db; end
+    def self.database_opened(db)
+      @db = db if self == Model && !@db
+    end
     
     def self.table_name
       @table_name ||= ((superclass != Model) && (superclass.table_name)) || nil
@@ -90,6 +93,10 @@ module Sequel
       create_table
     end
     
+    def self.subset(name, *args, &block)
+      meta_def(name) {filter(*args, &block)}
+    end
+    
     ONE_TO_ONE_PROC = "proc {i = @values[:%s]; %s[i] if i}".freeze
     ID_POSTFIX = "_id".freeze
     FROM_DATASET = "db[%s]".freeze
@@ -126,6 +133,10 @@ module Sequel
       self.class.get_hooks(key).each {|h| instance_eval(&h)}
     end
     
+    def self.before_save(&block)
+      get_hooks(:before_save).unshift(block)
+    end
+    
     def self.before_create(&block)
       get_hooks(:before_create).unshift(block)
     end
@@ -134,17 +145,25 @@ module Sequel
       get_hooks(:before_destroy).unshift(block)
     end
     
-    def self.after_destroy(&block)
-      get_hooks(:after_destroy).unshift(block)
+    def self.after_save(&block)
+      get_hooks(:after_save) << block
     end
     
     def self.after_create(&block)
       get_hooks(:after_create) << block
     end
     
+    def self.after_destroy(&block)
+      get_hooks(:after_destroy).unshift(block)
+    end
+    
     def self.find(cond)
       dataset[cond.is_a?(Hash) ? cond : {primary_key => cond}]
     end
+    
+    def self.find_or_create(cond)
+      find(cond) || create(cond)
+    end
 
     class << self; alias_method :[], :find; end
     
@@ -177,8 +196,8 @@ module Sequel
     
     def self.each(&block); dataset.each(&block); end
     def self.all; dataset.all; end
-    def self.filter(*arg); dataset.filter(*arg); end
-    def self.exclude(*arg); dataset.exclude(*arg); end
+    def self.filter(*arg, &block); dataset.filter(*arg, &block); end
+    def self.exclude(*arg, &block); dataset.exclude(*arg, &block); end
     def self.order(*arg); dataset.order(*arg); end
     def self.first(*arg); dataset.first(*arg); end
     def self.count; dataset.count; end
@@ -252,14 +271,14 @@ module Sequel
     def save
       run_hooks(:before_save)
       if @pkey
-        # run_hooks(:before_update)
+        run_hooks(:before_update)
         model.dataset.filter(primary_key => @pkey).update(@values)
-        # run_hooks(:after_update)
+        run_hooks(:after_update)
       else
-        # run_hooks(:before_create)
+        run_hooks(:before_create)
         @pkey = model.dataset.insert(@values)
         refresh
-        # run_hooks(:after_create)
+        run_hooks(:after_create)
       end
       run_hooks(:after_save)
     end

data/lib/sequel/mysql.rb

@@ -2,7 +2,7 @@ if !Object.const_defined?('Sequel')
   require File.join(File.dirname(__FILE__), '../sequel')
 end
 
-require 'mysql'
+#require 'mysql'
 
 module Sequel
   module MySQL
@@ -101,9 +101,9 @@ module Sequel
           result = @db.execute(sql)
           begin
             if use_model_class && @model_class
-              @model_class.new(result.fetch_hash)
+              row = @model_class.new(result.fetch_hash)
             else
-              result.fetch_hash
+              row = result.fetch_hash
             end
           ensure
             result.free

data/lib/sequel/postgres.rb

@@ -24,16 +24,12 @@ class PGconn
   
   def execute(sql)
     begin
-      # ServerSide.info(sql)
       async_exec(sql)
     rescue PGError => e
       unless connected?
-        # ServerSide.warn('Reconnecting to Postgres server')
         reset
         async_exec(sql)
       else
-        p sql
-        p e
         raise e
       end
     end
@@ -49,16 +45,13 @@ class PGconn
     if @transaction_in_progress
       return yield
     end
-    # ServerSide.info('BEGIN')
     async_exec(SQL_BEGIN)
     begin
       @transaction_in_progress = true
       result = yield
-      # ServerSide.info('COMMIT')
       async_exec(SQL_COMMIT)
       result
     rescue => e
-      # ServerSide.info('ROLLBACK')
       async_exec(SQL_ROLLBACK)
       raise e
     ensure
@@ -126,15 +119,8 @@ class String
     end
   end
 
-  TIME_REGEXP = /(\d{4})-(\d{2})-(\d{2})\s(\d{2}):(\d{2}):(\d{2})/
-  
   def postgres_to_time
     Time.parse(self)
-    # if self =~ TIME_REGEXP
-    #   Time.local($1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i)
-    # else
-    #   nil
-    # end
   end
 end
 
@@ -161,8 +147,8 @@ module Sequel
             @opts[:host] || 'localhost',
             @opts[:port] || 5432,
             '', '',
-            @opts[:database] || 'reality_development',
-            @opts[:user] || 'postgres',
+            @opts[:database],
+            @opts[:user],
             @opts[:password]
           )
         end
@@ -368,7 +354,6 @@ module Sequel
           result = @db.execute(sql)
           begin
             row = nil
-            # each_row(result, use_model_class) {|r| row = r}
             conv = row_converter(result, use_model_class)
             result.each {|r| row = conv.call(r)}
           ensure
@@ -393,60 +378,42 @@ module Sequel
         end
       end
       
-      def each_row(result, use_model_class)
-        fields = result.fields.map {|s| s.to_sym}
-        types = (0..(result.num_fields - 1)).map {|idx| PG_TYPES[result.type(idx)]}
-        m_klass = use_model_class && @model_class
-        result.each do |row|
-          hashed_row = {}
-          row.each_index do |cel_index|
-            column = row[cel_index]
-            if column && types[cel_index]
-              column = column.send(types[cel_index])
-            end
-            hashed_row[fields[cel_index]] = column
-          end
-          yield m_klass ? m_klass.new(hashed_row) : hashed_row
-        end
-      end
-    
-      COMMA = ','.freeze
-    
       @@converters_mutex = Mutex.new
       @@converters = {}
 
       def row_converter(result, use_model_class)
-        fields = result.fields.map {|s| s.to_sym}
-        types = (0..(result.num_fields - 1)).map {|idx| result.type(idx)}
-        klass = use_model_class ? @model_class : nil
+        fields = []; translators = []
+        result.fields.each_with_index do |f, idx|
+          fields << f.to_sym
+          translators << PG_TYPES[result.type(idx)]
+        end
+        klass = use_model_class && @model_class
         
         # create result signature and memoize the converter
-        sig = fields.join(COMMA) + types.join(COMMA) + klass.to_s
+        sig = [fields, translators, klass].hash
         @@converters_mutex.synchronize do
-          @@converters[sig] ||= compile_converter(fields, types, klass)
+          @@converters[sig] ||= compile_converter(fields, translators, klass)
         end
       end
     
-      CONVERT = "lambda {|r| {%s}}".freeze
-      CONVERT_MODEL_CLASS = "lambda {|r| %2$s.new(%1$s)}".freeze
-    
-      CONVERT_FIELD = '%s => r[%d]'.freeze
-      CONVERT_FIELD_TRANSLATE = '%s => ((t = r[%d]) ? t.%s : nil)'.freeze
-
-      def compile_converter(fields, types, klass)
+      def compile_converter(fields, translators, klass)
         used_fields = []
         kvs = []
         fields.each_with_index do |field, idx|
           next if used_fields.include?(field)
           used_fields << field
         
-          translate_fn = PG_TYPES[types[idx]]
-          kvs << (translate_fn ? CONVERT_FIELD_TRANSLATE : CONVERT_FIELD) %
-            [field.inspect, idx, translate_fn]
+          if translator = translators[idx]
+            kvs << ":#{field} => ((t = r[#{idx}]) ? t.#{translator} : nil)"
+          else
+            kvs << ":#{field} => r[#{idx}]"
+          end
+        end
+        if klass
+          eval("lambda {|r| #{klass}.new(#{kvs.join(COMMA_SEPARATOR)})}")
+        else
+          eval("lambda {|r| {#{kvs.join(COMMA_SEPARATOR)}}}")
         end
-        s = (klass ? CONVERT_MODEL_CLASS : CONVERT) %
-          [kvs.join(COMMA), klass]
-        eval(s)
       end
     end
   end

data/lib/sequel/sqlite.rb

@@ -40,10 +40,12 @@ module Sequel
       end
       
       def single_value(sql)
+        @logger.info(sql) if @logger
         @pool.hold {|conn| conn.get_first_value(sql)}
       end
       
       def result_set(sql, model_class, &block)
+        @logger.info(sql) if @logger
         @pool.hold do |conn|
           conn.query(sql) do |result|
             columns = result.columns

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: sequel
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
-date: 2007-04-28 00:00:00 +03:00
+  version: 0.1.2
+date: 2007-05-19 00:00:00 +03:00
 summary: Concise ORM for Ruby.
 require_paths: 
 - lib
@@ -33,7 +33,6 @@ files:
 - README
 - Rakefile
 - bin/sequel
-- doc/rdoc
 - lib/sequel
 - lib/sequel.rb
 - lib/sequel/connection_pool.rb