sequel_core 1.0.3 → 1.0.4

data/CHANGELOG

@@ -1,3 +1,21 @@
+=== 1.0.4 (2008-01-24)
+
+* Added Dataset#select_all method.
+
+* Changed ODBC::Database to support connection using driver and database name, also added support for untitled columns in ODBC::Dataset (thanks Leonid Borisenko).
+
+* Fixed MySQL adapter to correctly format foreign key definitions (#123).
+
+* Changed MySQL::Dataset to allow HAVING clause on ungrouped datasets, and put HAVING clause before ORDER BY clause (#133).
+
+* Changed Dataset#group_and_count to accept multiple columns (#134).
+
+* Fixed database spec to open YAML file in binary mode (#131).
+
+* Cleaned up gem spec (#132).
+
+* Added Dataset#table_exists? convenience method.
+
 === 1.0.3 (2008-01-17)
 
 * Added support for UNSIGNED constraint, used in MySQL? (#127).

data/Rakefile

@@ -9,7 +9,7 @@ include FileUtils
 # Configuration
 ##############################################################################
 NAME = "sequel_core"
-VERS = "1.0.3"
+VERS = "1.0.4"
 CLEAN.include ["**/.*.sw?", "pkg/*", ".config", "doc/*", "coverage/*"]
 RDOC_OPTS = [
   "--quiet", 
@@ -61,11 +61,6 @@ spec = Gem::Specification.new do |s|
   s.add_dependency("assistance", ">= 0.1")
 
   case RUBY_PLATFORM
-  when /mswin/
-    s.platform = Gem::Platform::CURRENT
-    s.add_dependency("RubyInline", ">= 3.6.6")
-    s.add_dependency("ParseTree", ">= 2.1.1")
-    s.add_dependency("ruby2ruby")
   when /java/
     s.platform = "jruby"
   else
@@ -162,6 +157,11 @@ Spec::Rake::SpecTask.new("rcov") do |t|
   t.rcov = true
 end
 
+desc "check documentation coverage"
+task :dcov do
+  sh "find lib -name '*.rb' | xargs dcov"
+end
+
 ##############################################################################
 # Statistics
 ##############################################################################

data/lib/sequel_core/adapters/mysql.rb

@@ -41,7 +41,7 @@ class Mysql::Result
       @column_types = []
       @columns = fetch_fields.map do |f|
         @column_types << f.type
-        (with_table ? (f.table + "." + f.name) : f.name).to_sym
+        (with_table ? "#{f.table}.#{f.name}" : f.name).to_sym
       end
     end
     @columns
@@ -162,6 +162,28 @@ module Sequel
           super(table, op)
         end
       end
+      
+      def column_definition_sql(column)
+        if column[:type] == :check
+          return constraint_definition_sql(column)
+        end
+        sql = "#{literal(column[:name].to_sym)} #{TYPES[column[:type]]}"
+        column[:size] ||= 255 if column[:type] == :varchar
+        elements = column[:size] || column[:elements]
+        sql << "(#{literal(elements)})" if elements
+        sql << UNIQUE if column[:unique]
+        sql << NOT_NULL if column[:null] == false
+        sql << UNSIGNED if column[:unsigned]
+        sql << " DEFAULT #{literal(column[:default])}" if column.include?(:default)
+        sql << PRIMARY_KEY if column[:primary_key]
+        sql << " #{auto_increment_sql}" if column[:auto_increment]
+        if column[:table]
+          sql << ", FOREIGN KEY (#{literal(column[:name].to_sym)}) REFERENCES #{column[:table]}"
+          sql << "(#{literal(column[:key])})" if column[:key]
+          sql << " ON DELETE #{on_delete_clause(column[:on_delete])}" if column[:on_delete]
+        end
+        sql
+      end
 
       def transaction
         @pool.hold do |conn|
@@ -217,6 +239,76 @@ module Sequel
         end
       end
 
+      # MySQL expects the having clause before the order by clause.
+      def select_sql(opts = nil)
+        opts = opts ? @opts.merge(opts) : @opts
+        
+        if sql = opts[:sql]
+          return sql
+        end
+
+        columns = opts[:select]
+        select_columns = columns ? column_list(columns) : WILDCARD
+
+        if distinct = opts[:distinct]
+          distinct_clause = distinct.empty? ? "DISTINCT" : "DISTINCT ON (#{column_list(distinct)})"
+          sql = "SELECT #{distinct_clause} #{select_columns}"
+        else
+          sql = "SELECT #{select_columns}"
+        end
+        
+        if opts[:from]
+          sql << " FROM #{source_list(opts[:from])}"
+        end
+        
+        if join = opts[:join]
+          sql << join
+        end
+
+        if where = opts[:where]
+          sql << " WHERE #{where}"
+        end
+
+        if group = opts[:group]
+          sql << " GROUP BY #{column_list(group)}"
+        end
+
+        if having = opts[:having]
+          sql << " HAVING #{having}"
+        end
+
+        if order = opts[:order]
+          sql << " ORDER BY #{column_list(order)}"
+        end
+
+        if limit = opts[:limit]
+          sql << " LIMIT #{limit}"
+          if offset = opts[:offset]
+            sql << " OFFSET #{offset}"
+          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_method :sql, :select_sql
+
+      # MySQL allows HAVING clause on ungrouped datasets.
+      def having(*cond, &block)
+        @opts[:having] = {}
+        filter(*cond, &block)
+      end
+
       # MySQL supports ORDER and LIMIT clauses in UPDATE statements.
       def update_sql(values, opts = nil)
         sql = super

data/lib/sequel_core/adapters/odbc.rb

@@ -5,12 +5,34 @@ module Sequel
     class Database < Sequel::Database
       set_adapter_scheme :odbc
     
+      # def connect
+      #   conn = ::ODBC::connect(@opts[:database], @opts[:user], @opts[:password])
+      #   conn.autocommit = true
+      #   conn
+      # end
+
+      GUARDED_DRV_NAME = /^\{.+\}$/.freeze
+      DRV_NAME_GUARDS = '{%s}'.freeze
+
       def connect
-        conn = ::ODBC::connect(@opts[:database], @opts[:user], @opts[:password])
+        if @opts.include? :driver
+          drv = ::ODBC::Driver.new
+          drv.name = 'Sequel ODBC Driver130'
+          @opts.each do |param, value|
+            if :driver == param and not (value =~ GUARDED_DRV_NAME)
+              value = DRV_NAME_GUARDS % value
+            end
+            drv.attrs[param.to_s.capitalize] = value
+          end
+          db = ::ODBC::Database.new
+          conn = db.drvconnect(drv)
+        else
+          conn = ::ODBC::connect(@opts[:database], @opts[:user], @opts[:password])
+        end
         conn.autocommit = true
         conn
-      end
-      
+      end      
+
       def disconnect
         @pool.disconnect {|c| c.disconnect}
       end
@@ -49,19 +71,41 @@ module Sequel
         end
       end
 
+      UNTITLED_COLUMN = 'untitled_%d'.freeze
+
       def fetch_rows(sql, &block)
         @db.synchronize do
           s = @db.execute sql
           begin
-            @columns = s.columns(true).map {|c| c.name.to_sym}
+            untitled_count = 0
+            @columns = s.columns(true).map do |c|
+              if (n = c.name).empty?
+                n = UNTITLED_COLUMN % (untitled_count += 1)
+              end
+              n.to_sym
+            end
             rows = s.fetch_all
-            rows.each {|row| yield hash_row(row)}
+            rows.each {|row| yield hash_row(row)} if rows
           ensure
             s.drop unless s.nil? rescue nil
           end
         end
         self
       end
+    
+      # def fetch_rows(sql, &block)
+      #   @db.synchronize do
+      #     s = @db.execute sql
+      #     begin
+      #       @columns = s.columns(true).map {|c| c.name.to_sym}
+      #       rows = s.fetch_all
+      #       rows.each {|row| yield hash_row(row)}
+      #     ensure
+      #       s.drop unless s.nil? rescue nil
+      #     end
+      #   end
+      #   self
+      # end
       
       def hash_row(row)
         hash = {}

data/lib/sequel_core/core_ext.rb

@@ -22,3 +22,4 @@ class Object
     nil
   end
 end
+

data/lib/sequel_core/database.rb

@@ -277,7 +277,8 @@ module Sequel
       if respond_to?(:tables)
         tables.include?(name.to_sym)
       else
-        from(name).first && true
+        from(name).first
+        true
       end
     rescue
       false

data/lib/sequel_core/dataset/convenience.rb

@@ -176,9 +176,11 @@ module Sequel
         single_value(:select => [column.AVG.AS(:v)])
       end
       
+      COUNT_OF_ALL_AS_COUNT = :count['*'.lit].AS(:count)
+      
       # Returns a dataset grouped by the given column with count by group.
-      def group_and_count(column)
-        group(column).select(column, :count[column].AS(:count)).order(:count)
+      def group_and_count(*columns)
+        group(*columns).select(columns + [COUNT_OF_ALL_AS_COUNT]).order(:count)
       end
       
       # Returns a Range object made from the minimum and maximum values for the
@@ -316,6 +318,23 @@ module Sequel
       def create_or_replace_view(name)
         @db.create_or_replace_view(name, self)
       end
+      
+      def table_exists?
+        if @opts[:sql]
+          raise Sequel::Error, "this dataset has fixed SQL"
+        end
+        
+        if @opts[:from].size != 1
+          raise Sequel::Error, "this dataset selects from multiple sources"
+        end
+        
+        t = @opts[:from].first
+        if t.is_a?(Dataset)
+          raise Sequel::Error, "this dataset selects from a sub query"
+        end
+        
+        @db.table_exists?(t.to_sym)
+      end
     end
   end
 end

data/lib/sequel_core/dataset/sql.rb

@@ -156,6 +156,11 @@ module Sequel
       def select(*columns)
         clone_merge(:select => columns)
       end
+      
+      # Returns a copy of the dataset selecting the wildcard.
+      def select_all
+        clone_merge(:select => nil)
+      end
 
       # Returns a copy of the dataset with the distinct option.
       def uniq(*args)

data/lib/sequel_core/schema/schema_sql.rb

@@ -62,12 +62,12 @@ module Sequel
         sql << UNSIGNED if column[:unsigned]
         sql << " DEFAULT #{literal(column[:default])}" if column.include?(:default)
         sql << PRIMARY_KEY if column[:primary_key]
+        sql << " #{auto_increment_sql}" if column[:auto_increment]
         if column[:table]
           sql << " REFERENCES #{column[:table]}"
           sql << "(#{column[:key]})" if column[:key]
+          sql << " ON DELETE #{on_delete_clause(column[:on_delete])}" if column[:on_delete]
         end
-        sql << " ON DELETE #{on_delete_clause(column[:on_delete])}" if column[:on_delete]
-        sql << " #{auto_increment_sql}" if column[:auto_increment]
         sql
       end
       

data/spec/adapters/mysql_spec.rb

@@ -267,12 +267,25 @@ end
 context "Joiמed MySQL dataset" do
   setup do
     @ds = MYSQL_DB[:nodes].join(:attributes, :node_id => :id)
+    @ds2 = MYSQL_DB[:nodes]
   end
   
   specify "should quote fields correctly" do
     @ds.sql.should == \
       "SELECT * FROM nodes INNER JOIN attributes ON (attributes.`node_id` = nodes.`id`)"
   end
+  
+  specify "should allow a having clause on ungrouped datasets" do
+    proc {@ds2.having('blah')}.should_not raise_error
+
+    @ds2.having('blah').sql.should == \
+      "SELECT * FROM nodes HAVING blah"
+  end
+  
+  specify "should put a having clause before an order by clause" do
+    @ds2.order(:aaa).having(:bbb => :ccc).sql.should == \
+      "SELECT * FROM nodes HAVING (`bbb` = `ccc`) ORDER BY `aaa`"
+  end
 end
 
 context "A MySQL database" do
@@ -339,6 +352,16 @@ context "A MySQL database" do
       "CREATE TABLE items (`active1` boolean DEFAULT 1, `active2` boolean DEFAULT 0)"
     ]
   end
+  
+  specify "should correctly format CREATE TABLE statements with foreign keys" do
+    g = Sequel::Schema::Generator.new(@db) do
+      foreign_key :p_id, :table => :users, :key => :id, 
+        :null => false, :on_delete => :cascade
+    end
+    @db.create_table_sql_list(:items, *g.create_info).should == [
+      "CREATE TABLE items (`p_id` integer NOT NULL, FOREIGN KEY (`p_id`) REFERENCES users(`id`) ON DELETE CASCADE)"
+    ]
+  end
 end  
 
 context "A MySQL database" do

data/spec/database_spec.rb

@@ -400,7 +400,6 @@ context "Database#table_exists?" do
     @db = DummyDatabase.new
     @db.stub!(:tables).and_return([:a, :b])
     @db2 = DummyDatabase.new
-    Sequel::Dataset.stub!(:first).and_return(nil)
   end
   
   specify "should use Database#tables if available" do
@@ -415,7 +414,6 @@ context "Database#table_exists?" do
   end
 end
 
-
 class Dummy3Database < Sequel::Database
   attr_reader :sql, :transactions
   def execute(sql); @sql ||= []; @sql << sql; end
@@ -820,7 +818,7 @@ context "Database.connect" do
     end
     
     @fn = File.join(File.dirname(__FILE__), 'eee.yaml')
-    File.open(@fn, 'w') {|f| f << EEE_YAML}
+    File.open(@fn, 'wb') {|f| f << EEE_YAML}
   end
   
   teardown do

data/spec/dataset_spec.rb

@@ -364,6 +364,11 @@ context "Dataset#where" do
     proc {@dataset.filter(:a == 1)}.should raise_error(Sequel::Error::InvalidFilter)
     proc {@dataset.filter(:a != 1)}.should raise_error(Sequel::Error::InvalidFilter)
   end
+
+  specify "should work for grouped datasets" do
+    @dataset.group(:a).filter(:b => 1).sql.should ==
+      'SELECT * FROM test WHERE (b = 1) GROUP BY a'
+  end
 end
 
 context "Dataset#or" do
@@ -684,8 +689,8 @@ context "Dataset#select" do
   end
 
   specify "should overrun the previous select option" do
-    @d.select(:a, :b, :c).select.sql.should == 'SELECT * FROM test'
-    @d.select(:price).select(:name).sql.should == 'SELECT name FROM test'
+    @d.select!(:a, :b, :c).select.sql.should == 'SELECT * FROM test'
+    @d.select!(:price).select(:name).sql.should == 'SELECT name FROM test'
   end
   
   specify "should accept arbitrary objects and literalize them correctly" do
@@ -697,6 +702,21 @@ context "Dataset#select" do
   end
 end
 
+context "Dataset#select_all" do
+  setup do
+    @d = Sequel::Dataset.new(nil).from(:test)
+  end
+
+  specify "should select the wildcard" do
+    @d.select_all.sql.should == 'SELECT * FROM test'
+  end
+  
+  specify "should overrun the previous select option" do
+    @d.select!(:a, :b, :c).select_all.sql.should == 'SELECT * FROM test'
+  end
+end
+
+
 context "Dataset#order" do
   setup do
     @dataset = Sequel::Dataset.new(nil).from(:test)
@@ -953,9 +973,14 @@ context "Dataset#group_and_count" do
   end
   
   specify "should format SQL properly" do
-    @ds.group_and_count(:name).sql.should == "SELECT name, count(name) AS count FROM test GROUP BY name ORDER BY count"
+    @ds.group_and_count(:name).sql.should == "SELECT name, count(*) AS count FROM test GROUP BY name ORDER BY count"
+  end
+
+  specify "should accept multiple columns for grouping" do
+    @ds.group_and_count(:a, :b).sql.should == "SELECT a, b, count(*) AS count FROM test GROUP BY a, b ORDER BY count"
   end
 end
+
 context "Dataset#empty?" do
   specify "should return true if #count == 0" do
     @c = Class.new(Sequel::Dataset) do
@@ -2297,7 +2322,7 @@ context "Dataset magic methods" do
     proc {@ds.count_by_name}.should_not raise_error
     @ds.should respond_to(:count_by_name)
     @ds.count_by_name.should be_a_kind_of(@c)
-    @ds.count_by_name.sql.should == "SELECT name, count(name) AS count FROM items GROUP BY name ORDER BY count"
+    @ds.count_by_name.sql.should == "SELECT name, count(*) AS count FROM items GROUP BY name ORDER BY count"
   end
 
   specify "should support filter_by_xxx" do
@@ -2399,5 +2424,58 @@ context "Dataset#update_sql" do
   specify "should accept array subscript references" do
     @ds.update_sql((:day|1) => 'd').should == "UPDATE items SET day[1] = 'd'"
   end
+end
+
+class DummyMummyDataset < Sequel::Dataset
+  def first
+    raise if @opts[:from] == [:a]
+    true
+  end
+end
+
+class DummyMummyDatabase < Sequel::Database
+  attr_reader :sqls
+  
+  def execute(sql)
+    @sqls ||= []
+    @sqls << sql
+  end
+  
+  def transaction; yield; end
+
+  def dataset
+    DummyMummyDataset.new(self)
+  end
+end
+
+context "Dataset#table_exists?" do
+  setup do
+    @db = DummyMummyDatabase.new
+    @db.stub!(:tables).and_return([:a, :b])
+    @db2 = DummyMummyDatabase.new
+  end
+  
+  specify "should use Database#tables if available" do
+    @db[:a].table_exists?.should be_true
+    @db[:b].table_exists?.should be_true
+    @db[:c].table_exists?.should be_false
+  end
+  
+  specify "should otherwise try to select the first record from the table's dataset" do
+    @db2[:a].table_exists?.should be_false
+    @db2[:b].table_exists?.should be_true
+  end
+  
+  specify "should raise Sequel::Error if dataset references more than one table" do
+    proc {@db.from(:a, :b).table_exists?}.should raise_error(Sequel::Error)
+  end
+
+  specify "should raise Sequel::Error if dataset is from a subquery" do
+    proc {@db.from(@db[:a]).table_exists?}.should raise_error(Sequel::Error)
+  end
+
+  specify "should raise Sequel::Error if dataset has fixed sql" do
+    proc {@db['select * from blah'].table_exists?}.should raise_error(Sequel::Error)
+  end
+end
 
-end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sequel_core
 version: !ruby/object:Gem::Version 
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors: 
 - Sharon Rosner
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-01-17 00:00:00 +02:00
+date: 2008-01-24 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency