Rustは万能じゃない — 言語パーサーはNimかRocで書け

type
  SqlNodeKind* = enum
    nkSelect, nkInsert, nkUpdate, nkDelete
    nkIdentifier, nkStringLit, nkIntLit, nkBoolLit, nkNull
    nkStar, nkColumnRef
    nkBinaryOp, nkUnaryOp, nkFunctionCall, nkAlias
    nkFromClause, nkWhereClause, nkJoin
    # ...

  BinaryOpKind* = enum
    opEq, opNeq, opLt, opLe, opGt, opGe
    opAdd, opSub, opMul, opDiv, opMod
    opAnd, opOr
    opLike, opNotLike, opIn, opNotIn, opBetween, opNotBetween, opIs

  SqlNode* = ref object
    case kind*: SqlNodeKind
    of nkIdentifier, nkStringLit:
      strVal*: string
    of nkIntLit:
      intVal*: int64
    of nkBinaryOp:
      binOp*: BinaryOpKind
      binLeft*, binRight*: SqlNode
    of nkJoin:
      joinKind*: JoinKind
      joinLeft*, joinRight*, joinCond*: SqlNode
    else:
      children*: seq[SqlNode]

proc newBinaryOp*(op: BinaryOpKind, left, right: SqlNode): SqlNode =
  SqlNode(kind: nkBinaryOp, binOp: op, binLeft: left, binRight: right)

SqlNode : [
    Ident Str,
    StrLit Str,
    IntLit I64,
    BoolLit Bool,
    NullLit,
    StarLit,
    BinOp { op : BinaryOp, left : SqlNode, right : SqlNode },
    UnOp { op : UnaryOp, operand : SqlNode },
    FnCall { name : Str, args : List SqlNode },
    ColRef { table : Str, column : Str },
    SelectStmt {
        columns : List SqlNode,
        from : List SqlNode,
        where : [Some SqlNode, None],
        orderBy : List SqlNode,
        # ...
    },
    InsertStmt { table : Str, columns : List Str, values : List SqlNode },
    UpdateStmt { table : Str, sets : List { col : Str, val : SqlNode }, where : [Some SqlNode, None] },
    DeleteStmt { table : Str, where : [Some SqlNode, None] },
    CreateTableStmt { table : Str, columns : List SqlNode, ifNotExists : Bool },
    DropTableStmt { table : Str, ifExists : Bool },
]

#[allow(clippy::large_enum_variant)]
pub enum SqlNode {
    Ident(String),
    StrLit(String),
    IntLit(i64),
    BoolLit(bool),
    NullLit,
    StarLit,
    BinOp {
        op: BinaryOp,
        left: Box<SqlNode>,
        right: Box<SqlNode>,
    },
    SelectStmt {
        columns: Vec<SqlNode>,
        from: Vec<SqlNode>,
        where_: Option<Box<SqlNode>>,
        // ...
    },
    // ...
}

proc parseMulDiv(p: var Parser): SqlNode =
  result = p.parsePrimary()
  while p.current.kind in {tkStar, tkSlash, tkPercent}:
    let op = case p.current.kind
      of tkStar:    opMul
      of tkSlash:   opDiv
      of tkPercent: opMod
      else: opMul  # unreachable
    discard p.advance()
    result = newBinaryOp(op, result, p.parsePrimary())

proc parseAddSub(p: var Parser): SqlNode =
  result = p.parseMulDiv()
  while p.current.kind in {tkPlus, tkMinus}:
    let op = if p.current.kind == tkPlus: opAdd else: opSub
    discard p.advance()
    result = newBinaryOp(op, result, p.parseMulDiv())

proc parseAndExpr(p: var Parser): SqlNode =
  result = p.parseComparison()
  while p.check(tkAnd):
    discard p.advance()
    result = newBinaryOp(opAnd, result, p.parseComparison())

proc parseExpr(p: var Parser): SqlNode =
  result = p.parseAndExpr()
  while p.check(tkOr):
    discard p.advance()
    result = newBinaryOp(opOr, result, p.parseAndExpr())

import npeg

let parser = peg("input"):
  input       <- select_stmt * !1
  select_stmt <- i"SELECT" * ws * columns * ws * i"FROM" * ws * >table_name
  columns     <- column * *(',' * ws * column)
  column      <- >+Alpha
  table_name  <- +Alpha
  ws          <- +' '

let r = parser.match("SELECT name, age FROM users")
echo r.captures  # @["name", "age", "users"]

ParseResult : { node : SqlNode, pos : U64 }

parseExpr : List Token, U64 -> Result ParseResult Str
parseExpr = |tokens, pos|
    parseOr(tokens, pos)

parseOr : List Token, U64 -> Result ParseResult Str
parseOr = |tokens, pos|
    when parseAnd(tokens, pos) is
        Ok({ node: left, pos: pos2 }) ->
            parseOrTail(tokens, pos2, left)
        Err(msg) -> Err(msg)

parseOrTail : List Token, U64, SqlNode -> Result ParseResult Str
parseOrTail = |tokens, pos, left|
    when getToken(tokens, pos) is
        Ok(tok) ->
            if tok.kind == TkOr then
                when parseAnd(tokens, pos + 1) is
                    Ok({ node: right, pos: pos2 }) ->
                        parseOrTail(tokens, pos2, BinOp({ op: Or, left, right }))
                    Err(msg) -> Err(msg)
            else
                Ok({ node: left, pos })
        Err(_) -> Ok({ node: left, pos })

import std/[json]
import ast, parser

type
  ParseResultKind {.exportc.} = enum
    prkOk = 0
    prkError = 1

  CParseResult {.exportc.} = object
    kind: ParseResultKind
    json_ptr: cstring
    json_len: cint
    error_ptr: cstring
    error_len: cint

proc NimMain() {.importc.}

proc alopex_parser_init*() {.exportc, dynlib, cdecl.} =
  ## Initialize Nim runtime. Must be called once.
  NimMain()

proc alopex_parse_sql*(input: cstring, length: cint): CParseResult
    {.exportc, dynlib, cdecl.} =
  let sql = if length > 0: ($input)[0 ..< length] else: $input
  try:
    let astNode = parseSql(sql)
    let jsonStr = $toJson(astNode)
    let copied = cast[cstring](alloc(jsonStr.len + 1))
    copyMem(copied, cstring(jsonStr), jsonStr.len + 1)
    result = CParseResult(
      kind: prkOk,
      json_ptr: copied,
      json_len: cint(jsonStr.len),
      error_ptr: nil,
      error_len: 0,
    )
  except ParseError:
    let errMsg = getCurrentExceptionMsg()
    let copied = cast[cstring](alloc(errMsg.len + 1))
    copyMem(copied, cstring(errMsg), errMsg.len + 1)
    result = CParseResult(
      kind: prkError, json_ptr: nil, json_len: 0,
      error_ptr: copied, error_len: cint(errMsg.len),
    )

#[repr(C)]
#[derive(Debug)]
pub enum ParseResultKind { Ok = 0, Error = 1 }

#[repr(C)]
pub struct CParseResult {
    pub kind: ParseResultKind,
    pub json_ptr: *const c_char,
    pub json_len: c_int,
    pub error_ptr: *const c_char,
    pub error_len: c_int,
}

extern "C" {
    fn alopex_parser_init();
    fn alopex_parse_sql(input: *const c_char, length: c_int) -> CParseResult;
    fn alopex_free_string(p: *const c_char);
}

pub fn parse_sql(sql: &str) -> Result<serde_json::Value, String> {
    unsafe { alopex_parser_init(); }  // 初回のみ
    let cs = CString::new(sql).unwrap();
    let r = unsafe { alopex_parse_sql(cs.as_ptr(), sql.len() as c_int) };
    match r.kind {
        ParseResultKind::Ok => { /* json_ptr → serde_json::Value */ }
        ParseResultKind::Error => { /* error_ptr → String */ }
    }
}

Roc App (パーサー、純粋関数)
   ↓ C ABI として export (roc_app_main 等)
Rust Platform Host (alopex-sql)
   ↓ extern "C" でリンク
alopex-core / alopex-embedded

┌─────────────────────────────────────────┐
│  SQL Parser (Nim)                       │
│  ・npeg PEG 文法 or 手書き Pratt        │
│  ・object variant で AST                │
│  ・JSON シリアライズして返す            │
│  出力: libalopex_sql_parser.so + .h     │
└──────────────┬──────────────────────────┘
               │ extern "C" FFI
               ▼
┌─────────────────────────────────────────┐
│  alopex-sql (Rust)                      │
│  ・AST(JSON) を受け取り LogicalPlan に  │
│  ・Planner / Optimizer / Executor       │
│  ・カタログ・トランザクション制御       │
└──────────────┬──────────────────────────┘
               │
               ▼
┌─────────────────────────────────────────┐
│  alopex-core (Rust)                     │
│  ・ストレージ、複製、分散              │
└─────────────────────────────────────────┘