sequel 4.14.0 → 4.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9b817d0bad633a1df7f0a331264d8ce67e0a2c40
-  data.tar.gz: e46c816ef87e537d58a982e876011f14ab42c6a3
+  metadata.gz: bed2efa61dbcb53c3a0ceb08e9ca858368631d35
+  data.tar.gz: 11da3e14b94c21e9719cd0d8a700e7f0727bc33b
 SHA512:
-  metadata.gz: d88876ee4814e172d6ed262b14a87f253e5864d03f8f3167420e10d6d3a873625a1fb797b406bc2438a28d7df846535f9af38f2dc90cc57c6167d6c333723345
-  data.tar.gz: c0a61d9260147f6fa4d458242b7ebb6139eacee710e84eb1361d9527a15dea1ecbad377893b3a0dede352af92061308c4e5fd76d4741df60cdc1cf0f3819ddc3
+  metadata.gz: a132e45671dda78cb933d50f21942ace99b938c3133d54b8dd82babe8fb5657f8c4f63ebb28dc1cd4c13bc08ee5a9736514a3be5ceb2c3dbcc4c7eeb09a5177f
+  data.tar.gz: a1e4be8380d22afda924e1fec932c47fb5be3f258279010753c12fc5dca9220f38b18b657e84a03875f9108572614292c150d8963ee8b0249eceff06df627d1b

data/CHANGELOG

@@ -1,3 +1,35 @@
+=== 4.15.0 (2014-10-01)
+
+* Make AssociationReflection#reciprocal not raise error if associated class contains association with invalid associated class (jeremyevans)
+
+* Make create_view(:view_name, dataset, :materialized=>true) reversible on PostgreSQL (jeremyevans)
+
+* Add support for creating foreign tables on PostgreSQL using :foreign and :options create_table options (jeremyevans)
+
+* Raise Error if a primary key is necessary to use an association, but the model doesn't have a primary key (jeremyevans)
+
+* Make tactical_eager_loading plugin work for limited associations (jeremyevans)
+
+* Add PlaceholderLiteralizer#with_dataset, for returning a new literalizer using a modified dataset (jeremyevans)
+
+* Support active_model 4.2.0beta1 in the active_model plugin (jeremyevans)
+
+* Make Dataset#insert in the informix adapter return last inserted id (jihwans) (#887)
+
+* Support :nolog option in the informix adapter to disable transactions (jihwans) (#887)
+
+* Remove optional argument for Postgres::{JSON,JSONB}Op#to_record and #to_recordset (jeremyevans)
+
+* Add support for FoundationDB SQL Layer, via fdbsql and jdbc/fdbsql adapters (ScottDugas, jeremyevans) (#884)
+
+* Work around bug in old versions of MySQL when schema dumping a table with multiple timestamp columns (jeremyevans) (#882)
+
+* Support more array types by default in the pg_array extension, such as xml[] and uuid[] (jeremyevans)
+
+* Add Sequel::Model.cache_associations accessor, which can be set to false to not cache association metadata (jeremyevans)
+
+* Add split_values plugin, for moving noncolumn entries from the values hash into a separate hash (jeremyevans) (#868)
+
 === 4.14.0 (2014-09-01)
 
 * Raise original exception if there is an exception raised when rolling back transaction/savepoint (jeremyevans) (#875)

data/README.rdoc

@@ -12,9 +12,9 @@ toolkit for Ruby.
   two-phase commit, transaction isolation, master/slave
   configurations, and database sharding.
 * Sequel currently has adapters for ADO, Amalgalite, CUBRID,
-  DataObjects, DB2, DBI, Firebird, IBM_DB, Informix, JDBC, MySQL,
-  Mysql2, ODBC, OpenBase, Oracle, PostgreSQL, SQLAnywhere, SQLite3,
-  Swift, and TinyTDS.
+  DataObjects, DB2, DBI, Firebird, FoundationDB SQL Layer,
+  IBM_DB, Informix, JDBC, MySQL, Mysql2, ODBC, OpenBase, Oracle,
+  PostgreSQL, SQLAnywhere, SQLite3, Swift, and TinyTDS.
 
 == Resources
 

data/Rakefile

@@ -144,7 +144,7 @@ begin
   spec_with_cov.call("spec_plugin", Dir["spec/extensions/*_spec.rb"].sort_by{rand}, "Run extension/plugin specs"){|t| t.rcov_opts.concat(%w'--exclude "lib/sequel/([a-z_]+\.rb|adapters|connection_pool|database|dataset|model)"')}
   spec_with_cov.call("spec_integration", Dir["spec/integration/*_test.rb"], "Run integration tests")
 
-  %w'postgres sqlite mysql informix oracle firebird mssql db2 sqlanywhere'.each do |adapter|
+  %w'postgres sqlite mysql informix oracle fdbsql firebird mssql db2 sqlanywhere'.each do |adapter|
     spec_with_cov.call("spec_#{adapter}", ["spec/adapters/#{adapter}_spec.rb"] + Dir["spec/integration/*_test.rb"], "Run #{adapter} specs"){|t| t.rcov_opts.concat(%w'--exclude "lib/sequel/([a-z_]+\.rb|connection_pool|database|dataset|model|extensions|plugins)"')}
   end
 

data/doc/opening_databases.rdoc

@@ -206,6 +206,18 @@ Connection string examples:
   do:postgres://user:password@host/database
   do:mysql://user:password@host/database
 
+=== fdbsql
+
+Requires: pg
+
+The following additional options are supported:
+
+:connect_timeout :: Set the number of seconds to wait for a connection (default 20).
+:notice_receiver :: A proc that be called with the PGresult objects that have notice or warning messages.
+                    The default notice receiver just prints the messages to stderr, but this can be used
+                    to handle notice/warning messages differently.
+:sslmode :: Set to 'disable', 'allow', 'prefer', 'require' to choose how to treat SSL.
+
 === firebird 
 
 Requires: fb (using code at http://github.com/wishdev/fb)
@@ -231,6 +243,10 @@ or set
    export DELIMIDENT=y
 
 in the scripts environment.
+
+The following additional options are supported:
+
+:nolog :: Disable transactions for the database.
  
 === jdbc 
 
@@ -239,8 +255,9 @@ Requires: java
 Houses Sequel's JDBC support when running on JRuby.
 Support for individual database types is done using sub adapters.
 There are currently subadapters for PostgreSQL, MySQL, SQLite, H2, HSQLDB, Derby,
-Oracle, MSSQL, JTDS, AS400, Progress, Firebird, Informix, and DB2.  For PostgreSQL, MySQL, SQLite, H2, HSQLDB, Derby,
-and JTDS, this can use the jdbc-* gem, for the others you need to have the .jar in your CLASSPATH
+Oracle, MSSQL, JTDS, AS400, Progress, Fdbsql, Firebird, Informix, and DB2.
+For PostgreSQL, MySQL, SQLite, H2, HSQLDB, Derby, and JTDS,
+this can use the jdbc-* gem, for the others you need to have the .jar in your CLASSPATH
 or load the Java class manually before calling Sequel.connect.
 
 You just use the JDBC connection string directly, which can be specified
@@ -274,6 +291,7 @@ Example connection strings:
   jdbc:jdbcprogress:T:hostname:port:database
   jdbc:cubrid:hostname:port:database:::
   jdbc:sqlanywhere://localhost?DBN=Test;UID=user;PWD=password
+  jdbc:fdbsql://localhost:15432/user?user=user&password=password
 
 You can also use JNDI connection strings:
 

data/doc/release_notes/4.15.0.txt

@@ -0,0 +1,56 @@
+= New Features
+
+* fdbsql and jdbc/fdbsql adapters have been added, for connecting to
+  FoundationDB SQL Layer.
+
+* A split_values plugin has been added, for moving non-column entries
+  from the values hash into a separate hash.  This allows you to
+  select additional columns (e.g. computed columns) when retrieving
+  model instances, and be able to save those instances without
+  removing the additional columns.
+
+* A Sequel::Model.cache_associations accessor has been added, which
+  can be set to false to not cache any association metadata.  This
+  can fix issues in a development environment that uses code
+  reloading.
+
+* The active_model plugin now supports activemodel 4.2.0beta1.
+
+* More PostgreSQL array types are handled automatically by the
+  pg_array extension, such as xml[] and uuid[].
+
+* Creating foreign tables is now supported on PostgreSQL via the
+  :foreign and :options create_table options.
+
+* The :nolog Database option is now supported in the informix
+  adapter, where it disables the use of transactions.
+
+* PlaceholderLiteralizer#with_dataset has been added, allowing you
+  to create another PlaceholderLiteralizer with a modified dataset,
+  useful if you want to change the row_proc or any non-SQL dataset
+  options.
+
+= Other Improvements
+
+* The tactical_eager_loading plugin once again works correctly with
+  limited associations.
+
+* A bug in older versions of MySQL is now worked around when schema
+  dumping a table with multiple timestamp columns.
+
+* On PostgreSQL, create_view(:view_name, dataset, :materialized=>true)
+  is now reversible.
+
+* Postgres::{JSON,JSONB}Op#to_record and #to_recordset no longer take
+  an optional argument.  This was supported in PostgreSQL 9.4beta1,
+  but removed before PostgreSQL 9.4beta2.
+
+* Dataset#insert now returns the last inserted id in the informix
+  adapter.
+
+* Sequel no longer raises an exception in
+  AssociationReflection#reciprocal if the associated class has an
+  association that does not have a valid associated class.
+
+* Sequel now raises an exception if a primary key is necessary to use
+  an association, but the model does not have a primary key.

data/doc/testing.rdoc

@@ -128,9 +128,13 @@ The order in which you delete/truncate the tables is important if you are using
 
 Sequel has multiple separate test suites.  All test suites run under rspec >=1.3.
 
+== rake
+
+The default rake task runs Sequel's core, model, plugin, and extension specs, the same as <tt>rake spec spec_plugin</tt>.
+
 == rake spec
 
-The +spec+ rake task (which is also the default rake task) runs Sequel's core and model specs.  These specs use a mocked database connection, and test for specific SQL used and for generally correct behavior.
+The +spec+ rake task runs Sequel's core and model specs.  These specs use a mocked database connection, and test for specific SQL used and for generally correct behavior.
 
 == rake spec_plugin
 
@@ -152,7 +156,7 @@ These specs are broken down into two parts.  For each database, there are specif
 
 == Environment variables
 
-Sequel often uses environment variables when testing to specify either the database to be tested or specify how testing should be done.  You can also specify the databases to test by copying spec/spec_config.rb.example to spec/spec_config.rb and modifying it.  See that file for details.  It may be necessary to use spec_config.rb as opposed to an environment variable if your database connection cannot be specified by a connection string.
+Sequel uses environment variables when testing to specify either the database to be tested or specify how testing should be done.  You can also specify the databases to test by copying spec/spec_config.rb.example to spec/spec_config.rb and modifying it.  See that file for details.  It may be necessary to use spec_config.rb as opposed to an environment variable if your database connection cannot be specified by a connection string.
 
 Sequel does not create test databases automatically, except for file-based databases such as SQLite/H2/HSQLDB/Derby.  It's up to the user to create the test databases manually and give Sequel a valid connection string in an environment variable (or setup the connection object in spec_config.rb).
 
@@ -162,9 +166,11 @@ The SEQUEL_INTEGRATION_URL environment variable specifies the Database connectio
 
 === Other
 
-SEQUEL_COLUMNS_INTROSPECTION :: Whether to run the specs with the columns_introspection extension loaded by default
+SEQUEL_COLUMNS_INTROSPECTION :: Use the columns_introspection extension when running the specs
 SEQUEL_CONNECTION_VALIDATOR :: Use the connection validator extension when running the specs
 SEQUEL_ERROR_SQL :: Use the error_sql extension when running the specs
+SEQUEL_NO_CACHE_ASSOCIATIONS :: Don't cache association metadata when running the specs
 SEQUEL_NO_CHECK_SQLS :: Don't check for specific SQL syntax when running the specs
-SEQUEL_NO_PENDING :: Don't mark any specs as pending, try running all specs
+SEQUEL_NO_PENDING :: Don't mark any specs as pending, try running all specs (note, can cause lockups for some adapters)
+SEQUEL_NO_SKIP_PENDING :: On RSpec 3, run specs marked as pending, and fail the pending spec if it passes (note, can cause lockups for some adapters)
 SKIPPED_TEST_WARN :: Warn when skipping any tests because libraries aren't available

data/lib/sequel/adapters/fdbsql.rb

@@ -0,0 +1,285 @@
+require 'pg'
+
+Sequel.require 'adapters/utils/pg_types'
+Sequel.require 'adapters/shared/fdbsql'
+
+module Sequel
+  module Fdbsql
+    CONVERTED_EXCEPTIONS << PGError
+
+    # Database class for the FoundationDB SQL Layer used with Sequel and the
+    # pg driver
+    class Database < Sequel::Database
+      include Sequel::Fdbsql::DatabaseMethods
+
+      set_adapter_scheme :fdbsql
+
+      # Connects to the database. In addition to the standard database options,
+      # :connect_timeout is a connection timeout in seconds,
+      # :sslmode sets whether to use ssl, and
+      # :notice_receiver handles server notices in a proc.
+      def connect(server)
+        opts = server_opts(server)
+        Connection.new(self, opts)
+      end
+
+      # Execute the given SQL with the given args on an available connection.
+      def execute(sql, opts = {}, &block)
+        res = nil
+        synchronize(opts[:server]) do |conn|
+          res = check_database_errors do
+            if sql.is_a?(Symbol)
+              execute_prepared_statement(conn, sql, opts, &block)
+            else
+              log_yield(sql) do
+                conn.query(sql, opts[:arguments])
+              end
+            end
+          end
+          yield res if block_given?
+          res.cmd_tuples
+        end
+      end
+
+      def server_version
+        return @server_version if @server_version
+
+        version = get{VERSION{}}
+        unless ver = version.match(/(\d+)\.(\d+)\.(\d+)/)
+          raise Error, "No match when checking FDB SQL Layer version: #{version}"
+        end
+
+        @server_version = (100 * ver[1].to_i + ver[2].to_i) * 100 + ver[3].to_i
+      end
+
+      private
+
+      def database_exception_sqlstate(exception, opts)
+        if exception.respond_to?(:result) && (result = exception.result)
+          result.error_field(::PGresult::PG_DIAG_SQLSTATE)
+        end
+      end
+
+      def execute_prepared_statement(conn, name, opts=OPTS, &block)
+        statement = prepared_statement(name)
+        sql = statement.prepared_sql
+        ps_name = name.to_s
+        if args = opts[:arguments]
+          args = args.map{|arg| bound_variable_arg(arg, conn)}
+        end
+        begin
+          # create prepared statement if it doesn't exist, or has new sql
+          unless conn.prepared_statements[ps_name] == sql
+            conn.execute("DEALLOCATE #{ps_name}") if conn.prepared_statements.include?(ps_name)
+            log_yield("PREPARE #{ps_name} AS #{sql}"){conn.prepare(ps_name, sql)}
+            conn.prepared_statements[ps_name] = sql
+          end
+
+          log_sql = "EXECUTE #{ps_name}"
+          if statement.log_sql
+            log_sql << " ("
+            log_sql << sql
+            log_sql << ")"
+          end
+          log_yield(sql, args) do
+            conn.execute_prepared_statement(ps_name, args)
+          end
+        rescue PGError => e
+          if (database_exception_sqlstate(e, opts) == STALE_STATEMENT_SQLSTATE)
+            conn.prepared_statements[ps_name] = nil
+            retry
+          end
+        end
+      end
+    end
+
+    # Dataset class for the FoundationDB SQL Layer that uses the pg driver.
+    class Dataset < Sequel::Dataset
+      include Sequel::Fdbsql::DatasetMethods
+
+      Database::DatasetClass = self
+
+      # Allow use of bind arguments for FDBSQL using the pg driver.
+      module BindArgumentMethods
+
+        include Sequel::Dataset::UnnumberedArgumentMapper
+        include DatasetMethods::PreparedStatementMethods
+
+        private
+
+        # Execute the given SQL with the stored bind arguments.
+        def execute(sql, opts=OPTS, &block)
+          super(sql, {:arguments=>bind_arguments}.merge(opts), &block)
+        end
+
+        # Same as execute, explicit due to intricacies of alias and super.
+        def execute_dui(sql, opts=OPTS, &block)
+          super(sql, {:arguments=>bind_arguments}.merge(opts), &block)
+        end
+      end
+
+      # Allow use of server side prepared statements for FDBSQL using the
+      # pg driver.
+      module PreparedStatementMethods
+        include BindArgumentMethods
+
+        # Raise a more obvious error if you attempt to call a unnamed prepared statement.
+        def call(*)
+          raise Error, "Cannot call prepared statement without a name" if prepared_statement_name.nil?
+          super
+        end
+
+        private
+
+        # Execute the stored prepared statement name and the stored bind
+        # arguments instead of the SQL given.
+        def execute(sql, opts=OPTS, &block)
+          super(prepared_statement_name, opts, &block)
+        end
+
+        # Same as execute, explicit due to intricacies of alias and super.
+        def execute_dui(sql, opts=OPTS, &block)
+          super(prepared_statement_name, opts, &block)
+        end
+      end
+
+
+      # Execute the given type of statement with the hash of values.
+      def call(type, bind_vars=OPTS, *values, &block)
+        ps = to_prepared_statement(type, values)
+        ps.extend(BindArgumentMethods)
+        ps.call(bind_vars, &block)
+      end
+
+      # Yield all rows returned by executing the given SQL and converting
+      # the types.
+      def fetch_rows(sql)
+        execute(sql) do |res|
+          columns = set_columns(res)
+          yield_hash_rows(res, columns) {|h| yield h}
+        end
+      end
+
+      # Prepare the given type of statement with the given name, and store
+      # it in the database to be called later.
+      def prepare(type, name=nil, *values)
+        ps = to_prepared_statement(type, values)
+        ps.extend(PreparedStatementMethods)
+        if name
+          ps.prepared_statement_name = name
+          db.set_prepared_statement(name, ps)
+        end
+        ps
+      end
+
+      private
+
+      def set_columns(res)
+        cols = []
+        procs = db.conversion_procs
+        res.nfields.times do |fieldnum|
+          cols << [fieldnum, procs[res.ftype(fieldnum)], output_identifier(res.fname(fieldnum))]
+        end
+        @columns = cols.map{|c| c[2]}
+        cols
+      end
+
+      # For each row in the result set, yield a hash with column name symbol
+      # keys and typecasted values.
+      def yield_hash_rows(res, cols)
+        res.ntuples.times do |recnum|
+          converted_rec = {}
+          cols.each do |fieldnum, type_proc, fieldsym|
+            value = res.getvalue(recnum, fieldnum)
+            converted_rec[fieldsym] = (value && type_proc) ? type_proc.call(value) : value
+          end
+          yield converted_rec
+        end
+      end
+
+    end
+
+    # Connection specific methods for Fdbsql with pg
+    class Connection < PG::Connection
+      # Regular expression for error messages that note that the connection is closed.
+      DISCONNECT_ERROR_RE = /\A(?:could not receive data from server|no connection to the server|connection not open|connection is closed)/
+
+      # Hash of prepared statements for this connection.  Keys are
+      # string names of the server side prepared statement, and values
+      # are SQL strings.
+      attr_accessor :prepared_statements
+
+      # Create a new connection to the FoundationDB SQL Layer. See Database#connect.
+      def initialize(db, opts)
+        connect_opts = {
+          :host => opts[:host] || 'localhost',
+          :port => opts[:port] || 15432,
+          :dbname => opts[:database],
+          :user => opts[:user],
+          :password => opts[:password],
+          :hostaddr => opts[:hostaddr],
+          :connect_timeout => opts[:connect_timeout] || 20,
+          :sslmode => opts[:sslmode]
+        }.delete_if{|key, value| value.nil? or (value.respond_to?(:empty?) and value.empty?)}
+	super(connect_opts)
+
+        @db = db
+        @prepared_statements = {}
+
+        if opts[:notice_receiver]
+          set_notice_receiver(opts[:notice_receiver])
+        else
+          # Swallow warnings
+          set_notice_receiver{|proc| }
+        end
+      end
+
+      # Close the connection.
+      def close
+        super
+      rescue PGError, IOError
+      end
+
+      # Execute the given SQL with this connection.  If a block is given,
+      # yield the results, otherwise, return the number of changed rows.
+      def execute(sql, args=nil)
+        q = query(sql, args)
+        block_given? ? yield(q) : q.cmd_tuples
+      end
+
+      # Execute the prepared statement of the given name, binding the given
+      # args.
+      def execute_prepared_statement(name, args)
+        check_disconnect_errors{exec_prepared(name, args)}
+      end
+
+      # Prepare a statement for later use.
+      def prepare(name, sql)
+        check_disconnect_errors{super}
+      end
+
+      # Execute the given query and return the results.
+      def query(sql, args=nil)
+        args = args.map{|v| @db.bound_variable_arg(v, self)} if args
+        check_disconnect_errors{super}
+      end
+
+      private
+
+      # Raise a Sequel::DatabaseDisconnectError if a PGError is raised and
+      # the connection status cannot be determined or it is not OK.
+      def check_disconnect_errors
+        begin
+          yield
+        rescue PGError => e
+          disconnect = false
+          disconnect ||= e.message =~ DISCONNECT_ERROR_RE
+          disconnect ? raise(Sequel.convert_exception_class(e, Sequel::DatabaseDisconnectError)) : raise
+        rescue IOError, Errno::EPIPE, Errno::ECONNRESET => e
+          disconnect = true
+          raise(Sequel.convert_exception_class(e, Sequel::DatabaseDisconnectError))
+        end
+      end
+    end
+  end
+end