如何在Granite ORM中自定义查询生成的SELECT语句？

嘿，刚好我对Granite ORM和Amber这块熟得很，针对遗留数据库做JOIN查询完全没问题！Granite其实提供了好几种灵活的方式来自定义查询的SELECT和FROM部分，完美适配跨表关联的需求，我给你举几个实用的例子：

1. 直接写原生SQL片段（最灵活） #

如果你的JOIN逻辑比较复杂，直接写原生SQL是最省心的方式，Granite的query方法完全支持自定义SELECT和FROM语句。假设你的遗留库还有makes（存厂商信息）和models（存车型信息）两张表，对应vehicles里的makeid和modelid，可以这么写：

# 先定义对应数据库表的模型（注意显式指定表名和字段，适配遗留库结构）
class Vehicle < Granite::Base
  table name: "vehicles"
  column vehicleid : Int32, primary: true
  column year : Int32
  column makeid : Int32
  column modelid : Int32
end

class Make < Granite::Base
  table name: "makes"
  column makeid : Int32, primary: true
  column name : String
end

class Model < Granite::Base
  table name: "models"
  column modelid : Int32, primary: true
  column name : String
end

# 自定义跨表JOIN查询
vehicles_with_details = Vehicle.query(<<-SQL)
  SELECT v.vehicleid, v.year, m.name AS make_name, md.name AS model_name
  FROM vehicles v
  JOIN makes m ON v.makeid = m.makeid
  JOIN models md ON v.modelid = md.modelid
  WHERE v.year >= 1999
SQL

# 遍历查询结果（返回的是哈希数组，直接通过键名取字段）
vehicles_with_details.each do |row|
  puts "ID: #{row["vehicleid"]}, Year: #{row["year"]}, Make: #{row["make_name"]}, Model: #{row["model_name"]}"
end

这种方式完全不受ORM默认规则限制，想怎么写JOIN就怎么写，适合复杂的多表关联场景。

2. 用Granite查询构建器（兼顾ORM便捷性） #

如果想保留模型实例的操作优势，不想完全写原生SQL，可以用Granite的查询构建器来拼接JOIN语句，灵活度也很高：

# 模型定义可以加可选的关联（方便后续链式查询）
class Vehicle < Granite::Base
  table name: "vehicles"
  column vehicleid : Int32, primary: true
  column year : Int32
  column makeid : Int32
  column modelid : Int32

  # 定义关联（可选，不是必须，但能让代码更清晰）
  belongs_to :make, foreign_key: "makeid", primary_key: "makeid"
  belongs_to :model, foreign_key: "modelid", primary_key: "modelid"
end

# 用查询构建器拼接JOIN和SELECT
vehicles = Vehicle.select("vehicles.*, makes.name AS make_name, models.name AS model_name")
                  .join("makes", on: "vehicles.makeid = makes.makeid")
                  .join("models", on: "vehicles.modelid = models.modelid")
                  .where("vehicles.year >= 1999")
                  .all

# 返回的是Vehicle实例，额外查询的字段可以通过[]访问
vehicles.each do |v|
  puts "ID: #{v.vehicleid}, Year: #{v.year}, Make: #{v["make_name"]}, Model: #{v["model_name"]}"
end

这种方式既保留了ORM的便捷（比如可以直接操作模型属性），又能自定义JOIN逻辑，适合中等复杂度的查询场景。

3. 封装成模型类方法（复用性强） #

如果这个JOIN查询会在多个地方用到，建议封装成模型的类方法，代码更整洁还能防止重复：

class Vehicle < Granite::Base
  # ... 之前的模型定义 ...

  # 封装带参数的JOIN查询（用?占位符做参数化，避免SQL注入）
  def self.with_make_and_model(min_year : Int32)
    query(<<-SQL, min_year)
      SELECT v.vehicleid, v.year, m.name AS make_name, md.name AS model_name
      FROM vehicles v
      JOIN makes m ON v.makeid = m.makeid
      JOIN models md ON v.modelid = md.modelid
      WHERE v.year >= ?
    SQL
  end
end

# 调用的时候直接传参数就行
vehicles = Vehicle.with_make_and_model(1999)

这样业务代码里调用起来非常简洁，而且参数化查询还能有效避免SQL注入风险。

几个关键注意点 #

• 因为是遗留数据库，一定要显式指定模型的表名（table name: "xxx"），Granite默认会按模型名复数处理，很可能和你的遗留表名不匹配。
• 模型里的字段名要和数据库表的字段完全一致，比如你的表是vehicleid，就不能写成id，必须显式定义column vehicleid : Int32, primary: true。
• 尽量用参数化查询（比如上面的?占位符），不要直接拼接字符串，避免SQL注入。

内容的提问来源于stack exchange，提问作者nlh