sequel 0.1.9.9 → 0.1.9.10

data/CHANGELOG

@@ -1,3 +1,21 @@
+=== 0.19.10 (2007-08-22)
+
+* Changed schema generation code to generate separate statements for CREATE TABLE and each CREATE INDEX (#34).
+
+* Refactored Dataset::SQL#field_name for better support of different quoting schemes by specific adapters.
+
+* Added #current_page_record_count for paginated datasets.
+
+* Removed Database#literal and included Dataset::SQL instead.
+
+* Sequel::Dataset:SQL#field_name can now take a hash (as well as #select and any method that uses #field_name) for aliasing column names.  E.g. Dataset.new(nil).from(:test).select(:_qqa => 'Date').sql #=> 'SELECT _qqa AS 'Date' FROM test'.
+
+* Moved SingleThreadedPool to lib/sequel/connection_pool.rb.
+
+* Changed SQLite::Dataset to return affected rows for #delete and #update (#33).
+
+* ADO adapter: Added use of Enumerable for Recordset#Fields, playing it safe and moving to the first row before getting results, and changing the auto_increment constant to work for MSSQL.
+
 === 0.1.9.9 (2007-08-18)
 
 * New ADO adapter by cdcarter (#31).

data/Rakefile

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

data/lib/sequel.rb

@@ -1,8 +1,8 @@
 require 'metaid'
 
 files = %w[
-  core_ext error schema database connection_pool pretty_table expressions 
-  dataset migration model
+  core_ext error connection_pool pretty_table expressions 
+  dataset migration model schema database 
 ]
 dir = File.join(File.dirname(__FILE__), 'sequel')
 files.each {|f| require(File.join(dir, f))}

data/lib/sequel/ado.rb

@@ -9,6 +9,12 @@ module Sequel
     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')
@@ -41,11 +47,11 @@ module Sequel
         @db.synchronize do
           s = @db.execute sql
           
-          num_cols = s.Fields.Count
-          @columns = Array.new(num_cols)
-          0.upto(num_cols-1) {|x| @columns[x] = s.Fields(x).Name.to_sym}
+          fields = s.Fields.extend(Enumerable)
+          @columns = fields.map {|x| x.Name.to_sym}
           
-          s.getRows.transpose.each {|r| yield hash_row(r) }
+          s.moveFirst
+          s.getRows.transpose.each {|r| yield hash_row(r)}
         end
         self
       end

data/lib/sequel/connection_pool.rb

@@ -105,5 +105,27 @@ module Sequel
           @allocated.delete(thread)
         end
       end
+  end
+
+  # A SingleThreadedPool acts as a replacement for a ConnectionPool for use
+  # in single-threaded applications. ConnectionPool imposes a substantial
+  # performance penalty, so SingleThreadedPool is used to gain some speed.
+  class SingleThreadedPool
+    attr_writer :connection_proc
+    
+    # Initializes the instance with the supplied block as the connection_proc.
+    def initialize(&block)
+      @connection_proc = block
+    end
+    
+    # Yields the connection to the supplied block. This method simulates the
+    # ConnectionPool#hold API.
+    def hold
+      @conn ||= @connection_proc.call
+      yield @conn
+    rescue Exception => e
+      # if the error is not a StandardError it is converted into RuntimeError.
+      raise e.is_a?(StandardError) ? e : e.message
     end
+  end
 end

data/lib/sequel/core_ext.rb

@@ -1,5 +1,7 @@
 # Enumerable extensions.
 module Enumerable
+  # Invokes the specified method for each item, along with the supplied
+  # arguments.
   def send_each(sym, *args)
     each {|i| i.send(sym, *args)}
   end
@@ -16,6 +18,9 @@ class Array
 end
 
 module Sequel
+  # ExpressionString is used to represent literal SQL expressions. An 
+  # ExpressionString is copied verbatim into an SQL statement. Instances of
+  # ExpressionString can be created by calling String#expr.
   class ExpressionString < ::String
   end
 end
@@ -33,50 +38,72 @@ class String
   def split_sql
     to_sql.split(';').map {|s| s.strip}
   end
-  
-  # Convert a string into an Expression String
+
+  # Converts a string into an ExpressionString, in order to override string
+  # literalization, e.g.:
+  #
+  #   DB[:items].filter(:abc => 'def').sql #=>
+  #     "SELECT * FROM items WHERE (abc = 'def')"
+  #
+  #   DB[:items].filter(:abc => 'def'.expr).sql #=>
+  #     "SELECT * FROM items WHERE (abc = def)"
+  #
   def expr
     Sequel::ExpressionString.new(self)
   end
   
-  # Convert a string into a Time object
+  # Converts a string into a Time object.
   def to_time
     Time.parse(self)
   end
   
+  # Converts a string into a field name.
   def to_field_name
     self
   end
 end
 
+# Methods to format field names and associated constructs. This module is
+# included in String and Symbol.
 module FieldCompositionMethods
+  # Constructs a DESC clause for use in an ORDER BY clause.
   def DESC
     "#{to_field_name} DESC"
   end
   
+  # Constructs an AS clause for field aliasing.
   def AS(target)
     "#{to_field_name} AS #{target}"
   end
 
+  # Constructs a qualified wildcard (*) clause.
   def ALL
     "#{to_s}.*"
   end
   
-  FIELD_TITLE_RE1 = /^(.*)\sAS\s(.+)$/.freeze
+  FIELD_TITLE_RE1 = /^(.*)\sAS\s(.+)$/i.freeze
   FIELD_TITLE_RE2 = /^([^\.]+)\.([^\.]+)$/.freeze
   
+  # Returns the field name. If the field name is aliased, the alias is 
+  # returned.
   def field_title
-    s = to_field_name
-    case s
+    case s = to_field_name
     when FIELD_TITLE_RE1, FIELD_TITLE_RE2: $2
     else
       s
     end
   end
 
+  # Formats a min(x) expression.
   def MIN; "min(#{to_field_name})"; end
+
+  # Formats a max(x) expression.
   def MAX; "max(#{to_field_name})"; end
+
+  # Formats a sum(x) expression.
   def SUM; "sum(#{to_field_name})"; end
+
+  # Formats an avg(x) expression.
   def AVG; "avg(#{to_field_name})"; end
 end
 
@@ -92,6 +119,16 @@ class Symbol
   FIELD_REF_RE1 = /^([a-z_]+)__([a-z_]+)___([a-z_]+)/.freeze
   FIELD_REF_RE2 = /^([a-z_]+)___([a-z_]+)$/.freeze
   FIELD_REF_RE3 = /^([a-z_]+)__([a-z_]+)$/.freeze
+  
+  # Converts a symbol into a field name. This method supports underscore
+  # notation in order to express qualified (two underscores) and aliased 
+  # (three underscores) fields:
+  #
+  #   :abc.to_field_name #=> "abc"
+  #   :abc___a.to_field_name #=> "abc AS a"
+  #   :items__abc.to_field_name #=> "items.abc"
+  #   :items__abc___a.to_field_name #=> "items.abc AS a"
+  #
   def to_field_name
     s = to_s
     case s

data/lib/sequel/database.rb

@@ -1,25 +1,6 @@
 require 'uri'
 
 module Sequel
-  # A SingleThreadedPool acts as a replacement for a ConnectionPool for use
-  # in single-threaded applications. ConnectionPool imposes a substantial
-  # performance penalty, so SingleThreadedPool is used to gain some speed.
-  class SingleThreadedPool
-    attr_writer :connection_proc
-    
-    def initialize(&block)
-      @connection_proc = block
-    end
-    
-    def hold
-      @conn ||= @connection_proc.call
-      yield @conn
-    rescue Exception => e
-      # if the error is not a StandardError it is converted into RuntimeError.
-      raise e.is_a?(StandardError) ? e : e.message
-    end
-  end
-  
   # A Database object represents a virtual connection to a database.
   # The Database class is meant to be subclassed by database adapters in order
   # to provide the functionality needed for executing queries.
@@ -110,33 +91,9 @@ module Sequel
       true
     end
     
+    include Dataset::SQL
     include Schema::SQL
     
-    NULL = "NULL".freeze
-    TIMESTAMP_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S'".freeze
-    DATE_FORMAT = "DATE '%Y-%m-%d'".freeze
-    TRUE = "'t'".freeze
-    FALSE = "'f'".freeze
-
-    # default literal implementation for use in schema definitions
-    def literal(v)
-      case v
-      when ExpressionString: v
-      when String: "'#{v.gsub(/'/, "''")}'"
-      when Integer, Float: v.to_s
-      when NilClass: NULL
-      when TrueClass: TRUE
-      when FalseClass: FALSE
-      when Symbol: v.to_field_name
-      when Array: v.empty? ? NULL : v.map {|i| literal(i)}.join(COMMA_SEPARATOR)
-      when Time: v.strftime(TIMESTAMP_FORMAT)
-      when Date: v.strftime(DATE_FORMAT)
-      when Dataset: "(#{v.sql})"
-      else
-        raise SequelError, "can't express #{v.inspect} as a SQL literal"
-      end
-    end
-    
     # default serial primary key definition. this should be overriden for each adapter.
     def serial_primary_key_options
       {:primary_key => true, :type => :integer, :auto_increment => true}
@@ -152,7 +109,7 @@ module Sequel
     #   end
     def create_table(name, &block)
       g = Schema::Generator.new(self, name, &block)
-      execute(create_table_sql(*g.create_info))
+      create_table_sql_list(*g.create_info).each {|sta| execute(sta)}
     end
     
     # Drops a table.

data/lib/sequel/dataset/dataset_convenience.rb

@@ -129,6 +129,16 @@ module Sequel
         a..b
       end
 
+      # Returns the number of records in the current page
+      def current_page_record_count
+        return 0 if @current_page > @page_count
+        
+        a = 1 + (@current_page - 1) * @page_size
+        b = a + @page_size - 1
+        b = @pagination_record_count if b > @pagination_record_count
+        b - a + 1
+      end
+
       # Returns the minimum value for the given field.
       def min(field)
         single_value(:select => [field.MIN.AS(:v)])

data/lib/sequel/dataset/dataset_sql.rb

@@ -7,9 +7,23 @@ module Sequel
       # symbols can include double underscores to denote a dot separator, e.g.
       # :posts__id will be converted into posts.id.
       def field_name(field)
-        field.is_a?(Symbol) ? field.to_field_name : field
+        case field
+        when Symbol, String:
+          quoted_field_name(field.to_field_name)
+        when Hash:
+          field.map {|f,a| "#{field_name(f)} AS #{field_name(a)}"}.join(COMMA_SEPARATOR)
+        else
+          field
+        end
       end
 
+      # Adds quoting to field references. This method is just a stub and can
+      # be overriden in adapters in order to provide correct field quoting
+      # behavior.
+      def quoted_field_name(name)
+        name
+      end
+      
       ALIASED_REGEXP = /^(.*)\s(.*)$/.freeze
       QUALIFIED_REGEXP = /^(.*)\.(.*)$/.freeze
 
@@ -203,7 +217,7 @@ module Sequel
       # Returns a copy of the dataset with the order reversed. If no order is
       # given, the existing order is inverted.
       def reverse_order(*order)
-        order(invert_order(order.empty? ? @opts[:order] : order))
+        order(*invert_order(order.empty? ? @opts[:order] : order))
       end
 
       DESC_ORDER_REGEXP = /(.*)\sDESC/.freeze
@@ -420,7 +434,7 @@ module Sequel
         sql = opts[:distinct] ? \
           "SELECT DISTINCT #{select_fields} FROM #{select_source}" : \
           "SELECT #{select_fields} FROM #{select_source}"
-
+        
         if join = opts[:join]
           sql << join
         end

data/lib/sequel/mysql.rb

@@ -137,27 +137,25 @@ module Sequel
     end
     
     class Dataset < Sequel::Dataset
-      FIELD_EXPR_RE = /^([^\(]+\()?([^\.]+\.)?([^\s\)]+)(\))?(\s[Aa][Ss]\s(.+))?$/.freeze
-      FIELD_ORDER_RE = /^(.*) (DESC|ASC)$/.freeze
-      FIELD_NOT_QUOTABLE_RE = /^(`(.+)`)|\*$/.freeze
-
-      def quote_field(field)
-        field =~ FIELD_NOT_QUOTABLE_RE ? field : "`#{field}`"
+      UNQUOTABLE_FIELD_RE = /^(`(.+)`)|\*$/.freeze
+      def quote_field(f)
+        f =~ UNQUOTABLE_FIELD_RE ? f : "`#{f}`"
       end
       
-      def field_name(field)
-        f = field.is_a?(Symbol) ? field.to_field_name : field
-        case f
+      FIELD_EXPR_RE = /^([^\(]+\()?([^\.]+\.)?([^\s\)]+)(\))?(\sAS\s(.+))?$/i.freeze
+      FIELD_ORDER_RE = /^(.*) (DESC|ASC)$/i.freeze
+      def quoted_field_name(name)
+        case name
         when FIELD_EXPR_RE:
           $6 ? \
             "#{$1}#{$2}#{quote_field($3)}#{$4} AS #{quote_field($6)}" : \
             "#{$1}#{$2}#{quote_field($3)}#{$4}"
         when FIELD_ORDER_RE: "#{quote_field($1)} #{$2}"
         else
-          quote_field(f)
+          quote_field(name)
         end
       end
-
+      
       def literal(v)
         case v
         when true: '1'

data/lib/sequel/schema/schema_sql.rb

@@ -66,16 +66,18 @@ module Sequel
         end
       end
     
-      def index_list_sql(table_name, indexes)
-        indexes.map {|i| index_definition_sql(table_name, i)}.join
+      def index_list_sql_list(table_name, indexes)
+        indexes.map {|i| index_definition_sql(table_name, i)}
       end
   
-      def create_table_sql(name, columns, indexes = nil)
-        sql = "CREATE TABLE #{name} (#{column_list_sql(columns)});"
-        sql << index_list_sql(name, indexes) if indexes && !indexes.empty?
+      def create_table_sql_list(name, columns, indexes = nil)
+        sql = ["CREATE TABLE #{name} (#{column_list_sql(columns)});"]
+        if indexes && !indexes.empty?
+          sql.concat(index_list_sql_list(name, indexes))
+        end
         sql
       end
-    
+      
       def drop_table_sql(name)
         "DROP TABLE #{name};"
       end

data/lib/sequel/sqlite.rb

@@ -34,7 +34,7 @@ module Sequel
     
       def execute(sql)
         @logger.info(sql) if @logger
-        @pool.hold {|conn| conn.execute_batch(sql)}
+        @pool.hold {|conn| conn.execute_batch(sql); conn.changes}
       end
       
       def execute_insert(sql)
@@ -122,12 +122,19 @@ module Sequel
     
       def update(values, opts = nil)
         @db.execute update_sql(values, opts)
-        self
       end
     
       def delete(opts = nil)
-        @db.execute delete_sql(opts)
-        self
+        # 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

data/spec/adapters/mysql_spec.rb

@@ -7,6 +7,8 @@ end
 MYSQL_DB.create_table :items do
   text :name
   integer :value
+  
+  index :value
 end
 
 context "A MySQL dataset" do
@@ -94,7 +96,7 @@ context "A MySQL dataset" do
       'SELECT max(items.`name`) AS `max_name` FROM items'
 
     @d.insert_sql(:value => 333).should == \
-      'INSERT INTO items (`value`) VALUES (333)'
+      'INSERT INTO items (`value`) VALUES (333);'
   end
   
   specify "should support ORDER clause in UPDATE statements" do

data/spec/adapters/sqlite_spec.rb

@@ -115,7 +115,7 @@ context "An SQLite dataset" do
   end
 end
 
-context "An SQLITE dataset" do
+context "An SQLite dataset" do
   setup do
     @d = SQLITE_DB[:items]
     @d.delete # remove all records
@@ -139,4 +139,50 @@ context "An SQLITE dataset" do
   specify "should correctly return min" do
     @d.min(:value).should == 1.23.to_s
   end
-end
+end
+
+context "SQLite::Dataset#delete" do
+  setup do
+    @d = SQLITE_DB[:items]
+    @d.delete # remove all records
+    @d << {:name => 'abc', :value => 1.23}
+    @d << {:name => 'def', :value => 4.56}
+    @d << {:name => 'ghi', :value => 7.89}
+  end
+  
+  specify "should return the number of records affected when filtered" do
+    @d.count.should == 3
+    @d.filter {value < 3}.delete.should == 1
+    @d.count.should == 2
+
+    @d.filter {value < 3}.delete.should == 0
+    @d.count.should == 2
+  end
+  
+  specify "should return the number of records affected when unfiltered" do
+    @d.count.should == 3
+    @d.delete.should == 3
+    @d.count.should == 0
+
+    @d.delete.should == 0
+  end
+end
+
+context "SQLite::Dataset#update" do
+  setup do
+    @d = SQLITE_DB[:items]
+    @d.delete # remove all records
+    @d << {:name => 'abc', :value => 1.23}
+    @d << {:name => 'def', :value => 4.56}
+    @d << {:name => 'ghi', :value => 7.89}
+  end
+  
+  specify "should return the number of records affected" do
+    @d.filter(:name => 'abc').update(:value => 2).should == 1
+    
+    @d.update(:value => 10).should == 3
+    
+    @d.filter(:name => 'xxx').update(:value => 23).should == 0
+  end
+end
+

data/spec/core_ext_spec.rb

@@ -115,6 +115,25 @@ context "Symbol#to_field_name" do
   end
 end
 
+context "FieldCompositionMethods#field_title" do
+  specify "should return the field name for non aliased fields" do
+    :xyz.field_title.should == 'xyz'
+    :abc__xyz.field_title.should == 'xyz'
+    
+    'abc'.field_title.should == 'abc'
+    'abc.def'.field_title.should == 'def'
+  end
+  
+  specify "should return the field alias for aliased fields" do
+    :xyz___x.field_title.should == 'x'
+    :abc__xyz___y.field_title.should == 'y'
+    
+    'abc AS x'.field_title.should == 'x'
+    'abc as y'.field_title.should == 'y'
+    'abc.def AS d'.field_title.should == 'd'
+  end
+end
+
 context "Symbol" do
   specify "should support MIN for specifying min function" do
     :abc__def.MIN.should == 'min(abc.def)'

data/spec/database_spec.rb

@@ -181,7 +181,12 @@ end
 
 class DummyDatabase < Sequel::Database
   attr_reader :sql
-  def execute(sql); @sql = sql; end
+  
+  def execute(sql)
+    @sql ||= ""
+    @sql << sql
+  end
+  
   def transaction; yield; end
 
   def dataset

data/spec/dataset_spec.rb

@@ -551,6 +551,11 @@ context "Dataset#select" do
   specify "should use the wildcard if no arguments are given" do
     @d.select.sql.should == 'SELECT * FROM test'
   end
+  
+  specify "should accept a hash for AS values" do
+    @d.select(:name => 'n', :__ggh => 'age').sql.should =~
+      /SELECT ((name AS n, __ggh AS age)|(__ggh AS age, name AS n)) FROM test/
+  end
 
   specify "should overrun the previous select option" do
     @d.select(:a, :b, :c).select.sql.should == 'SELECT * FROM test'
@@ -1199,6 +1204,10 @@ context "Dataset#set_model" do
     all[3].class.should == @m1
     #...
   end
+  
+  specify "should raise an error if more than two arguments are supplied" do
+    proc {@dataset.set_model(1, 2, 3)}.should raise_error(SequelError)
+  end
 end
 
 context "Dataset#model_classes" do
@@ -1420,6 +1429,13 @@ context "A paginated dataset" do
     @d.paginate(4, 50).current_page_record_range.should == (151..153)
     @d.paginate(5, 50).current_page_record_range.should == (0..0)
   end
+
+  specify "should return the record count for the current page" do
+    @paginated.current_page_record_count.should == 20
+    @d.paginate(3, 50).current_page_record_count.should == 50
+    @d.paginate(4, 50).current_page_record_count.should == 3
+    @d.paginate(5, 50).current_page_record_count.should == 0
+  end
 end
 
 context "Dataset#columns" do

data/spec/schema_spec.rb

@@ -136,7 +136,7 @@ context "DB#create_table" do
       integer :id
       index :id
     end
-    @db.sqls.should == ["CREATE TABLE cats (id integer);CREATE INDEX cats_id_index ON cats (id);"]
+    @db.sqls.should == ["CREATE TABLE cats (id integer);", "CREATE INDEX cats_id_index ON cats (id);"]
   end
 
   specify "should accept multiple index definitions" do
@@ -145,7 +145,7 @@ context "DB#create_table" do
       index :id
       index :name
     end
-    @db.sqls.should == ["CREATE TABLE cats (id integer);CREATE INDEX cats_id_index ON cats (id);CREATE INDEX cats_name_index ON cats (name);"]
+    @db.sqls.should == ["CREATE TABLE cats (id integer);", "CREATE INDEX cats_id_index ON cats (id);", "CREATE INDEX cats_name_index ON cats (name);"]
   end
   
   specify "should accept custom index names" do
@@ -153,7 +153,7 @@ context "DB#create_table" do
       integer :id
       index :id, :name => 'abc'
     end
-    @db.sqls.should == ["CREATE TABLE cats (id integer);CREATE INDEX abc ON cats (id);"]
+    @db.sqls.should == ["CREATE TABLE cats (id integer);", "CREATE INDEX abc ON cats (id);"]
   end
 
   specify "should accept unique index definitions" do
@@ -161,7 +161,7 @@ context "DB#create_table" do
       integer :id
       index :id, :unique => true
     end
-    @db.sqls.should == ["CREATE TABLE cats (id integer);CREATE UNIQUE INDEX cats_id_index ON cats (id);"]
+    @db.sqls.should == ["CREATE TABLE cats (id integer);", "CREATE UNIQUE INDEX cats_id_index ON cats (id);"]
   end
   
   specify "should accept compound index definitions" do
@@ -169,7 +169,7 @@ context "DB#create_table" do
       integer :id
       index [:id, :name], :unique => true
     end
-    @db.sqls.should == ["CREATE TABLE cats (id integer);CREATE UNIQUE INDEX cats_id_name_index ON cats (id, name);"]
+    @db.sqls.should == ["CREATE TABLE cats (id integer);", "CREATE UNIQUE INDEX cats_id_name_index ON cats (id, name);"]
   end
 end
 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: sequel
 version: !ruby/object:Gem::Version 
-  version: 0.1.9.9
-date: 2007-08-18 00:00:00 +03:00
+  version: 0.1.9.10
+date: 2007-08-23 00:00:00 +03:00
 summary: Lightweight ORM library for Ruby
 require_paths: 
 - lib
@@ -33,7 +33,6 @@ files:
 - README
 - Rakefile
 - bin/sequel
-- doc/rdoc
 - spec/adapters
 - spec/connection_pool_spec.rb
 - spec/core_ext_spec.rb