aboutsummaryrefslogtreecommitdiffstats
path: root/activerecord/lib/active_record/connection_adapters/column.rb
Commit message (Collapse)AuthorAgeFilesLines
* Move the collation handling code from the MySQL adapter to common classesRyuta Kamizono2015-05-041-3/+4
| | | | | Some databases like MySQL allow defining collation charset for specific columns.
* Add `:charset` and `:collation` options support for MySQL string and text ↵Ryuta Kamizono2015-03-061-0/+1
| | | | | | | | | | | columns Example: create_table :foos do |t| t.string :string_utf8_bin, charset: 'utf8', collation: 'utf8_bin' t.text :text_ascii, charset: 'ascii' end
* Correctly dump `serial` and `bigserial`Ryuta Kamizono2015-03-041-1/+1
|
* Add `Column#bigint?` methodRyuta Kamizono2015-03-041-0/+4
|
* rm `Column#cast_type`Sean Griffin2015-02-031-21/+13
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | The type from the column is never used, except when being passed to the attributes API. While leaving the type on the column wasn't necessarily a bad thing, I worry that it's existence there implies that it is something which should be used. During the design and implementation process of the attributes API, there have been plenty of cases where getting the "right" type object was hard, but I had easy access to the column objects. For any contributor who isn't intimately familiar with the intents behind the type casting system, grabbing the type from the column might easily seem like the "correct" thing to do. As such, the goal of this change is to express that the column is not something that should be used for type casting. The only places that are "valid" (at the time of this commit) uses of acquiring a type object from the column are fixtures (as the YAML file is going to mirror the database more closely than the AR object), and looking up the type during schema detection to pass to the attributes API Many of the failing tests were removed, as they've been made obsolete over the last year. All of the PG column tests were testing nothing beyond polymorphism. The Mysql2 tests were duplicating the mysql tests, since they now share a column class. The implementation is a little hairy, and slightly verbose, but it felt preferable to going back to 20 constructor options for the columns. If you are git blaming to figure out wtf I was thinking with them, and have a better idea, go for it. Just don't use a type object for this.
* Remove unused `Column#with_type`Sean Griffin2015-02-021-6/+0
| | | | | Now that type casting has nothing to do with columns, our only usage of this method is gone.
* Remove most type related predicates from `Column`Sean Griffin2015-01-301-5/+1
| | | | | | 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
* Change the behavior of boolean columns to be closer to Ruby's semantics.Rafael Mendonça França2015-01-041-1/+0
| | | | | | | | Before this change we had a small set of "truthy", and all others are "falsy". Now, we have a small set of "falsy" values and all others are "truthy" matching Ruby's semantics.
* Return a null column from `column_for_attribute` when no column exists.Rafael Mendonça França2015-01-041-0/+6
| | | | | | | | This reverts commit ae96f229f6501d8635811d6b22d75d43cdb880a4. Conflicts: activerecord/CHANGELOG.md activerecord/lib/active_record/attribute_methods.rb
* Prefer `array?` rather than `array`Ryuta Kamizono2015-01-041-2/+2
| | | | | | Slightly refactoring `PostgreSQLColumn`. `array` should be readonly. `default_function` should be initialized by `super`. `sql_type` has been removed `[]`. Since we already choose to remove it we should not change.
* Correctly ignore `case_sensitive` for UUID uniqueness validationSean Griffin2014-12-261-1/+1
| | | | | | | | I think we should deprecate this behavior and just error if you tell us to do a case insensitive comparison for types which are not case sensitive. Partially reverts 35592307 Fixes #18195
* Add mysql and pg specific attributes to Column#== and hashSean Griffin2014-10-281-2/+9
|
* Implement hash equality on columnSean Griffin2014-10-281-0/+5
| | | | | | The query cache uses bind values as hash keys. The current implementation relies on reference equality for hash equality. This is brittle, and can easily break in the future.
* Implement #== for columnSean Griffin2014-10-281-0/+8
| | | | We shouldn't rely on reference equality of these objects in tests
* Remove unused text? predicate method and delegationCarlos Antonio da Silva2014-08-051-1/+1
| | | | | | | | The method has been removed in 09206716f8695f6b8467f15c1befa5a4c3c10978 (PR #16074), but the delegation was apparently missed, and one instance of the method was added back with the addition of OID::Xml in 336be2bdf7dfa1b31879d0ab27e5f3101b351923 (PR #16072), so we can safely rm both.
* Add a deprecation cycle for `NullColumn` from `column_for_attribute`Sean Griffin2014-06-231-6/+0
| | | | | | This is public API, and `simple_form` depends on the `nil` return value. We need to go through a deprecation cycle to return a null object. If people want hash access, they can access the hash.
* Don't type cast the default on the columnSean Griffin2014-06-171-7/+2
| | | | | | | If we want to have type decorators mess with the attribute, but not the column, we need to stop type casting on the column. Where possible, we changed the tests to test the value of `column_defaults`, which is public API. `Column#default` is not.
* Remove `serialized?` from the type interfaceSean Griffin2014-06-131-1/+1
|
* Remove YAML serialization workaround for columnsSean Griffin2014-06-111-6/+2
| | | | | We are no longer including column objects in YAML serialization, thanks to https://github.com/rails/rails/pull/15621
* Keep the types of virtual columns after yaml serializationSean Griffin2014-06-101-2/+6
| | | | | On MySQL and PostgreSQL, the adapter does not type cast virtual columns for us.
* Rename `type_cast` to `type_cast_from_database`Sean Griffin2014-06-091-2/+2
| | | | | | | | In some cases there is a difference between the two, we should always be doing one or the other. For convenience, `type_cast` is still a private method on type, so new types that do not need different behavior don't need to implement two methods, but it has been moved to private so it cannot be used accidentally.
* Make `_before_type_cast` actually be before type castSean Griffin2014-06-091-1/+1
| | | | | | | | | | | | | - The following is now true for all types, all the time - `model.attribute_before_type_cast == given_value` - `model.attribute == model.save_and_reload.attribute` - `model.attribute == model.dup.attribute` - `model.attribute == YAML.load(YAML.dump(model)).attribute` - Removes the remaining types implementing `type_cast_for_write` - Simplifies the implementation of time zone aware attributes - Brings tz aware attributes closer to being implemented as an attribute decorator - Adds additional point of control for custom types
* Don't query the database schema when calling `serialize`Sean Griffin2014-06-071-4/+11
| | | | | | We need to decorate the types lazily. This is extracted to a separate API, as there are other refactorings that will be able to make use of it, and to allow unit testing the finer points more granularly.
* have an actual `NullColumn` object and update docs accordingly.Yves Senn2014-06-041-0/+6
| | | | | | Follow up to #15438 and #15502. /cc @sgrif
* Merge pull request #15492 from sgrif/sg-dirty-defaultsRafael Mendonça França2014-06-031-1/+1
|\ | | | | Keep column defaults in type cast form
| * Keep column defaults in type cast formSean Griffin2014-06-031-1/+1
| | | | | | | | | | | | | | | | | | | | The contract of `_field_changed?` assumes that the old value is always type cast. That is not the case for the value in `Column#default` as things are today. It appears there are other public methods that assume that `Column#default` is type cast, as well. The reason for this change originally was because the value gets put into `@raw_attributes` in initialize. This reverts to the old behavior on `Column`, and updates `initialize` to make sure that the values are in the right format.
* | Refactor determination of whether the field has changedSean Griffin2014-06-031-1/+1
|/ | | | | The types know more about what is going on than the dirty module. Let's ask them!
* Remove most code related to serialized propertiesSean Griffin2014-06-011-2/+2
| | | | | | | | | | | Nearly completely implemented in terms of custom properties. `_before_type_cast` now stores the raw serialized string consistently, which removes the need to keep track of "state". The following is now consistently true: - `model.serialized == model.reload.serialized` - A model can be dumped and loaded infinitely without changing - A model can be saved and reloaded infinitely without changing
* refactor, introduce `Type#type_cast_for_schema` to cast for schema.rbYves Senn2014-05-301-0/+1
| | | | | | | This removes the case statement in `SchemaDumper` and gives every `Type` the possibility to control the SchemaDumper default value output. /cc @sgrif
* Move `type_cast_for_write` behavior over to the serialized type objectSean Griffin2014-05-291-1/+1
|
* Refactor serialized types to be partially defined as custom propertiesSean Griffin2014-05-291-2/+4
| | | | | | | Many of the methods defined in `AttributeMethods::Serialization` can be refactored onto this type as well, but this is a reasonable small step. Removes the `Type` class, and the need for `decorate_columns` to handle serialized types.
* Remove unused `Column#coder`Sean Griffin2014-05-281-14/+1
| | | | | It appears this property was added, but never actually used. It would be broken if it were, as it only type casts one way.
* Add an interface for type objects to control Ruby => SQLSean Griffin2014-05-261-1/+2
| | | | | Adds the ability to save custom types, which type cast to non-primitive ruby objects.
* Remove `Column#primary`Sean Griffin2014-05-231-2/+1
| | | | | | | | It appears to have been used at some point in the past, but is no longer used in any meaningful way. Whether a column is considered primary is a property of the model, not the schema/column. This also removes the need for yet another layer of caching of the model's schema, and we can leave that to the schema cache.
* Push limit to type objectsSean Griffin2014-05-221-8/+2
| | | | | Columns and injected types no longer have any conditionals based on the format of SQL type strings! Hooray!
* Push precision to type objectsSean Griffin2014-05-221-5/+2
|
* Push scale to type objectsSean Griffin2014-05-221-4/+3
| | | | | | Ideally types will be usable without having to specify a sql type string, so we should keep the information related to parsing them on the adapter or another object.
* Move `extract_precision` onto type objectsDan Croak and Sean Griffin2014-05-221-5/+1
|
* push `extract_scale` to the `Type`.Yves Senn2014-05-211-1/+1
| | | | | | | - `extract_precision`, `extract_limit`, and `extract_default` probably need to follow. - would be good to remove the delegation `Column#extract_scale`. /cc @sgrif
* Delegate `klass` to the injected type objectSean Griffin2014-05-201-14/+1
|
* Delegate `type_cast_for_write` to injected type objectSean Griffin2014-05-201-19/+1
|
* Merge pull request #15207 from sgrif/sg-inline-column-helpersRafael Mendonça França2014-05-201-112/+0
|\ | | | | Inline typecasting helpers from Column to the appropriate types
| * Inline typecasting helpers from Column to the appropriate typesSean Griffin2014-05-201-112/+0
| |
* | Delegate predicate methods to injected type object on ColumnSean Griffin2014-05-201-15/+1
|/
* Replace `type_cast` case statement with delegationSean Griffin2014-05-201-22/+4
| | | | | | | | All subclasses of column were now delegating `type_cast` to their injected type object. We can remove the overriding methods, and generalize it on the `Column` class itself. This also enabled us to remove several column classes completely, as they no longer had any meaningful behavior of their own.
* Delegate type_cast to injected type object in mysqlSean Griffin2014-05-201-15/+2
|
* Remove :timestamp column typeSean Griffin2014-05-191-2/+2
| | | | | | | | | | | | The `:timestamp` type for columns is unused. All database adapters treat them as the same database type. All code in `ActiveRecord` which changes its behavior based on the column's type acts the same in both cases. However, when the type is passed to code that checks for the `:datetime` type, but not `:timestamp` (such as XML serialization), the result is unexpected behavior. Existing schema definitions will continue to work, and the `timestamp` type is transparently aliased to `datetime`.
* Delegate `Column#type` to the injected type objectSean Griffin2014-05-191-36/+5
| | | | | | | | | | | | | | | | The decision to wrap type registrations in a proc was made for two reasons. 1. Some cases need to make an additional decision based on the type (e.g. a `Decimal` with a 0 scale) 2. Aliased types are automatically updated if they type they point to is updated later. If a user or another adapter decides to change the object used for `decimal` columns, `numeric`, and `number` will automatically point to the new type, without having to track what types are aliased explicitly. Everything else here should be pretty straightforward. PostgreSQL ranges had to change slightly, since the `simplified_type` method is gone.
* Add a type object to Column constructorSean Griffin2014-05-171-1/+3
| | | | | | Part of #15134. In order to perform typecasting polymorphically, we need to add another argument to the constructor. The order was chosen to match the `oid_type` on `PostgreSQLColumn`.
* [ci skip] document type_cast_for_writeschneems2014-05-071-0/+2
|
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-05 04:06:27 +0000