feat: honor omit_unused_structs (#74)

README.md

@@ -76,3 +76,9 @@ class Status(str, enum.Enum):
     OPEN = "op!en"
     CLOSED = "clo@sed"
 ```
+
+### Omit unused table and enum structs
+
+Option: `omit_unused_structs`
+
+If `true`, sqlc won't generate table and enum structs that aren't used in queries for a given package.

internal/config.go

@@ -8,6 +8,7 @@ type Config struct {
 	Out                         string   `json:"out"`
 	EmitPydanticModels          bool     `json:"emit_pydantic_models"`
 	EmitStrEnum                 bool     `json:"emit_str_enum"`
+	OmitUnusedStructs           bool     `json:"omit_unused_structs,omitempty"`
 	QueryParameterLimit         *int32   `json:"query_parameter_limit"`
 	InflectionExcludeTableNames []string `json:"inflection_exclude_table_names"`
 }

internal/endtoend/testdata/omit_unused_structs/db/models.py

@@ -0,0 +1,66 @@
+# Code generated by sqlc. DO NOT EDIT.
+# versions:
+#   sqlc v1.28.0
+import dataclasses
+import enum
+from typing import List, Optional
+
+
+class ArrayEnum(enum.StrEnum):
+    O = "o"
+    P = "p"
+
+
+class QueryParamEnumTableEnum(enum.StrEnum):
+    G = "g"
+    H = "h"
+
+
+class QueryParamStructEnumTableEnum(enum.StrEnum):
+    I = "i"
+    J = "j"
+
+
+class QueryReturnEnumTableEnum(enum.StrEnum):
+    K = "k"
+    L = "l"
+
+
+class QueryReturnFullTableEnum(enum.StrEnum):
+    E = "e"
+    F = "f"
+
+
+class QueryReturnStructEnumTableEnum(enum.StrEnum):
+    K = "k"
+    L = "l"
+
+
+class QuerySqlcEmbedEnum(enum.StrEnum):
+    M = "m"
+    N = "n"
+
+
+@dataclasses.dataclass()
+class ArrayEnumTable:
+    id: int
+    value: Optional[List[ArrayEnum]]
+
+
+@dataclasses.dataclass()
+class QueryParamEnumTable:
+    id: int
+    other: QueryParamEnumTableEnum
+    value: Optional[QueryParamEnumTableEnum]
+
+
+@dataclasses.dataclass()
+class QueryReturnFullTable:
+    id: int
+    value: Optional[QueryReturnFullTableEnum]
+
+
+@dataclasses.dataclass()
+class QuerySqlcEmbedTable:
+    id: int
+    value: Optional[QuerySqlcEmbedEnum]

internal/endtoend/testdata/omit_unused_structs/db/query.py

@@ -0,0 +1,168 @@
+# Code generated by sqlc. DO NOT EDIT.
+# versions:
+#   sqlc v1.28.0
+# source: query.sql
+import dataclasses
+from typing import Any, AsyncIterator, Iterator, Optional
+
+import sqlalchemy
+import sqlalchemy.ext.asyncio
+
+from db import models
+
+
+QUERY_ENUM_ARRAY_TABLE = """-- name: query_enum_array_table \\:many
+SELECT id, value FROM array_enum_table
+"""
+
+
+QUERY_PARAM_ENUM_TABLE = """-- name: query_param_enum_table \\:one
+SELECT id, other, value FROM query_param_enum_table WHERE value = :p1
+"""
+
+
+QUERY_PARAM_STRUCT_ENUM_TABLE = """-- name: query_param_struct_enum_table \\:one
+SELECT id FROM query_param_struct_enum_table WHERE id = :p1 AND value = :p2
+"""
+
+
+QUERY_RETURN_ENUM_TABLE = """-- name: query_return_enum_table \\:one
+SELECT value FROM query_return_enum_table WHERE id = :p1
+"""
+
+
+QUERY_RETURN_FULL_TABLE = """-- name: query_return_full_table \\:many
+SELECT id, value FROM query_return_full_table
+"""
+
+
+QUERY_RETURN_STRUCT_ENUM_TABLE = """-- name: query_return_struct_enum_table \\:one
+SELECT value, another FROM query_return_struct_enum_table WHERE id = :p1
+"""
+
+
+@dataclasses.dataclass()
+class query_return_struct_enum_tableRow:
+    value: Optional[models.QueryReturnStructEnumTableEnum]
+    another: Optional[int]
+
+
+QUERY_SQLC_EMBED_TABLE = """-- name: query_sqlc_embed_table \\:one
+SELECT query_sqlc_embed_table.id, query_sqlc_embed_table.value FROM query_sqlc_embed_table WHERE id = :p1
+"""
+
+
+class Querier:
+    def __init__(self, conn: sqlalchemy.engine.Connection):
+        self._conn = conn
+
+    def query_enum_array_table(self) -> Iterator[models.ArrayEnumTable]:
+        result = self._conn.execute(sqlalchemy.text(QUERY_ENUM_ARRAY_TABLE))
+        for row in result:
+            yield models.ArrayEnumTable(
+                id=row[0],
+                value=row[1],
+            )
+
+    def query_param_enum_table(self, *, value: Optional[models.QueryParamEnumTableEnum]) -> Optional[models.QueryParamEnumTable]:
+        row = self._conn.execute(sqlalchemy.text(QUERY_PARAM_ENUM_TABLE), {"p1": value}).first()
+        if row is None:
+            return None
+        return models.QueryParamEnumTable(
+            id=row[0],
+            other=row[1],
+            value=row[2],
+        )
+
+    def query_param_struct_enum_table(self, *, id: int, value: Optional[models.QueryParamStructEnumTableEnum]) -> Optional[int]:
+        row = self._conn.execute(sqlalchemy.text(QUERY_PARAM_STRUCT_ENUM_TABLE), {"p1": id, "p2": value}).first()
+        if row is None:
+            return None
+        return row[0]
+
+    def query_return_enum_table(self, *, id: int) -> Optional[Optional[models.QueryReturnEnumTableEnum]]:
+        row = self._conn.execute(sqlalchemy.text(QUERY_RETURN_ENUM_TABLE), {"p1": id}).first()
+        if row is None:
+            return None
+        return row[0]
+
+    def query_return_full_table(self) -> Iterator[models.QueryReturnFullTable]:
+        result = self._conn.execute(sqlalchemy.text(QUERY_RETURN_FULL_TABLE))
+        for row in result:
+            yield models.QueryReturnFullTable(
+                id=row[0],
+                value=row[1],
+            )
+
+    def query_return_struct_enum_table(self, *, id: int) -> Optional[query_return_struct_enum_tableRow]:
+        row = self._conn.execute(sqlalchemy.text(QUERY_RETURN_STRUCT_ENUM_TABLE), {"p1": id}).first()
+        if row is None:
+            return None
+        return query_return_struct_enum_tableRow(
+            value=row[0],
+            another=row[1],
+        )
+
+    def query_sqlc_embed_table(self, *, id: int) -> Optional[Optional[Any]]:
+        row = self._conn.execute(sqlalchemy.text(QUERY_SQLC_EMBED_TABLE), {"p1": id}).first()
+        if row is None:
+            return None
+        return row[0]
+
+
+class AsyncQuerier:
+    def __init__(self, conn: sqlalchemy.ext.asyncio.AsyncConnection):
+        self._conn = conn
+
+    async def query_enum_array_table(self) -> AsyncIterator[models.ArrayEnumTable]:
+        result = await self._conn.stream(sqlalchemy.text(QUERY_ENUM_ARRAY_TABLE))
+        async for row in result:
+            yield models.ArrayEnumTable(
+                id=row[0],
+                value=row[1],
+            )
+
+    async def query_param_enum_table(self, *, value: Optional[models.QueryParamEnumTableEnum]) -> Optional[models.QueryParamEnumTable]:
+        row = (await self._conn.execute(sqlalchemy.text(QUERY_PARAM_ENUM_TABLE), {"p1": value})).first()
+        if row is None:
+            return None
+        return models.QueryParamEnumTable(
+            id=row[0],
+            other=row[1],
+            value=row[2],
+        )
+
+    async def query_param_struct_enum_table(self, *, id: int, value: Optional[models.QueryParamStructEnumTableEnum]) -> Optional[int]:
+        row = (await self._conn.execute(sqlalchemy.text(QUERY_PARAM_STRUCT_ENUM_TABLE), {"p1": id, "p2": value})).first()
+        if row is None:
+            return None
+        return row[0]
+
+    async def query_return_enum_table(self, *, id: int) -> Optional[Optional[models.QueryReturnEnumTableEnum]]:
+        row = (await self._conn.execute(sqlalchemy.text(QUERY_RETURN_ENUM_TABLE), {"p1": id})).first()
+        if row is None:
+            return None
+        return row[0]
+
+    async def query_return_full_table(self) -> AsyncIterator[models.QueryReturnFullTable]:
+        result = await self._conn.stream(sqlalchemy.text(QUERY_RETURN_FULL_TABLE))
+        async for row in result:
+            yield models.QueryReturnFullTable(
+                id=row[0],
+                value=row[1],
+            )
+
+    async def query_return_struct_enum_table(self, *, id: int) -> Optional[query_return_struct_enum_tableRow]:
+        row = (await self._conn.execute(sqlalchemy.text(QUERY_RETURN_STRUCT_ENUM_TABLE), {"p1": id})).first()
+        if row is None:
+            return None
+        return query_return_struct_enum_tableRow(
+            value=row[0],
+            another=row[1],
+        )
+
+    async def query_sqlc_embed_table(self, *, id: int) -> Optional[Optional[Any]]:
+        row = (await self._conn.execute(sqlalchemy.text(QUERY_SQLC_EMBED_TABLE), {"p1": id})).first()
+        if row is None:
+            return None
+        return row[0]

internal/endtoend/testdata/omit_unused_structs/query.sql

@@ -0,0 +1,20 @@
+-- name: query_return_full_table :many
+SELECT * FROM query_return_full_table;
+
+-- name: query_param_enum_table :one
+SELECT * FROM query_param_enum_table WHERE value = $1;
+
+-- name: query_param_struct_enum_table :one
+SELECT id FROM query_param_struct_enum_table WHERE id = $1 AND value = $2;
+
+-- name: query_return_enum_table :one
+SELECT value FROM query_return_enum_table WHERE id = $1;
+
+-- name: query_return_struct_enum_table :one
+SELECT value, another FROM query_return_struct_enum_table WHERE id = $1;
+
+-- name: query_sqlc_embed_table :one
+SELECT sqlc.embed(query_sqlc_embed_table) FROM query_sqlc_embed_table WHERE id = $1;
+
+-- name: query_enum_array_table :many
+SELECT * FROM array_enum_table;

internal/endtoend/testdata/omit_unused_structs/schema.sql

@@ -0,0 +1,69 @@
+CREATE TYPE unused_enum AS ENUM (
+    'a', 'b'
+);
+
+CREATE TYPE unused_table_enum AS ENUM (
+    'c', 'd'
+);
+CREATE TABLE unused_table (
+    id      INTEGER PRIMARY KEY,
+    value   unused_table_enum
+);
+
+CREATE TYPE query_return_full_table_enum AS ENUM (
+    'e', 'f'
+);
+CREATE TABLE query_return_full_table (
+    id      INTEGER PRIMARY KEY,
+    value   query_return_full_table_enum
+);
+
+CREATE TYPE query_param_enum_table_enum AS ENUM (
+    'g', 'h'
+);
+CREATE TABLE query_param_enum_table (
+    id      INTEGER PRIMARY KEY,
+    other   query_param_enum_table_enum NOT NULL,
+    value   query_param_enum_table_enum
+);
+
+CREATE TYPE query_param_struct_enum_table_enum AS ENUM (
+    'i', 'j'
+);
+CREATE TABLE query_param_struct_enum_table (
+    id      INTEGER PRIMARY KEY,
+    value   query_param_struct_enum_table_enum
+);
+
+CREATE TYPE query_return_enum_table_enum AS ENUM (
+    'k', 'l'
+);
+CREATE TABLE query_return_enum_table (
+    id      INTEGER PRIMARY KEY,
+    value   query_return_enum_table_enum
+);
+
+CREATE TYPE query_return_struct_enum_table_enum AS ENUM (
+    'k', 'l'
+);
+CREATE TABLE query_return_struct_enum_table (
+    id      INTEGER PRIMARY KEY,
+    value   query_return_struct_enum_table_enum,
+    another INTEGER
+);
+
+CREATE TYPE query_sqlc_embed_enum AS ENUM (
+    'm', 'n'
+);
+CREATE TABLE query_sqlc_embed_table (
+    id      INTEGER PRIMARY KEY,
+    value   query_sqlc_embed_enum
+);
+
+CREATE TYPE array_enum AS ENUM (
+    'o', 'p'
+);
+CREATE TABLE array_enum_table (
+    id      INTEGER PRIMARY KEY,
+    value   array_enum[]
+);

internal/endtoend/testdata/omit_unused_structs/sqlc.yaml

@@ -0,0 +1,19 @@
+version: "2"
+plugins:
+  - name: py
+    wasm:
+      url: file://../../../../bin/sqlc-gen-python.wasm
+      sha256: "d6846ffad948181e611e883cedd2d2be66e091edc1273a0abc6c9da18399e0ca"
+sql:
+  - schema: schema.sql
+    queries: query.sql
+    engine: postgresql
+    codegen:
+      - plugin: py
+        out: db
+        options:
+          package: db
+          emit_sync_querier: true
+          emit_async_querier: true
+          emit_str_enum: true
+          omit_unused_structs: true