When working with database queries in Active Record, it's essential to understand the precise behavior of query methods to avoid unexpected results and performance issues. Key considerations: 1. **Method Override Behaviors**: Some methods replace previous configurations rather than augmenting them. For example, `pluck` ignores any previous `select` clauses: ```ruby # This ignores the select(:email) - only id is selected Customer.select(:email).pluck(:id) # => SELECT "customers"."id" FROM customers # For raw SQL in pluck, use Arel.sql: Customer.pluck(Arel.sql("DISTINCT id")) # => SELECT DISTINCT id FROM customers ``` 2. **Query Merging Complexity**: When combining queries with `merge`, `or`, and `and`, be careful about how conditions are combined to avoid incorrect SQL generation: ```ruby # Complex queries can generate unexpected SQL if not carefully constructed base = Comment.joins(:post).where(user_id: 1).where("recent = 1") base.merge(base.where(draft: true).or(Post.where(archived: true))) ``` 3. **Index Usage Control**: For performance optimization, understand how to control which indexes are used in queries: ```ruby # When using implicit_order_column with multiple columns # Adding nil at the end prevents appending the primary key add_index :users, [:created_at, :id], name: "optimal_recent_users_query" User.implicit_order_column = [:created_at, nil] # Prevents adding id twice to ORDER BY ``` Carefully understanding these behaviors helps you write more predictable, efficient database queries and avoid unexpected results when refactoring.