aboutsummaryrefslogtreecommitdiffstats
path: root/activerecord/test
Commit message (Collapse)AuthorAgeFilesLines
* Merge pull request #18512 from vipulnsward/18492-fixtures-with-stiAaron Patterson2015-01-316-11/+41
|\ | | | | Fix STI for fixtures from multi-files
| * Fixes #18492Vipul A M2015-01-146-11/+41
| | | | | | | | | | | | | | - Add check for not deleting previously created fixtures, to overcome sti fixtures from multiple files - Added fixtures and fixtures test to verify the same - Fixed wrong fixtures duplicating data insertion in same table
* | Merge pull request #18700 from nygrenh/better-required-messageAaron Patterson2015-01-311-2/+22
|\ \ | | | | | | Provide a better error message on :required association
| * | Provide a better error message on :required associationHenrik Nygren2015-01-281-2/+22
| | | | | | | | | | | | Fixes #18696.
* | | Remove most type related predicates from `Column`Sean Griffin2015-01-3018-83/+117
| | | | | | | | | | | | | | | | | | Remaining are `limit`, `precision`, `scale`, and `type` (the symbol version). These will remain on the column, since they mirror the options to the `column` method in the schema definition DSL
* | | Fix a state leak in `autosave_association_test`Sean Griffin2015-01-301-0/+5
| | | | | | | | | | | | | | | | | | The test added in 85465ed3e6c582d25f0c8fafe21f7a2c182c2f67 was passing when the file was run on its own, but failing when the entire suite was run since this test modifies the class and doesn't clean up.
* | | Always perform validations on nested attribute associationsSean Griffin2015-01-302-1/+9
| | | | | | | | | | | | | | | | | | | | | Collection associations would have already been validated, but singular associations were not. Fixes #18735.
* | | Post.all.or(anything) == Post.allSean Griffin2015-01-292-5/+5
| | |
* | | Fixed AR::Relation#group method when argument is a SQL reserved keywordBogdan Gusiev2015-01-291-0/+5
| | |
* | | Don't error when grouped calculations return 0 recordsSean Griffin2015-01-281-0/+5
| | | | | | | | | | | | Fixes #18717
* | | Merge Pull Request #16052 Added #or to ActiveRecord::RelationSean Griffin2015-01-283-0/+107
|\ \ \
| * | | Bring the implementation of Relation#or up to speedSean Griffin2015-01-282-3/+26
| | | |
| * | | Added #or to ActiveRecord::RelationMatthew Draper2015-01-282-0/+84
| | | | | | | | | | | | | | | | | | | | | | | | | | | | Post.where('id = 1').or(Post.where('id = 2')) # => SELECT * FROM posts WHERE (id = 1) OR (id = 2) [Matthew Draper & Gael Muller]
* | | | Always convert strings to UTF-8, regardless of column type in SQLiteSean Griffin2015-01-281-1/+1
|/ / / | | | | | | | | | | | | | | | | | | | | | All columns which would map to a string primitive need this behavior. Binary has it's own marker type, so it won't go through this conversion. String and text, which need this, will. Fixes #18585.
* / / Don't redefine autosave association callbacks in nested attrsSean Griffin2015-01-284-0/+13
|/ / | | | | | | | | | | | | | | These callbacks will already have been defined when the association was built. The check against `reflection.autosave` happens at call time, not at define time, so simply modifying the reflection is sufficient. Fixes #18704
* | Remove Relation#bind_paramsSean Griffin2015-01-2713-54/+43
| | | | | | | | | | | | | | | | `bound_attributes` is now used universally across the board, removing the need for the conversion layer. These changes are mostly mechanical, with the exception of the log subscriber. Additional, we had to implement `hash` on the attribute objects, so they could be used as a key for query caching.
* | Use an `Attribute` object to represent a bind valueSean Griffin2015-01-275-25/+13
| | | | | | | | | | | | | | | | | | | | | | The column is primarily used for type casting, which we're trying to separate from the idea of a column. Since what we really need is the combination of a name, type, and value, let's use the object that we already have to represent that concept, rather than this tuple. No consumers of the bind values have been changed, only the producers (outside of tests which care too much about internals). This is *finally* possible since the bind values are now produced from a reasonable number of lcoations.
* | `WhereClause#predicates` does not need to be publicSean Griffin2015-01-2710-125/+45
| | | | | | | | | | | | | | | | | | | | | | The only place it was accessed was in tests. Many of them have another way that they can test their behavior, that doesn't involve reaching into internals as far as they did. `AssociationScopeTest` is testing a situation where the where clause would have one bind param per predicate, so it can just ignore the predicates entirely. The where chain test was primarly duplicating the logic tested on `WhereClause` directly, so I instead just make sure it calls the appropriate method which is fully tested in isolation.
* | Move where grouping into `WhereClause`Sean Griffin2015-01-271-0/+33
| |
* | Move the `from` bind logic to a `FromClause` classSean Griffin2015-01-261-3/+3
| | | | | | | | | | | | | | Contrary to my previous commit message, it wasn't overkill, and led to much cleaner code. [Sean Griffin & anthonynavarre]
* | Remove `Relation#bind_values=`Sean Griffin2015-01-261-1/+1
| | | | | | | | | | | | | | | | | | | | The last place that was assigning it was when `from` is called with a relation to use as a subquery. The implementation was actually completely broken, and would break if you called `from` more than once, or if you called it on a relation, which also had its own join clause, as the bind values would get completely scrambled. The simplest solution was to just move it into its own array, since creating a `FromClause` class for this would be overkill.
* | Remove unused `bind` and `bind!` methods from `Relation`Sean Griffin2015-01-261-9/+0
| |
* | Go through normal `where` logic in `AssociationScope`Sean Griffin2015-01-261-1/+1
| | | | | | | | | | | | | | | | | | | | | | | | This removes the need to duplicate much of the logic in `WhereClause` and `PredicateBuilder`, simplifies the code, removes the need for the connection adapter to be continuously passed around, and removes one place that cares about the internal representation of `bind_values` Part of the larger refactoring to change how binds are represented internally [Sean Griffin & anthonynavarre]
* | Generate a query that makes sense when testing having clausesSean Griffin2015-01-261-3/+4
| | | | | | | | | | | | PG expects us to not give it nonsenes [Sean Griffin & anthonynavarre]
* | Change `having_values` to use the `WhereClause` classSean Griffin2015-01-261-2/+18
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | This fixed an issue where `having` can only be called after the last call to `where`, because it messes with the same `bind_values` array. With this change, the two can be called as many times as needed, in any order, and the final query will be correct. However, once something assigns `bind_values`, that stops. This is because we have to move all of the bind values from the having clause over to the where clause since we can't differentiate the two, and assignment was likely in the form of: `relation.bind_values += other.bind_values` This will go away once we remove all places that are assigning `bind_values`, which is next on the list. While this fixes a bug that was present in at least 4.2 (more likely present going back as far as 3.0, becoming more likely in 4.1 and later as we switched to prepared statements in more cases), I don't think this can be easily backported. The internal changes to `Relation` are non-trivial, anything that involves modifying the `bind_values` array would need to change, and I'm not confident that we have sufficient test coverage of all of those locations (when `having` was called with a hash that could generate bind values). [Sean Griffin & anthonynavarre]
* | Improve consistency of counter caches updating in memorySean Griffin2015-01-262-1/+10
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | When we made sure that the counter gets updated in memory, we only did it on the has many side. The has many side only does the update if the belongs to cannot. The belongs to side was updated to update the counter cache (if it is able). This means that we need to check if the belongs_to is able to update in memory on the has_many side. We also found an inconsistency where the reflection names were used to grab the association which should update the counter cache. Since reflection names are now strings, this means it was using a different instance than the one which would have the inverse instance set. Fixes #18689 [Sean Griffin & anthonynavarre]
* | Test association was eager loaded, rather than reaching into internalsSean Griffin2015-01-262-4/+4
| |
* | Move flattening records added to an association farther outSean Griffin2015-01-261-0/+9
| | | | | | | | | | | | | | | | | | There are many ways that things end up getting passed to `concat`. Not all of those entry points called `flatten` on their input. It seems that just about every method that is meant to take a single record, or that splats its input, is meant to also take an array. `concat` is the earliest point that is common to all of the methods which add records to the association. Partially fixes #18689
* | Remove all references to `where_values` in testsSean Griffin2015-01-2510-62/+62
| |
* | Move `where_unscoping` logic over to `WhereClause`Sean Griffin2015-01-251-0/+14
| |
* | Move `where.not` logic into `WhereClause`Sean Griffin2015-01-251-0/+26
| |
* | Remove all references to `where_values` in association codeSean Griffin2015-01-251-0/+5
| |
* | Move where merging logic over to `WhereClause`Sean Griffin2015-01-251-0/+42
| | | | | | | | | | | | This object being a black box, it knows the details of how to merge itself with another where clause. This removes all references to where values or bind values in `Relation::Merger`
* | Introduce `Relation::WhereClause`Sean Griffin2015-01-252-8/+43
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | The way that bind values are currently stored on Relation is a mess. They can come from `having`, `where`, or `join`. I'm almost certain that `having` is actually broken, and calling `where` followed by `having` followed by `where` will completely scramble the binds. Joins don't actually add the bind parameters to the relation itself, but instead add it onto an accessor on the arel AST which is undocumented, and unused in Arel itself. This means that the bind values must always be accessed as `relation.arel.bind_values + relation.bind_values`. Anything that doesn't is likely broken (and tons of bugs have come up for exactly that reason) The result is that everything dealing with `Relation` instances has to know far too much about the internals. The binds are split, combined, and re-stored in non-obvious ways that makes it difficult to change anything about the internal representation of `bind_values`, and is extremely prone to bugs. So the goal is to move a lot of logic off of `Relation`, and into separate objects. This is not the same as what is currently done with `JoinDependency`, as `Relation` knows far too much about its internals, and vice versa. Instead these objects need to be black boxes that can have their implementations swapped easily. The end result will be two classes, `WhereClause` and `JoinClause` (`having` will just re-use `WhereClause`), and there will be a single method to access the bind values of a `Relation` which will be implemented as ``` join_clause.binds + where_clause.binds + having_clause.binds ``` This is the first step towards that refactoring, with the internal representation of where changed, and an intermediate representation of `where_values` and `bind_values` to let the refactoring take small steps. These will be removed shortly.
* | Merge pull request #18474 from notEthan/pretty_print_inspectSean Griffin2015-01-231-0/+11
|\ \ | | | | | | | | | pretty_print will use #inspect if a subclass redefines it
| * | pretty_print will use #inspect if a subclass redefines itEthan2015-01-121-0/+11
| |/
* | Fix test failure on PG caused by 7c6f3938dee47f093Sean Griffin2015-01-231-2/+2
| |
* | Merge pull request #10776 from bogdan/assign-attributesSean Griffin2015-01-234-6/+6
|\ \ | | | | | | | | | Extracted attributes assingment from ActiveRecord to ActiveModel
| * | Extracted `ActiveRecord::AttributeAssignment` to ↵Bogdan Gusiev2015-01-234-6/+6
| | | | | | | | | | | | | | | | | | `ActiveModel::AttributesAssignment` Allows to use it for any object as an includable module.
* | | Move integer range validation to never raise on assignmentSean Griffin2015-01-232-15/+28
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | Given that this was originally added to normalize an error that would have otherwise come from the database (inconsistently), it's more natural for us to raise in `type_cast_for_database`, rather than `type_cast_from_user`. This way, things like numericality validators can handle it instead if the user chooses to do so. It also fixes an issue where assigning an out of range value would make it impossible to assign a new value later. This fixes several vague issues, none of which were ever directly reported, so I have no issue number to give. Places it was mentioned which I can remember: - https://github.com/thoughtbot/shoulda-matchers/blob/9ba21381d7caf045053a81f32df7de2f49687820/lib/shoulda/matchers/active_model/allow_value_matcher.rb#L261-L263 - https://github.com/rails/rails/issues/18653#issuecomment-71197026
* | | Errors raised in `type_cast_for_database` no longer raise on assignmentSean Griffin2015-01-231-0/+17
| | | | | | | | | | | | Fixes #18580.
* | | Don't remove join dependencies in `Relation#exists?`Sean Griffin2015-01-231-0/+6
|/ / | | | | | | Fixes #18632
* | Don't error when invalid json is assigned to a JSON columnSean Griffin2015-01-211-0/+8
| | | | | | | | | | | | | | Keeping with our behavior elsewhere in the system, invalid input is assumed to be `nil`. Fixes #18629.
* | Replace `if exists` with `table_exists?` and drop table statement with ↵Yasuo Honda2015-01-212-3/+3
| | | | | | | | | | | | | | `drop_table` since 'drop table if exists' statement does not always work with some databases such as Oracle. also Oracle drop table statement will not drop sequence objects.
* | Introduce `ActiveRecord::Base#accessed_fields`Sean Griffin2015-01-203-0/+40
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | This method can be used to see all of the fields on a model which have been read. This can be useful during development mode to quickly find out which fields need to be selected. For performance critical pages, if you are not using all of the fields of a database, an easy performance win is only selecting the fields which you need. By calling this method at the end of a controller action, it's easy to determine which fields need to be selected. While writing this, I also noticed a place for an easy performance win internally which I had been wanting to introduce. You cannot mutate a field which you have not read. Therefore, we can skip the calculation of in place changes if we have never read from the field. This can significantly speed up methods like `#changed?` if any of the fields have an expensive mutable type (like `serialize`) ``` Calculating ------------------------------------- #changed? with serialized column (before) 391.000 i/100ms #changed? with serialized column (after) 1.514k i/100ms ------------------------------------------------- #changed? with serialized column (before) 4.243k (± 3.7%) i/s - 21.505k #changed? with serialized column (after) 16.789k (± 3.2%) i/s - 84.784k ```
* | TransactionManager should call rollback recordsArthur Neves2015-01-201-1/+1
| |
* | Merge pull request #18458 from brainopia/fix_after_commit_for_fixturesJeremy Kemper2015-01-203-18/+31
|\ \ | | | | | | Support after_commit callbacks in transactional fixtures
| * | after_commit runs after transactions with non-joinable parentsbrainopia2015-01-163-18/+31
| | | | | | | | | | | | | | | | | | after_commit callbacks run after committing a transaction whose parent is not `joinable?`: un-nested transactions, transactions within test cases, and transactions in `console --sandbox`.
* | | tests, use `drop_table if_exists: true` in our test suite.Yves Senn2015-01-209-13/+13
| | |
* | | Merge pull request #18597 from kamipo/add-if-exists-to-drop-tableYves Senn2015-01-201-0/+11
|\ \ \ | | | | | | | | Add an `:if_exists` option to `drop_table`
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-18 09:23:26 +0000