sequel 4.26.0 → 5.37.0

data/doc/release_notes/4.5.0.txt

@@ -1,34 +0,0 @@
-= New Features
-
-* An mssql_optimistic_locking plugin has been added.  This is similar
-  to the regular optimistic_locking plugin, but instead of using an
-  integer lock column, it uses a timestamp/rowversion lock column.
-
-* Database#create_table with the :temp=>true option on PostgreSQL now
-  supports an :on_commit option.  This option can be set to :drop or
-  :delete_rows to either drop or empty the temporary table on
-  transaction commit.
-
-= Other Improvements
-
-* Dataset#insert no longer errors on PostgreSQL if the related table
-  is a placeholder literal string.
-
-* Unique constraints are now copied when emulating alter_table
-  operations on SQLite.
-
-* Clob column values are no longer returned as SQL::Blob instances
-  by the db2 and ibmdb adapters unless use_clob_as_blob is true.
-
-* SQL::Blob objects now work correctly as prepared statement
-  arguments in the jdbc/db2 adapter if use_clob_as_blob is false.
-
-= Backwards Compatibility
-
-* The Model.primary_key array for models with composite keys is now
-  frozen.
-
-* On DB2, use_clob_as_blob now defaults to false instead of true.
-
-* Sequel no longer uses RubyForge. The Sequel website is now located
-  at http://sequel.jeremyevans.net.

data/doc/release_notes/4.6.0.txt

@@ -1,30 +0,0 @@
-= New Features
-
-* Database#call_mssql_sproc is now available for calling
-  stored procedures on Microsoft SQL Server, including the use
-  of output parameters.
-
-* The Database#{commit,rollback}_prepared_transaction methods now
-  support a :server option for the server on which to operate.
-
-= Other Improvements
-
-* On Microsoft SQL Server 2012, the native OFFSET/FETCH support
-  is now used for offsets, instead of emulating support via the
-  ROW_NUMBER window function.
-
-* Eager loading is now skipped when doing eager(...).naked.all on
-  a model dataset, instead of raising an error.  This can fix issues
-  when the eager_each plugin is used.
-
-* A couple additional disconnection errors are now detected in the
-  jdbc/postgresql adapter.
-
-* The tinytds adapter now handles returning rows when the fields
-  are not immediately available.
-
-* RuntimeErrors raised by oci8 are now handled correctly in the
-  oracle adapter.
-
-* Sequel's specs now work with RSpec 3, while still running
-  correctly on RSpec 1.3 and 2.

data/doc/release_notes/4.7.0.txt

@@ -1,103 +0,0 @@
-= New Features
-
-* Alternatives for the more complex virtual row method calls have
-  been added:
-
-    # Window Functions using SQL::Function#over
-    # before: select{sum(:over, :args=>:col1, :partition=>:col2){}}
-    select{sum(:col1).over(:partition=>:col2)}
-
-    # count(*) using SQL::Function#*
-    # before: select{count(:*){}}
-    select{count{}.*}
-
-    # count(distinct col) using SQL::Function#distinct
-    # before: select{count(:distinct, :col){}}
-    select{count(:col).distinct}
-
-  Additionally, schema qualified functions are now supported via
-  SQL::QualifiedIdentifier#function, and quoted functions are now
-  supported via SQL::Identifier#function on some databases:
-
-    # "func"("col")
-    select{func.function(:col)}
-
-    # "schema"."func"("col1")
-    select{schema__func.function(:col1)}
-
-  If the database does not support quoting function names, then
-  Sequel will not quote them.
-
-* An update_or_create plugin has been added, for updating a matching
-  object if one exists, or creating an object if it does not. For
-  example, the following code will update the number of copies sold
-  for album with the name 'Hello', or it will create an album with
-  the name 'Hello' and 1000 number of copies sold:
-
-    Album.plugin :update_or_create
-    Album.update_or_create(:name=>'Hello') do |album|
-      album.num_copies_sold = 1000
-    end
-
-  You can also use a shorter form of this, with two hashes:
-    
-    Album.update_or_create({:name=>'Hello'}, {:num_copies_sold=>1000})
-
-  This plugin also adds a method named find_or_new, which does the
-  same thing as update_or_create, except it doesn't persist any
-  changes.
-
-* A :raise_on_save_failure option has been added for one_to_many,
-  pg_array_to_many, and many_to_pg_array associations.  This mirrors
-  the Model.raise_on_save_failure setting, and if set to false, it
-  will make the add/remove methods return nil instead of raising
-  an error if there is a validation/hook error when saving the
-  associated record.
-
-* The validates_unique validation in validation_helpers now supports a
-  :dataset option to provide the base dataset to use to check
-  uniqueness.  This is useful when the model itself uses a filtered
-  dataset, but the unique index in the database is on an unfiltered
-  dataset.
-
-  The auto_validations plugin uses this option to ensure that unique
-  validations are setup correctly in subclasses using single table
-  inheritance.
-
-= Other Improvements
-
-* Sequel now automatically rolls back transactions in killed threads
-  on ruby 2.0+.  It is still impossible to do so on ruby 1.9.
-
-* In the instance_hooks plugin, validation instance hooks are now
-  not cleared until after a successful save.
-
-* Composite unique key constraint violations are now recognized
-  and raised as Sequel::UniqueConstraintViolation on SQLite.
-
-* Primary key unique constraint violations are now recognized and
-  and raised as Sequel::UniqueConstraintViolation on Microsoft
-  SQL Server and SQLAnywhere.
-
-* If an exception occurs when using a cursor in the postgres adapter,
-  and an exception also occurs when closing the cursor when cleaning
-  up, the initial exception is now raised.
-
-* You can now get tables in a specific schema in the jdbc adapter
-  using the :schema option to Database#tables.  This was already
-  supported in most jdbc subadapters because they implement #tables
-  using database specific code instead of looking at the JDBC
-  metadata, but it should now work for all jdbc subadapters.
-
-* Sequel::SQLTime#to_s is now defined and returns a string in
-  HH:MM:SS format (leaving off the date).
-
-= Backwards Compatibility
-
-* The odbc adapter's :driver option is no longer deprecated, as reports
-  were received that it still works.
-
-* If you were re-adding instance validation hooks using instance_hooks
-  after a save failure, and then retrying the save, you may now end up
-  with duplicate validations.  You no longer need to re-add validation
-  hooks unless the object was saved successfully.

data/doc/release_notes/4.8.0.txt

@@ -1,175 +0,0 @@
-= New Features
-
-* A one_through_one association type has been added.  This is similar
-  to the many_to_many association type in that it uses a join table,
-  but it returns a single record instead of an array of records.
-  This is designed for cases where the foreign key in the join table
-  that references the current table has a unique constraint, or where
-  you want to use an order to just pick the first matching record.
-
-  Similarly, the many_through_many plugin now also offers a
-  one_through_many association.
-
-* An association_join method has been added to model datasets, for
-  setting up joins based on associations.  This basically does the
-  same join that eager_graph would do, but does not make the other
-  changes that eager_graph makes.
-
-  Unlike eager_graph (which uses LEFT OUTER JOINs by default),
-  association_join uses INNER JOINs, but there are also
-  association_*_join methods (e.g. association_left_join) for
-  using different join types.
-
-  Similar to eager_graph, you can use cascading of associations or
-  multiple associations.
-
-    Album.association_join(:artist, :tracks)
-    Artist.association_left_join(:albums=>:tracks)
-
-* Dataset#eager_graph_with_options has been added for model
-  datasets.  It currently supports a :join_type option, for
-  overriding the type of join to use on a per-call basis, as well
-  as a :limit_strategy option.  The API is similar to eager_graph,
-  except that the associations to eagerly load are passed in as
-  a single argument, and it takes an options hash.
-
-  The :limit_strategy option works similarly to the
-  :eager_limit_strategy option when eagerly loading.  If set to
-  true and the database supports window functions, it will join
-  the current dataset to a subquery that uses a window function
-  to correctly restrict the join to only those objects that fall
-  within the association's limit/offset.
-
-  The :limit_strategy option is not on by default.  It is possible
-  for it to perform significantly worse than the default strategy
-  (which uses array slicing in ruby).  The :limit_strategy
-  significantly changes the SQL used, and can change the results
-  of the query if any filters/orders related to the association
-  are used.
-
-  It's recommended you only use the :limit_strategy option if you
-  are experiencing a bottleneck and you have benchmarked that it
-  is faster and still produces the desired results.
-
-    Artist.eager_graph_with_options(:first_10_albums,
-      :limit_strategy=>true)
-    # SELECT artists.id, artists.name,
-    #   first_10_albums.id AS first_10_albums_id,
-    #   first_10_albums.name AS first_10_albums_name,
-    #   first_10_albums.artist_id,
-    #   first_10_albums.release_date
-    # FROM artists
-    # LEFT OUTER JOIN (
-    #   SELECT id, name, artist_id, release_date
-    #   FROM (
-    #     SELECT *, row_number() OVER (PARTITION BY tracks.album_id)
-    #       AS x_sequel_row_number_x
-    #     FROM albums
-    #   ) AS t1 WHERE (x_sequel_row_number_x <= 10)
-    # ) AS first_10_albums ON (first_10_albums.artist_id = artists.id)
-
-* Dataset#full_text_search on PostgreSQL now supports :plain and
-  :phrase options.  :plain takes the search terms as a single
-  string, and searches for rows where all terms are used.
-  :phrase is similar to :plain, but also adds a substring search
-  to ensure that the string given appears verbatim in the text.
-
-* A :graph_order association option has been added, for using a
-  different order when using eager_graph.  This is mostly
-  designed for cases where :order should be qualified in other
-  cases, but using a qualification breaks eager_graph because the
-  correct qualifier is not known until runtime.
-
-* SQL::AliasedExpression#alias has been added as an alias for #aliaz.
-
-= Other Improvements
-
-* Sequel will now automatically use an eager limit strategy for
-  *_one associations that use an :order option.  For associations
-  that are truly one-to-one, an :order option is not needed, so it
-  only makes sense to have an :order option if the association
-  could theoretically return multiple results (in which case an
-  eager limit strategy is helpful).
-
-* The queries that Sequel uses to filter by associations when
-  those associations have conditions are now simpler and easier
-  for the database to execute.
-
-* The queries that Sequel uses for dataset associations now handle
-  cases where unqualified identifiers were used in the receiving
-  dataset that would be made ambiguous by a join.
-
-* A limit strategy is now used when filtering by associations if
-  the association has a limit and the database supports window
-  functions.  This allows Sequel to setup a correct filter in
-  such cases.
-
-    Artist.where(:first_10_albums=>Album[1]).all
-    # SELECT *
-    # FROM artists
-    # WHERE (artists.id IN (
-    #   SELECT albums.artist_id
-    #   FROM albums
-    #   WHERE ((albums.artist_id IS NOT NULL) AND (albums.id IN (
-    #     SELECT id FROM (
-    #       SELECT albums.id, row_number() OVER
-    #         (PARTITION BY albums.artist_id ORDER BY release_date)
-    #         AS x_sequel_row_number_x
-    #       FROM albums
-    #     ) AS t1
-    #     WHERE (x_sequel_row_number_x <= 10)
-    #   )) AND (albums.id = 1))))
-
-* A limit strategy is now used in the dataset_associations plugin
-  if the association has a limit and the database supports window
-  functions.  This makes the resulting datasets return correct
-  results.
-
-    Artist.first_10_albums
-    # SELECT *
-    # FROM albums
-    # WHERE ((albums.artist_id IN (
-    #   SELECT artists.id FROM artists)
-    # ) AND (albums.id IN (
-    #   SELECT id FROM (
-    #     SELECT albums.id, row_number() OVER
-    #       (PARTITION BY albums.artist_id ORDER BY release_date)
-    #       AS x_sequel_row_number_x
-    #     FROM albums
-    #   ) AS t1
-    #   WHERE (x_sequel_row_number_x <= 10)
-    # )))
-    # ORDER BY release_date
-
-* You can now pass symbols with embedded qualifiers or aliases,
-  as well as SQL::Identifier, SQL::QualifiedIdentifier, and
-  SQL::AliasedExpression objects as the first argument to
-  Dataset#graph.
-
-* The nested_attributes plugin now automatically handles presence
-  validations on foreign keys when creating associated objects.
-  It now sets the foreign key value (or a placeholder value)
-  before validating such objects.
-
-* Offsets on *_one associations are now respected when using
-  eager_graph.
-
-* eager graphing *_many associations with offsets no longer breaks
-  if there are no associated results.
-
-* Database#register_array_type in the pg_array extension now works
-  correctly if there is no existing scalar conversion proc for
-  the type.
-
-* Unique, foreign key, and not null constraint violations are now
-  recognized correctly on SQLite 3.8.2+.
-
-* The odbc adapter now returns fractional seconds in timestamps.
-
-* The obdc/mssql adapter now inputs timestamps with 3 decimal
-  places.
-
-= Backwards Compatibility
-
-* The private Model.apply_window_function_eager_limit_strategy
-  method has been removed.

data/doc/release_notes/4.9.0.txt

@@ -1,190 +0,0 @@
-= Performance Enhancements
-
-* Dataset::PlaceholderLiteralizer has been added as an optimization
-  framework.  This allows you to record changes to a given dataset
-  using placeholder arguments, and later quickly execute the query
-  providing values for the placeholders.  This is similar in idea
-  to prepared statements, except that the SQL for each query can
-  change depending on the values for the placeholders.
-
-  Using this optimization framework, generating the SQL for query
-  is about 3x faster, and since SQL generation time is a significant
-  portion of total time for simple queries, simple queries can
-  execute up to 50% faster.
-
-  There are two APIs for this optimization framework.  There is a
-  lower level dataset API:
-
-    loader = Sequel::Dataset::PlaceholderLiteralizer.
-     loader(DB[:items]) do |pl, ds|
-      ds.where(:id=>pl.arg).exclude(:name=>pl.arg).limit(1)
-    end
-
-    loader.first(1, "foo")
-    # SELECT * FROM items WHERE ((id = 1) AND (name != 'foo')) LIMIT 1 
-
-    loader.first([1, 2], %w"foo bar")
-    # SELECT * FROM items WHERE ((id IN (1, 2)) AND
-    #   (name NOT IN ('foo', 'bar'))) LIMIT 1
-
-  There is also a higher level model API (Model.finder):
-
-    class Item < Sequel::Model
-      # Given class method that returns a dataset
-      def self.by_id_and_not_name(id, not_name)
-        where(:id=>id).exclude(:name=>not_name)
-      end
-
-      # Create optimized method that returns first value
-      finder :by_id_and_not_name
-    end
-    
-    # Call optimized method
-    Album.first_by_id_and_not_name(1, 'foo')
-    # SELECT * FROM items WHERE ((id = 1) AND (name != 'foo')) LIMIT 1 
-
-  Model.finder defaults to creating a method that returns the first
-  matching row, but using the :type option you can create methods
-  that call each, all, or get.  There is also an option to choose the
-  method name (:name), as well as one to specify the number of
-  arguments to use if the method doesn't take a fixed number
-  (:arity).
-
-  Finally, Model.find, .first, and .first! now automatically use an
-  optimized finder if given a single argument. Model.[] uses an
-  optimized finder if given a single hash, and Model.[], .with_pk,
-  and .with_pk! use an optimized finder if the model has a composite
-  primary key.  In all of these cases, these methods are about 50%
-  faster than before.
-
-* The pure-ruby PostgreSQL array parser that ships with Sequel has
-  been replaced with a strscan-based parser.  This parser avoids
-  O(n^2) performance for arrays with multibyte strings, and in general
-  is much faster.  Parsing an array with a single string with 100,000
-  multibyte characters is about 1000x faster, and now about half the
-  speed of the C implementation in sequel_pg.
-
-* Dataset#paged_each now has a :strategy=>:filter option that
-  dramatically improves performance, especially if the columns
-  being ordered by are indexed.
-
-  Unfortunately, there are enough corner cases to this approach
-  that it cannot be used by default.  At the least, the dataset
-  needs to be selecting the columns it is ordering by, not aliasing
-  the columns it is ordering by in the SELECT clause, not have
-  NULLs in any of the columns being ordered by, and not itself use
-  a limit or offset.
-
-  If you are ordering by expressions that are not simple column
-  values, you can provide a :filter_value option proc that takes the
-  last retrieved row and array of order by expressions, and returns 
-  an array of values in the last retrieved row for those order by
-  expressions.
-
-* In the postgres adapter, Dataset#paged_each now automatically uses
-  a cursor for improved performance.
-
-* In the mysql2 adapter, Dataset#paged_each now automatically uses
-  streaming for improved performance, if streaming is supported.
-
-* Dataset#with_sql_{each,all,first,single_value,insert,update}
-  have been added.  These methods take specific SQL and execute
-  it on the database, returning the appropriate value.  They
-  are significantly faster than the previous approach of
-  with_sql(SQL).{each,all,first,single_value,insert,update},
-  as they don't require cloning the dataset.
-
-= New Features
-
-* Database#create_join_table! and #create_join_table? have been added,
-  for consistency with #create_table! and #create_table?.
-
-* A :hold option has been added to Dataset#use_cursor in the postgres
-  adapter, which uses WITH HOLD in the query, allowing for usage of
-  the cursor outside the enclosing transaction.  When :hold is used,
-  Sequel does not automatically use a transaction around the cursor
-  call.
-
-* Dataset#where_current_of has been added to the postgres adapter,
-  for updating rows based on a cursor's current position.  This can
-  be used to update a large dataset where new values depend on
-  some ruby method, without keeping all rows in memory.
-
-    ds = DB[:huge_table]
-    ds.use_cursor(:rows_per_fetch=>1).each do |row|
-      ds.where_current_of.update(:column=>ruby_method(row))
-    end
-
-* A current_datetime_timestamp extension has been added, for
-  creating Time/DateTime instances that are literalized as
-  CURRENT_TIMESTAMP.  When the dataset uses this extension, models
-  that use the touch and timestamps plugins will use
-  CURRENT_TIMESTAMP for the timestamps.
-
-* The jdbc adapter now supports a :driver option, useful when
-  Sequel doesn't have direct support for the underlying driver, and
-  where java.sql.DriverManager.getConnection does not work
-  correctly due to Java class loading issues.
-
-= Other Improvements
-
-* Multiple corner cases in Dataset#eager_graph have been fixed.
-
-* Calling Dataset#columns when using the eager_each plugin no
-  longer triggers eager loading.
-
-* Database#column_schema_to_ruby_default is now a public method
-  in the schema_dumper extension.
-
-* When validating associated objects for one_to_many and one_to_one
-  associations in the nested_attributes plugin, don't remove column
-  values if the association's foreign key is the associated model's
-  primary key.
-
-* On PostgreSQL, Dataset#disable_insert_returning has been added
-  back.  This disables the automatic use of RETURNING for INSERTs
-  for the dataset.  This is necessary in cases where INSERT
-  RETURNING doesn't work, such as PostgreSQL <8.2 (or PostgreSQL
-  variants that forked before 8.2), or when using partitioning
-  with trigger functions, or conditional rules.
-
-  Note that if you use disable_insert_returning, insert will not
-  return the autoincremented primary key.  You need to call
-  currval or lastval manually using the same connection to get
-  the value, or use nextval to get the value to use before
-  inserting.
-
-* The pg_array extension now uses the correct database type when
-  typecasting values for smallint, oid, real, character, and varchar
-  arrays.  Previously, Sequel did not use the correct database type
-  in some cases (e.g. text[] for a varchar[]), which resulted in
-  errors if the value was used in a filter expression.
-
-* Additional unique constraint violations are now recognized on
-  SQLite.
-
-* Check constraint violations are now recognized on SQLite >=3.8.2.
-
-* Adapters that emulate bitwise operators now do so using an append
-  only design, similar to how all other queries are built in Sequel.
-
-= Backwards Compatibility
-
-* In some cases Sequel no longer adds superfluous parentheses when
-  constructing SQL strings.  If you are testing for specific SQL,
-  this can cause test failures.
-
-* The pg_array extension no longer recognizes the :typecast_method
-  option when registering an array type.  The option allowed reuse
-  of an existing typecast method, but as that results in an incorrect
-  type at the database level, the option was fundementally broken.
-
-* The internals of the PostgreSQL array parser have changed.  If you
-  were relying on them, you'll need to update your code.
-
-* Dataset#complex_expression_arg_pairs private method now returns
-  nested expression objects instead of an already literalized string
-  in some cases.  Custom adapters that call this method will probably
-  need to be changed.  It's recommended that such adapters switch to
-  using the new Dataset#complex_expression_emulate_append method if
-  possible.