sequel 4.1.1 → 4.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e97437793fba5f6d584ca832d9188c5779809da
-  data.tar.gz: bf8b6218bf26ea9dc03387724dc904951e0f81d9
+  metadata.gz: cab63d0878683dcadae2a2192c6969b1afd46a8d
+  data.tar.gz: c06204a0ba11736b055e57e109b7d8886014dd8e
 SHA512:
-  metadata.gz: 8fd114ba94ddf1c53718cbf10b8454dac4ad8cceec47414dca2fbd4a21527f7bfd2f2f3811d18f2bf7035631701c7fa54f352af593517f283e09f8f991cc17da
-  data.tar.gz: b171c79c198bd268e1aee3ff16a26369bfcb0eac4abf5787fc47bf0a1cd16dfa95919ded5455fac1dd4d7290bc3066d58df38cd128c1183a7ca593dff531c12c
+  metadata.gz: 03ea44b1eb6d126258b335e3e28935506360c8d1e2e54c773d26b9f5e795b71f6f8c27eb04ad1fe6dd0deb32d86c42b88ac11b6e9356b735dc54b791310e16d8
+  data.tar.gz: 7d4084003d7202c8507ae31746f0e941a23a187edd8f479b22994a100283b5671982ab877aa4cb72029a846a899e8e356be0f14c7161361994913963547de1a6

data/CHANGELOG

@@ -1,3 +1,35 @@
+=== 4.2.0 (2013-09-01)
+
+* Support custom :flags option in mysql2 adapter (jeremyevans) (#700)
+
+* Add implementations of Dataset#freeze and Dataset#dup (jeremyevans)
+
+* Add implementations of Model#dup and Model#clone (jeremyevans)
+
+* Don't have partial_indexes returned by Database#indexes on MSSQL 2008+ (jeremyevans)
+
+* Support partial indexes on SQLite 3.8.0+ (jeremyevans)
+
+* Add Database#supports_partial_indexes? to check for partial index support (mluu, jeremyevans) (#698)
+
+* The static_cache plugin now disallows saving/destroying if the :frozen=>false option is not used (jeremyevans)
+
+* Support :frozen=>false option in static_cache plugin, for having new instances returned instead of frozen cached instances (jeremyevans)
+
+* Add pg_static_cache_updater Database extension for listening for changes to tables and updating static_cache caches automatically (jeremyevans)
+
+* Add mssql_emulate_lateral_with_apply extension for emulating LATERAL queries using CROSS/OUTER APPLY (jeremyevans)
+
+* Support LATERAL queries via Dataset#lateral (jeremyevans)
+
+* Add pg_loose_count Database extension, for fast approximate counts of PostgreSQL tables (jeremyevans)
+
+* Add from_block Database extension, for having Database#from block affect FROM instead of WHERE (jeremyevans)
+
+* Support :cursor_name option in postgres adapter Dataset#use_cursor (heeringa, jeremyevans) (#696)
+
+* Fix placeholder literal strings when used with an empty placeholder hash (trydionel, jeremyevans) (#695)
+
 === 4.1.1 (2013-08-01)
 
 * Fix select_map, select_order_map, and single_value methods on eager_graphed datasets (jeremyevans)

data/doc/opening_databases.rdoc

@@ -312,6 +312,10 @@ This is a newer MySQL adapter that does typecasting in C, so it is often faster
 mysql adapter.  Supports the same additional options as the mysql adapter, except for :compress, and uses
 :timeout instead of :read_timeout and :connect_timeout.
 
+The following additional options are supported:
+
+:flags :: Override the flags to use for the connection (e.g. ::Mysql2::Client::MULTI_STATEMENTS)
+
 === odbc 
 
 The ODBC adapter allows you to connect to any database with the appropriate ODBC drivers installed.  

data/doc/release_notes/4.2.0.txt

@@ -0,0 +1,129 @@
+= New Features
+
+* LATERAL subqueries are now supported on PostgreSQL 9.3+, HSQLDB,
+  and DB2 via Dataset#lateral:
+
+    DB.from(:a, DB[:b].where(:c=>:a__d).lateral)
+    # SELECT * FROM a,
+    # LATERAL (SELECT * FROM b WHERE (c = a.d)) AS t1
+
+  You can use a similar syntax when joining tables:
+
+    DB[:a].cross_join(DB[:b].where(:c=>:a__d).lateral)
+    # SELECT * FROM a
+    # CROSS JOIN LATERAL (SELECT * FROM b WHERE (c = a.d)) AS t1
+
+  If you are using Microsoft SQL Server, you can use the new
+  mssql_emulate_lateral_with_apply extension to emulate LATERAL
+  subqueries via CROSS/OUTER APPLY.
+
+* The static_cache plugin now supports a :frozen=>false option.  When
+  this option is used, instead of returning the frozen cached values,
+  the model now returns new, unfrozen objects that can be modified.
+  Note that if you make any database modifications, you are
+  responsible for updating the cache manually.
+
+* A pg_static_cache_updater extension has been added.  This extension
+  can automatically update the caches used by the static_cache plugin,
+  whenever the underlying database table is updated, using PostgreSQL's
+  notification channels.
+
+  This works by defining triggers on the underlying model tables that
+  use NOTIFY, and spinning up a thread in your application processes
+  that uses LISTEN, and refreshes the cache for the related model
+  whenever it receives a notification that the underlying table has
+  been modified.
+
+  This extension should make it possible to use the static_cache plugin
+  with the :frozen=>false option for any table that is small and not
+  frequently updated.
+
+* A from_block extension has been added that makes Database#from operate
+  like Dataset#from in regards to a passed block, allowing you to write
+  code like:
+
+    DB.from{table_returning_function(arg1, arg2)}
+
+* Database#supports_partial_indexes? has been added for checking for
+  partial index support.  Partial indexes are now supported on SQLite
+  3.8.0+.
+
+* A pg_loose_count extension has been added for fast approximate counts
+  of PostgreSQL tables.  This uses the system tables and should be
+  fairly accurate if the table statistics are up to date:
+
+    DB.loose_count(:table)
+
+* The Dataset#use_cursor method in the postgres adapter now supports
+  a :cursor_name option.  You can set this option if you want to
+  use nested cursors.
+
+* The mysql2 adapter now supports a :flags Database option allowing to
+  set custom mysql2 flags (e.g. ::Mysql2::Client::MULTI_STATEMENTS).
+
+= Other Improvements
+
+* Dataset#freeze has been implemented.  Previously, it was not
+  implemented, so Object#freeze was used, which resulted in a dataset
+  that wasn't cloneable.  Dataset#freeze now works as expected,
+  resulting in a cloneable dataset, but it doesn't allow methods to
+  be called that mutate the receiver.
+
+* Dataset#dup has been implemented.  Previously, it was not
+  implemented, so Object#dup was used, which resulted in a dataset
+  that shared an options hash with the receiver, so modifying the
+  dup's opts could also change the original dataset. Now dup works
+  similarly to clone, except that the returned object will not be
+  frozen.
+
+* Model#dup has been implemented.  Previously, it was not implemented,
+  so Object#dup was used, which resulted in a model instance that
+  shared the values hash with the receiver, so modifying the dup's
+  values also changed the original's values.  Now, dup does a shallow
+  copy of some of the internal data structures as well, so the copy
+  is more independent.
+
+  Note that you still need to be careful if you mutate objects:
+
+    m = Model.new(:a=>'a')
+    m2 = m.dup
+    m.a.gsub!('a', 'b') # also changes m2
+
+* Model#clone has been implemented.  Previously, it had the same
+  issues as dup.  Now, it calls the new Model#dup, but also
+  freezes the returned object if the receiver is frozen.
+
+* Placeholder literal strings with an empty parameter hash are now
+  handled correctly.
+
+= Backwards Compatibility
+
+* The static_cache plugin now disallows saving/destroying instances
+  unless the :frozen=>false option is used.  As the cached objects
+  returned by the model were frozen anyway, this affects creating
+  new instances or saving/destroying instances returned from the
+  underlying dataset.
+
+* Model#set_values has been removed (it was deprecated starting in
+  Sequel 4.0).
+
+* The following Model class methods are no longer defined:
+  insert_multiple, set, to_csv, paginate, query, set_overrides,
+  set_defaults.  By default, these methods used call the
+  dataset method of the same name, but as those methods are no
+  longer defined on datasets by default, they also resulted in a
+  NoMethodError.
+
+* Dataset#query!, #set_defaults!, and #set_overrides! are no longer
+  defined on all datasets.  They are now only defined on datasets
+  that use the query or set_overrides extensions.
+
+* Partial indexes are no longer returned by Database#indexes on MSSQL,
+  for consistency with PostgreSQL.  Note that the same change was
+  desired for SQLite, but SQLite currently does not offer reflection
+  support for determining which indexes are partial.
+
+* Database#foreign_key_list on MSSQL now will return a
+  SQL::QualifiedIdentifier instead of a symbol for the :table entry if
+  the schema of the referenced table does not match the schema of the
+  referencing table.

data/lib/sequel/adapters/jdbc/hsqldb.rb

@@ -160,6 +160,11 @@ module Sequel
           false
         end
 
+        # HSQLDB supports lateral subqueries.
+        def supports_lateral_subqueries?
+          true
+        end
+
         private
 
         # Use string in hex format for blob data.

data/lib/sequel/adapters/mysql2.rb

@@ -30,7 +30,8 @@ module Sequel
         opts = server_opts(server)
         opts[:host] ||= 'localhost'
         opts[:username] ||= opts.delete(:user)
-        opts[:flags] = ::Mysql2::Client::FOUND_ROWS if ::Mysql2::Client.const_defined?(:FOUND_ROWS)
+        opts[:flags] ||= 0
+        opts[:flags] |= ::Mysql2::Client::FOUND_ROWS if ::Mysql2::Client.const_defined?(:FOUND_ROWS)
         conn = ::Mysql2::Client.new(opts)
         conn.query_options.merge!(:symbolize_keys=>true, :cache_rows=>false)
 

data/lib/sequel/adapters/postgres.rb

@@ -633,16 +633,19 @@ module Sequel
       #
       # * :rows_per_fetch - the number of rows per fetch (default 1000).  Higher
       #   numbers result in fewer queries but greater memory use.
+      # * :cursor_name - the name assigned to the cursor (default 'sequel_cursor').
+      #   Nested cursors require different names.
       #
       # Usage:
       #
       #   DB[:huge_table].use_cursor.each{|row| p row}
       #   DB[:huge_table].use_cursor(:rows_per_fetch=>10000).each{|row| p row}
+      #   DB[:huge_table].use_cursor(:cursor_name=>'my_cursor').each{|row| p row}      
       #
       # This is untested with the prepared statement/bound variable support,
       # and unlikely to work with either.
       def use_cursor(opts=OPTS)
-        clone(:cursor=>{:rows_per_fetch=>1000}.merge(opts))
+        clone(:cursor=>{:rows_per_fetch=>1000, :cursor_name => 'sequel_cursor'}.merge(opts))
       end
 
       if SEQUEL_POSTGRES_USES_PG
@@ -757,12 +760,13 @@ module Sequel
       # Use a cursor to fetch groups of records at a time, yielding them to the block.
       def cursor_fetch_rows(sql)
         server_opts = {:server=>@opts[:server] || :read_only}
+        cursor_name = quote_identifier(@opts[:cursor][:cursor_name])
         db.transaction(server_opts) do 
           begin
-            execute_ddl("DECLARE sequel_cursor NO SCROLL CURSOR WITHOUT HOLD FOR #{sql}", server_opts)
+            execute_ddl("DECLARE #{cursor_name} NO SCROLL CURSOR WITHOUT HOLD FOR #{sql}", server_opts)
             rows_per_fetch = @opts[:cursor][:rows_per_fetch].to_i
             rows_per_fetch = 1000 if rows_per_fetch <= 0
-            fetch_sql = "FETCH FORWARD #{rows_per_fetch} FROM sequel_cursor"
+            fetch_sql = "FETCH FORWARD #{rows_per_fetch} FROM #{cursor_name}"
             cols = nil
             # Load columns only in the first fetch, so subsequent fetches are faster
             execute(fetch_sql) do |res|
@@ -777,7 +781,7 @@ module Sequel
               end
             end
           ensure
-            execute_ddl("CLOSE sequel_cursor", server_opts)
+            execute_ddl("CLOSE #{cursor_name}", server_opts)
           end
         end
       end

data/lib/sequel/adapters/shared/db2.rb

@@ -293,6 +293,11 @@ module Sequel
         false
       end
 
+      # DB2 supports lateral subqueries
+      def supports_lateral_subqueries?
+        true
+      end
+      
       # DB2 does not support multiple columns in IN.
       def supports_multiple_column_in?
         false

data/lib/sequel/adapters/shared/mssql.rb

@@ -75,7 +75,7 @@ module Sequel
             referenced_schema = m.call(row[:schema])
             referenced_table = m.call(row[:table])
             h[row[:name]] = { :name      => m.call(row[:name]), 
-                              :table     => (referenced_schema == current_schema) ? referenced_table : :"#{referenced_schema}__#{referenced_table}",
+                              :table     => (referenced_schema == current_schema) ? referenced_table : Sequel.qualify(referenced_schema, referenced_table),
                               :columns   => [m.call(row[:column])], 
                               :key       => [m.call(row[:referenced_column])], 
                               :on_update => fk_action_map[row[:update_referential_action]], 
@@ -90,15 +90,20 @@ module Sequel
         m = output_identifier_meth
         im = input_identifier_meth
         indexes = {}
-        metadata_dataset.from(:sys__tables___t).
+        ds = metadata_dataset.from(:sys__tables___t).
          join(:sys__indexes___i, :object_id=>:object_id).
          join(:sys__index_columns___ic, :object_id=>:object_id, :index_id=>:index_id).
          join(:sys__columns___c, :object_id=>:object_id, :column_id=>:column_id).
          select(:i__name, :i__is_unique, :c__name___column).
          where{{t__name=>im.call(table)}}.
          where(:i__is_primary_key=>0, :i__is_disabled=>0).
-         order(:i__name, :ic__index_column_id).
-         each do |r|
+         order(:i__name, :ic__index_column_id)
+
+        if supports_partial_indexes?
+          ds = ds.where(:i__has_filter=>0)
+        end
+
+        ds.each do |r|
           index = indexes[m.call(r[:name])] ||= {:columns=>[], :unique=>(r[:is_unique] && r[:is_unique]!=0)}
           index[:columns] << m.call(r[:column])
         end
@@ -119,6 +124,11 @@ module Sequel
         @server_version
       end
         
+      # MSSQL 2008+ supports partial indexes.
+      def supports_partial_indexes?
+        dataset.send(:is_2008_or_later?)
+      end
+
       # MSSQL supports savepoints, though it doesn't support committing/releasing them savepoint
       def supports_savepoints?
         true
@@ -276,6 +286,7 @@ module Sequel
       # support for clustered index type
       def index_definition_sql(table_name, index)
         index_name = index[:name] || default_index_name(table_name, index[:columns])
+        raise Error, "Partial indexes are not supported for this database" if index[:where] && !supports_partial_indexes?
         if index[:type] == :full_text
           "CREATE FULLTEXT INDEX ON #{quote_schema_table(table_name)} #{literal(index[:columns])} KEY INDEX #{literal(index[:key_index])}"
         else

data/lib/sequel/adapters/shared/mysql.rb

@@ -401,6 +401,7 @@ module Sequel
       # Handle MySQL specific index SQL syntax
       def index_definition_sql(table_name, index)
         index_name = quote_identifier(index[:name] || default_index_name(table_name, index[:columns]))
+        raise Error, "Partial indexes are not supported for this database" if index[:where] && !supports_partial_indexes?
         index_type = case index[:type]
         when :full_text
           "FULLTEXT "

data/lib/sequel/adapters/shared/oracle.rb

@@ -56,7 +56,7 @@ module Sequel
         true
       end
 
-      # DB2 supports transaction isolation levels.
+      # Oracle supports transaction isolation levels.
       def supports_transaction_isolation_levels?
         true
       end

data/lib/sequel/adapters/shared/postgres.rb

@@ -470,6 +470,11 @@ module Sequel
         true
       end
 
+      # PostgreSQL supports partial indexes.
+      def supports_partial_indexes?
+        true
+      end
+
       # PostgreSQL supports prepared transactions (two-phase commit) if
       # max_prepared_transactions is greater than 0.
       def supports_prepared_transactions?
@@ -1238,6 +1243,11 @@ module Sequel
         true
       end
 
+      # PostgreSQL 9.3rc1+ supports lateral subqueries
+      def supports_lateral_subqueries?
+        server_version >= 90300
+      end
+      
       # PostgreSQL supports modifying joined datasets
       def supports_modifying_joins?
         true

data/lib/sequel/adapters/shared/sqlite.rb

@@ -148,6 +148,11 @@ module Sequel
         sqlite_version >= 30619
       end
 
+      # SQLite 3.8.0+ supports partial indexes.
+      def supports_partial_indexes?
+        sqlite_version >= 30800
+      end
+
       # SQLite 3.6.8+ supports savepoints. 
       def supports_savepoints?
         sqlite_version >= 30608

data/lib/sequel/database/features.rb

@@ -47,6 +47,11 @@ module Sequel
       respond_to?(:indexes)
     end
 
+    # Whether the database supports partial indexes (indexes on a subset of a table).
+    def supports_partial_indexes?
+      false
+    end
+
     # Whether the database and adapter support prepared transactions
     # (two-phase commit), false by default.
     def supports_prepared_transactions?
@@ -90,7 +95,7 @@ module Sequel
     end
 
     private
-    
+
     # Whether the database supports combining multiple alter table
     # operations into a single query, false by default.
     def supports_combining_alter_table_ops?

data/lib/sequel/database/schema_methods.rb

@@ -716,13 +716,9 @@ module Sequel
     # and index specifications.
     def index_definition_sql(table_name, index)
       index_name = index[:name] || default_index_name(table_name, index[:columns])
-      if index[:type]
-        raise Error, "Index types are not supported for this database"
-      elsif index[:where]
-        raise Error, "Partial indexes are not supported for this database"
-      else
-        "CREATE #{'UNIQUE ' if index[:unique]}INDEX #{quote_identifier(index_name)} ON #{quote_schema_table(table_name)} #{literal(index[:columns])}"
-      end
+      raise Error, "Index types are not supported for this database" if index[:type]
+      raise Error, "Partial indexes are not supported for this database" if index[:where] && !supports_partial_indexes?
+      "CREATE #{'UNIQUE ' if index[:unique]}INDEX #{quote_identifier(index_name)} ON #{quote_schema_table(table_name)} #{literal(index[:columns])}#{" WHERE #{filter_expr(index[:where])}" if index[:where]}"
     end
   
     # Array of SQL DDL statements, one for each index specification,

data/lib/sequel/dataset/actions.rb

@@ -9,12 +9,11 @@ module Sequel
     
     # Action methods defined by Sequel that execute code on the database.
     ACTION_METHODS = (<<-METHS).split.map{|x| x.to_sym}
-      << [] []= all avg count columns columns! delete each
-      empty? fetch_rows first first! get import insert insert_multiple interval last
+      << [] all avg count columns columns! delete each
+      empty? fetch_rows first first! get import insert interval last
       map max min multi_insert paged_each range select_hash select_hash_groups select_map select_order_map
-      set single_record single_value sum to_csv to_hash to_hash_groups truncate update
+      single_record single_value sum to_hash to_hash_groups truncate update
     METHS
-    # REMOVE40 []= insert_multiple set to_csv
 
     # Inserts the given argument into the database.  Returns self so it
     # can be used safely when chaining:

data/lib/sequel/dataset/features.rb

@@ -95,6 +95,11 @@ module Sequel
       true
     end
     
+    # Whether the dataset supports LATERAL for subqueries in the FROM or JOIN clauses.
+    def supports_lateral_subqueries?
+      false
+    end
+    
     # Whether modifying joined datasets is supported.
     def supports_modifying_joins?
       false