AutoModel – 더 큰 DX 및 AI 시대를 위해 구축된 Rust용 SQL 우선 역방향 ORM

Database access in Rust typically falls into two camps: ORMs (Diesel, SeaORM) and compile-time checked SQL (sqlx). Both have trade-offs that become sharply worse when an AI assistant — or any automated tool — is working with your code, and humans are exposed to far more intense code reviewing cycle. AutoModel is different: you write plain SQL, and the tool generates real Rust source files. queries/users/get_user.sql → src/generated/users.rs (checked into git) - Human or AI can read everything. Generated structs, function signatures, error enums, and type aliases — all corresponding to the actual database schema, including constraints exposed as structured Rust enums — are ordinary .rs files sitting in your repo. An LLM can inspect them, reason about types, and produce correct calling code on the first try — no PostgreSQL agent, no database connection, no special tooling required. - Plain SQL stays plain SQL. Your queries are .sql files with full syntax highlighting. There is no query builder to learn, no expression DSL. Any valid PostgreSQL query works — window functions, CTEs, recursive queries, lateral joins, subqueries, aggregations,UNNEST batch inserts, partitioned tables, domain types, composite types, conditional clauses — all features of SQL, with no restrictions. - Build-time code generation, not compile-time magic. build.rs connects to the database once, extracts types from prepared statements, and writes.rs files — the whole step takes seconds, not the minutes of a full application compile. After that, builds are fully offline. CI can verify that generated code is up-to-date without a live database. - Diff-friendly and reviewable. Because the generated code is committed, pull request reviewers (human or AI) see exactly what changed — a renamed field, a new column, a constraint added. Nothing is hidden inside macro expansion. - Built-in query analytics. During code generation, AutoModel runs EXPLAIN on every query. Every generated function includes the query plan in its doc comments, and a warnings file is committed to the repo flagging sequential scans (missing indexes) and multi-partition access on partitioned tables. Warnings are surfaced during build time and visible at review time — reviewers (human or AI) catch performance problems before they reach production. Analysis can be opted out per query. - Feature-rich control over generated code. Struct reuse and deduplication across queries. Diff-based conditional updates for the load → transform → save pattern. Custom struct naming for cleaner, domain-specific APIs. Automated multiunzip support combined withUNNEST for batch inserts. Strongly typed mappings forjson /jsonb columns. Full support for composite types and whole-record column insertion and selection — and much more. - Less code to write, review, and test. The glue between SQL and Rust — structs, parameter binding, error enums, type conversions — is an entire class of code that no human needs to write, review, or maintain. It is machine-generated from your SQL and the database schema. Reviewers focus on the .sql file and the business logic that calls it. This directly translates to faster development cycles: adding a new query is a single.sql file, and you have a strongly typed Rust function to call on the next build. The result: a workflow where SQL is the source of truth, types are real files, every tool in the ecosystem — IDE, AI, CI, code review — can see the full picture, and development moves faster because an entire layer of boilerplate is eliminated. This is a Cargo workspace with three main components: automodel-lib/ - The core library for generating typed functions from SQL queriesautomodel-cli/ - Command-line interface with advanced featuresexample-app/ - An example application that demonstrates build-time code generation [dependencies] automodel = "0.9" [build-dependencies] automodel = "0.9" tokio = { version = "1.0", features = ["rt"] } #[tokio::main] async fn main() -> Result> { let defaults = automodel::DefaultsConfig { telemetry: automodel::DefaultsTelemetryConfig { level: automodel::TelemetryLevel::Debug, include_sql: true, }, ensure_indexes: true, derives: automodel::DefaultsDerivesConfig { return_type: vec!["Clone".to_string()], parameters_type: vec!["Clone".to_string()], conditions_type: vec!["Clone".to_string()], error_type: vec!["Clone".to_string()], }, }; automodel::AutoModel::generate( || { if std::env::var("CI").is_err() { std::env::var("AUTOMODEL_DATABASE_URL").map_err(|_| { "AUTOMODEL_DATABASE_URL environment variable must be set for code generation" .to_string() }) } else { Err( "Detecting not up to date AutoModel generated code in CI environment" .to_string(), ) } }, "queries", "src/generated", defaults, ) .await } Create a queries/ directory and add .sql files organized by module: my-project/ ├── queries/ │ └── users/ │ ├── get_user_by_id.sql │ ├── create_user.sql │ └── update_user_profile.sql ├── build.rs └── src/ └── main.rs Each SQL file contains an optio