gormcol

Type-safe GORM column descriptors and model generation utilities.

Library

The library provides Field for type-safe column references and methods to extract column/table names.

Field

Field represents a GORM column descriptor with table context. Generated code creates package-level variables with typed field references:

var ProductCols = struct {
    ID    gormcol.Field
    Name  gormcol.Field
    Price gormcol.Field
}{
    ID:    gormcol.Field{}.Set((&Product{}).TableName(), "id_product"),
    Name:  gormcol.Field{}.Set((&Product{}).TableName(), "name"),
    Price: gormcol.Field{}.Set((&Product{}).TableName(), "price"),
}

Field Methods

TabCol

Returns "table.column" format for use in SQL with table qualification.

model.ProductCols.Price.TabCol() // "ps_product.price"

Col

Returns just the column name.

model.ProductCols.Price.Col() // "price"

Tab

Returns the table name.

model.ProductCols.Price.Tab() // "ps_product"

CLI

The cmd/ directory contains a standalone tool that generates GORM model files with column descriptors.

Install

go install git.ma-al.com/goc_marek/gormcol/cmd/gormcol@latest

Or from source:

go install ./cmd/gormcol

Prerequisites

• fzf - required for interactive mode (optional for --all)

Usage

gormcol [options]

DSN can be provided via --dsn flag or DSN env var (from .env file).

Modes:

• Interactive (default): select tables with fzf
• Batch (--filter or --all): generate matching tables with confirmation

Flag	Default	Description
--dsn	(from DSN env)	MySQL/MariaDB DSN, e.g. user:pass@tcp(localhost:3306)/dbname
--filter	(interactive)	Regex matching table names to generate (triggers batch mode)
--all	(interactive)	Generate all tables matching filter (shows confirmation)
--out	./app/model/dbmodel	Output directory for generated files
--pkg	dbmodel	Go package name for generated files
--clean	false	Remove existing model files before generation

Interactive Mode (Default)

Without flags, the tool launches an interactive table selector:

gormcol --dsn "user:pass@tcp(localhost:3306)/mydb"

Features:

• Fuzzy search as you type
• Tab - toggle table selection (multi-select)
• Enter - confirm selection
• Esc - cancel

Batch Mode (--filter)

Use --filter to generate all tables matching a regex pattern:

gormcol --dsn "user:pass@tcp(localhost:3306)/mydb" --filter "ps_product.*"

Generate All Tables (--all)

Use --all to generate all tables matching the default filter (ps_|b2b_).*:

gormcol --dsn "user:pass@tcp(localhost:3306)/mydb" --all

A confirmation prompt appears:

WARNING: Generate all 325 tables? [Enter] confirm / [Esc] cancel

• Enter - confirm and generate
• Esc - cancel

Example

./gormcol --dsn "user:pass@tcp(localhost:3306)/mydb" --filter "ps_.*" --out ./internal/model --pkg model

This connects to the database, generates a .go model file for each matching table, and appends <Model>Cols variables with typed gormcol.Field descriptors to each file.

Configuration File (.env)

Create a .env file in your project root for default values:

# Database connection
DSN=user:pass@tcp(localhost:3306)/mydb

# Table filter (regex)
FILTER=(ps_|b2b_).*

# Output settings
OUT=./app/model/dbmodel
PKG=dbmodel

Command-line flags override .env values.

Library Functions Reference

ConnectDSN

Opens a MySQL/MariaDB connection from a DSN string.

db, err := gormcol.ConnectDSN("user:pass@tcp(localhost:3306)/dbname")

New

Creates a new GormGen with default configuration.

gg := gormcol.New(db)

NewWithConfig

Creates a new GormGen with custom configuration.

gg := gormcol.NewWithConfig(db, gormcol.GenConfig{
    OutputDir:   "./models",
    PkgName:     "models",
    TableFilter: "ps_.*",
})

GenModels

Generates GORM model files and column descriptors for matched tables.

ctx := context.Background()
err := gg.GenModels(ctx)

GenConfig

Configuration for model generation.

Field	Default	Description
OutputDir	./app/model/dbmodel	Directory for generated files
PkgName	dbmodel	Go package name
TableFilter	ps_.*	Regex pattern to match table names
SelectedTables	(none)	Specific tables to generate (overrides filter)
Clean	true	Remove existing files before generation

Generated Models

After generation, each model file contains a struct and a Cols variable:

// model/product.go
type Product struct {
    ID    uint    `gorm:"column:id_product;primaryKey"`
    Name  string  `gorm:"column:name"`
    Price float32 `gorm:"column:price;type:decimal(20,6)"`
}

var ProductCols = struct {
    ID    gormcol.Field
    Name  gormcol.Field
    Price gormcol.Field
}{
    ID:    gormcol.Field{}.Set((&Product{}).TableName(), "id_product"),
    Name:  gormcol.Field{}.Set((&Product{}).TableName(), "name"),
    Price: gormcol.Field{}.Set((&Product{}).TableName(), "price"),
}

Using Generated Models

Table-qualified columns

Use TabCol() for table-qualified column references:

import "git.ma-al.com/goc_marek/gormcol"

// Where clauses
db.Where(
    model.ProductCols.Price.TabCol() + " > ?",
    100.0,
).Find(&products)

// Order
db.Order(model.ProductCols.Name.TabCol() + " ASC").Find(&products)

// Joins
db.Joins("JOIN ps_category ON " +
    model.ProductCols.ID.TabCol() + " = ps_category.id_product",
).Find(&products)

Unqualified column names

Use Col() when the table is already scoped:

db.Select(model.ProductCols.Name.Col()).Find(&products)

// Raw queries
db.Raw("SELECT " + model.ProductCols.Name.Col() + " FROM ps_product").Scan(&names)

Table name

Use Tab() to get the table name from a column descriptor:

table := model.ProductCols.ID.Tab() // "ps_product"

Dependencies

• gorm.io/gorm
• gorm.io/gen
• gorm.io/driver/mysql