sequel 0.3.3 → 0.3.4.1

data/CHANGELOG

@@ -1,3 +1,23 @@
+=== 0.3.4.1 (2007-11-10)
+
+* Changed Dataset#select_sql to support queries without a FROM clause.
+
+=== 0.3.4 (2007-11-10)
+
+* Fixed MySQL adapter to allow calling stored procedures (thanks Sebastian).
+
+* Changed Dataset#each to always return self.
+
+* Fixed SQL functions without arguments in block filters.
+
+* Implemented super-cool Symbol#cast_as method.
+
+* Fixed error message in command-line tool if failed to load adapter (#85).
+
+* Refactored code relating to column references for better extendibility (#88).
+
+* Tiny fix to Model#run_hooks.
+
 === 0.3.3 (2007-11-04)
 
 * Revised code to generate SQL statements without trailing semicolons.

data/README

@@ -28,11 +28,13 @@ If you have any comments or suggestions please send an email to ciconia at gmail
 
 Sequel currently supports:
 
-* Postgresql
-* SQLite 3
+* ADO (on Windows)
 * DBI
-* ODBC
 * MySQL
+* ODBC
+* Oracle
+* PostgreSQL
+* SQLite 3
 
 == The Sequel Console
 

data/Rakefile

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

data/bin/sequel

@@ -24,8 +24,8 @@ end
 begin
   scheme = URI.parse(db).scheme
   require File.join('sequel', scheme)
-rescue LoadError
-  puts "Invalid adapter specified: #{scheme}"
+rescue LoadError => e
+  puts "Failed to load #{scheme} adapter: #{e.message}"
   exit
 rescue => e
   puts e.message

data/lib/sequel.rb

@@ -1,7 +1,7 @@
 require 'metaid'
 
 files = %w[
-  core_ext array_keys error connection_pool pretty_table
+  core_ext core_sql array_keys error connection_pool pretty_table
   dataset migration model schema database worker
 ]
 dir = File.join(File.dirname(__FILE__), 'sequel')

data/lib/sequel/array_keys.rb

@@ -208,6 +208,7 @@ module ArrayKeys
             else
               fetch_rows(select_sql(opts)) {|r| block[@row_proc[transform_load(Array.from_hash(r))]]}
             end
+            self
           end
         end
       elsif @row_proc
@@ -218,18 +219,21 @@ module ArrayKeys
             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

data/lib/sequel/core_ext.rb

@@ -7,16 +7,6 @@ module Enumerable
   end
 end
 
-# Array extensions
-class Array
-  # Concatenates an array of strings into an SQL string. ANSI SQL and C-style
-  # comments are removed, as well as excessive white-space.
-  def to_sql
-    map {|l| (l =~ /^(.*)--/ ? $1 : l).chomp}.join(' '). \
-      gsub(/\/\*.*\*\//, '').gsub(/\s+/, ' ').strip
-  end
-end
-
 # Range extensions
 class Range
   # Returns the interval between the beginning and end of the range.
@@ -25,133 +15,11 @@ class Range
   end
 end
 
-module Sequel
-  # LiteralString is used to represent literal SQL expressions. An 
-  # LiteralString is copied verbatim into an SQL statement. Instances of
-  # LiteralString can be created by calling String#expr.
-  class LiteralString < ::String
-  end
-end
-
-# String extensions
-class String
-  # Converts a string into an SQL string by removing comments.
-  # See also Array#to_sql.
-  def to_sql
-    split($/).to_sql
-  end
-  
-  # Splits a string into separate SQL statements, removing comments
-  # and excessive white-space.
-  def split_sql
-    to_sql.split(';').map {|s| s.strip}
-  end
-
-  # Converts a string into an LiteralString, 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'.lit).sql #=>
-  #     "SELECT * FROM items WHERE (abc = def)"
-  #
-  def lit
-    Sequel::LiteralString.new(self)
-  end
-  
-  alias_method :expr, :lit
-  
-  # Converts a string into a Time object.
-  def to_time
-    Time.parse(self)
-  end
-  
-  # Converts a string into a column name.
-  def to_field_name
-    self
-  end
-  alias_method :to_column_name, :to_field_name
-end
-
-# Methods to format column names and associated constructs. This module is
-# included in String and Symbol.
-module ColumnCompositionMethods
-  # Constructs a DESC clause for use in an ORDER BY clause.
-  def DESC
-    "#{to_column_name} DESC".lit
-  end
-  
-  # Constructs an AS clause for column aliasing.
-  def AS(target)
-    "#{to_column_name} AS #{target}".lit
-  end
-
-  # Constructs a qualified wildcard (*) clause.
-  def ALL
-    "#{to_s}.*".lit
-  end
-  
-  COLUMN_TITLE_RE1 = /^(.*)\sAS\s(.+)$/i.freeze
-  COLUMN_TITLE_RE2 = /^([^\.]+)\.([^\.]+)$/.freeze
-  
-  # Returns the column name. If the column name is aliased, the alias is 
-  # returned.
-  def field_title
-    case s = to_column_name
-    when COLUMN_TITLE_RE1, COLUMN_TITLE_RE2: $2
-    else
-      s
-    end
-  end
-  alias_method :column_title, :field_title
-end
-
-# String extensions
-class String
-  include ColumnCompositionMethods
-end
-
-# Symbol extensions
-class Symbol
-  include ColumnCompositionMethods
-  
-
-  COLUMN_REF_RE1 = /^(\w+)__(\w+)___(\w+)/.freeze
-  COLUMN_REF_RE2 = /^(\w+)___(\w+)$/.freeze
-  COLUMN_REF_RE3 = /^(\w+)__(\w+)$/.freeze
-  
-  # Converts a symbol into a column name. This method supports underscore
-  # notation in order to express qualified (two underscores) and aliased 
-  # (three underscores) columns:
-  #
-  #   :abc.to_column_name #=> "abc"
-  #   :abc___a.to_column_name #=> "abc AS a"
-  #   :items__abc.to_column_name #=> "items.abc"
-  #   :items__abc___a.to_column_name #=> "items.abc AS a"
-  #
-  def to_field_name
-    s = to_s
-    case s
-    when COLUMN_REF_RE1: "#{$1}.#{$2} AS #{$3}"
-    when COLUMN_REF_RE2: "#{$1} AS #{$2}"
-    when COLUMN_REF_RE3: "#{$1}.#{$2}"
-    else
-      s
-    end
-  end
-  alias_method :to_column_name, :to_field_name
-  
-  # Converts missing method calls into functions on columns, if the
-  # method name is made of all upper case letters.
-  def method_missing(sym)
-    ((s = sym.to_s) =~ /^([A-Z]+)$/) ? \
-      "#{s.downcase}(#{to_column_name})".lit : super
-  end
-  
-  # Formats an SQL function with optional parameters
-  def [](*args)
-    "#{to_s}(#{args.join(', ')})".lit
+# Object extensions
+class Object
+  def is_one_of?(*classes)
+    classes.each {|c| return c if is_a?(c)}
+    nil
   end
 end
 

data/lib/sequel/core_sql.rb

@@ -0,0 +1,151 @@
+# Array extensions
+class Array
+  # Concatenates an array of strings into an SQL string. ANSI SQL and C-style
+  # comments are removed, as well as excessive white-space.
+  def to_sql
+    map {|l| (l =~ /^(.*)--/ ? $1 : l).chomp}.join(' '). \
+      gsub(/\/\*.*\*\//, '').gsub(/\s+/, ' ').strip
+  end
+end
+
+module Sequel
+  # LiteralString is used to represent literal SQL expressions. An 
+  # LiteralString is copied verbatim into an SQL statement. Instances of
+  # LiteralString can be created by calling String#expr.
+  class LiteralString < ::String
+  end
+end
+
+# String extensions
+class String
+  # Converts a string into an SQL string by removing comments.
+  # See also Array#to_sql.
+  def to_sql
+    split($/).to_sql
+  end
+  
+  # Splits a string into separate SQL statements, removing comments
+  # and excessive white-space.
+  def split_sql
+    to_sql.split(';').map {|s| s.strip}
+  end
+
+  # Converts a string into an LiteralString, 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'.lit).sql #=>
+  #     "SELECT * FROM items WHERE (abc = def)"
+  #
+  def lit
+    Sequel::LiteralString.new(self)
+  end
+  
+  alias_method :expr, :lit
+  
+  # Converts a string into a Time object.
+  def to_time
+    Time.parse(self)
+  end
+end
+
+
+module Sequel
+  module SQL
+    class Expression
+      def lit; self; end
+    end
+    
+    class ColumnExpr < Expression
+      def initialize(l, op, r = nil); @l, @op, @r = l, op, r; end
+      
+      def to_s(ds)
+        @r ? \
+          "#{ds.literal(@l)} #{@op} #{ds.literal(@r)}" : \
+          "#{ds.literal(@l)} #{@op}"
+      end
+    end
+    
+    class Function < Expression
+      def initialize(f, *args); @f, @args = f, args; end
+
+      def to_s(ds)
+        args = @args.empty? ? '' : ds.literal(@args)
+        "#{@f}(#{args})"
+      end
+    end
+    
+    class ColumnAll < Expression
+      def initialize(t); @t = t; end
+      def to_s(ds); "#{@t}.*"; end
+    end
+    
+    module ColumnMethods
+      AS = 'AS'.freeze
+      DESC = 'DESC'.freeze
+      ASC = 'ASC'.freeze
+      
+      def as(a); ColumnExpr.new(self, AS, a); end
+      alias_method :AS, :as
+      
+      def desc; ColumnExpr.new(self, DESC); end
+      alias_method :DESC, :desc
+      
+      def asc; ColumnExpr.new(self, ASC); end
+      alias_method :ASC, :asc
+
+      def all; Sequel::SQL::ColumnAll.new(self); end
+      alias_method :ALL, :all
+
+      def cast_as(t)
+        if t.is_a?(Symbol)
+          t = t.to_s.lit
+        end
+        Sequel::SQL::Function.new(:cast, self.as(t))
+      end
+    end
+  end
+end
+
+class Object
+  include Sequel::SQL::ColumnMethods
+end
+
+class Symbol
+  def [](*args); Sequel::SQL::Function.new(self, *args); end
+  
+  COLUMN_REF_RE1 = /^(\w+)__(\w+)___(\w+)/.freeze
+  COLUMN_REF_RE2 = /^(\w+)___(\w+)$/.freeze
+  COLUMN_REF_RE3 = /^(\w+)__(\w+)$/.freeze
+
+  # Converts a symbol into a column name. This method supports underscore
+  # notation in order to express qualified (two underscores) and aliased 
+  # (three underscores) columns:
+  #
+  #   ds = DB[:items]
+  #   :abc.to_column_ref(ds) #=> "abc"
+  #   :abc___a.to_column_ref(ds) #=> "abc AS a"
+  #   :items__abc.to_column_ref(ds) #=> "items.abc"
+  #   :items__abc___a.to_column_ref(ds) #=> "items.abc AS a"
+  #
+  def to_column_ref(ds)
+    case s = to_s
+    when COLUMN_REF_RE1: "#{$1}.#{ds.quote_column_ref($2)} AS #{ds.quote_column_ref($3)}"
+    when COLUMN_REF_RE2: "#{ds.quote_column_ref($1)} AS #{ds.quote_column_ref($2)}"
+    when COLUMN_REF_RE3: "#{$1}.#{ds.quote_column_ref($2)}"
+    else                 ds.quote_column_ref(s)
+    end
+  end
+  
+  # Converts missing method calls into functions on columns, if the
+  # method name is made of all upper case letters.
+  def method_missing(sym)
+    if ((s = sym.to_s) =~ /^([A-Z]+)$/)
+      Sequel::SQL::Function.new(s.downcase, self)
+    else
+      super
+    end
+  end
+end

data/lib/sequel/dataset.rb

@@ -161,6 +161,7 @@ module Sequel
     # Iterates over the records in the dataset
     def each(opts = nil, &block)
       fetch_rows(select_sql(opts), &block)
+      self
     end
 
     # Returns the the model classes associated with the dataset as a hash.
@@ -347,6 +348,7 @@ module Sequel
             else
               fetch_rows(select_sql(opts)) {|r| block[@row_proc[transform_load(r)]]}
             end
+            self
           end
         end
       elsif @row_proc
@@ -357,18 +359,21 @@ module Sequel
             else
               fetch_rows(select_sql(opts)) {|r| block[@row_proc[r]]}
             end
+            self
           end
         end
       elsif @transform
         class << self
           def each(opts = nil, &block)
             fetch_rows(select_sql(opts)) {|r| block[transform_load(r)]}
+            self
           end
         end
       else
         class << self
           def each(opts = nil, &block)
             fetch_rows(select_sql(opts), &block)
+            self
           end
         end
       end

data/lib/sequel/dataset/sequelizer.rb

@@ -108,7 +108,8 @@ class Sequel::Dataset
       when :>, :<, :>=, :<=
         l = eval_expr(e[1], b)
         r = eval_expr(e[3][1], b)
-        if (Symbol === l) || (Sequel::LiteralString === l) || (Symbol === r) || (Sequel::LiteralString === r)
+        if l.is_one_of?(Symbol, Sequel::LiteralString, Sequel::SQL::Expression) || \
+          r.is_one_of?(Symbol, Sequel::LiteralString, Sequel::SQL::Expression)
           "(#{literal(l)} #{op} #{literal(r)})"
         else
           ext_expr(e, b)
@@ -124,7 +125,8 @@ class Sequel::Dataset
       when :+, :-, :*, :/, :%
         l = eval_expr(e[1], b)
         r = eval_expr(e[3][1], b)
-        if (Symbol === l) || (Sequel::LiteralString === l) || (Symbol === r) || (Sequel::LiteralString === r)
+        if l.is_one_of?(Symbol, Sequel::LiteralString, Sequel::SQL::Expression) || \
+          r.is_one_of?(Symbol, Sequel::LiteralString, Sequel::SQL::Expression)
           "(#{literal(l)} #{op} #{literal(r)})".lit
         else
           ext_expr(e, b)
@@ -146,7 +148,11 @@ class Sequel::Dataset
       else
         if (op == :[]) && (e[1][0] == :lit) && (Symbol === e[1][1])
           # SQL Functions, e.g.: :sum[:x]
-          e[1][1][*pt_expr(e[3], b)]
+          if e[3]
+            e[1][1][*eval_expr(e[3], b)]
+          else
+            e[1][1][]
+          end
         else
           # external code
           ext_expr(e, b)

data/lib/sequel/dataset/sql.rb

@@ -3,26 +3,10 @@ module Sequel
     # The Dataset SQL module implements all the dataset methods concerned with
     # generating SQL statements for retrieving and manipulating records.
     module SQL
-      # Returns a valid SQL column name as a string. Column names specified as 
-      # symbols can include double underscores to denote a dot separator, e.g.
-      # :posts__id will be converted into posts.id.
-      def column_name(column)
-        case column
-        when Symbol, String:
-          quoted_column_name(column.to_column_name)
-        when Hash:
-          column.map {|f,a| "#{column_name(f)} AS #{column_name(a)}"}.join(COMMA_SEPARATOR)
-        else
-          column
-        end
-      end
-
       # Adds quoting to column references. This method is just a stub and can
       # be overriden in adapters in order to provide correct column quoting
       # behavior.
-      def quoted_column_name(name)
-        name
-      end
+      def quote_column_ref(name); name.to_s; end
       
       ALIASED_REGEXP = /^(.*)\s(.*)$/.freeze
       QUALIFIED_REGEXP = /^(.*)\.(.*)$/.freeze
@@ -30,7 +14,7 @@ module Sequel
       # Returns a qualified column name (including a table name) if the column
       # name isn't already qualified.
       def qualified_column_name(column, table)
-        column = column_name(column)
+        column = literal(column)
         if column =~ QUALIFIED_REGEXP
           # column is already qualified
           column
@@ -105,7 +89,8 @@ module Sequel
         when NilClass: NULL
         when TrueClass: TRUE
         when FalseClass: FALSE
-        when Symbol: quoted_column_name(v.to_column_name)
+        when Symbol: v.to_column_ref(self)
+        when Sequel::SQL::Expression: v.to_s(self)
         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)
@@ -170,20 +155,25 @@ module Sequel
         order(*invert_order(order.empty? ? @opts[:order] : order))
       end
 
-      DESC_ORDER_REGEXP = /(.*)\sDESC/i.freeze
+      DESC_ORDER_REGEXP = /^(.*)\sDESC$/i.freeze
 
       # Inverts the given order by breaking it into a list of column references
       # and inverting them.
       #
-      #   dataset.invert_order('id DESC') #=> "id"
-      #   dataset.invert_order('category, price DESC') #=>
-      #     "category DESC, price"
+      #   dataset.invert_order(['id DESC']) #=> ["id"]
+      #   dataset.invert_order(['category, price DESC']) #=>
+      #     ["category DESC, price"]
       def invert_order(order)
         new_order = []
         order.each do |f|
-          f.to_s.split(',').map do |p|
-            p.strip!
-            new_order << ((p =~ DESC_ORDER_REGEXP ? $1 : p.to_sym.DESC).lit)
+          if f.is_a?(String)
+            f.split(',').each do |r|
+              r.strip!
+              new_order << ((r =~ DESC_ORDER_REGEXP ? $1 : r.to_sym.desc).lit)
+            end
+          else
+            r = literal(f).strip
+            new_order << ((r =~ DESC_ORDER_REGEXP ? $1 : r.to_sym.desc).lit)
           end
         end
         new_order
@@ -381,10 +371,13 @@ module Sequel
 
         columns = opts[:select]
         select_columns = columns ? column_list(columns) : WILDCARD
-        select_source = source_list(opts[:from])
         sql = opts[:distinct] ? \
-          "SELECT DISTINCT #{select_columns} FROM #{select_source}" : \
-          "SELECT #{select_columns} FROM #{select_source}"
+        "SELECT DISTINCT #{select_columns}" : \
+        "SELECT #{select_columns}"
+        
+        if opts[:from]
+          sql << " FROM #{source_list(opts[:from])}"
+        end
         
         if join = opts[:join]
           sql << join
@@ -460,7 +453,7 @@ module Sequel
               "INSERT INTO #{@opts[:from]} DEFAULT VALUES"
             else
               fl, vl = [], []
-              values.each {|k, v| fl << column_name(k); vl << literal(v)}
+              values.each {|k, v| fl << literal(k); vl << literal(v)}
               "INSERT INTO #{@opts[:from]} (#{fl.join(COMMA_SEPARATOR)}) VALUES (#{vl.join(COMMA_SEPARATOR)})"
             end
           when Dataset
@@ -488,7 +481,7 @@ module Sequel
           values = values.to_hash
         end
         values = transform_save(values) if @transform
-        set_list = values.map {|k, v| "#{column_name(k)} = #{literal(v)}"}.
+        set_list = values.map {|k, v| "#{literal(k)} = #{literal(v)}"}.
           join(COMMA_SEPARATOR)
         sql = "UPDATE #{@opts[:from]} SET #{set_list}"
 

data/lib/sequel/model/hooks.rb

@@ -116,7 +116,7 @@ module Sequel
 
     # Evaluates specified chain of Hooks through <tt>instance_eval</tt>.
     def run_hooks(key)
-      model.hooks[key].each { |h| instance_eval &h }
+      model.hooks[key].each {|h| instance_eval(&h)}
     end
     
     def self.has_hooks?(key)

data/lib/sequel/mysql.rb

@@ -93,7 +93,7 @@ module Sequel
 
       def connect
         conn = Mysql.real_connect(@opts[:host], @opts[:user], @opts[:password], 
-          @opts[:database], @opts[:port])
+          @opts[:database], @opts[:port], nil, Mysql::CLIENT_MULTI_RESULTS)
         conn.query_with_result = false
         if encoding = @opts[:encoding] || @opts[:charset]
           conn.query("set character_set_connection = '#{encoding}'")
@@ -172,31 +172,14 @@ module Sequel
     end
     
     class Dataset < Sequel::Dataset
-      UNQUOTABLE_COLUMN_RE = /^(`(.+)`)|\*$/.freeze
-      def quote_column(f)
-        (f.nil? || f.empty? || f =~ UNQUOTABLE_COLUMN_RE) ? f : "`#{f}`"
-      end
-      
-      COLUMN_EXPR_RE = /^([^\(]+\()?([^\.]+\.)?([^\s\)]+)?(\))?(\sAS\s(.+))?$/i.freeze
-      COLUMN_ORDER_RE = /^(.*) (DESC|ASC)$/i.freeze
-      def quoted_column_name(name)
-        case name
-        when COLUMN_EXPR_RE:
-          $6 ? \
-            "#{$1}#{$2}#{quote_column($3)}#{$4} AS #{quote_column($6)}" : \
-            "#{$1}#{$2}#{quote_column($3)}#{$4}"
-        when COLUMN_ORDER_RE: "#{quote_column($1)} #{$2}"
-        else
-          quote_column(name)
-        end
-      end
+      def quote_column_ref(c); "`#{c}`"; end
       
       TRUE = '1'
       FALSE = '0'
       
       def literal(v)
         case v
-        when LiteralString: quoted_column_name(v)
+        when LiteralString: v
         when String: "'#{v.gsub(/'|\\/, '\&\&')}'"
         when true: TRUE
         when false: FALSE

data/spec/adapters/mysql_spec.rb

@@ -97,17 +97,29 @@ context "A MySQL dataset" do
     @d.order(:name.DESC).sql.should == \
       'SELECT * FROM items ORDER BY `name` DESC'
       
-    @d.select('items.name AS item_name'.to_sym).sql.should == \
-      'SELECT items.`name` AS `item_name` FROM items'
+    @d.select('items.name AS item_name'.lit).sql.should == \
+      'SELECT items.name AS item_name FROM items'
       
     @d.select('`name`'.lit).sql.should == \
       'SELECT `name` FROM items'
 
     @d.select('max(items.`name`) AS `max_name`'.lit).sql.should == \
       'SELECT max(items.`name`) AS `max_name` FROM items'
+      
+    @d.select(:test[:abc, 'hello']).sql.should == \
+      "SELECT test(`abc`, 'hello') FROM items"
+
+    @d.select(:test[:abc__def, 'hello']).sql.should == \
+      "SELECT test(abc.`def`, 'hello') FROM items"
+
+    @d.select(:test[:abc__def, 'hello'].as(:x2)).sql.should == \
+      "SELECT test(abc.`def`, 'hello') AS `x2` FROM items"
 
     @d.insert_sql(:value => 333).should == \
       'INSERT INTO items (`value`) VALUES (333)'
+
+      @d.insert_sql(:x => :y).should == \
+        'INSERT INTO items (`x`) VALUES (`y`)'
   end
   
   specify "should support ORDER clause in UPDATE statements" do
@@ -188,3 +200,37 @@ context "A MySQL dataset in array tuples mode" do
     a[:value].should == '123'
   end
 end
+
+context "MySQL datasets" do
+  setup do
+    @d = MYSQL_DB[:orders]
+  end
+  
+  specify "should correctly quote column references" do
+    market = 'ICE'
+    ack_stamp = Time.now - 15 * 60 # 15 minutes ago
+    @d.query do
+      select :market, :minute[:from_unixtime[:ack]].as(:minute)
+      where do
+        :ack > ack_stamp
+        :market == market
+      end
+      group_by :minute[:from_unixtime[:ack]]
+    end.sql.should == \
+      "SELECT `market`, minute(from_unixtime(`ack`)) AS `minute` FROM orders WHERE ((`ack` > #{@d.literal(ack_stamp)}) AND (`market` = 'ICE')) GROUP BY minute(from_unixtime(`ack`))"
+  end
+end
+
+context "Simple stored procedure test" do
+  setup do
+    # Create a simple stored procedure but drop it first if there
+    MYSQL_DB.execute("DROP PROCEDURE IF EXISTS sp_get_server_id;")
+    MYSQL_DB.execute("CREATE PROCEDURE sp_get_server_id() SQL SECURITY DEFINER SELECT @@SERVER_ID as server_id;")
+  end
+
+  specify "should return the server-id via a stored procedure call" do
+    @server_id = MYSQL_DB["SELECT @@SERVER_ID as server_id;"].first[:server_id] # grab the server_id via a simple query
+    @server_id_by_sp = MYSQL_DB["CALL sp_get_server_id();"].first[:server_id]
+    @server_id_by_sp.should == @server_id  # compare it to output from stored procedure
+  end
+end

data/spec/core_ext_spec.rb

@@ -8,92 +8,6 @@ context "Enumerable#send_each" do
   end
 end
 
-context "Array#to_sql" do
-  specify "should concatenate multiple lines into a single string" do
-    "SELECT * \r\nFROM items\r\n WHERE a = 1".split.to_sql. \
-      should == 'SELECT * FROM items WHERE a = 1'
-  end
-  
-  specify "should remove superfluous white space and line breaks" do
-    "\tSELECT * \n FROM items    ".split.to_sql. \
-      should == 'SELECT * FROM items'
-  end
-  
-  specify "should remove ANSI SQL comments" do
-    "SELECT *   --comment\r\n  FROM items\r\n  --comment".split.to_sql. \
-      should == 'SELECT * FROM items'
-  end
-  
-  specify "should remove C-style comments" do
-    "SELECT * \r\n /* comment comment\r\n comment\r\n FROM items */\r\n FROM items\r\n--comment".split.to_sql. \
-      should == 'SELECT * FROM items'
-  end
-end
-
-context "String#to_sql" do
-  specify "should concatenate multiple lines into a single string" do
-    "SELECT * \r\nFROM items\r\nWHERE a = 1".to_sql. \
-      should == 'SELECT * FROM items WHERE a = 1'
-  end
-  
-  specify "should remove superfluous white space and line breaks" do
-    "\tSELECT * \r\n FROM items    ".to_sql. \
-      should == 'SELECT * FROM items'
-  end
-  
-  specify "should remove ANSI SQL comments" do
-    "SELECT *   --comment \r\n FROM items\r\n  --comment".to_sql. \
-      should == 'SELECT * FROM items'
-  end
-  
-  specify "should remove C-style comments" do
-    "SELECT * \r\n/* comment comment\r\ncomment\r\nFROM items */\r\nFROM items\r\n--comment".to_sql. \
-      should == 'SELECT * FROM items'
-  end
-end
-
-context "String#lit" do
-  specify "should return an LiteralString object" do
-    'xyz'.lit.should be_a_kind_of(Sequel::LiteralString)
-    'xyz'.lit.to_s.should == 'xyz'
-  end
-  
-  specify "should inhibit string literalization" do
-    db = Sequel::Database.new
-    ds = db[:t]
-    
-    ds.update_sql(:stamp => "NOW()".lit).should == \
-      "UPDATE t SET stamp = NOW()"
-  end
-end
-
-context "String#expr" do
-  specify "should return an LiteralString object" do
-    'xyz'.expr.should be_a_kind_of(Sequel::LiteralString)
-    'xyz'.expr.to_s.should == 'xyz'
-  end
-
-  specify "should inhibit string literalization" do
-    db = Sequel::Database.new
-    ds = db[:t]
-    
-    ds.update_sql(:stamp => "NOW()".expr).should == \
-      "UPDATE t SET stamp = NOW()"
-  end
-end
-
-context "String#split_sql" do
-  specify "should split a string containing multiple statements" do
-    "DROP TABLE a; DROP TABLE c".split_sql.should == \
-      ['DROP TABLE a', 'DROP TABLE c']
-  end
-  
-  specify "should remove comments from the string" do
-    "DROP TABLE a;/* DROP TABLE b; DROP TABLE c;*/DROP TABLE d".split_sql.should == \
-      ['DROP TABLE a', 'DROP TABLE d']
-  end
-end
-
 context "String#to_time" do
   specify "should convert the string into a Time object" do
     "2007-07-11".to_time.should == Time.parse("2007-07-11")
@@ -101,112 +15,6 @@ context "String#to_time" do
   end
 end
 
-context "Symbol#DESC" do
-  specify "should append the symbol with DESC" do
-    :hey.DESC.should == 'hey DESC'
-  end
-  
-  specify "should support qualified symbol notation" do
-    :abc__def.DESC.should == 'abc.def DESC'
-  end
-end
-
-context "Symbol#AS" do
-  specify "should append an AS clause" do
-    :hey.AS(:ho).should == 'hey AS ho'
-  end
-  
-  specify "should support qualified symbol notation" do
-    :abc__def.AS(:x).should == 'abc.def AS x'
-  end
-end
-
-context "Symbol#ALL" do
-  specify "should format a qualified wildcard" do
-    :xyz.ALL.should == 'xyz.*'
-  end
-end
-
-context "Symbol#to_column_name" do
-  specify "should convert qualified symbol notation into dot notation" do
-    :abc__def.to_column_name.should == 'abc.def'
-  end
-  
-  specify "should convert AS symbol notation into SQL AS notation" do
-    :xyz___x.to_column_name.should == 'xyz AS x'
-    :abc__def___x.to_column_name.should == 'abc.def AS x'
-  end
-  
-  specify "should support names with digits" do
-    :abc2.to_column_name.should == 'abc2'
-    :xx__yy3.to_column_name.should == 'xx.yy3'
-    :ab34__temp3_4ax.to_column_name.should == 'ab34.temp3_4ax'
-    :x1___y2.to_column_name.should == 'x1 AS y2'
-    :abc2__def3___ggg4.to_column_name.should == 'abc2.def3 AS ggg4'
-  end
-  
-  specify "should support upper case and lower case" do
-    :ABC.to_column_name.should == 'ABC'
-    :Zvashtoy__aBcD.to_column_name.should == 'Zvashtoy.aBcD'
-    
-  end
-end
-
-context "ColumnCompositionMethods#column_title" do
-  specify "should return the column name for non aliased columns" do
-    :xyz.column_title.should == 'xyz'
-    :abc__xyz.column_title.should == 'xyz'
-    
-    'abc'.column_title.should == 'abc'
-    'abc.def'.column_title.should == 'def'
-  end
-  
-  specify "should return the column alias for aliased columns" do
-    :xyz___x.column_title.should == 'x'
-    :abc__xyz___y.column_title.should == 'y'
-    
-    'abc AS x'.column_title.should == 'x'
-    'abc as y'.column_title.should == 'y'
-    'abc.def AS d'.column_title.should == 'd'
-  end
-end
-
-context "Symbol" do
-  specify "should support MIN for specifying min function" do
-    :abc__def.MIN.should == 'min(abc.def)'
-  end
-
-  specify "should support MAX for specifying max function" do
-    :abc__def.MAX.should == 'max(abc.def)'
-  end
-
-  specify "should support SUM for specifying sum function" do
-    :abc__def.SUM.should == 'sum(abc.def)'
-  end
-
-  specify "should support AVG for specifying avg function" do
-    :abc__def.AVG.should == 'avg(abc.def)'
-  end
-  
-  specify "should support COUNT for specifying count function" do
-    :abc__def.COUNT.should == 'count(abc.def)'
-  end
-  
-  specify "should support any other function using upper case letters" do
-    :abc__def.DADA.should == 'dada(abc.def)'
-  end
-  
-  specify "should support upper case outer functions" do
-    :COUNT['1'].should == 'COUNT(1)'
-  end
-  
-  specify "should inhibit string literalization" do
-    db = Sequel::Database.new
-    ds = db[:t]
-    ds.select(:COUNT['1']).sql.should == "SELECT COUNT(1) FROM t"
-  end
-end
-
 context "Range#interval" do
   specify "should return the interval between the beginning and end of the range" do
     (1..10).interval.should == 9

data/spec/core_sql_spec.rb

@@ -0,0 +1,279 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+context "Array#to_sql" do
+  specify "should concatenate multiple lines into a single string" do
+    "SELECT * \r\nFROM items\r\n WHERE a = 1".split.to_sql. \
+      should == 'SELECT * FROM items WHERE a = 1'
+  end
+  
+  specify "should remove superfluous white space and line breaks" do
+    "\tSELECT * \n FROM items    ".split.to_sql. \
+      should == 'SELECT * FROM items'
+  end
+  
+  specify "should remove ANSI SQL comments" do
+    "SELECT *   --comment\r\n  FROM items\r\n  --comment".split.to_sql. \
+      should == 'SELECT * FROM items'
+  end
+  
+  specify "should remove C-style comments" do
+    "SELECT * \r\n /* comment comment\r\n comment\r\n FROM items */\r\n FROM items\r\n--comment".split.to_sql. \
+      should == 'SELECT * FROM items'
+  end
+end
+
+context "String#to_sql" do
+  specify "should concatenate multiple lines into a single string" do
+    "SELECT * \r\nFROM items\r\nWHERE a = 1".to_sql. \
+      should == 'SELECT * FROM items WHERE a = 1'
+  end
+  
+  specify "should remove superfluous white space and line breaks" do
+    "\tSELECT * \r\n FROM items    ".to_sql. \
+      should == 'SELECT * FROM items'
+  end
+  
+  specify "should remove ANSI SQL comments" do
+    "SELECT *   --comment \r\n FROM items\r\n  --comment".to_sql. \
+      should == 'SELECT * FROM items'
+  end
+  
+  specify "should remove C-style comments" do
+    "SELECT * \r\n/* comment comment\r\ncomment\r\nFROM items */\r\nFROM items\r\n--comment".to_sql. \
+      should == 'SELECT * FROM items'
+  end
+end
+
+context "String#lit" do
+  specify "should return an LiteralString object" do
+    'xyz'.lit.should be_a_kind_of(Sequel::LiteralString)
+    'xyz'.lit.to_s.should == 'xyz'
+  end
+  
+  specify "should inhibit string literalization" do
+    db = Sequel::Database.new
+    ds = db[:t]
+    
+    ds.update_sql(:stamp => "NOW()".lit).should == \
+      "UPDATE t SET stamp = NOW()"
+  end
+end
+
+context "String#expr" do
+  specify "should return an LiteralString object" do
+    'xyz'.expr.should be_a_kind_of(Sequel::LiteralString)
+    'xyz'.expr.to_s.should == 'xyz'
+  end
+
+  specify "should inhibit string literalization" do
+    db = Sequel::Database.new
+    ds = db[:t]
+    
+    ds.update_sql(:stamp => "NOW()".expr).should == \
+      "UPDATE t SET stamp = NOW()"
+  end
+end
+
+context "String#split_sql" do
+  specify "should split a string containing multiple statements" do
+    "DROP TABLE a; DROP TABLE c".split_sql.should == \
+      ['DROP TABLE a', 'DROP TABLE c']
+  end
+  
+  specify "should remove comments from the string" do
+    "DROP TABLE a;/* DROP TABLE b; DROP TABLE c;*/DROP TABLE d".split_sql.should == \
+      ['DROP TABLE a', 'DROP TABLE d']
+  end
+end
+
+context "#DESC/#desc" do
+  setup do
+    @ds = Sequel::Dataset.new(nil)
+  end
+  
+  specify "should format a DESC clause for a column ref" do
+    :test.DESC.to_s(@ds).should == 'test DESC'
+    :test.desc.to_s(@ds).should == 'test DESC'
+    
+    :items__price.DESC.to_s(@ds).should == 'items.price DESC'
+    :items__price.desc.to_s(@ds).should == 'items.price DESC'
+  end
+
+  specify "should format a DESC clause for a function" do
+    :avg[:test].DESC.to_s(@ds).should == 'avg(test) DESC'
+    :avg[:test].desc.to_s(@ds).should == 'avg(test) DESC'
+  end
+  
+  specify "should format a DESC clause for a literal value" do
+    1.DESC.to_s(@ds).should == '1 DESC'
+    'abc'.desc.to_s(@ds).should == "'abc' DESC"
+  end
+end
+
+context "#ASC/#asc" do
+  setup do
+    @ds = Sequel::Dataset.new(nil)
+  end
+  
+  specify "should format a ASC clause for a column ref" do
+    :test.ASC.to_s(@ds).should == 'test ASC'
+    :test.asc.to_s(@ds).should == 'test ASC'
+    
+    :items__price.ASC.to_s(@ds).should == 'items.price ASC'
+    :items__price.asc.to_s(@ds).should == 'items.price ASC'
+  end
+
+  specify "should format a ASC clause for a function" do
+    :avg[:test].ASC.to_s(@ds).should == 'avg(test) ASC'
+    :avg[:test].asc.to_s(@ds).should == 'avg(test) ASC'
+  end
+  
+  specify "should format a ASC clause for a literal value" do
+    1.ASC.to_s(@ds).should == '1 ASC'
+    'abc'.asc.to_s(@ds).should == "'abc' ASC"
+  end
+end
+
+context "#AS/#as" do
+  setup do
+    @ds = Sequel::Dataset.new(nil)
+  end
+  
+  specify "should format a AS clause for a column ref" do
+    :test.AS(:t).to_s(@ds).should == 'test AS t'
+    :test.as(:t).to_s(@ds).should == 'test AS t'
+    
+    :items__price.AS(:p).to_s(@ds).should == 'items.price AS p'
+    :items__price.as(:p).to_s(@ds).should == 'items.price AS p'
+  end
+
+  specify "should format a AS clause for a function" do
+    :avg[:test].AS(:avg).to_s(@ds).should == 'avg(test) AS avg'
+    :avg[:test].as(:avg).to_s(@ds).should == 'avg(test) AS avg'
+  end
+  
+  specify "should format a AS clause for a literal value" do
+    1.AS(:one).to_s(@ds).should == '1 AS one'
+    'abc'.as(:abc).to_s(@ds).should == "'abc' AS abc"
+  end
+end
+
+context "Column references" do
+  setup do
+    @c = Class.new(Sequel::Dataset) do
+      def quote_column_ref(c); "`#{c}`"; end
+    end
+    @ds = @c.new(nil)
+  end
+  
+  specify "should be quoted properly" do
+    @ds.literal(:xyz).should == "`xyz`"
+    @ds.literal(:xyz__abc).should == "xyz.`abc`"
+
+    @ds.literal(:xyz.as(:x)).should == "`xyz` AS `x`"
+    @ds.literal(:xyz__abc.as(:x)).should == "xyz.`abc` AS `x`"
+
+    @ds.literal(:xyz___x).should == "`xyz` AS `x`"
+    @ds.literal(:xyz__abc___x).should == "xyz.`abc` AS `x`"
+  end
+  
+  specify "should be quoted properly in SQL functions" do
+    @ds.literal(:avg[:xyz]).should == "avg(`xyz`)"
+    @ds.literal(:avg[:xyz, 1]).should == "avg(`xyz`, 1)"
+    @ds.literal(:avg[:xyz].as(:a)).should == "avg(`xyz`) AS `a`"
+  end
+
+  specify "should be quoted properly in ASC/DESC clauses" do
+    @ds.literal(:xyz.ASC).should == "`xyz` ASC"
+    @ds.literal(:avg[:xyz, 1].desc).should == "avg(`xyz`, 1) DESC"
+  end
+  
+  specify "should be quoted properly in a cast function" do
+    @ds.literal(:x.cast_as(:integer)).should == "cast(`x` AS integer)"
+    @ds.literal(:x__y.cast_as(:varchar[20])).should == "cast(x.`y` AS varchar(20))"
+  end
+end
+
+context "Symbol#ALL/#all" do
+  setup do
+    @ds = Sequel::Dataset.new(nil)
+  end
+  
+  specify "should format a qualified wildcard" do
+    :xyz.ALL.to_s(@ds).should == 'xyz.*'
+    :abc.all.to_s(@ds).should == 'abc.*'
+  end
+end
+
+context "Symbol#to_column_ref" do
+  setup do
+    @ds = Sequel::Dataset.new(nil)
+  end
+  
+  specify "should convert qualified symbol notation into dot notation" do
+    :abc__def.to_column_ref(@ds).should == 'abc.def'
+  end
+  
+  specify "should convert AS symbol notation into SQL AS notation" do
+    :xyz___x.to_column_ref(@ds).should == 'xyz AS x'
+    :abc__def___x.to_column_ref(@ds).should == 'abc.def AS x'
+  end
+  
+  specify "should support names with digits" do
+    :abc2.to_column_ref(@ds).should == 'abc2'
+    :xx__yy3.to_column_ref(@ds).should == 'xx.yy3'
+    :ab34__temp3_4ax.to_column_ref(@ds).should == 'ab34.temp3_4ax'
+    :x1___y2.to_column_ref(@ds).should == 'x1 AS y2'
+    :abc2__def3___ggg4.to_column_ref(@ds).should == 'abc2.def3 AS ggg4'
+  end
+  
+  specify "should support upper case and lower case" do
+    :ABC.to_column_ref(@ds).should == 'ABC'
+    :Zvashtoy__aBcD.to_column_ref(@ds).should == 'Zvashtoy.aBcD'
+  end
+end
+
+context "Symbol" do
+  setup do
+    @ds = Sequel::Dataset.new(nil)
+  end
+  
+  specify "should support MIN for specifying min function" do
+    :abc__def.MIN.to_s(@ds).should == 'min(abc.def)'
+  end
+
+  specify "should support MAX for specifying max function" do
+    :abc__def.MAX.to_s(@ds).should == 'max(abc.def)'
+  end
+
+  specify "should support SUM for specifying sum function" do
+    :abc__def.SUM.to_s(@ds).should == 'sum(abc.def)'
+  end
+
+  specify "should support AVG for specifying avg function" do
+    :abc__def.AVG.to_s(@ds).should == 'avg(abc.def)'
+  end
+  
+  specify "should support COUNT for specifying count function" do
+    :abc__def.COUNT.to_s(@ds).should == 'count(abc.def)'
+  end
+  
+  specify "should support any other function using upper case letters" do
+    :abc__def.DADA.to_s(@ds).should == 'dada(abc.def)'
+  end
+  
+  specify "should support upper case outer functions" do
+    :COUNT['1'].to_s(@ds).should == "COUNT('1')"
+  end
+  
+  specify "should inhibit string literalization" do
+    db = Sequel::Database.new
+    ds = db[:t]
+    ds.select(:COUNT['1']).sql.should == "SELECT COUNT('1') FROM t"
+  end
+  
+  specify "should support cast function" do
+    :abc.cast_as(:integer).to_s(@ds).should == "cast(abc AS integer)"
+  end
+end
+

data/spec/dataset_spec.rb

@@ -795,12 +795,12 @@ context "Dataset#qualified_column_name" do
   end
   
   specify "should return the same if already qualified" do
-    @dataset.qualified_column_name('test.a', :items).should == 'test.a'
+    @dataset.qualified_column_name('test.a'.lit, :items).should == 'test.a'
     @dataset.qualified_column_name(:ccc__b, :items).should == 'ccc.b'
   end
   
   specify "should qualify the column with the supplied table name" do
-    @dataset.qualified_column_name('a', :items).should == 'items.a'
+    @dataset.qualified_column_name('a'.lit, :items).should == 'items.a'
     @dataset.qualified_column_name(:b1, :items).should == 'items.b1'
   end
 end
@@ -1274,16 +1274,16 @@ context "Dataset#last" do
   
   specify "should invert the order" do
     @d.order(:a).last
-    @c.last_dataset.opts[:order].should == ['a DESC']
+    @d.literal(@c.last_dataset.opts[:order]).should == @d.literal([:a.DESC])
     
     @d.order(:b.DESC).last
-    @c.last_dataset.opts[:order].should == ['b']
+    @d.literal(@c.last_dataset.opts[:order]).should == @d.literal(:b)
     
     @d.order(:c, :d).last
-    @c.last_dataset.opts[:order].should == ['c DESC', 'd DESC']
+    @d.literal(@c.last_dataset.opts[:order]).should == @d.literal([:c.DESC, :d.DESC])
     
     @d.order(:e.DESC, :f).last
-    @c.last_dataset.opts[:order].should == ['e', 'f DESC']
+    @d.literal(@c.last_dataset.opts[:order]).should == @d.literal([:e, :f.DESC])
   end
   
   specify "should return the first matching record if a hash is specified" do

data/spec/sequelizer_spec.rb

@@ -163,6 +163,13 @@ context "Proc#to_sql" do
       "(x(1, (SELECT z FROM y), 'a''b') > 100)"
   end
   
+  specify "should support SQL functions without arguments" do
+    proc {:abc[] > 100}.to_sql.should == "(abc() > 100)"
+    
+    proc {:now[] - :last_stamp > 100}.to_sql.should == \
+      "((now() - last_stamp) > 100)"
+  end
+  
   specify "should do stuff like..." do
     proc {:price < 100 || :category != 'ruby'}.to_sql.should == \
       "((price < 100) OR (NOT (category = 'ruby')))"

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: sequel
 version: !ruby/object:Gem::Version 
-  version: 0.3.3
-date: 2007-11-04 00:00:00 +02:00
+  version: 0.3.4.1
+date: 2007-11-10 00:00:00 +02:00
 summary: Lightweight ORM library for Ruby
 require_paths: 
 - lib
@@ -33,7 +33,6 @@ files:
 - README
 - Rakefile
 - bin/sequel
-- doc/rdoc
 - spec/adapters
 - spec/adapters/mysql_spec.rb
 - spec/adapters/oracle_spec.rb
@@ -42,6 +41,7 @@ files:
 - spec/array_keys_spec.rb
 - spec/connection_pool_spec.rb
 - spec/core_ext_spec.rb
+- spec/core_sql_spec.rb
 - spec/database_spec.rb
 - spec/dataset_spec.rb
 - spec/migration_spec.rb
@@ -57,6 +57,7 @@ files:
 - lib/sequel/array_keys.rb
 - lib/sequel/connection_pool.rb
 - lib/sequel/core_ext.rb
+- lib/sequel/core_sql.rb
 - lib/sequel/database.rb
 - lib/sequel/dataset
 - lib/sequel/dataset/convenience.rb