Group items tagged

Return an ActiveRecord::Relation

Filtering in Ruby is slower

trigger the query and therefore, we lose our Relation

leaving trivial ordering out of scopes all together.

where

where

ActiveRecord provides an easy API for doing many things with our database, but it also makes it pretty easy to do things inefficiently. The layer of abstraction hides what’s really happening.

first pure SQL, then ActiveRecord

Databases can only do fast lookups for columns with indexes, otherwise it’s doing a sequential scan

Add an index on every id column as well as any column that is used in a where clause.

use a Query class to encapsulate the potentially gnarly query.

subqueries

Single Responsibility Principle

Avoid ad-hoc queries outside of Scopes and Query Objects

encapsulate data access into scopes and Query objects

An ad-hoc query embedded in a controller (or view, task, etc) is harder to test in isolation and cannot be reused

to scopes and Query objects

Every databases provides more datatypes than your ORM might have you believe

Both Postgres and MySQL have full-text search capabilities

end up with invalid data

Any other changed attributes are also saved

set all the attributes you pass it. The changes are not saved to the database. Any attributes you don’t pass will be left unchanged

also saves other changed attributes to the database

executes a direct SQL UPDATE query and bypasses any validations or callbacks.

finds the object with the specified ID and updates it’s attributes with the passed in hash

pass in an array of ID’s and parameters

runs an SQL UPDATE query that updates the attributes of all objects without running any validations or callbacks

call this method on a scoped relation

objects carry both persistent data and behavior which operates on that data

Object-Relational Mapping, commonly referred to as its abbreviation ORM, is a technique that connects the rich objects of an application to tables in a relational database management system

Represent associations between these models

Validate models before they get persisted to the database

The idea is that if you configure your applications in the very same way most of the times then this should be the default way.

use the ActiveRecord::Base.table_name= method to specify the table name

Foreign keys - These fields should be named following the pattern singularized_table_name_id

Primary keys - By default, Active Record will use an integer column named id as the table's primary key

created_at

updated_at

(table_name)_count - Used to cache the number of belonging objects on associations.

Single Table Inheritance (STI)

Object Relational Mapping

class_name.yml

ActiveRecord::Base.primary_key=

CRUD is an acronym for the four verbs we use to operate on data: Create, Read, Update and Delete.

new method will return a new object

create will return the object and save it to the database.

Using the new method, an object can be instantiated without being saved

user.save will commit the record to the database

update_all class method

an Active Record object can be destroyed which removes it from the database

Validation is a very important issue to consider when persisting to database, so the methods create, save and update take it into account when running: they return false when validation fails and they didn't actually perform any operation on database.

Active Record callbacks allow you to attach code to certain events in the life-cycle of your models

Rails keeps track of which files have been committed to the database and provides rollback features

Convention over Configuration

Replace MODEL with the class name used for the application’s users (it’s frequently User but could also be Admin)

If you add an option, be sure to inspect the migration file (created by the generator if your ORM supports them) and uncomment the appropriate section

set up the default URL options for the Devise mailer in each environment

should restart your application after changing Devise's configuration options

set up a controller with user authentication, just add this before_action

when using a :user resource, the user_root_path will be used if it exists; otherwise, the default root_path will be used