sequel 4.0.0 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3f1f6d7107eb83ff3840572817d310bdf10371ad
-  data.tar.gz: 4f04ad59f41290e20d2aba5af08947ef0ceb52e0
+  metadata.gz: a449facae4b3dcc14c19ce0f524ca2025db4c74e
+  data.tar.gz: 19e4bbb80143055d03da8134f6308363ff8e2406
 SHA512:
-  metadata.gz: 355ac8d6ada27fbb499219b662c1a0a884777b0f6e95e98681415acc321bcef3178e494e5252fffa3417b086c3fcc2c04bd6fa9f45fbdc7d0f894fe5883fcbc8
-  data.tar.gz: 5cb1f4ef00bfaabc721e75baf1b02756e2b82a9f9c1fa2c241f01a6d717bee27c6d37b7c0bfd6876c85d9d0b78447a1d57ee9e2f6906902cf079f9d1773c0c9d
+  metadata.gz: 68c5cbe1672f325a040584b37b78188c34322b6505b7b267d61d7103ee8a3f2364e335324f330a4c63e239eb21896c66242c9c62de91b2052d6bc2ad03289dcf
+  data.tar.gz: 0ee8a1dbc5118fa916c90f112142b3580b2dbbfb4a5eca8f3f5924b510043e488cfbc2d1f1335db587a30b8dfe3a3b02754b46586ce770a38b6bc76ddb004fd0

data/CHANGELOG

@@ -1,3 +1,35 @@
+=== 4.1.0 (2013-08-01)
+
+* Support :inherits option in Database#create_table on PostgreSQL, for table inheritance (jeremyevans)
+
+* Handle dropping indexes for schema qualified tables on PostgreSQL (jeremyevans)
+
+* Add Database#error_info on PostgreSQL 9.3+ if pg-0.16.0+ is used, to get a hash of metadata for a given database exception (jeremyevans)
+
+* Allow prepared_statements plugin to work with instance_filters and update_primary_key plugins (jeremyevans)
+
+* Support deferrable exclusion constraints on PostgreSQL using the :deferrable option (mfoody) (#687)
+
+* Make Database#run and #<< accept SQL::PlaceholderLiteralString values (jeremyevans)
+
+* Deprecate :driver option in odbc adapter since it appears to be broken (jeremyevans)
+
+* Support :drvconnect option in odbc adapter for supplying the ODBC connection string directly (jeremyevans)
+
+* Support mysql2 0.3.12+ result streaming via Dataset#stream (jeremyevans)
+
+* Convert Java::JavaUtil::HashMap to ruby Hash in jdbc adapter, for better handling of PostgreSQL hstore type (jeremyevans) (#686)
+
+* Raise NoMatchingRow if calling add_association with a primary key value that doesn't match an existing row (jeremyevans)
+
+* Allow PostgreSQL add_constraint to support :not_valid option (jeremyevans)
+
+* Allow CHECK constraints to have options by using an options hash as the constraint name (jeremyevans)
+
+* Correctly raise error when using an invalid virtual row block function call (jeremyevans)
+
+* Support REPLACE on SQLite via Dataset#replace and #multi_replace (etehtsea) (#681)
+
 === 4.0.0 (2013-07-01)
 
 * Correctly parse composite primary keys on SQLite 3.7.16+ (jeremyevans)

data/doc/active_record.rdoc

@@ -742,12 +742,12 @@ ActiveRecord Method :: Notes, Workarounds
 <tt>clear_active_connections!</tt> :: Sequel doesn't leak connections like ActiveRecord, so you don't need to worry about this
 <tt>clear_reloadable_connections!</tt> :: Sequel doesn't leak connections like ActiveRecord, so you don't need to worry about this
 +content_columns+ :: Not needed internally, you can probably do <tt>Album.columns.map{|x| x.to_s}.delete_if{|x| x == Album.primary_key || x =~ /_(id|count)\z/}</tt>
-+decrement_counter+ :: <tt>Album.where(:id=>:id).update(:counter_name=>:counter_name - 1)</tt>
++decrement_counter+ :: <tt>Album.where(:id=>:id).update(:counter_name=>Sequel.-(:counter_name, 1))</tt>
 +define_attribute_methods+, +define_read_methods+ :: <tt>def_column_accessor(*columns)</tt>, a private method
 <tt>descends_from_active_record?</tt> :: Not needed internally, if using single table inheritance, <tt>Album.sti_dataset.model == Album</tt>
 +find_each+, +find_in_batches+ :: Use the +pagination+ extension
 <tt>generated_methods?</tt> :: No equivalent
-+increment_counter+ :: <tt>Album.where(:id=>:id).update(:counter_name=>:counter_name + 1)</tt>
++increment_counter+ :: <tt>Album.where(:id=>:id).update(:counter_name=>Sequel.+(:counter_name, 1))</tt>
 <tt>instance_method_already_implemented?</tt> :: No equivalent, Sequel does not create column accessors that override other methods, it just skips them.
 <tt>match_attribute_method?</tt> :: No equivalent
 +readonly_attributes+ :: No equivalent

data/doc/cheat_sheet.rdoc

@@ -166,11 +166,6 @@ Without a filename argument, the sqlite adapter will setup a new sqlite database
 
   DB.drop_table :items
 
-  DB.create_table :test do
-    String :zipcode
-    enum :system, :elements => ['mac', 'linux', 'windows']
-  end
-
 == Aliasing
 
   DB[:items].select(Sequel.as(:name, :item_name))

data/doc/opening_databases.rdoc

@@ -321,8 +321,9 @@ The :database option given ODBC database should be the DSN (Descriptive Service
 
 The :host and :port options are not respected. The following additional options are supported:
 
-:db_type :: Can be specified as 'mssql' or 'progress' to use SQL syntax specific to those databases.
-:driver :: The name of the ODBC driver to utilize.
+:db_type :: Can be specified as 'mssql', 'progress', or 'db2' to use SQL syntax specific to those databases.
+:drvconnect :: Can be given an ODBC connection string, and will use ODBC::Database#drvconnect to
+               do the connection.  Typical usage would be: <tt>Sequel.odbc(:drvconnect=>'driver={...};...')</tt>
 
 === openbase 
 

data/doc/prepared_statements.rdoc

@@ -31,6 +31,12 @@ placeholders, e.g.:
 
   ds = DB[:items].where(:name=>:$n)
 
+You can use these placeholders in most places where you can use the value
+directly.  For example, if you want to use placeholders while also using
+raw SQL, you can do:
+
+  ds = DB["SELECT * FROM items WHERE name = ?", :$n]
+
 == Bound Variables
 
 Using bound variables for this query is simple:

data/doc/release_notes/4.1.0.txt

@@ -0,0 +1,85 @@
+= New Features
+
+* Database#run and #<< now accept SQL::PlaceholderLiteralString
+  objects, allowing you to more easily run arbitrary DDL queries with
+  placeholders:
+
+    DB.run Sequel.lit("CREATE TABLE ? (? integer)", :table, :column)
+
+* You can now provide options for check constraints by calling the
+  constraint/add_constraint methods with a hash as the first argument.
+  On PostgreSQL, you can now use the :not_valid option for check
+  constraints, so they are enforced for inserts and updates, but
+  not for existing rows.
+
+    DB.create_table(:table) do
+      ...
+      constraint({:name=>:constraint_name, :not_valid=>true}) do
+        column_name > 10
+      end
+    end
+    
+* Dataset#stream has been added to the mysql2 adapter, and will have
+  the dataset stream results if used with mysql2 0.3.12+.  This
+  allows you to process large datasets without keeping the entire
+  dataset in memory.
+
+    DB[:large_table].stream.each{|r| ...}
+
+* Database#error_info has been added to the postgres adapter.  It
+  is supported on PostgreSQL 9.3+ if pg-0.16.0+ is used as the
+  underlying driver, and it gives you a hash of metadata related
+  to the exception:
+
+    DB[:table_name].insert(1) rescue DB.error_info($!)
+    # => {:schema=>"public", :table=>"table_name", :column=>nil,
+          :constraint=>"constraint_name", :type=>nil}
+ 
+* The :deferrable option is now supported when adding exclusion
+  constraints on PostgreSQL, to allow setting up deferred exclusion
+  constraints.
+
+* The :inherits option is now supported in Database#create_table on
+  PostgreSQL, for table inheritance:
+
+    DB.create_table(:t1, :inherits=>:t0){}
+    # CREATE TABLE t1 () INHERITS (t0)
+
+* Dataset#replace and #multi_replace are now supported on SQLite,
+  just as they have been previously on MySQL.
+
+* In the jdbc adapter, Java::JavaUtil::HashMap objects are now
+  converted to ruby Hash objects.  This is to make it easier to
+  handle the PostgreSQL hstore type when using the jdbc/postgres
+  adapter.
+
+* The odbc adapter now supports a :drvconnect option that accepts
+  an ODBC connection string that is passed to ruby-odbc verbatim.
+
+= Other Improvements
+
+* The prepared_statements plugin no longer breaks the
+  instance_filters and update_primary_key plugins.
+
+* Dropping indexes for tables in a specific schema is now supported
+  on PostgreSQL.  Sequel now explicitly specifies the same schema
+  as the table when dropping such indexes.
+
+* Calling Model#add_association methods with a primary key value
+  now raises a Sequel::NoMatchingRow if there is no object in the
+  associated table with that primary key.  Previously, this
+  situation was not handled and resulted in a NoMethodError being
+  raised later.
+
+* When an invalid virtual row block function call is detected, an
+  error is now properly raised.  Previously, the error was not
+  raised until the SQL was produced for the query.
+
+= Backwards Compatibility
+
+* The :driver option to the odbc adapter is deprecated and will be
+  removed in a future version.  It is thought to be broken, and
+  users wanting to use DSN-less connections should use the new
+  :drvconnect option.
+
+* The Postgres::ArrayOp#text_op private method has been removed.

data/doc/schema_modification.rdoc

@@ -88,6 +88,9 @@ method, the fourth argument is the options hash.  The following options are supp
 :primary_key :: Mark this column as the primary key.  This is used instead of the
                 primary key method if you want a non-autoincrementing primary key.
 :primary_key_constraint_name :: The name to give the primary key constraint.
+:type :: Overrides the type given as the method name or a separate argument.
+         Not usually used by +column+ itself, but often by other methods such
+         as +primary_key+ or +foreign_key+.
 :unique :: Mark the column as unique, generally has the same effect as
            creating a unique index on the column.
 :unique_constraint_name :: The name to give the unique key constraint.
@@ -137,12 +140,16 @@ as it's third argument.  A simple example is:
     String :name
   end
 
-+foreign_key+ accepts some specific options:
++foreign_key+ accepts the same options as +column+.  For example, to have a unique foreign key with varchar(16) type:
+
+  foreign_key :column_name, :unique=>true, :type=>'varchar(16)'
+
++foreign_key+ also accepts some specific options:
 
 :deferrable :: Makes the foreign key constraint checks deferrable, so they aren't checked
                until the end of the transaction.
 :foreign_key_constraint_name :: The name to give the foreign key constraint.
-:key :: For foreign key columns, the column in the associated table
+:key :: The column in the associated table
         that this column references.  Unnecessary if this column
         references the primary key of the associated table, at least
         on most databases.

data/lib/sequel/adapters/jdbc.rb

@@ -696,6 +696,7 @@ module Sequel
       JAVA_BIG_DECIMAL      = Java::JavaMath::BigDecimal
       JAVA_BYTE_ARRAY       = Java::byte[]
       JAVA_UUID             = Java::JavaUtil::UUID
+      JAVA_HASH_MAP         = Java::JavaUtil::HashMap
 
       # Handle type conversions for common Java types.
       class TYPE_TRANSLATOR
@@ -717,6 +718,7 @@ module Sequel
           lines
         end
         def uuid(v) v.to_string end
+        def hash_map(v) v.to_hash end
       end
       TYPE_TRANSLATOR_INSTANCE = tt = TYPE_TRANSLATOR.new
 
@@ -730,6 +732,7 @@ module Sequel
       BLOB_METHOD = tt.method(:blob)
       CLOB_METHOD = tt.method(:clob)
       UUID_METHOD = tt.method(:uuid)
+      HASH_MAP_METHOD = tt.method(:hash_map)
 
       # Convert the given Java timestamp to an instance of Sequel.datetime_class.
       def convert_type_timestamp(v)
@@ -759,6 +762,8 @@ module Sequel
           CLOB_METHOD
         when JAVA_UUID
           UUID_METHOD
+        when JAVA_HASH_MAP
+          HASH_MAP_METHOD
         else
           false
         end

data/lib/sequel/adapters/mysql2.rb

@@ -72,9 +72,23 @@ module Sequel
       # yield the connection if a block is given.
       def _execute(conn, sql, opts)
         begin
-          r = log_yield((log_sql = opts[:log_sql]) ? sql + log_sql : sql){conn.query(sql, :database_timezone => timezone, :application_timezone => Sequel.application_timezone)}
+          stream = opts[:stream]
+          r = log_yield((log_sql = opts[:log_sql]) ? sql + log_sql : sql){conn.query(sql, :database_timezone => timezone, :application_timezone => Sequel.application_timezone, :stream=>stream)}
           if opts[:type] == :select
-            yield r if r
+            if r
+              if stream
+                begin
+                  r2 = yield r
+                ensure
+                  # If r2 is nil, it means the block did not exit normally,
+                  # so the rest of the results must be drained to prevent
+                  # "commands out of sync" errors.
+                  r.each{} unless r2
+                end
+              else
+                yield r
+              end
+            end
           elsif block_given?
             yield conn
           end
@@ -145,6 +159,13 @@ module Sequel
         self
       end
 
+      # Return a clone of the dataset that will stream rows when iterating
+      # over the result set, so it can handle large datasets that
+      # won't fit in memory (Requires mysql 0.3.12 to have an effect).
+      def stream
+        clone(:stream=>true)
+      end
+
       private
 
       # Whether to cast tinyint(1) columns to integer instead of boolean.
@@ -156,7 +177,7 @@ module Sequel
 
       # Set the :type option to :select if it hasn't been set.
       def execute(sql, opts=OPTS, &block)
-        super(sql, {:type=>:select}.merge(opts), &block)
+        super(sql, {:type=>:select, :stream=>@opts[:stream]}.merge(opts), &block)
       end
 
       # Handle correct quoting of strings using ::Mysql2::Client#escape.

data/lib/sequel/adapters/odbc.rb

@@ -11,7 +11,10 @@ module Sequel
 
       def connect(server)
         opts = server_opts(server)
-        if opts.include? :driver
+        conn = if opts.include?(:drvconnect)
+          ::ODBC::Database.new.drvconnect(opts[:drvconnect])
+        elsif opts.include?(:driver)
+          Deprecation.deprecate("The odbc driver's handling of the :driver option is thought to be broken and will probably be removed in the future. If you are successfully using it, please contact the developers.")
           drv = ::ODBC::Driver.new
           drv.name = 'Sequel ODBC Driver130'
           opts.each do |param, value|
@@ -20,10 +23,9 @@ module Sequel
             end
             drv.attrs[param.to_s.upcase] = value.to_s
           end
-          db = ::ODBC::Database.new
-          conn = db.drvconnect(drv)
+          ::ODBC::Database.new.drvconnect(drv)
         else
-          conn = ::ODBC::connect(opts[:database], opts[:user], opts[:password])
+          ::ODBC::connect(opts[:database], opts[:user], opts[:password])
         end
         conn.autocommit = true
         conn

data/lib/sequel/adapters/postgres.rb

@@ -276,6 +276,31 @@ module Sequel
         rescue PGError, IOError
         end
       end
+
+      if SEQUEL_POSTGRES_USES_PG && Object.const_defined?(:PG) && ::PG.const_defined?(:Constants) && ::PG::Constants.const_defined?(:PG_DIAG_SCHEMA_NAME)
+        # Return a hash of information about the related PGError (or Sequel::DatabaseError that
+        # wraps a PGError), with the following entries:
+        #
+        # :schema :: The schema name related to the error
+        # :table :: The table name related to the error
+        # :column :: the column name related to the error
+        # :constraint :: The constraint name related to the error
+        # :type :: The datatype name related to the error
+        #
+        # This requires a PostgreSQL 9.3+ server and 9.3+ client library,
+        # and ruby-pg 0.16.0+ to be supported.
+        def error_info(e)
+          e = e.wrapped_exception if e.is_a?(DatabaseError)
+          r = e.result
+          h = {}
+          h[:schema] = r.error_field(::PG::PG_DIAG_SCHEMA_NAME)
+          h[:table] = r.error_field(::PG::PG_DIAG_TABLE_NAME)
+          h[:column] = r.error_field(::PG::PG_DIAG_COLUMN_NAME)
+          h[:constraint] = r.error_field(::PG::PG_DIAG_CONSTRAINT_NAME)
+          h[:type] = r.error_field(::PG::PG_DIAG_DATATYPE_NAME)
+          h
+        end
+      end
       
       # Execute the given SQL with the given args on an available connection.
       def execute(sql, opts=OPTS, &block)

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

@@ -1,4 +1,5 @@
 Sequel.require 'adapters/utils/split_alter_table'
+Sequel.require 'adapters/utils/replace'
 
 module Sequel
   Dataset::NON_SQL_OPTIONS << :insert_ignore
@@ -532,7 +533,6 @@ module Sequel
       PAREN_CLOSE = Dataset::PAREN_CLOSE
       NOT_SPACE = Dataset::NOT_SPACE
       FROM = Dataset::FROM
-      INSERT = Dataset::INSERT
       COMMA = Dataset::COMMA
       LIMIT = Dataset::LIMIT
       GROUP_BY = Dataset::GROUP_BY
@@ -552,7 +552,6 @@ module Sequel
       EMPTY_COLUMNS = " ()".freeze
       EMPTY_VALUES = " VALUES ()".freeze
       IGNORE = " IGNORE".freeze
-      REPLACE = 'REPLACE'.freeze
       ON_DUPLICATE_KEY_UPDATE = " ON DUPLICATE KEY UPDATE ".freeze
       EQ_VALUES = '=VALUES('.freeze
       EQ = '='.freeze
@@ -565,7 +564,9 @@ module Sequel
       QUAD_BACKSLASH = "\\\\\\\\".freeze
       BLOB_START = "0x".freeze
       HSTAR = "H*".freeze
-      
+
+      include Sequel::Dataset::Replace
+
       # MySQL specific syntax for LIKE/REGEXP searches, as well as
       # string concatenation.
       def complex_expression_sql_append(sql, op, args)
@@ -647,11 +648,6 @@ module Sequel
         SQL::PlaceholderLiteralString.new((opts[:boolean] ? MATCH_AGAINST_BOOLEAN : MATCH_AGAINST), [Array(cols), terms])
       end
 
-      # MySQL allows HAVING clause on ungrouped datasets.
-      def having(*cond, &block)
-        _filter(:having, *cond, &block)
-      end
-      
       # Transforms an CROSS JOIN to an INNER JOIN if the expr is not nil.
       # Raises an error on use of :full_outer type, since MySQL doesn't support it.
       def join_table(type, table, expr=nil, opts=OPTS, &block)
@@ -719,23 +715,7 @@ module Sequel
       def quoted_identifier_append(sql, c)
         sql << BACKTICK << c.to_s.gsub(BACKTICK_RE, DOUBLE_BACKTICK) << BACKTICK
       end
-      
-      # Execute a REPLACE statement on the database.
-      def replace(*values)
-        execute_insert(replace_sql(*values))
-      end
 
-      # MySQL specific syntax for REPLACE (aka UPSERT, or update if exists,
-      # insert if it doesn't).
-      def replace_sql(*values)
-        clone(:replace=>true).insert_sql(*values)
-      end
-
-      # Replace multiple rows in a single query.
-      def multi_replace(*values)
-        clone(:replace=>true).multi_insert(*values)
-      end
-      
       # MySQL can emulate DISTINCT ON with its non-standard GROUP BY implementation,
       # though the rows returned cannot be made deterministic through ordering.
       def supports_distinct_on?
@@ -832,11 +812,6 @@ module Sequel
         sql << IGNORE if opts[:update_ignore]
       end
 
-      # If this is an replace instead of an insert, use replace instead
-      def insert_insert_sql(sql)
-        sql << (@opts[:replace] ? REPLACE : INSERT)
-      end
-
       # MySQL supports INSERT ... ON DUPLICATE KEY UPDATE
       def insert_on_duplicate_key_update_sql(sql)
         if update_cols = opts[:on_duplicate_key_update]

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

@@ -636,8 +636,10 @@ module Sequel
         case constraint[:type]
         when :exclude
           elements = constraint[:elements].map{|c, op| "#{literal(c)} WITH #{op}"}.join(', ')
-          "#{"CONSTRAINT #{quote_identifier(constraint[:name])} " if constraint[:name]}EXCLUDE USING #{constraint[:using]||'gist'} (#{elements})#{" WHERE #{filter_expr(constraint[:where])}" if constraint[:where]}"
-        when :foreign_key
+          sql = "#{"CONSTRAINT #{quote_identifier(constraint[:name])} " if constraint[:name]}EXCLUDE USING #{constraint[:using]||'gist'} (#{elements})#{" WHERE #{filter_expr(constraint[:where])}" if constraint[:where]}"
+          constraint_deferrable_sql_append(sql, constraint[:deferrable])
+          sql
+        when :foreign_key, :check
           sql = super
           if constraint[:not_valid]
             sql << " NOT VALID"
@@ -768,6 +770,14 @@ module Sequel
         "CREATE #{temp_or_unlogged_sql}TABLE#{' IF NOT EXISTS' if options[:if_not_exists]} #{options[:temp] ? quote_identifier(name) : quote_schema_table(name)}"
       end
 
+      def create_table_sql(name, generator, options)
+        sql = super
+        if inherits = options[:inherits]
+          sql << " INHERITS (#{Array(inherits).map{|t| quote_schema_table(t)}.join(', ')})"
+        end
+        sql
+      end
+
       # Use a PostgreSQL-specific create table generator
       def create_table_generator_class
         Postgres::CreateTableGenerator
@@ -797,7 +807,8 @@ module Sequel
       
       # Support :if_exists, :cascade, and :concurrently options.
       def drop_index_sql(table, op)
-        "DROP INDEX#{' CONCURRENTLY' if op[:concurrently]}#{' IF EXISTS' if op[:if_exists]} #{quote_identifier(op[:name] || default_index_name(table, op[:columns]))}#{' CASCADE' if op[:cascade]}"
+        sch, _ = schema_and_table(table)
+        "DROP INDEX#{' CONCURRENTLY' if op[:concurrently]}#{' IF EXISTS' if op[:if_exists]} #{"#{quote_identifier(sch)}." if sch}#{quote_identifier(op[:name] || default_index_name(table, op[:columns]))}#{' CASCADE' if op[:cascade]}"
       end
 
       # SQL for dropping a procedural language from the database.