sequel 0.0.1 → 0.0.2

data/CHANGELOG

@@ -1,3 +1,16 @@
+*0.0.2*
+
+* Added Sequel.open as alias to Sequel.connect.
+
+* Refactored Dataset#where_equal_condition into Dataset#where_condition, allowing arrays and ranges, e.g. posts.filter(:stamp => (3.days.ago)..(1.day.ago)), or posts.filter(:category => ['ruby', 'postgres', 'linux']).
+
+* Added Model#[]= method for changing column values and Model#save 
+method for saving them.
+
+* Added Dataset#destroy for deleting each record individually as support for models. Renamed Model#delete to Model#destroy (and Model#destroy_all) ala ActiveRecord.
+
+* Refactored Dataset#first and Dataset#last code. These methods can now accept the number of records to fetch.
+
 *0.0.1*
 
 * More documentation for Dataset.
@@ -10,4 +23,4 @@
 
 * Added Database#<< method for executing arbitrary SQL.
 
-* Imported Sequel code.
+* Imported Sequel code.

data/README

@@ -2,14 +2,6 @@
 
 Sequel is an ORM framework for Ruby. Sequel provides thread safety, connection pooling, and a DSL for constructing queries and table schemas.
 
-== Sequel vs. ActiveRecord
-
-Sequel offers the following advantages over ActiveRecord:
-
-* Better performance with large tables: unlike ActiveRecord, Sequel does not load the entire resultset into memory, but fetches each record separately and implements an Enumerable interface.
-* Easy construction of queries using a DSL.
-* Using model classes is possible, but not mandatory.
-
 == Resources
 
 * {Project page}[http://code.google.com/p/ruby-sequel/]
@@ -24,6 +16,13 @@ To check out the source code:
 == Installation
 
   sudo gem install sequel
+  
+== Supported Databases
+
+Sequel currently supports:
+
+* Postgresql
+* SQLite 3
 
 == A Short Tutorial
 
@@ -31,19 +30,18 @@ To check out the source code:
 
 There are two ways to create a connection to a database. The easier way is to provide a connection URL:
 
-  DB = Sequel.connect("postgres://postgres:postgres@localhost:5432/my_db")
+  DB = Sequel.connect("sqlite:///blog.db")
 
 You can also specify optional parameters, such as the connection pool size:
 
-  DB = Sequel.connect("postgres://postgres:postgres@localhost:5432/my_db",
+  DB = Sequel.connect("postgres://postgres:postgres@localhost/my_db",
     :max_connections => 10)
 
 The second, more verbose, way is to create an instance of a database class:
 
-  DB = Sequel::Postgres::Database.new(:database => 'my_db', :host => 'localhost',
-    :port => 5432)
+  DB = Sequel::Postgres::Database.new(:database => 'my_db', :host => 'localhost')
 
-== Arbitrary SQL queries
+=== Arbitrary SQL queries
 
   DB.execute("create table t (a text, b text)")
   DB.execute("insert into t values ('a', 'b')")
@@ -55,9 +53,9 @@ Or more succintly:
 
 === Creating Datasets
 
-Dataset is the primary means through which records are retrieved and manipulated. You can create an blank dataset by using the query method:
+Dataset is the primary means through which records are retrieved and manipulated. You can create an blank dataset by using the dataset method:
 
-  dataset = DB.query
+  dataset = DB.dataset
 
 Or by using the from methods:
 
@@ -102,9 +100,13 @@ The simplest way to filter records is to provide a hash of values to match:
   
 You can also specify ranges:
 
-  my_posts = posts.filter(:stamp => 2.weeks.ago..1.week.ago)
+  my_posts = posts.filter(:stamp => (2.weeks.ago)..(1.week.ago))
+  
+Or lists of values:
+
+  my_posts = posts.filter(:category => ['ruby', 'postgres', 'linux'])
   
-Some adapters will also let you specify Regexps:
+Some adapters (like postgresql) will also let you specify Regexps:
 
   my_posts = posts.filter(:category => /ruby/i)
   
@@ -120,9 +122,13 @@ You can also specify a custom WHERE clause:
 
   posts.filter('(stamp < ?) AND (author <> ?)', 3.days.ago, author_name)
   
-=== Counting Records
+=== Summarizing Records
 
-  posts.count
+Counting records is easy:
+  posts.filter(:category => /ruby/i).count
+
+And you can also query maximum/minimum values:
+  max_value = DB[:history].max(:value)
   
 === Ordering Records
 
@@ -147,5 +153,3 @@ Or alternatively:
 === Updating Records
 
   posts.filter('stamp < ?', 3.days.ago).update(:state => 'archived')
-  
-=== 

data/Rakefile

@@ -6,7 +6,7 @@ require 'fileutils'
 include FileUtils
 
 NAME = "sequel"
-VERS = "0.0.1"
+VERS = "0.0.2"
 CLEAN.include ['**/.*.sw?', 'pkg/*', '.config', 'doc/*', 'coverage/*']
 RDOC_OPTS = ['--quiet', '--title', "Sequel Documentation",
   "--opname", "index.html",
@@ -40,12 +40,13 @@ spec = Gem::Specification.new do |s|
   s.description = s.summary
   s.author = "Sharon Rosner"
   s.email = 'ciconia@gmail.com'
-  s.homepage = 'http://code.google.com/p/ruby-sequel/'
+  s.homepage = 'http://sequel.rubyforge.org'
 
   s.add_dependency('metaid')
   s.required_ruby_version = '>= 1.8.2'
 
-  s.files = %w(COPYING README Rakefile) + Dir.glob("{doc,spec,lib}/**/*")
+#  s.files = %w(COPYING README Rakefile) + Dir.glob("{doc,spec,lib}/**/*")
+  s.files = %w(COPYING README Rakefile) + Dir.glob("{doc,lib}/**/*")
       
   s.require_path = "lib"
 end

data/lib/sequel.rb

@@ -7,7 +7,11 @@ require File.join(dir, 'dataset')
 require File.join(dir, 'model')
 
 module Sequel #:nodoc:
-  def self.connect(url)
-    Database.connect(url)
+  class << self
+    def connect(url)
+      Database.connect(url)
+    end
+    
+    alias_method :open, :connect
   end
 end

data/lib/sequel/database.rb

@@ -1,6 +1,7 @@
 require 'uri'
 
 require File.join(File.dirname(__FILE__), 'schema')
+require File.join(File.dirname(__FILE__), 'dataset')
 
 module Sequel
   # A Database object represents a virtual connection to a database.
@@ -14,6 +15,11 @@ module Sequel
     def initialize(opts = {})
       @opts = opts
     end
+    
+    # Returns a blank dataset
+    def dataset
+      Dataset.new(self)
+    end
 
     # Returns a new dataset with the from method invoked.
     def from(*args); dataset.from(*args); end
@@ -27,6 +33,10 @@ module Sequel
       dataset.from(table)
     end
     
+    def execute(sql)
+      raise RuntimeError
+    end
+    
     # call-seq:
     #   db.execute(sql)
     #   db << sql

data/lib/sequel/dataset.rb

@@ -22,7 +22,7 @@ module Sequel
   class Dataset
     include Enumerable
     
-    attr_reader :db
+    attr_reader :db, :opts
     attr_accessor :record_class
   
     # Constructs a new instance of a dataset with a database instance, initial
@@ -94,28 +94,40 @@ module Sequel
       end 
     end
     
+    NULL = "NULL".freeze
+    
     # Returns a literal representation of a value to be used as part
     # of an SQL expression. This method is overriden in descendants.
     def literal(v)
       case v
       when String: "'%s'" % v
+      when Array: v.empty? ? NULL : v.join(COMMA_SEPARATOR)
       else v.to_s
       end
     end
     
     AND_SEPARATOR = " AND ".freeze
     EQUAL_COND = "(%s = %s)".freeze
+    IN_EXPR = "(%s IN (%s))".freeze
+    BETWEEN_EXPR = "(%s BETWEEN %s AND %s)".freeze
     
     # Formats an equality condition SQL expression.
-    def where_equal_condition(left, right)
-      EQUAL_COND % [field_name(left), literal(right)]
+    def where_condition(left, right)
+      case right
+      when Range:
+        BETWEEN_EXPR % [field_name(left), literal(right.begin), literal(right.end)]
+      when Array:
+        IN_EXPR % [field_name(left), literal(right)]
+      else
+        EQUAL_COND % [field_name(left), literal(right)]
+      end
     end
     
     # Formats a where clause.
     def where_list(where)
       case where
       when Hash:
-        where.map {|kv| where_equal_condition(kv[0], kv[1])}.join(AND_SEPARATOR)
+        where.map {|kv| where_condition(*kv)}.join(AND_SEPARATOR)
       when Array:
         fmt = where.shift
         fmt.gsub('?') {|i| literal(where.shift)}
@@ -322,6 +334,42 @@ module Sequel
     def max(field)
       select(field.MAX).first[:max]
     end
+    
+    LIMIT_1 = {:limit => 1}.freeze
+    
+    def limit(l)
+      dup_merge(:limit => l)
+    end
+
+    def first(num = 1)
+      if num == 1
+        first_record
+      else
+        limit(num).all
+      end
+    end
+  
+    def last(num = 1)
+      raise RuntimeError, 'No order specified' unless
+        @opts[:order] || (opts && opts[:order])
+      
+      l = {:limit => num}
+      opts = {:order => reverse_order(@opts[:order])}.
+        merge(opts ? opts.merge(l) : l)
+
+      if num == 1
+        first_record(opts)
+      else
+        dup_merge(opts).all
+      end
+    end
+    
+    def destroy
+      raise RuntimeError, 'Dataset not associated with model' unless
+        @record_class
+      
+      @db.transaction {each {|r| r.destroy}}
+    end
   end
 end
 

data/lib/sequel/model.rb

@@ -42,7 +42,7 @@ module Sequel
         rec
       end
       
-      alias_method :delete, :delete_and_invalidate_cache
+      alias_method :destroy, :destroy_and_invalidate_cache
       alias_method :set, :set_and_update_cache
     end
     
@@ -119,8 +119,8 @@ module Sequel
       self.class.get_hooks(key).each {|h| instance_eval(&h)}
     end
 
-    def self.before_delete(&block)
-      get_hooks(:before_delete).unshift(block)
+    def self.before_destroy(&block)
+      get_hooks(:before_destroy).unshift(block)
     end
     
     def self.after_create(&block)
@@ -168,13 +168,10 @@ module Sequel
     def self.hash_column(column); dataset.hash_column(primary_key, column); end
     def self.join(*args); dataset.join(*args); end
     def self.lock(mode, &block); dataset.lock(mode, &block); end
-    def self.delete_all
-      if has_hooks?(:before_delete)
-        db.transaction {dataset.all.each {|r| r.delete}}
-      else
-        dataset.delete
-      end
+    def self.destroy_all
+      has_hooks?(:before_destroy) ? dataset.destroy : dataset.delete
     end
+    def self.delete_all; dataset.delete; end
     
     def self.[](key)
       find key.is_a?(Hash) ? key : {primary_key => key}
@@ -188,13 +185,17 @@ module Sequel
       end
     end
     
-    def delete
+    def destroy
       db.transaction do
-        run_hooks(:before_delete)
-        model.dataset.filter(primary_key => @pkey).delete
+        run_hooks(:before_destroy)
+        delete
       end
     end
     
+    def delete
+      model.dataset.filter(primary_key => @pkey).delete
+    end
+    
     FIND_BY_REGEXP = /^find_by_(.*)/.freeze
     FILTER_BY_REGEXP = /^filter_by_(.*)/.freeze
     
@@ -227,6 +228,12 @@ module Sequel
       model.dataset.filter(primary_key => @pkey).update(values)
       @values.merge!(values)
     end
+
+    def []=(field, value); @values[field] = value; end
+    
+    def save
+      model.dataset.filter(primary_key => @pkey).update(@values)
+    end
   end
   
   def self.Model(table_name)

data/lib/sequel/postgres.rb

@@ -162,9 +162,9 @@ module Sequel
   
       def literal(v)
         case v
+        when Array: super
         when Time: v.to_sql_timestamp
         when Symbol: PGconn.quote(v.to_s)
-        when Array: v.empty? ? EMPTY_ARRAY : v.join(COMMA_SEPARATOR)
         else
           PGconn.quote(v)
         end
@@ -173,16 +173,11 @@ module Sequel
       LIKE = '%s ~ %s'.freeze
       LIKE_CI = '%s ~* %s'.freeze
     
-      IN_ARRAY = '%s IN (%s)'.freeze
-      EMPTY_ARRAY = 'NULL'.freeze
-    
-      def where_equal_condition(left, right)
+      def where_condition(left, right)
         case right
         when Regexp:
           (right.casefold? ? LIKE_CI : LIKE) %
             [field_name(left), PGconn.quote(right.source)]
-        when Array:
-          IN_ARRAY % [field_name(left), literal(right)]
         else
           super
         end
@@ -192,21 +187,8 @@ module Sequel
         query_each(select_sql(opts), true, &block)
         self
       end
-    
-      LIMIT_1 = {:limit => 1}.freeze
-    
-      def first(opts = nil)
-        opts = opts ? opts.merge(LIMIT_1) : LIMIT_1
-        query_first(select_sql(opts), true)
-      end
-    
-      def last(opts = nil)
-        raise RuntimeError, 'No order specified' unless
-          @opts[:order] || (opts && opts[:order])
-      
-        opts = {:order => reverse_order(@opts[:order])}.
-          merge(opts ? opts.merge(LIMIT_1) : LIMIT_1)
       
+      def first_record(opts = nil)
         query_first(select_sql(opts), true)
       end
     

data/lib/sequel/schema.rb

@@ -11,6 +11,7 @@ module Sequel
     PRIMARY_KEY = ' PRIMARY KEY'.freeze
     REFERENCES = ' REFERENCES %s'.freeze
     ON_DELETE = ' ON DELETE %s'.freeze
+    AUTOINCREMENT = ' AUTOINCREMENT'.freeze
     
     RESTRICT = 'RESTRICT'.freeze
     CASCADE = 'CASCADE'.freeze
@@ -40,6 +41,7 @@ module Sequel
       c << REFERENCES % column[:table] if column[:table]
       c << ON_DELETE % on_delete_action(column[:on_delete]) if 
         column[:on_delete]
+      c << AUTOINCREMENT if column[:auto_increment]
       c
     end
   

data/lib/sequel/sqlite.rb

@@ -70,20 +70,10 @@ module Sequel
     
       LIMIT_1 = {:limit => 1}.freeze
     
-      def first(opts = nil)
-        opts = opts ? opts.merge(LIMIT_1) : LIMIT_1
+      def first_record(opts = nil)
         @db.result_set(select_sql(opts), @record_class) {|r| return r}
       end
     
-      def last(opts = nil)
-        raise RuntimeError, 'No order specified' unless
-          @opts[:order] || (opts && opts[:order])
-      
-        opts = {:order => reverse_order(@opts[:order])}.
-          merge(opts ? opts.merge(LIMIT_1) : LIMIT_1)
-        @db.result_set(select_sql(opts), @record_class) {|r| return r}
-      end
-      
       def count(opts = nil)
         @db.single_value(count_sql(opts)).to_i
       end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.2
+rubygems_version: 0.9.0
 specification_version: 1
 name: sequel
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
-date: 2007-03-05 00:00:00 +02:00
+  version: 0.0.2
+date: 2007-03-18 00:00:00 +02:00
 summary: ORM framework for Ruby.
 require_paths: 
 - lib
 email: ciconia@gmail.com
-homepage: http://code.google.com/p/ruby-sequel/
+homepage: http://sequel.rubyforge.org
 rubyforge_project: 
 description: ORM framework for Ruby.
 autorequire: 
@@ -33,19 +33,16 @@ files:
 - README
 - Rakefile
 - doc/rdoc
-- spec/database_spec.rb
-- spec/dataset_spec.rb
-- spec/postgres_spec.rb
 - lib/sequel
 - lib/sequel.rb
+- lib/sequel/connection_pool.rb
+- lib/sequel/core_ext.rb
+- lib/sequel/database.rb
 - lib/sequel/dataset.rb
 - lib/sequel/model.rb
 - lib/sequel/postgres.rb
 - lib/sequel/schema.rb
 - lib/sequel/sqlite.rb
-- lib/sequel/connection_pool.rb
-- lib/sequel/database.rb
-- lib/sequel/core_ext.rb
 - CHANGELOG
 test_files: []
 

data/spec/database_spec.rb

@@ -1,18 +0,0 @@
-require File.join(File.dirname(__FILE__), '../lib/sequel')
-
-
-class Sequel::Database
-  attr_accessor :opts
-end
-
-context "A new Database" do
-  specify "should accept options and store them in @opts" do
-    opts = :my_options
-    Sequel::Database.new(opts).opts.should_be opts
-  end
-  
-  specify "should set opts to empty hash if not specified" do
-    Sequel::Database.new.opts.should == {}
-  end
-end
-

data/spec/dataset_spec.rb

@@ -1,124 +0,0 @@
-require File.join(File.dirname(__FILE__), '../lib/sequel')
-
-class sequel::Dataset
-  attr_accessor :db, :opts
-end
-
-context "The Dataset Class" do
-  specify "should include the Enumerable mix-in" do
-    Sequel::Dataset.included_modules.should_include Enumerable
-  end
-end
-
-context "A new Dataset instance" do
-  specify "should store db and opts in @db and @opts" do
-    db = "my db"
-    opts = [1, 2, 3, 4]
-    
-    d = Sequel::Dataset.new(db, opts)
-    d.db.should_be db
-    d.opts.should_be opts
-  end
-  
-  specify "should set opts to empty hash if ommited" do
-    Sequel::Dataset.new(:db).opts.should == {}
-  end
-end
-
-context "Dataset#dup_merge" do
-  specify "should create a new instance of the same class with merged opts" do
-    subclass = Class.new(Sequel::Dataset)
-    db = "my db"
-    orig = subclass.new(db, {1 => 2, 3 => 4})
-    dup = orig.dup_merge({3 => 5})
-    
-    dup.class.should_be subclass
-    dup.opts.should == {1 => 2, 3 => 5}
-    dup.db.should_be db
-  end
-end
-
-context "Dataset#field_name" do
-  setup {@d = Sequel::Dataset.new(:db)}
-
-  specify "should return the argument as is if not a symbol" do
-    @d.field_name(nil).should == nil
-    @d.field_name(1).should == 1
-    @d.field_name('field').should == 'field'
-  end
-  
-  specify "should parse fields with underscore without change" do
-    @d.field_name(:node_id).should == 'node_id'
-  end
-  
-  specify "should parse double-underscore as dot-notation" do
-    @d.field_name(:posts__id).should == 'posts.id'
-  end
-  
-  specify "should parse triple-underscore as AS notation" do
-    @d.field_name(:posts__id___pid).should == 'posts.id AS pid'
-  end
-end
-
-context "Dataset#field_list" do
-  setup {@d = Sequel::Dataset.new(:db)}
-
-  specify "should return the sql wildcard if an empty array is specified" do
-    @d.field_list([]).should == '*'
-  end
-  
-  specify "should return comma-separated field list if an array is passed" do
-    @d.field_list([:a, :b]).should == 'a, b'
-  end
-  
-  specify "should return the argument as is if not an array" do
-    @d.field_list(nil).should_be_nil
-    @d.field_list(23).should_be 23
-    @d.field_list("wowie zowie").should == "wowie zowie"
-  end
-  
-  specify "should parse field names using #field_name" do
-    @d.field_list([:posts__author_id, :authors__name]).should ==
-      'posts.author_id, authors.name'
-    
-    @d.field_list([:posts__id___pid, :authors__name___aname]).should ==
-      'posts.id AS pid, authors.name AS aname'
-  end
-end
-
-context "Dataset#source_list" do
-  setup {@d = Sequel::Dataset.new(:db)}
-
-  specify "should return the argument if not an array or hash" do
-    @d.source_list(nil).should_be_nil
-    @d.source_list(1).should == 1
-    @d.source_list('hello').should == 'hello'
-    @d.source_list(:symbol).should == :symbol
-  end
-  
-  specify "should return comma-separated value if an array is specified" do
-    @d.source_list([1, 2, 3]).should == '1, 2, 3'
-  end
-end
-
-context "Dataset DSL: " do
-  specify "#form should create a duplicate dataset with the source argument merged" do
-    subclass = Class.new(Sequel::Dataset)
-    d1 = subclass.new(:db, {:select => '*'})
-    
-    d2 = d1.from(:posts)
-    d2.class.should_be subclass
-    d2.opts[:select].should == '*'
-    d2.opts[:from].should == :posts
-  end 
-
-  specify "#select should create a duplicate dataset with the select argument merged" do
-    subclass = Class.new(Sequel::Dataset)
-    d1 = subclass.new(:db, {:from => :posts})
-    
-    d2 = d1.select(:id, :name)
-    d2.class.should_be subclass
-    d2.opts[:from].should == :posts
-    d2.opts[:select].should == [:id, :name]
-  end 
-end

data/spec/postgres_spec.rb

@@ -1,6 +0,0 @@
-require File.join(File.dirname(__FILE__), '../lib/sequel')
-require File.join(File.dirname(__FILE__), '../lib/sequel/postgres')
-
-context "A new Postgres::Database" do
-end
-