sequel_core 1.4.0 → 1.5.0

data/CHANGELOG

@@ -1,3 +1,77 @@
+=== HEAD
+
+* Set a timeout in the Sqlite adapter, default to 5 seconds (hrvoje.marjanovic) (#218)
+
+* Document that calling Sequel::ODBC::Database#execute manually requires you to manually drop the returned object (jeremyevans) (#217)
+
+* Paginating an already paginated/limited dataset now raises an error (jeremyevans)
+
+* Add support for PostgreSQL partial indexes (dlee)
+
+* Added support for arbitrary index types (including spatial indexes) (dlee)
+
+* Quote column names in SQL generated for SQLite (tmm1)
+
+* Deprecate Object#rollback! (jeremyevans)
+
+* Make some Dataset methods private (qualified_column_name, column_list, table_ref, source_list) (jeremyevans)
+
+* Deprecate Dataset methods #set_options, #set_row_proc, #remove_row_proc, and #clone_merge (jeremyevans)
+
+* Add Symbol#*, a replacement for Symbol#all (jeremyevans)
+
+* Deprecate including ColumnMethods in Object, include it in Symbol, String, and Sequel::SQL::Expression (jeremyevans)
+
+* Deprecate Symbol#method_missing, and #AS, #DESC, #ASC, #ALL, and #all from ColumnMethods (jeremyevans)
+
+* Fix table joining in MySQL (jeremyevans)
+
+* Deprecate Sequel.method_missing and Object#Sequel, add real Sequel.adapter methods (jeremyevans)
+
+* Move dataset methods applicable only to paginated datasets into Sequel::Dataset::Pagination (jeremyevans)
+
+* Make Sequel::Dataset::Sequelizer methods private (jeremyevans)
+
+* Deprecate Dataset#method_missing, add real mutation methods (e.g. filter!) (jeremyevans)
+
+* Fix connecting to an MSSQL server via ODBC using domain user credentials (jeremyevans) (#216)
+
+* No longer depend on the assistance gem, merge in the ConnectionPool and .blank methods (jeremyevans)
+
+* No longer depend on ParseTree, RubyInline, or ruby2ruby, but you still need them if you want to use the block filters (jeremyevans)
+
+* Fix JDBC adapter by issuing index things start at 1 (pdamer)
+
+* Fix connecting to a database via the ADO adapter (now requires options instead of URI) (timuckun, jeremyevans) (#204)
+
+* Support storing microseconds in postgres timestamp fields (schnarch...@rootimage.msu.edu) (#215)
+
+* Allow joining of multiple datasets, by making the table alias different for each dataset joined (jeremyevans)
+
+* SECURITY: Fix backslash escaping of strings (dlee)
+
+* Add ability to create a graph of objects from a query, with the result split into corresponding tables (jeremyevans) (#113)
+
+* Add attr_accessor for dataset row_proc (jeremyevans)
+
+* Don't redefine Dataset#each when adding a transform or row_proc (jeremyevans)
+
+* Remove array_keys.rb from sequel_core, it was partially broken (since the arrays came from hashes), and redefined Dataset#each (jeremyevans)
+
+* Fix MySQL default values insert (matt.binary) (#196)
+
+* Fix ODBC adapter improperly escaping date and timestamp values (leo.borisenko) (#165)
+
+* Fix renaming columns on MySQL with type :varchar (jeremyevans) (#206)
+
+* Add Sequel::SQL::Function#==, for comparing SQL Functions (jeremyevans) (#209)
+
+* Update Informix adapter to work with Ruby/Informix 0.7.0 (gerardo.santana@gmail.com)
+
+* Remove sequel_core's knowledge of Sequel::Model (jeremyevans)
+
+* Use "\n" instead of $/ (since $/ can be redefined in ways we do not want) (jeremyevans)
+
 === 1.4.0 (2008-04-08) 
 
 * Merge 3 mysql patches from the bugtracker (mvyver) (#200, #201, #202).

data/COPYING

@@ -1,4 +1,5 @@
 Copyright (c) 2007-2008 Sharon Rosner
+Copyright (c) 2008 Jeremy Evans
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to

data/README

@@ -158,19 +158,19 @@ The simplest way to filter records is to provide a hash of values to match:
   
 You can also specify ranges:
 
-  my_posts = posts.filter(:stamp => (2.weeks.ago)..(1.week.ago))
+  my_posts = posts.filter(:stamp => (Date.today - 14)..(Date.today - 7))
   
 Or lists of values:
 
   my_posts = posts.filter(:category => ['ruby', 'postgres', 'linux'])
   
-Sequel now also accepts expressions as closures, AKA block filters:
+If ParseTree is installed, Sequel also accepts expressions as closures, AKA block filters:
 
   my_posts = posts.filter {:category == ['ruby', 'postgres', 'linux']}
   
 Which also lets you do stuff like:
 
-  my_posts = posts.filter {:stamp > 1.month.ago}
+  my_posts = posts.filter {:stamp > Date.today << 1}
   
 Some adapters (like postgresql) will also let you specify Regexps:
 
@@ -186,7 +186,7 @@ You can then retrieve the records by using any of the retrieval methods:
   
 You can also specify a custom WHERE clause:
 
-  posts.filter('(stamp < ?) AND (author <> ?)', 3.days.ago, author_name)
+  posts.filter('(stamp < ?) AND (author <> ?)', Date.today - 3, author_name)
 
 Datasets can also be used as subqueries:
 
@@ -213,7 +213,7 @@ You can also specify descending order
 
 === Deleting Records
 
-  posts.filter('stamp < ?', 3.days.ago).delete
+  posts.filter('stamp < ?', Date.today - 3).delete
   
 === Inserting Records
 
@@ -225,7 +225,7 @@ Or alternatively:
   
 === Updating Records
 
-  posts.filter('stamp < ?', 3.days.ago).update(:state => 'archived')
+  posts.filter('stamp < ?', Date.today - 7).update(:state => 'archived')
 
 === Joining Tables
 
@@ -250,3 +250,14 @@ Which is equivalent to the SQL:
   ON order_items.item_id = items.id
   WHERE order_items.order_id = 1234
   
+=== Graphing Datasets
+
+When retrieving records from joined datasets, you get the results in a single hash, which is subject to clobbering:
+
+  DB[:items].join(:order_items, :item_id => :id).first
+  => {:id=>(could be items.id or order_items.id), :item_id=>order_items.order_id}
+
+Using graph, you can split the resulting dataset into separate hashes:
+
+  DB[:items].graph(:order_items, :item_id => :id).first
+  => {:items->{:id=>items.id}, :order_items=>{:id=>order_items.id, :item_id=>order_items.item_id}}

data/Rakefile

@@ -9,16 +9,9 @@ include FileUtils
 # Configuration
 ##############################################################################
 NAME = "sequel_core"
-VERS = "1.4.0"
+VERS = "1.5.0"
 CLEAN.include ["**/.*.sw?", "pkg/*", ".config", "doc/*", "coverage/*"]
-RDOC_OPTS = [
-  "--quiet", 
-  "--title", "Sequel: The Database Toolkit for Ruby",
-  "--opname", "index.html",
-  "--line-numbers", 
-  "--main", "README",
-  "--inline-source"
-]
+RDOC_OPTS = ["--quiet", "--line-numbers", "--inline-source"]
 
 ##############################################################################
 # RDoc
@@ -29,15 +22,14 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_dir = "doc/rdoc"
   rdoc.options += RDOC_OPTS
   rdoc.main = "README"
-  rdoc.title = "Sequel: The Database Toolkit for Ruby"
-  rdoc.rdoc_files.add ["README", "COPYING", "lib/sequel_core.rb", "lib/**/*.rb"]
+  rdoc.title = "Sequel: The Database Toolkit for Ruby: Core Library and Adapters"
+  rdoc.rdoc_files.add ["README", "COPYING", "lib/**/*.rb"]
 end
 
 ##############################################################################
 # Gem packaging
 ##############################################################################
 desc "Packages up Sequel."
-task :default => [:package]
 task :package => [:clean]
 
 spec = Gem::Specification.new do |s|
@@ -47,28 +39,22 @@ spec = Gem::Specification.new do |s|
   s.platform = Gem::Platform::RUBY
   s.has_rdoc = true
   s.extra_rdoc_files = ["README", "CHANGELOG", "COPYING"]
-  s.rdoc_options += RDOC_OPTS + 
-    ["--exclude", "^(examples|extras)\/", "--exclude", "lib/sequel_core.rb"]
+  s.rdoc_options += RDOC_OPTS + ["--exclude", "^(examples|extras)\/"]
   s.summary = "The Database Toolkit for Ruby: Core Library and Adapters"
   s.description = s.summary
-  s.author = "Aman Gupta"
-  s.email = "themastermind1@gmail.com"
+  s.author = "Jeremy Evans"
+  s.email = "code@jeremyevans.net"
   s.homepage = "http://sequel.rubyforge.org"
   s.executables = ["sequel"]
   s.required_ruby_version = ">= 1.8.4"
 
   s.add_dependency("metaid")
-  s.add_dependency("assistance", ">= 0.1")
 
   case RUBY_PLATFORM
   when /java/
     s.platform = "jruby"
   else
     s.platform = Gem::Platform::RUBY
-    # ParseTree on win32 requires PT2.1.1 and RI3.6.6
-    s.add_dependency("RubyInline", ">= 3.6.6")
-    s.add_dependency("ParseTree", ">= 2.1.1")
-    s.add_dependency("ruby2ruby")
   end
   
   s.files = %w(COPYING README Rakefile) + Dir.glob("{bin,doc,spec,lib}/**/*")
@@ -122,6 +108,7 @@ Spec::Rake::SpecTask.new("spec") do |t|
 end
 
 desc "Run specs without coverage"
+task :default => [:spec_no_cov]
 Spec::Rake::SpecTask.new("spec_no_cov") do |t|
   t.spec_files = FileList["spec/*_spec.rb"]
   t.spec_opts  = File.read("spec/spec.opts").split("\n")
@@ -133,6 +120,14 @@ Spec::Rake::SpecTask.new("spec_adapters") do |t|
   t.spec_opts  = File.read("spec/spec.opts").split("\n")
 end
 
+%w'postgres sqlite mysql informix oracle'.each do |adapter|
+  desc "Run #{adapter} specs without coverage"
+  Spec::Rake::SpecTask.new("spec_#{adapter}") do |t|
+    t.spec_files = "spec/adapters/#{adapter}_spec.rb"
+    t.spec_opts  = File.read("spec/spec.opts").split("\n")
+  end
+end
+
 desc "Run all specs with coverage"
 Spec::Rake::SpecTask.new("spec_all") do |t|
   t.spec_files = FileList["spec/*_spec.rb", "spec/adapters/*_spec.rb"]

data/lib/sequel_core.rb

@@ -1,18 +1,17 @@
-gem "assistance", ">= 0.1"
-
 require "metaid"
-require "assistance"
 require "bigdecimal"
 require "bigdecimal/util"
 
 files = %w[
-  core_ext core_sql array_keys exceptions pretty_table
-  dataset migration model schema database worker
+  deprecated core_ext core_sql connection_pool exceptions pretty_table
+  dataset migration schema database worker object_graph
 ]
 dir = File.join(File.dirname(__FILE__), "sequel_core")
 files.each {|f| require(File.join(dir, f))}
 
 module Sequel #:nodoc:
+  Deprecation.deprecation_message_stream = STDERR
+  #Deprecation.print_tracebacks = true
   class << self
     # call-seq:
     #   Sequel::Database.connect(conn_string)
@@ -31,32 +30,23 @@ module Sequel #:nodoc:
     def single_threaded=(value)
       Database.single_threaded = value
     end
-    
-    def method_missing(m, *args)
-      c = Database.adapter_class(m)
-      begin
-        # three ways to invoke this:
-        # 0 arguments: Sequel.dbi 
-        # 1 argument:  Sequel.dbi(db_name)
-        # more args:   Sequel.dbi(db_name, opts)
-        case args.size
-        when 0
-          opts = {}
-        when 1
-          opts = args[0].is_a?(Hash) ? args[0] : {:database => args[0]}
-        else
-          opts = args[1].merge(:database => args[0])
+
+    def self.def_adapter_method(*adapters)
+      adapters.each do |adapter|
+        define_method(adapter) do |*args|
+          raise(::Sequel::Error, "Wrong number of arguments, 0-2 arguments valid") if args.length > 2
+          opts = {:adapter=>adapter.to_sym}
+          opts[:database] = args.shift if args.length >= 1 && !(args[0].is_a?(Hash))
+          if Hash === (arg = args[0])
+            opts.merge!(arg)
+          elsif !arg.nil?
+            raise ::Sequel::Error, "Wrong format of arguments, either use (), (String), (Hash), or (String, Hash)"
+          end
+          ::Sequel::Database.connect(opts)
         end
-      rescue
-        raise Error::AdapterNotFound, "Unknown adapter (#{m})"
       end
-      c.new(opts)
     end
-  end
-end
 
-class Object
-  def Sequel(*args)
-    Sequel.connect(*args)
+    def_adapter_method(*Database::ADAPTERS)
   end
 end

data/lib/sequel_core/adapters/ado.rb

@@ -21,9 +21,9 @@ module Sequel
       end
       
       def connect
-        dbname = @opts[:database]
+        s = "driver=#{@opts[:driver] || 'SQL Server'};server=#{@opts[:host]};database=#{@opts[:database]}#{";uid=#{@opts[:user]};pwd=#{@opts[:password]}" if @opts[:user]}"
         handle = WIN32OLE.new('ADODB.Connection')
-        handle.Open(dbname)
+        handle.Open(s)
         handle
       end
       
@@ -72,18 +72,6 @@ module Sequel
         end
       end
     
-      def array_tuples_fetch_rows(sql, &block)
-        @db.synchronize do
-          s = @db.execute sql
-          
-          @columns = s.Fields.extend(Enumerable).map {|x| x.Name.to_sym}
-          
-          s.moveFirst
-          s.getRows.transpose.each {|r| r.keys = @columns; yield r}
-        end
-        self
-      end
-      
       def insert(*values)
         @db.do insert_sql(*values)
       end
@@ -97,4 +85,4 @@ module Sequel
       end
     end
   end
-end
+end

data/lib/sequel_core/adapters/dbi.rb

@@ -90,19 +90,6 @@ module Sequel
         self
       end
       
-      def array_tuples_fetch_rows(sql, &block)
-        @db.synchronize do
-          s = @db.execute sql
-          begin
-            @columns = s.column_names.map {|c| c.to_sym}
-            s.fetch {|r| r.keys = @columns; yield r}
-          ensure
-            s.finish rescue nil
-          end
-        end
-        self
-      end
-      
       def hash_row(stmt, row)
         @columns.inject({}) do |m, c|
           m[c] = row.shift
@@ -123,4 +110,4 @@ module Sequel
       end
     end
   end
-end
+end

data/lib/sequel_core/adapters/informix.rb

@@ -26,7 +26,7 @@ module Sequel
       # Returns number of rows affected
       def execute(sql)
         @logger.info(sql) if @logger
-        @pool.hold {|c| c.do(sql)}
+        @pool.hold {|c| c.immediate(sql)}
       end
       alias_method :do, :execute
       
@@ -62,7 +62,7 @@ module Sequel
         @db.synchronize do
           @db.query(sql) do |cursor|
             begin
-              cursor.open.each_hash {|r| block[r]}
+              cursor.open.each_hash(&block)
             ensure
               cursor.drop
             end
@@ -84,4 +84,4 @@ module Sequel
       end
     end
   end
-end
+end

data/lib/sequel_core/adapters/jdbc.rb

@@ -79,12 +79,12 @@ module Sequel
             meta = result.getMetaData
             column_count = meta.getColumnCount
             @columns = []
-            column_count.times {|i| @columns << meta.getColumnName(i).to_sym}
+            column_count.times {|i| @columns << meta.getColumnName(i+1).to_sym}
 
             # get rows
             while result.next
               row = {}
-              @columns.each_with_index {|v, i| row[v] = result.getObject(i)}
+              @columns.each_with_index {|v, i| row[v] = result.getObject(i+1)}
               yield row
             end
           end

data/lib/sequel_core/adapters/mysql.rb

@@ -154,11 +154,13 @@ module Sequel
       end
 
       def alter_table_sql(table, op)
+        type = type_literal(op[:type])
+        type << '(255)' if type == 'varchar'
         case op[:op]
         when :rename_column
-          "ALTER TABLE #{table} CHANGE COLUMN #{literal(op[:name])} #{literal(op[:new_name])} #{type_literal(op[:type])}"
+          "ALTER TABLE #{table} CHANGE COLUMN #{literal(op[:name])} #{literal(op[:new_name])} #{type}"
         when :set_column_type
-          "ALTER TABLE #{table} CHANGE COLUMN #{literal(op[:name])} #{literal(op[:name])} #{type_literal(op[:type])}"
+          "ALTER TABLE #{table} CHANGE COLUMN #{literal(op[:name])} #{literal(op[:name])} #{type}"
         when :drop_index
           "DROP INDEX #{default_index_name(table, op[:columns])} ON #{table}"
         else
@@ -191,12 +193,16 @@ module Sequel
 
       def index_definition_sql(table_name, index)
         index_name = index[:name] || default_index_name(table_name, index[:columns])
-        if index[:full_text]
+        unique = "UNIQUE " if index[:unique]
+        case index[:type]
+        when :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])})"
+        when :spatial
+          "CREATE SPATIAL INDEX #{index_name} ON #{table_name} (#{literal(index[:columns])})"
+        when nil
+          "CREATE #{unique}INDEX #{index_name} ON #{table_name} (#{literal(index[:columns])})"
         else
-          "CREATE INDEX #{index_name} ON #{table_name} (#{literal(index[:columns])})"
+          "CREATE #{unique}INDEX #{index_name} ON #{table_name} (#{literal(index[:columns])}) USING #{index[:type]}"
         end
       end
     
@@ -290,26 +296,22 @@ module Sequel
       #   @ds.join_expr(:natural_left_outer, :nodes)
       #   # 'NATURAL LEFT OUTER JOIN nodes'
       #
-      def join_expr(type, table, expr = nil)
-        join_type = JOIN_TYPES[type || :inner]
-        unless join_type
-          raise Error::InvalidJoinType, "Invalid join type: #{type}"
-        end
-        @opts[:server_version] = @db.server_version unless @opts[:server_version]
+      def join_expr(type, table, expr = nil, options = {})
+        raise Error::InvalidJoinType, "Invalid join type: #{type}" unless join_type = JOIN_TYPES[type || :inner]
+        
+        server_version = @opts[:server_version] ||= @db.server_version
         type = :inner if type == :cross && !expr.nil?
-        if type.to_s =~ /natural|cross|straight/ &&  @opts[:server_version] >= 50014
-          tbl_factor = table.to_s
-          if table.is_a?(Dataset)
-            tbl_factor = table.sql << " AS t1"
-          end
-          if table.is_a?(Array)
-            tbl_factor = "( #{literal(table)} )"
-          end
-          join_string = "#{join_type} " << tbl_factor
-          return join_string
+
+        if (server_version >= 50014) && /\Anatural|cross|straight\z/.match(type.to_s)
+          table = "( #{literal(table)} )" if table.is_a?(Array)
+          "#{join_type} #{table}"
+        else
+          super
         end
+      end
 
-        super
+      def insert_default_values_sql
+        "INSERT INTO #{source_list(@opts[:from])} () VALUES ()"
       end
 
       def match_expr(l, r)
@@ -414,8 +416,9 @@ module Sequel
       end
       
       def replace_sql(*values)
+        from = source_list(@opts[:from])
         if values.empty?
-          "REPLACE INTO #{@opts[:from]} DEFAULT VALUES"
+          "REPLACE INTO #{from} DEFAULT VALUES"
         else
           values = values[0] if values.size == 1
           
@@ -425,30 +428,32 @@ module Sequel
           end
 
           case values
-          when Sequel::Model
-            insert_sql(values.values)
           when Array
             if values.empty?
-              "REPLACE INTO #{@opts[:from]} DEFAULT VALUES"
+              "REPLACE INTO #{from} DEFAULT VALUES"
             elsif values.keys
               fl = values.keys.map {|f| literal(f.is_a?(String) ? f.to_sym : f)}
               vl = values.values.map {|v| literal(v)}
-              "REPLACE INTO #{@opts[:from]} (#{fl.join(COMMA_SEPARATOR)}) VALUES (#{vl.join(COMMA_SEPARATOR)})"
+              "REPLACE INTO #{from} (#{fl.join(COMMA_SEPARATOR)}) VALUES (#{vl.join(COMMA_SEPARATOR)})"
             else
-              "REPLACE INTO #{@opts[:from]} VALUES (#{literal(values)})"
+              "REPLACE INTO #{from} VALUES (#{literal(values)})"
             end
           when Hash
             if values.empty?
-              "REPLACE INTO #{@opts[:from]} DEFAULT VALUES"
+              "REPLACE INTO #{from} DEFAULT VALUES"
             else
               fl, vl = [], []
               values.each {|k, v| fl << literal(k.is_a?(String) ? k.to_sym : k); vl << literal(v)}
-              "REPLACE INTO #{@opts[:from]} (#{fl.join(COMMA_SEPARATOR)}) VALUES (#{vl.join(COMMA_SEPARATOR)})"
+              "REPLACE INTO #{from} (#{fl.join(COMMA_SEPARATOR)}) VALUES (#{vl.join(COMMA_SEPARATOR)})"
             end
           when Dataset
-            "REPLACE INTO #{@opts[:from]} #{literal(values)}"
+            "REPLACE INTO #{from} #{literal(values)}"
           else
-            "REPLACE INTO #{@opts[:from]} VALUES (#{literal(values)})"
+            if values.respond_to?(:values)
+              replace_sql(values.values)
+            else  
+              "REPLACE INTO #{from} VALUES (#{literal(values)})"
+            end
           end
         end
       end
@@ -492,35 +497,10 @@ module Sequel
         self
       end
 
-      def array_tuples_fetch_rows(sql, &block)
-        @db.execute_select(sql) do |r|
-          @columns = r.columns
-          r.each_array(&block)
-        end
-        self
-      end
-      
-      def array_tuples_transform_load(r)
-        a = []; a.keys = []
-        r.each_pair do |k, v|
-          a[k] = (tt = @transform[k]) ? tt[0][v] : v
-        end
-        a
-      end
-
-      # Applies the value transform for data saved to the database.
-      def array_tuples_transform_save(r)
-        a = []; a.keys = []
-        r.each_pair do |k, v|
-          a[k] = (tt = @transform[k]) ? tt[1][v] : v
-        end
-        a
-      end
-
       def multi_insert_sql(columns, values)
         columns = literal(columns)
         values = values.map {|r| "(#{literal(r)})"}.join(COMMA_SEPARATOR)
-        ["INSERT INTO #{@opts[:from]} (#{columns}) VALUES #{values}"]
+        ["INSERT INTO #{source_list(@opts[:from])} (#{columns}) VALUES #{values}"]
       end
     end
   end