sequel_core 1.0.8.2 → 1.0.9.1

data/CHANGELOG

@@ -1,3 +1,21 @@
+=== SVN
+
+* Changed Dataset#all to accept opts and iteration block.
+
+=== 1.0.9 (2008-02-10)
+
+* Implemented Dataset#inspect and Database#inspect (#151).
+
+* Added full-text searching for odbc_mssql adapter (thanks Joseph Love).
+
+* Added AlterTableGenerator#add_full_text_index method.
+
+* Implemented full_text indexing and searching for PostgreSQL adapter (thanks David Lee).
+
+* Implemented full_text indexing and searching for MySQL adapter (thanks David Lee).
+
+* Fixed Dataset#insert_sql to work with array subscript references (thanks Jim Morris).
+
 === 1.0.8 (2008-02-08)
 
 * Added support for multiple choices in string matching expressions (#147).

data/Rakefile

@@ -9,7 +9,7 @@ include FileUtils
 # Configuration
 ##############################################################################
 NAME = "sequel_core"
-VERS = "1.0.8.2"
+VERS = "1.0.9.1"
 CLEAN.include ["**/.*.sw?", "pkg/*", ".config", "doc/*", "coverage/*"]
 RDOC_OPTS = [
   "--quiet", 

data/lib/sequel_core/adapters/mysql.rb

@@ -173,6 +173,17 @@ module Sequel
         sql
       end
 
+      def index_definition_sql(table_name, index)
+        index_name = index[:name] || default_index_name(table_name, index[:columns])
+        if index[:full_text]
+          "CREATE FULLTEXT INDEX #{index_name} ON #{table_name} (#{literal(index[:columns])})"
+        elsif index[:unique]
+          "CREATE UNIQUE INDEX #{index_name} ON #{table_name} (#{literal(index[:columns])})"
+        else
+          "CREATE INDEX #{index_name} ON #{table_name} (#{literal(index[:columns])})"
+        end
+      end
+    
       def transaction
         @pool.hold do |conn|
           @transactions ||= []
@@ -290,6 +301,11 @@ module Sequel
         sql
       end
       alias_method :sql, :select_sql
+      
+      def full_text_search(cols, terms, opts = {})
+        mode = opts[:boolean] ? " IN BOOLEAN MODE" : ""
+        filter("MATCH (#{literal(cols)}) AGAINST (#{literal(terms)}#{mode})")
+      end
 
       # MySQL allows HAVING clause on ungrouped datasets.
       def having(*cond, &block)

data/lib/sequel_core/adapters/odbc_mssql.rb

@@ -87,6 +87,10 @@ module Sequel
           sql
         end
         alias_method :sql, :select_sql
+        
+        def full_text_search(cols, terms, opts = {})
+          filter("CONTAINS (#{literal(cols)}, #{literal(terms)})")
+        end
       end
     end
   end

data/lib/sequel_core/adapters/postgres.rb

@@ -311,6 +311,20 @@ module Sequel
         {:primary_key => true, :type => :serial}
       end
 
+      def index_definition_sql(table_name, index)
+        index_name = index[:name] || default_index_name(table_name, index[:columns])
+        if index[:full_text]
+          lang = index[:language] ? "#{literal(index[:language])}, " : ""
+          cols = index[:columns].map {|c| literal(c)}.join(" || ")
+          expr = "gin(to_tsvector(#{lang}#{cols}))"
+          "CREATE INDEX #{index_name} ON #{table_name} USING #{expr}"
+        elsif index[:unique]
+          "CREATE UNIQUE INDEX #{index_name} ON #{table_name} (#{literal(index[:columns])})"
+        else
+          "CREATE INDEX #{index_name} ON #{table_name} (#{literal(index[:columns])})"
+        end
+      end
+    
       def drop_table_sql(name)
         "DROP TABLE #{name} CASCADE"
       end
@@ -341,6 +355,13 @@ module Sequel
         end
       end
       
+      def full_text_search(cols, terms, opts = {})
+        lang = opts[:language] ? "#{literal(opts[:language])}, " : ""
+        cols = cols.is_a?(Array) ? cols.map {|c| literal(c)}.join(" || ") : literal(cols)
+        terms = terms.is_a?(Array) ? literal(terms.join(" | ")) : literal(terms)
+        filter("to_tsvector(#{lang}#{cols}) @@ to_tsquery(#{lang}#{terms})")
+      end
+
       FOR_UPDATE = ' FOR UPDATE'.freeze
       FOR_SHARE = ' FOR SHARE'.freeze
     

data/lib/sequel_core/database.rb

@@ -337,6 +337,12 @@ module Sequel
         end
       end
     end
+    
+    # Returns a string representation of the database object including the
+    # class name and the connection URI.
+    def inspect
+      '#<%s: %s>' % [self.class.to_s, uri.inspect]
+    end
 
     @@adapters = Hash.new
     

data/lib/sequel_core/dataset.rb

@@ -72,8 +72,16 @@ module Sequel
     attr_reader :db
     attr_accessor :opts
     
-    alias_method :all, :to_a
     alias_method :size, :count
+    
+    # Returns an array with all records in the dataset. If a block is given,
+    # the array is iterated over.
+    def all(opts = nil, &block)
+      a = []
+      each(opts) {|r| a << r}
+      a.each(&block) if block
+      a
+    end
   
     # Constructs a new instance of a dataset with a database instance, initial
     # options and an optional record class. Datasets are usually constructed by
@@ -421,6 +429,12 @@ module Sequel
     def self.inherited(c) #:nodoc:
       @@dataset_classes << c
     end
+    
+    # Returns a string representation of the dataset including the class name 
+    # and the corresponding SQL select statement.
+    def inspect
+      '#<%s: %s>' % [self.class.to_s, sql.inspect]
+    end
   end
 end
 

data/lib/sequel_core/dataset/sql.rb

@@ -496,7 +496,7 @@ module Sequel
             if values.empty?
               "INSERT INTO #{@opts[:from]} DEFAULT VALUES"
             elsif values.keys
-              fl = values.keys.map {|f| literal(f.to_sym)}
+              fl = values.keys.map {|f| literal(f.is_a?(String) ? f.to_sym : f)}
               vl = @transform ? transform_save(values.values) : values.values
               vl.map! {|v| literal(v)}
               "INSERT INTO #{@opts[:from]} (#{fl.join(COMMA_SEPARATOR)}) VALUES (#{vl.join(COMMA_SEPARATOR)})"
@@ -509,7 +509,7 @@ module Sequel
               "INSERT INTO #{@opts[:from]} DEFAULT VALUES"
             else
               fl, vl = [], []
-              values.each {|k, v| fl << literal(k.to_sym); vl << literal(v)}
+              values.each {|k, v| fl << literal(k.is_a?(String) ? k.to_sym : k); vl << literal(v)}
               "INSERT INTO #{@opts[:from]} (#{fl.join(COMMA_SEPARATOR)}) VALUES (#{vl.join(COMMA_SEPARATOR)})"
             end
           when Dataset

data/lib/sequel_core/schema/schema_generator.rb

@@ -58,6 +58,11 @@ module Sequel
         @indexes << {:columns => columns}.merge(opts)
       end
       
+      def full_text_index(columns, opts = {})
+        columns = [columns] unless columns.is_a?(Array)
+        @indexes << {:columns => columns, :full_text => true}.merge(opts)
+      end
+      
       def unique(columns, opts = {})
         index(columns, {:unique => true}.merge(opts))
       end
@@ -126,6 +131,15 @@ module Sequel
         }.merge(opts)
       end
       
+      def add_full_text_index(columns, opts = {})
+        columns = [columns] unless columns.is_a?(Array)
+        @operations << { \
+          :op => :add_index, \
+          :columns => columns, \
+          :full_text => true \
+        }.merge(opts)
+      end
+      
       def drop_index(columns)
         columns = [columns] unless columns.is_a?(Array)
         @operations << { \

data/lib/sequel_core/schema/schema_sql.rb

@@ -90,7 +90,9 @@ module Sequel
     
       def index_definition_sql(table_name, index)
         index_name = index[:name] || default_index_name(table_name, index[:columns])
-        if index[:unique]
+        if index[:full_text]
+          raise Error, "Full-text indexes are not supported for this database"
+        elsif index[:unique]
           "CREATE UNIQUE INDEX #{index_name} ON #{table_name} (#{literal(index[:columns])})"
         else
           "CREATE INDEX #{index_name} ON #{table_name} (#{literal(index[:columns])})"

data/spec/adapters/mysql_spec.rb

@@ -413,3 +413,31 @@ context "A grouped MySQL dataset" do
     ds.count.should == 1
   end
 end
+
+context "A MySQL database" do
+  setup do
+  end
+  
+  specify "should support fulltext indexes" do
+    g = Sequel::Schema::Generator.new(MYSQL_DB) do
+      text :title
+      text :body
+      full_text_index [:title, :body]
+    end
+    MYSQL_DB.create_table_sql_list(:posts, *g.create_info).should == [
+      "CREATE TABLE posts (`title` text, `body` text)",
+      "CREATE FULLTEXT INDEX posts_title_body_index ON posts (`title`, `body`)"
+    ]
+  end
+  
+  specify "should support full_text_search" do
+    MYSQL_DB[:posts].full_text_search(:title, 'ruby').sql.should ==
+      "SELECT * FROM posts WHERE (MATCH (`title`) AGAINST ('ruby'))"
+    
+    MYSQL_DB[:posts].full_text_search([:title, :body], ['ruby', 'sequel']).sql.should ==
+      "SELECT * FROM posts WHERE (MATCH (`title`, `body`) AGAINST ('ruby', 'sequel'))"
+      
+    MYSQL_DB[:posts].full_text_search(:title, '+ruby -rails', :boolean => true).sql.should ==
+      "SELECT * FROM posts WHERE (MATCH (`title`) AGAINST ('+ruby -rails' IN BOOLEAN MODE))"
+  end
+end

data/spec/adapters/postgres_spec.rb

@@ -245,3 +245,43 @@ context "A PostgreSQL database" do
     @db[:test2].first[:xyz].should == 57
   end
 end  
+
+context "A PostgreSSQL database" do
+  setup do
+  end
+  
+  specify "should support fulltext indexes" do
+    g = Sequel::Schema::Generator.new(PGSQL_DB) do
+      text :title
+      text :body
+      full_text_index [:title, :body]
+    end
+    PGSQL_DB.create_table_sql_list(:posts, *g.create_info).should == [
+      "CREATE TABLE posts (\"title\" text, \"body\" text)",
+      "CREATE INDEX posts_title_body_index ON posts USING gin(to_tsvector(\"title\" || \"body\"))"
+    ]
+  end
+  
+  specify "should support fulltext indexes with a specific language" do
+    g = Sequel::Schema::Generator.new(PGSQL_DB) do
+      text :title
+      text :body
+      full_text_index [:title, :body], :language => 'french'
+    end
+    PGSQL_DB.create_table_sql_list(:posts, *g.create_info).should == [
+      "CREATE TABLE posts (\"title\" text, \"body\" text)",
+      "CREATE INDEX posts_title_body_index ON posts USING gin(to_tsvector('french', \"title\" || \"body\"))"
+    ]
+  end
+  
+  specify "should support full_text_search" do
+    PGSQL_DB[:posts].full_text_search(:title, 'ruby').sql.should ==
+      "SELECT * FROM posts WHERE (to_tsvector(\"title\") @@ to_tsquery('ruby'))"
+    
+    PGSQL_DB[:posts].full_text_search([:title, :body], ['ruby', 'sequel']).sql.should ==
+      "SELECT * FROM posts WHERE (to_tsvector(\"title\" || \"body\") @@ to_tsquery('ruby | sequel'))"
+      
+    PGSQL_DB[:posts].full_text_search(:title, 'ruby', :language => 'french').sql.should ==
+      "SELECT * FROM posts WHERE (to_tsvector('french', \"title\") @@ to_tsquery('french', 'ruby'))"
+  end
+end

data/spec/database_spec.rb

@@ -835,3 +835,15 @@ context "Database.connect" do
     db.opts[:host].should == 'alfonso'
   end
 end
+
+context "Database#inspect" do
+  setup do
+    @db = DummyDatabase.new
+    
+    @db.meta_def(:uri) {'blah://blahblah/blah'}
+  end
+  
+  specify "should include the class name and the connection url" do
+    @db.inspect.should == '#<DummyDatabase: "blah://blahblah/blah">'
+  end
+end

data/spec/dataset_spec.rb

@@ -18,21 +18,21 @@ context "Dataset" do
     d.opts.should == {}
   end
   
-  specify "should provide clone for chainability." do
-    d1 = @dataset.clone(:from => :test)
+  specify "should provide clone for chainability" do
+    d1 = @dataset.clone(:from => [:test])
     d1.class.should == @dataset.class
     d1.should_not == @dataset
     d1.db.should be(@dataset.db)
-    d1.opts[:from].should == :test
+    d1.opts[:from].should == [:test]
     @dataset.opts[:from].should be_nil
     
-    d2 = d1.clone(:order => :name)
+    d2 = d1.clone(:order => [:name])
     d2.class.should == @dataset.class
     d2.should_not == d1
     d2.should_not == @dataset
     d2.db.should be(@dataset.db)
-    d2.opts[:from].should == :test
-    d2.opts[:order].should == :name
+    d2.opts[:from].should == [:test]
+    d2.opts[:order].should == [:name]
     d1.opts[:order].should be_nil
   end
   
@@ -2539,6 +2539,24 @@ context "Dataset#update_sql" do
   end
 end
 
+context "Dataset#insert_sql" do
+  setup do
+    @ds = Sequel::Dataset.new(nil).from(:items)
+  end
+  
+  specify "should accept hash with symbol keys" do
+    @ds.insert_sql(:c => 'd').should == "INSERT INTO items (c) VALUES ('d')"
+  end
+
+  specify "should accept hash with string keys" do
+    @ds.insert_sql('c' => 'd').should == "INSERT INTO items (c) VALUES ('d')"
+  end
+
+  specify "should accept array subscript references" do
+    @ds.insert_sql((:day|1) => 'd').should == "INSERT INTO items (day[1]) VALUES ('d')"
+  end
+end
+
 class DummyMummyDataset < Sequel::Dataset
   def first
     raise if @opts[:from] == [:a]
@@ -2592,3 +2610,51 @@ context "Dataset#table_exists?" do
   end
 end
 
+context "Dataset#inspect" do
+  setup do
+    @ds = Sequel::Dataset.new(nil).from(:blah)
+  end
+  
+  specify "should include the class name and the corresponding SQL statement" do
+    @ds.inspect.should == '#<%s: %s>' % [@ds.class.to_s, @ds.sql.inspect]
+  end
+end
+
+context "Dataset#all" do
+  setup do
+    @c = Class.new(Sequel::Dataset) do
+      def fetch_rows(sql, &block)
+        block.call({:x => 1, :y => 2})
+        block.call({:x => 3, :y => 4})
+        block.call(sql)
+      end
+    end
+    @dataset = @c.new(nil).from(:items)
+  end
+
+  specify "should return an array with all records" do
+    @dataset.all.should == [
+      {:x => 1, :y => 2},
+      {:x => 3, :y => 4},
+      "SELECT * FROM items"
+    ]
+  end
+  
+  specify "should accept options and pass them to #each" do
+    @dataset.all(:limit => 33).should == [
+      {:x => 1, :y => 2},
+      {:x => 3, :y => 4},
+      "SELECT * FROM items LIMIT 33"
+    ]
+  end
+
+  specify "should iterate over the array if a block is given" do
+    a = []
+    
+    @dataset.all do |r|
+      a << (r.is_a?(Hash) ? r[:x] : r)
+    end
+    
+    a.should == [1, 3, "SELECT * FROM items"]
+  end
+end

data/spec/schema_generator_spec.rb

@@ -81,6 +81,7 @@ describe Sequel::Schema::AlterTableGenerator do
       set_column_default :eee, 1
       add_index [:fff, :ggg]
       drop_index :hhh
+      add_full_text_index :blah
     end
   end
   
@@ -92,7 +93,8 @@ describe Sequel::Schema::AlterTableGenerator do
       {:op => :set_column_type, :name => :ddd, :type => :float},
       {:op => :set_column_default, :name => :eee, :default => 1},
       {:op => :add_index, :columns => [:fff, :ggg]},
-      {:op => :drop_index, :columns => [:hhh]}
+      {:op => :drop_index, :columns => [:hhh]},
+      {:op => :add_index, :columns => [:blah], :full_text => true}
     ]
   end
 end

data/spec/schema_spec.rb

@@ -180,6 +180,15 @@ context "DB#create_table" do
     @db.sqls.should == ["CREATE TABLE cats (name text)", "CREATE UNIQUE INDEX cats_name_index ON cats (name)"]
   end
 
+  specify "should raise on full-text index definitions" do
+    proc {
+      @db.create_table(:cats) do
+        text :name
+        full_text_index :name
+      end
+    }.should raise_error(Sequel::Error)
+  end
+
   specify "should accept multiple index definitions" do
     @db.create_table(:cats) do
       integer :id

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sequel_core
 version: !ruby/object:Gem::Version 
-  version: 1.0.8.2
+  version: 1.0.9.1
 platform: ruby
 authors: 
 - Sharon Rosner
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-02-09 00:00:00 +02:00
+date: 2008-02-11 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency