arel-helpers - GitLite

KO | EN

gitlite — search

#hacktoberfest #typescript #machine-learning #rust #linux #docker #macos #windows #vue #awesome-list #pytorch #ios #openai #open-source

arel-helpers

(★ 430)

Useful tools to help construct database queries with ActiveRecord and Arel.

파일 탐색기

최종 버전 다운로드 (.zip)

- - unit_tests.yml
- rails_4.0.x.gemfile
- rails_4.1.x.gemfile
- rails_4.2.x.gemfile
- rails_5.0.x.gemfile
- rails_5.1.x.gemfile
- rails_5.2.0.gemfile
- rails_5.2.1.gemfile
- rails_6.0.x.gemfile
- rails_6.1.x.gemfile
- rails_7.0.x.gemfile
- rails_7.1.x.gemfile
- rails_7.2.x.gemfile
- rails_8.0.x.gemfile
- rails_8.1.x.gemfile
- - aliases.rb
  - arel_table.rb
  - join_association.rb
  - query_builder.rb
  - version.rb
- arel-helpers.rb
- - models.rb
- aliases_spec.rb
- arel_table_spec.rb
- join_association_spec.rb
- query_builder_spec.rb
- spec_helper.rb
.gitignore
.rspec
.tool-versions
Appraisals
arel-helpers.gemspec
CHANGELOG.md
Gemfile
LICENSE.txt
Rakefile
README.md

# 설치 가이드

1. 코드 내려받기

git clone https://github.com/camertron/arel-helpers

깃허브에서 프로젝트 코드 전체를 내 컴퓨터로 내려받습니다.

cd arel-helpers

방금 내려받은 프로젝트 폴더 안으로 이동합니다.

2. Ruby

쉬움 추천

사전 준비물

Git GitHub에서 프로젝트 코드를 내려받으려면 필요합니다.
Ruby bundle 명령어를 쓰려면 Ruby가 필요합니다.

bundle install

Gemfile에 명시된 루비 라이브러리를 설치합니다.

✅ bundle install이 에러 없이 끝나면 README에 안내된 실행 명령어(예: rails server)로 마저 실행해보세요.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

![Unit Tests](https://github.com/camertron/arel-helpers/actions/workflows/unit_tests.yml/badge.svg?branch=master)

## arel-helpers

Useful tools to help construct database queries with ActiveRecord and Arel.

## Installation

`gem install arel-helpers`

## Usage

```ruby
require 'arel-helpers'
```

### ArelTable Helper

Usually you'd reference database columns in Arel via the `#arel_table` method on your ActiveRecord models. For example:

```ruby
class Post < ActiveRecord::Base
  ...
end

Post.where(Post.arel_table[:id].eq(1))
```

Typing ".arel_table" over and over again can get pretty old and make constructing queries unnecessarily verbose. Try using the `ArelTable` helper to clean things up a bit:

```ruby
class Post < ActiveRecord::Base
  include ArelHelpers::ArelTable
  ...
end

Post.where(Post[:id].eq(1))
```

### JoinAssociation Helper

Using pure Arel is one of the only ways to do an outer join with ActiveRecord. For example, let's say we have these two models:

```ruby
class Author < ActiveRecord::Base
  has_many :posts

# attribute id
  # attribute username
end

class Post < ActiveRecord::Base
  belongs_to :author
  has_many :comments

# attribute id
  # attribute author_id
  # attribute subject
end

class Comment < ActiveRecord::Base
  belongs_to :post
  belongs_to :author

# attribute id
  # attribute post_id
  # attribute author_id
end
```

A join between posts and comments might look like this:

```ruby
Post.joins(:comments)
```

ActiveRecord introspects the association between posts and comments and automatically chooses the right columns to use in the join conditions.

Things start to get messy however if you want to do an outer join instead of the default inner join. Your query might look like this:

```ruby
Post.joins(
  Post.arel_table.join(Comment.arel_table, Arel::Nodes::OuterJoin)
    .on(Post[:id].eq(Comment[:post_id]))
    .join_sources
)
```

Such verbose. Much code. Very bloat. Wow. We've lost all the awesome association introspection that ActiveRecord would otherwise have given us. Enter `ArelHelpers.join_association`:

```ruby
Post.joins(
  ArelHelpers.join_association(Post, :comments, Arel::Nodes::OuterJoin)
)
```

Easy peasy.

Note that pretty much anything you can pass to ActiveRecord's `#join` method you can also pass to `#join_association`'s second argument. For example, you can pass a hash to indicate a set of nested associations:

```ruby
Post.joins(
  ArelHelpers.join_association(Post, { comments: :author })
)
```

This might execute the following query:

```sql
SELECT "posts".*
FROM "posts"
INNER JOIN "comments" ON "comments"."post_id" = "posts"."id"
INNER JOIN "authors" ON "authors"."id" = "comments"."author_id"
```

`#join_association` also allows you to customize the join conditions via a block:

```ruby
Post.joins(
  ArelHelpers.join_association(Post, :comments, Arel::Nodes::OuterJoin) do |assoc_name, join_conditions|
    join_conditions.and(Post[:author_id].eq(4))
  end
)
```

But wait, there's more! Include the `ArelHelpers::JoinAssociation` concern into your models to have access to the `join_association` method directly from the model's class:

```ruby
include ArelHelpers::JoinAssociation

Post.joins(
  Post.join_association(:comments, Arel::Nodes::OuterJoin) do |assoc_name, join_conditions|
    join_conditions.and(Post[:author_id].eq(4))
  end
)
```

### Query Builders

ArelHelpers also contains a very simple class that's designed to provide a light framework for constructing queries using the builder pattern. For example, let's write a class that encapsulates generating queries for blog posts:

```ruby
class PostQueryBuilder < ArelHelpers::QueryBuilder
  def initialize(query = nil)
    # whatever you want your initial query to be
    super(query || post.unscoped)
  end

def with_title_matching(title)
    reflect(
      query.where(post[:title].matches("%#{title}%"))
    )
  end

def with_comments_by(usernames)
    reflect(
      query
        .joins(comments: :author)
        .where(author[:username].in(usernames))
    )
  end

def since_yesterday
    reflect(
      query.where(post[:created_at].gteq(Date.yesterday))
    )
  end

private

def author
    Author
  end

def post
    Post
  end
end
```

The `#reflect` method creates a new instance of `PostQueryBuilder`, copies the query into it and returns the new query builder instance. This allows you to chain your method calls:

```ruby
PostQueryBuilder.new
  .with_comments_by(['camertron', 'catwithtail'])
  .with_title_matching("arel rocks")
  .since_yesterday
```

#### Conditional reflections

If you have parts of a query that should only be added under certain conditions you can return `reflect(query)` from your method. E.g:

```ruby
  def with_comments_by(usernames)
    if usernames
      reflect(
        query.where(post[:title].matches("%#{title}%"))
      )
    else
      reflect(query)
    end
  end
```

This can become repetitive, and as an alternative you can choose to prepend `not_nil` to your method definition:

```ruby
  class PostQueryBuilder < ArelHelpers::QueryBuilder
    not_nil def with_comments_by(usernames)
      reflect(query.where(post[:title].matches("%#{title}%"))) if usernames
    end
  end
```

## Requirements

Requires ActiveRecord >= 3.1.0, < 8.1. Depends on SQLite for testing purposes.

## Running Tests

`bundle exec rspec`

## Authors

- Cameron C. Dutro: http://github.com/camertron