kotovalexarian-likes-github/rails--rails
1
0
Fork 0
mirror of https://github.com/rails/rails.git synced 2022-11-09 12:12:34 -05:00
Code Releases Activity
rails--rails/activerecord/lib/arel/nodes.rb

72 lines
1.7 KiB
Ruby
Raw Normal View History

Enable frozen_string_literal in all files in arel
2017-02-13 13:58:58 -05:00
# frozen_string_literal: true
Arel: rubocop -a
2018-02-24 01:45:50 -05:00
cleaning up more nodes
2010-12-15 00:06:16 -05:00
# node
Arel: rubocop -a
2018-02-24 01:45:50 -05:00
require "arel/nodes/node"
require "arel/nodes/node_expression"
require "arel/nodes/select_statement"
require "arel/nodes/select_core"
require "arel/nodes/insert_statement"
require "arel/nodes/update_statement"
require "arel/nodes/bind_param"
cleaning up more nodes
2010-12-14 23:53:19 -05:00
adding Distinct ON node
2011-04-21 16:46:24 -04:00
# terminal
Arel: rubocop -a
2018-02-24 01:45:50 -05:00
require "arel/nodes/terminal"
require "arel/nodes/true"
require "arel/nodes/false"
adding Distinct ON node
2011-04-21 16:46:24 -04:00
cleaning up more nodes
2010-12-15 00:06:16 -05:00
# unary
Arel: rubocop -a
2018-02-24 01:45:50 -05:00
require "arel/nodes/unary"
require "arel/nodes/grouping"
Perf: Improve performance of where when using an array of values A coworker at GitHub found a few months back that if we used `santitize_sql` over `where` when we knew the values going into `where` it was a lot faster than `where`. This PR adds a new Arel node type called `HomogenousIn` that will be used when Rails knows the values are all homogenous and can therefore pick a faster codepath. This new codepath skips some of the required processing by `where` to make `wheres` with homogenous arrays faster without requiring the application author to know when to use which query type. Using our benchmark code: ```ruby ids = (1..1000).each.map do |n| Post.create!.id end Benchmark.ips do |x| x.report("where with ids") do Post.where(id: ids).to_a end x.report("where with sanitize") do Post.where(ActiveRecord::Base.sanitize_sql(["id IN (?)", ids])).to_a end x.compare! end ``` Before this PR comparing where with a list of IDs to santitize sql: ``` Warming up -------------------------------------- where with ids 11.000 i/100ms where with sanitize 17.000 i/100ms Calculating ------------------------------------- where with ids 115.733 (± 4.3%) i/s - 583.000 in 5.045828s where with sanitize 174.231 (± 4.0%) i/s - 884.000 in 5.081495s Comparison: where with sanitize: 174.2 i/s where with ids: 115.7 i/s - 1.51x slower ``` After this PR comparing where with a list of IDs to santitize sql: ``` Warming up -------------------------------------- where with ids 16.000 i/100ms where with sanitize 19.000 i/100ms Calculating ------------------------------------- where with ids 158.293 (± 6.3%) i/s - 800.000 in 5.072208s where with sanitize 169.141 (± 3.5%) i/s - 855.000 in 5.060878s Comparison: where with sanitize: 169.1 i/s where with ids: 158.3 i/s - same-ish: difference falls within error ``` Co-authored-by: Aaron Patterson <aaron.patterson@gmail.com>
2020-01-14 16:14:39 -05:00
require "arel/nodes/homogeneous_in"
Allow #nulls_first and #nulls_last in PostgreSQL When using PostgreSQL, it's useful to be able to specify NULLS FIRST and NULLS LAST on ordered columns. With this commit you can do that now, as in: ```ruby User.arel_table[:first_name].desc.nulls_last ```
2019-12-31 15:59:59 -05:00
require "arel/nodes/ordering"
Arel: rubocop -a
2018-02-24 01:45:50 -05:00
require "arel/nodes/ascending"
require "arel/nodes/descending"
require "arel/nodes/unqualified_column"
require "arel/nodes/with"
cleaning up more nodes
2010-12-14 23:53:19 -05:00
cleaning up more nodes
2010-12-15 00:06:16 -05:00
# binary
Arel: rubocop -a
2018-02-24 01:45:50 -05:00
require "arel/nodes/binary"
require "arel/nodes/equality"
Arel: Add support for FILTER clause (SQL:2003) Currently supported by PostgreSQL 9.4+ and SQLite 3.30+ See: - http://modern-sql.com/feature/filter - https://www.postgresql.org/docs/9.4/static/sql-expressions.html#SYNTAX-AGGREGATES - https://sqlite.org/lang_aggfunc.html#aggfilter Example: Model.all.pluck( Arel.star.count.as('records_total').to_sql, Arel.star.count.filter(Model.arel_table[:some_column].not_eq(nil)).as('records_filtered').to_sql, )
2020-10-30 13:11:19 -04:00
require "arel/nodes/filter"
Implement `equality?` rather than inheriting `Equality` for `In` node Related #39644. Historically subclasses of `Equality` has a special equality ability, but it has migrated to `equality?` method. Since we have added `HomogeneousIn`, `Equality === node` could no longer detect all equality nodes, we should check the response of `equality?` method for the purpose. Originally, it wasn't common understanding that the `In` node was a subclass of the `Equality` node, so it was unclear whether `Equality === node` really wanted to detect the `In` node as well. As another problem, we need to check `In === node` first if intend to detect only `Equality` node. Example: https://github.com/rails/rails/blob/4148590ed99f76debd2a016ed03d2e2bd65eab37/activerecord/lib/active_record/relation/where_clause.rb#L98-L103 This solves the problems described above.
2020-06-14 01:20:22 -04:00
require "arel/nodes/in"
Arel: rubocop -a
2018-02-24 01:45:50 -05:00
require "arel/nodes/join_source"
require "arel/nodes/delete_statement"
require "arel/nodes/table_alias"
require "arel/nodes/infix_operation"
require "arel/nodes/unary_operation"
require "arel/nodes/over"
require "arel/nodes/matches"
require "arel/nodes/regexp"
cleaning up more nodes
2010-12-15 00:06:16 -05:00
# nary
Arel: rubocop -a
2018-02-24 01:45:50 -05:00
require "arel/nodes/and"
cleaning up more nodes
2010-12-15 00:06:16 -05:00
# function
# FIXME: Function + Alias can be rewritten as a Function and Alias node.
# We should make Function a Unary node and deprecate the use of "aliaz"
Arel: rubocop -a
2018-02-24 01:45:50 -05:00
require "arel/nodes/function"
require "arel/nodes/count"
require "arel/nodes/extract"
require "arel/nodes/values_list"
require "arel/nodes/named_function"
cleaning up more nodes
2010-12-15 00:06:16 -05:00
Support ANSI SQL2003 window functions.
2012-02-22 09:25:10 -05:00
# windows
Arel: rubocop -a
2018-02-24 01:45:50 -05:00
require "arel/nodes/window"
Support ANSI SQL2003 window functions.
2012-02-22 09:25:10 -05:00
Implement CASE Conditional Expression
2015-12-19 13:40:46 -05:00
# conditional expressions
Arel: rubocop -a
2018-02-24 01:45:50 -05:00
require "arel/nodes/case"
Implement CASE Conditional Expression
2015-12-19 13:40:46 -05:00
cleaning up more nodes
2010-12-15 00:06:16 -05:00
# joins
Arel: rubocop -a
2018-02-24 01:45:50 -05:00
require "arel/nodes/full_outer_join"
require "arel/nodes/inner_join"
require "arel/nodes/outer_join"
require "arel/nodes/right_outer_join"
require "arel/nodes/string_join"
cleaning up more nodes
2010-12-15 00:06:16 -05:00
Add Relation#annotate for SQL commenting This patch has two main portions: 1. Add SQL comment support to Arel via Arel::Nodes::Comment. 2. Implement a Relation#annotate method on top of that. == Adding SQL comment support Adds a new Arel::Nodes::Comment node that represents an optional SQL comment and teachers the relevant visitors how to handle it. Comment nodes may be added to the basic CRUD statement nodes and set through any of the four (Select|Insert|Update|Delete)Manager objects. For example: manager = Arel::UpdateManager.new manager.table table manager.comment("annotation") manager.to_sql # UPDATE "users" /* annotation */ This new node type will be used by ActiveRecord::Relation to enable query annotation via SQL comments. == Implementing the Relation#annotate method Implements `ActiveRecord::Relation#annotate`, which accepts a comment string that will be appeneded to any queries generated by the relation. Some examples: relation = Post.where(id: 123).annotate("metadata string") relation.first # SELECT "posts".* FROM "posts" WHERE "posts"."id" = 123 # LIMIT 1 /* metadata string */ class Tag < ActiveRecord::Base scope :foo_annotated, -> { annotate("foo") } end Tag.foo_annotated.annotate("bar").first # SELECT "tags".* FROM "tags" LIMIT 1 /* foo */ /* bar */ Also wires up the plumbing so this works with `#update_all` and `#delete_all` as well. This feature is useful for instrumentation and general analysis of queries generated at runtime.
2019-03-14 15:57:14 -04:00
require "arel/nodes/comment"
Arel: rubocop -a
2018-02-24 01:45:50 -05:00
require "arel/nodes/sql_literal"
add the casting node to the AST at build time If we add the casting node to the ast at build time, then we can avoid doing the lookup at visit time.
2014-03-24 19:26:09 -04:00
Arel: rubocop -a
2018-02-24 01:45:50 -05:00
require "arel/nodes/casted"
Copy permalink