当前位置：首页 > news >正文

Ecto查询构建器终极指南：从基础到高级查询技巧完全掌握

news 2026/8/31 19:12:26

Ecto查询构建器终极指南：从基础到高级查询技巧完全掌握

【免费下载链接】ectoA toolkit for data mapping and language integrated query.项目地址: https://gitcode.com/gh_mirrors/ec/ecto

Ecto是Elixir生态中强大的数据映射和查询工具，它提供了直观的查询构建器API，帮助开发者轻松编写安全、高效的数据库查询。本指南将从基础语法到高级技巧，全面解析Ecto查询构建器的使用方法，让你快速掌握从简单筛选到复杂关联查询的全部技能。

快速入门：Ecto查询基础语法

Ecto查询构建器支持两种主要语法：关键字语法和管道语法。两种方式功能等效，可根据个人习惯选择。

关键字语法基础

关键字语法通过from/2宏创建查询，所有条件通过关键字列表定义：

# 导入Ecto.Query模块 import Ecto.Query, only: [from: 2] # 基础查询示例 query = from u in "users", where: u.age > 18, select: u.name # 执行查询 Repo.all(query)

管道语法基础

管道语法利用Elixir的管道操作符，将查询条件链式拼接：

"users" |> where([u], u.age > 18) |> select([u], u.name) |> Repo.all()

绑定less查询简化

对于简单查询，可省略绑定变量，直接使用关键字列表：

from Post, where: [category: "fresh and new"], order_by: [desc: :published_at], select: [:id, :title, :body]

核心查询操作：筛选、排序与限制

灵活的条件筛选（WHERE）

Ecto提供多种筛选方式，满足不同场景需求：

# 基础条件 from u in User, where: u.age > 18 # 关键字列表条件 from u in User, where: [active: true, role: "admin"] # 动态条件组合 filters = [active: true] from u in User, where: ^filters # OR条件 from u in User, where: u.age > 18, or_where: u.email == ^admin_email

结果排序（ORDER BY）

支持多字段排序及自定义排序方向：

# 基础排序 from p in Post, order_by: p.inserted_at # 多字段排序 from p in Post, order_by: [desc: p.inserted_at, asc: p.title] # 空值处理（数据库特定） from p in Post, order_by: [asc_nulls_last: p.published_at]

结果限制与分页（LIMIT/OFFSET）

轻松实现分页功能：

# 限制结果数量 from p in Post, limit: 10 # 分页查询 def paginate(query, page, per_page) do from query, limit: ^per_page, offset: ^((page - 1) * per_page) end

数据选择与转换：SELECT的高级用法

字段选择

灵活选择需要返回的字段：

# 选择单个字段 from u in User, select: u.name # 选择多个字段（元组形式） from u in User, select: {u.id, u.name} # 选择部分字段（结构体形式） from u in User, select: struct(u, [:id, :name, :email]) # 选择部分字段（映射形式） from u in User, select: map(u, [:id, :name, :email])

计算字段与别名

使用as为计算字段创建别名：

from p in Post, select: %{ id: p.id, title: p.title, word_count: fragment("LENGTH(?) - LENGTH(REPLACE(?, ' ', '')) + 1", p.body, p.body) }

合并选择（select_merge）

动态合并多个选择条件：

query = from p in Post, select: %{} query = if include_title?, do: from(p in query, select_merge: %{title: p.title}), else: query query = if include_stats?, do: from(p in query, select_merge: %{views: p.views}), else: query

关联查询：JOIN操作完全指南

Ecto支持多种JOIN类型，满足复杂数据关联需求。

基础关联查询

# 内连接 from p in Post, join: c in Comment, on: c.post_id == p.id, select: {p.title, c.body} # 左连接 from p in Post, left_join: c in Comment, on: c.post_id == p.id, select: {p.title, c.body}

关联预加载（Preload）

Ecto提供两种预加载方式：自动预加载和显式预加载。

自动预加载

# 自动预加载关联 from p in Post, preload: :comments

基于JOIN的预加载

# 结合JOIN的预加载 from p in Post, join: c in assoc(p, :comments), where: c.published == true, preload: [comments: c]

多表关联与命名绑定

使用命名绑定简化多表关联：

from p in Post, as: :post, join: c in assoc(p, :comments), as: :comment, join: u in assoc(c, :user), as: :user, where: u.age > 18, select: {p.title, c.body, u.name}

高级查询技巧：子查询与CTE

子查询（Subquery）

将一个查询作为另一个查询的数据源：

# 获取每个用户的最新帖子 latest_posts = from p in Post, group_by: p.user_id, select: %{user_id: p.user_id, max_inserted_at: max(p.inserted_at)} from p in Post, join: lp in subquery(latest_posts), on: p.user_id == lp.user_id and p.inserted_at == lp.max_inserted_at

公用表表达式（CTE）

对于复杂查询，使用CTE提高可读性：

# 递归CTE示例：获取分类树 category_tree = from c in Category, where: is_nil(c.parent_id) |> union_all( from c in Category, join: ct in "category_tree", on: c.parent_id == ct.id ) from p in Product, recursive_ctes(true), with_cte("category_tree", as: ^category_tree), join: c in "category_tree", on: p.category_id == c.id, select: %{p | category_path: fragment("ARRAY_AGG(?)", c.name)}

动态查询构建：应对复杂业务逻辑

动态表达式（Dynamic）

构建动态查询条件：

def filter_posts(query, params) do query = if params["category"], do: where(query, [p], p.category == ^params["category"]), else: query query = if params["min_views"], do: where(query, [p], p.views >= ^params["min_views"]), else: query query end # 更优雅的动态查询 def filter_posts(query, params) do Enum.reduce(params, query, fn {"category", value}, q -> where(q, [p], p.category == ^value) {"min_views", value}, q -> where(q, [p], p.views >= ^String.to_integer(value)) _, q -> q end) end

动态排序与分页

def sort(query, sort_by, direction \\ :asc) do case sort_by do "title" -> from query, order_by: [{^direction, :title}] "date" -> from query, order_by: [{^direction, :inserted_at}] _ -> query end end

性能优化：索引、分页与查询分析

使用EXPLAIN分析查询

# 分析查询性能 query = from p in Post, where: p.category == "elixir" Repo.explain(query)

批量操作与事务

# 批量更新 from(p in Post, where: p.published == false) |> Repo.update_all(set: [published: true]) # 事务处理 Repo.transaction(fn -> post = Repo.insert!(%Post{title: "Ecto Guide"}) Repo.insert!(%Comment{post_id: post.id, body: "Great post!"}) end)

最佳实践与常见陷阱

参数化查询防止注入

始终使用^操作符进行参数插值，避免SQL注入：

# 安全的参数插值 from u in User, where: u.email == ^email # 不安全的做法（不要这样做） from u in User, where: fragment("email = '#{email}'")

避免N+1查询问题

使用预加载解决N+1查询问题：

# 会导致N+1查询 posts = Repo.all(Post) # 每个post都会触发额外查询获取comments Enum.each(posts, fn post -> IO.inspect(Repo.preload(post, :comments)) end) # 优化后的查询 posts = Repo.all(from p in Post, preload: :comments)

复杂查询的代码组织

将复杂查询拆分为可组合的函数：

defmodule PostQueries do def published(query), do: where(query, published: true) def by_category(query, category), do: where(query, category: ^category) def recent(query, days), do: where(query, [p], p.inserted_at > ago(^days, "day")) def with_comments(query), do: preload(query, :comments) end # 使用组合查询 Post |> PostQueries.published() |> PostQueries.by_category("elixir") |> PostQueries.recent(30) |> PostQueries.with_comments() |> Repo.all()