599 lines
18 KiB
Go
599 lines
18 KiB
Go
package pgsql
|
|
|
|
import (
|
|
"bytes"
|
|
"embed"
|
|
"fmt"
|
|
"strings"
|
|
"text/template"
|
|
|
|
"git.warky.dev/wdevs/relspecgo/pkg/models"
|
|
)
|
|
|
|
//go:embed templates/*.tmpl
|
|
var templateFS embed.FS
|
|
|
|
// TemplateExecutor manages and executes SQL templates
|
|
type TemplateExecutor struct {
|
|
templates *template.Template
|
|
}
|
|
|
|
// NewTemplateExecutor creates a new template executor.
|
|
// flattenSchema controls whether schema.table identifiers use dot or underscore separation.
|
|
func NewTemplateExecutor(flattenSchema bool) (*TemplateExecutor, error) {
|
|
// Create template with custom functions
|
|
funcMap := make(template.FuncMap)
|
|
for k, v := range TemplateFunctions() {
|
|
funcMap[k] = v
|
|
}
|
|
|
|
// qual_table returns a quoted, schema-qualified identifier.
|
|
// With flatten=false: "schema"."table".
|
|
// With flatten=true: "schema_table".
|
|
funcMap["qual_table"] = func(schema, name string) string {
|
|
if schema == "" {
|
|
return quoteIdent(name)
|
|
}
|
|
if flattenSchema {
|
|
return quoteIdent(schema + "_" + name)
|
|
}
|
|
return quoteIdent(schema) + "." + quoteIdent(name)
|
|
}
|
|
|
|
funcMap["dollar_delimiter"] = func() string { return "$$" }
|
|
tmpl := template.New("").Funcs(funcMap)
|
|
entries, err := templateFS.ReadDir("templates")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, entry := range entries {
|
|
source, err := templateFS.ReadFile("templates/" + entry.Name())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if _, err := tmpl.New(entry.Name()).Parse(string(source)); err != nil {
|
|
return nil, fmt.Errorf("parse %s: %w", entry.Name(), err)
|
|
}
|
|
}
|
|
|
|
return &TemplateExecutor{
|
|
templates: tmpl,
|
|
}, nil
|
|
}
|
|
|
|
// execute chooses a delimiter absent from rendered data, including SQL expressions.
|
|
// Only explicit template calls emit delimiters; user text is never rewritten.
|
|
func (te *TemplateExecutor) execute(name string, data any) (string, error) {
|
|
for n := 0; ; n++ {
|
|
delimiter := fmt.Sprintf("$relspec_%d$", n)
|
|
count := 0
|
|
tmpl, err := te.templates.Clone()
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
tmpl.Funcs(template.FuncMap{"dollar_delimiter": func() string { count++; return delimiter }})
|
|
var buf bytes.Buffer
|
|
if err := tmpl.ExecuteTemplate(&buf, name, data); err != nil {
|
|
return "", fmt.Errorf("execute %s: %w", name, err)
|
|
}
|
|
rendered := buf.String()
|
|
if strings.ContainsRune(rendered, 0) {
|
|
return "", fmt.Errorf("%s contains a NUL byte", name)
|
|
}
|
|
if strings.Count(rendered, delimiter) == count {
|
|
return rendered, nil
|
|
}
|
|
}
|
|
}
|
|
|
|
// Template data structures
|
|
|
|
// CreateTableData contains data for create table template
|
|
type CreateTableData struct {
|
|
SchemaName string
|
|
TableName string
|
|
Columns []ColumnData
|
|
}
|
|
|
|
// ColumnData represents column information
|
|
type ColumnData struct {
|
|
Name string
|
|
Type string
|
|
Default string
|
|
NotNull bool
|
|
// Generated is the expression of a GENERATED ALWAYS AS (...) STORED column.
|
|
Generated string
|
|
// Identity is "ALWAYS" or "BY DEFAULT" for a GENERATED ... AS IDENTITY column.
|
|
Identity string
|
|
}
|
|
|
|
// AddColumnData contains data for add column template
|
|
type AddColumnData struct {
|
|
SchemaName string
|
|
TableName string
|
|
ColumnName string
|
|
ColumnType string
|
|
Default string
|
|
NotNull bool
|
|
// Generated is the expression of a GENERATED ALWAYS AS (...) STORED column.
|
|
Generated string
|
|
// Identity is "ALWAYS" or "BY DEFAULT" for a GENERATED ... AS IDENTITY column.
|
|
Identity string
|
|
}
|
|
|
|
// AlterColumnTypeWithCheckData contains data for the guarded alter column
|
|
// type template, which only alters existing columns whose live type
|
|
// differs from the desired one. Conversion errors propagate unchanged.
|
|
type AlterColumnTypeWithCheckData struct {
|
|
SchemaName string
|
|
TableName string
|
|
ColumnName string
|
|
NewType string
|
|
EquivalentTypes string
|
|
UsingExpr string
|
|
PreflightPredicate string
|
|
}
|
|
|
|
// AlterColumnDefaultWithCheckData contains data for the guarded alter
|
|
// column default template, which only alters existing columns whose live
|
|
// default differs from the desired one.
|
|
type AlterColumnDefaultWithCheckData struct {
|
|
SchemaName string
|
|
TableName string
|
|
ColumnName string
|
|
SetDefault bool
|
|
DefaultValue string
|
|
}
|
|
|
|
// AlterColumnNullabilityWithCheckData contains data for the guarded alter
|
|
// column nullability template, which only alters existing columns whose
|
|
// live NOT NULL state differs from the desired one.
|
|
type AlterColumnNullabilityWithCheckData struct {
|
|
SchemaName string
|
|
TableName string
|
|
ColumnName string
|
|
NotNull bool
|
|
}
|
|
|
|
// CreatePrimaryKeyData contains data for create primary key template
|
|
type CreatePrimaryKeyData struct {
|
|
SchemaName string
|
|
TableName string
|
|
ConstraintName string
|
|
Columns string
|
|
}
|
|
|
|
// CreateIndexData contains data for create index template
|
|
type CreateIndexData struct {
|
|
SchemaName string
|
|
TableName string
|
|
IndexName string
|
|
IndexType string
|
|
Columns string
|
|
Unique bool
|
|
Concurrent bool
|
|
// StorageParameters holds access-method parameters rendered as WITH (...),
|
|
// e.g. "lists = 100" for ivfflat or "m = 16, ef_construction = 64" for hnsw.
|
|
StorageParameters string
|
|
}
|
|
|
|
// CreateForeignKeyData contains data for create foreign key template
|
|
type CreateForeignKeyData struct {
|
|
SchemaName string
|
|
TableName string
|
|
ConstraintName string
|
|
SourceColumns string
|
|
TargetSchema string
|
|
TargetTable string
|
|
TargetColumns string
|
|
OnDelete string
|
|
OnUpdate string
|
|
Deferral string // DEFERRABLE / DEFERRABLE INITIALLY DEFERRED / NOT DEFERRABLE, or empty
|
|
}
|
|
|
|
// DropConstraintData contains data for drop constraint template
|
|
type DropConstraintData struct {
|
|
SchemaName string
|
|
TableName string
|
|
ConstraintName string
|
|
}
|
|
|
|
// DropIndexData contains data for drop index template
|
|
type DropIndexData struct {
|
|
SchemaName string
|
|
IndexName string
|
|
}
|
|
|
|
// CommentTableData contains data for table comment template
|
|
type CommentTableData struct {
|
|
SchemaName string
|
|
TableName string
|
|
Comment string
|
|
}
|
|
|
|
// CommentColumnData contains data for column comment template
|
|
type CommentColumnData struct {
|
|
SchemaName string
|
|
TableName string
|
|
ColumnName string
|
|
Comment string
|
|
}
|
|
|
|
// AuditTablesData contains data for audit tables template
|
|
type AuditTablesData struct {
|
|
AuditSchema string
|
|
}
|
|
|
|
// AuditColumnData represents a column in audit template
|
|
type AuditColumnData struct {
|
|
Name string
|
|
OldValue string
|
|
NewValue string
|
|
}
|
|
|
|
// AuditFunctionData contains data for audit function template
|
|
type AuditFunctionData struct {
|
|
SchemaName string
|
|
FunctionName string
|
|
TableName string
|
|
TablePrefix string
|
|
PrimaryKey string
|
|
AuditSchema string
|
|
UserFunction string
|
|
AuditInsert bool
|
|
AuditUpdate bool
|
|
AuditDelete bool
|
|
UpdateCondition string
|
|
UpdateColumns []AuditColumnData
|
|
DeleteColumns []AuditColumnData
|
|
}
|
|
|
|
// AuditTriggerData contains data for audit trigger template
|
|
type AuditTriggerData struct {
|
|
SchemaName string
|
|
TableName string
|
|
TriggerName string
|
|
FunctionName string
|
|
Events string
|
|
}
|
|
|
|
// CreateUniqueConstraintData contains data for create unique constraint template
|
|
type CreateUniqueConstraintData struct {
|
|
SchemaName string
|
|
TableName string
|
|
ConstraintName string
|
|
Columns string
|
|
UsingIndex string // when set, promotes this existing unique index instead of building a new one
|
|
}
|
|
|
|
// CreateCheckConstraintData contains data for create check constraint template
|
|
type CreateCheckConstraintData struct {
|
|
SchemaName string
|
|
TableName string
|
|
ConstraintName string
|
|
Expression string
|
|
}
|
|
|
|
// CreateForeignKeyWithCheckData contains data for create foreign key with existence check template
|
|
type CreateForeignKeyWithCheckData struct {
|
|
SchemaName string
|
|
TableName string
|
|
ConstraintName string
|
|
SourceColumns string
|
|
TargetSchema string
|
|
TargetTable string
|
|
TargetColumns string
|
|
OnDelete string
|
|
OnUpdate string
|
|
Deferral string // DEFERRABLE / DEFERRABLE INITIALLY DEFERRED / NOT DEFERRABLE, or empty
|
|
}
|
|
|
|
// SetSequenceValueData contains data for set sequence value template
|
|
type SetSequenceValueData struct {
|
|
SchemaName string
|
|
TableName string
|
|
SequenceName string
|
|
ColumnName string
|
|
}
|
|
|
|
// CreateSequenceData contains data for create sequence template
|
|
type CreateSequenceData struct {
|
|
SchemaName string
|
|
SequenceName string
|
|
Increment int
|
|
MinValue int64
|
|
MaxValue int64
|
|
StartValue int64
|
|
CacheSize int
|
|
}
|
|
|
|
// AddColumnWithCheckData contains data for add column with existence check template
|
|
type AddColumnWithCheckData struct {
|
|
SchemaName string
|
|
TableName string
|
|
ColumnName string
|
|
ColumnDefinition string
|
|
}
|
|
|
|
// CreatePrimaryKeyWithAutoGenCheckData contains data for primary key with auto-generated key check template
|
|
type CreatePrimaryKeyWithAutoGenCheckData struct {
|
|
SchemaName string
|
|
TableName string
|
|
ConstraintName string
|
|
AutoGenNames string // Comma-separated list of names like "'name1', 'name2'"
|
|
Columns string
|
|
ColumnNames string // Comma-separated list of quoted column names like "'id', 'tenant_id'"
|
|
}
|
|
|
|
// Execute methods for each template
|
|
|
|
// ExecuteCreateTable executes the create table template
|
|
func (te *TemplateExecutor) ExecuteCreateTable(data CreateTableData) (string, error) {
|
|
return te.execute("create_table.tmpl", data)
|
|
}
|
|
|
|
// ExecuteAddColumn executes the add column template
|
|
func (te *TemplateExecutor) ExecuteAddColumn(data AddColumnData) (string, error) {
|
|
return te.execute("add_column.tmpl", data)
|
|
}
|
|
|
|
// ExecuteAlterColumnTypeWithCheck executes the guarded alter column type
|
|
// template shared by the full-schema writer and the diff-based migration
|
|
// writer.
|
|
func (te *TemplateExecutor) ExecuteAlterColumnTypeWithCheck(data AlterColumnTypeWithCheckData) (string, error) {
|
|
return te.execute("alter_column_type_with_check.tmpl", data)
|
|
}
|
|
|
|
// ExecuteAlterColumnDefaultWithCheck executes the guarded alter column
|
|
// default template shared by the full-schema writer and the diff-based
|
|
// migration writer.
|
|
func (te *TemplateExecutor) ExecuteAlterColumnDefaultWithCheck(data AlterColumnDefaultWithCheckData) (string, error) {
|
|
return te.execute("alter_column_default_with_check.tmpl", data)
|
|
}
|
|
|
|
// ExecuteAlterColumnNullabilityWithCheck executes the guarded alter column
|
|
// nullability template.
|
|
func (te *TemplateExecutor) ExecuteAlterColumnNullabilityWithCheck(data AlterColumnNullabilityWithCheckData) (string, error) {
|
|
return te.execute("alter_column_nullability_with_check.tmpl", data)
|
|
}
|
|
|
|
// ExecuteCreatePrimaryKey executes the create primary key template
|
|
func (te *TemplateExecutor) ExecuteCreatePrimaryKey(data CreatePrimaryKeyData) (string, error) {
|
|
return te.execute("create_primary_key.tmpl", data)
|
|
}
|
|
|
|
// ExecuteCreateIndex executes the create index template
|
|
func (te *TemplateExecutor) ExecuteCreateIndex(data CreateIndexData) (string, error) {
|
|
return te.execute("create_index.tmpl", data)
|
|
}
|
|
|
|
// ExecuteCreateForeignKey executes the create foreign key template
|
|
func (te *TemplateExecutor) ExecuteCreateForeignKey(data CreateForeignKeyData) (string, error) {
|
|
return te.execute("create_foreign_key.tmpl", data)
|
|
}
|
|
|
|
// ExecuteDropConstraint executes the drop constraint template
|
|
func (te *TemplateExecutor) ExecuteDropConstraint(data DropConstraintData) (string, error) {
|
|
return te.execute("drop_constraint.tmpl", data)
|
|
}
|
|
|
|
// ExecuteDropIndex executes the drop index template
|
|
func (te *TemplateExecutor) ExecuteDropIndex(data DropIndexData) (string, error) {
|
|
return te.execute("drop_index.tmpl", data)
|
|
}
|
|
|
|
// ExecuteCommentTable executes the table comment template
|
|
func (te *TemplateExecutor) ExecuteCommentTable(data CommentTableData) (string, error) {
|
|
return te.execute("comment_table.tmpl", data)
|
|
}
|
|
|
|
// ExecuteCommentColumn executes the column comment template
|
|
func (te *TemplateExecutor) ExecuteCommentColumn(data CommentColumnData) (string, error) {
|
|
return te.execute("comment_column.tmpl", data)
|
|
}
|
|
|
|
// ExecuteAuditTables executes the audit tables template
|
|
func (te *TemplateExecutor) ExecuteAuditTables(data AuditTablesData) (string, error) {
|
|
return te.execute("audit_tables.tmpl", data)
|
|
}
|
|
|
|
// ExecuteAuditFunction executes the audit function template
|
|
func (te *TemplateExecutor) ExecuteAuditFunction(data AuditFunctionData) (string, error) {
|
|
return te.execute("audit_function.tmpl", data)
|
|
}
|
|
|
|
// ExecuteAuditTrigger executes the audit trigger template
|
|
func (te *TemplateExecutor) ExecuteAuditTrigger(data AuditTriggerData) (string, error) {
|
|
return te.execute("audit_trigger.tmpl", data)
|
|
}
|
|
|
|
// ExecuteCreateUniqueConstraint executes the create unique constraint template
|
|
func (te *TemplateExecutor) ExecuteCreateUniqueConstraint(data CreateUniqueConstraintData) (string, error) {
|
|
return te.execute("create_unique_constraint.tmpl", data)
|
|
}
|
|
|
|
// ExecuteCreateCheckConstraint executes the create check constraint template
|
|
func (te *TemplateExecutor) ExecuteCreateCheckConstraint(data CreateCheckConstraintData) (string, error) {
|
|
return te.execute("create_check_constraint.tmpl", data)
|
|
}
|
|
|
|
// ExecuteCreateForeignKeyWithCheck executes the create foreign key with check template
|
|
func (te *TemplateExecutor) ExecuteCreateForeignKeyWithCheck(data CreateForeignKeyWithCheckData) (string, error) {
|
|
return te.execute("create_foreign_key_with_check.tmpl", data)
|
|
}
|
|
|
|
// ExecuteSetSequenceValue executes the set sequence value template
|
|
func (te *TemplateExecutor) ExecuteSetSequenceValue(data SetSequenceValueData) (string, error) {
|
|
return te.execute("set_sequence_value.tmpl", data)
|
|
}
|
|
|
|
// ExecuteCreateSequence executes the create sequence template
|
|
func (te *TemplateExecutor) ExecuteCreateSequence(data CreateSequenceData) (string, error) {
|
|
return te.execute("create_sequence.tmpl", data)
|
|
}
|
|
|
|
// ExecuteAddColumnWithCheck executes the add column with check template
|
|
func (te *TemplateExecutor) ExecuteAddColumnWithCheck(data AddColumnWithCheckData) (string, error) {
|
|
return te.execute("add_column_with_check.tmpl", data)
|
|
}
|
|
|
|
// ExecuteCreatePrimaryKeyWithAutoGenCheck executes the create primary key with auto-generated key check template
|
|
func (te *TemplateExecutor) ExecuteCreatePrimaryKeyWithAutoGenCheck(data CreatePrimaryKeyWithAutoGenCheckData) (string, error) {
|
|
return te.execute("create_primary_key_with_autogen_check.tmpl", data)
|
|
}
|
|
|
|
// Helper functions to build template data from models
|
|
|
|
// columnGenerationClauses returns the generation expression of a GENERATED ... STORED
|
|
// column and the generation mode of an identity column ("" for each that does not apply).
|
|
// Such columns cannot carry a DEFAULT.
|
|
func columnGenerationClauses(col *models.Column) (generated, identity string) {
|
|
if col.Generated && col.GenerationExpression != "" {
|
|
return col.GenerationExpression, ""
|
|
}
|
|
if col.Identity && col.IdentityGeneration != "" {
|
|
return "", strings.ToUpper(col.IdentityGeneration)
|
|
}
|
|
return "", ""
|
|
}
|
|
|
|
// BuildCreateTableData builds CreateTableData from a models.Table
|
|
func BuildCreateTableData(schemaName string, table *models.Table) CreateTableData {
|
|
columns := make([]ColumnData, 0, len(table.Columns))
|
|
|
|
// Get sorted columns
|
|
sortedCols := getSortedColumns(table.Columns)
|
|
for _, col := range sortedCols {
|
|
colData := ColumnData{
|
|
Name: col.Name,
|
|
Type: col.Type,
|
|
NotNull: col.NotNull,
|
|
}
|
|
colData.Generated, colData.Identity = columnGenerationClauses(col)
|
|
if col.Default != nil && colData.Generated == "" && colData.Identity == "" {
|
|
if value, ok := col.Default.(string); ok {
|
|
colData.Default = quoteDefaultValue(stripBackticks(value), col.Type)
|
|
} else {
|
|
colData.Default = fmt.Sprintf("%v", col.Default)
|
|
}
|
|
}
|
|
columns = append(columns, colData)
|
|
}
|
|
|
|
return CreateTableData{
|
|
SchemaName: schemaName,
|
|
TableName: table.Name,
|
|
Columns: columns,
|
|
}
|
|
}
|
|
|
|
// BuildAuditFunctionData builds AuditFunctionData from table and config
|
|
func BuildAuditFunctionData(
|
|
schemaName string,
|
|
table *models.Table,
|
|
pk *models.Column,
|
|
config *TableAuditConfig,
|
|
auditSchema string,
|
|
userFunction string,
|
|
) AuditFunctionData {
|
|
funcName := fmt.Sprintf("tf_audit_%s", table.Name)
|
|
|
|
// Build list of audited columns
|
|
auditedColumns := make([]*models.Column, 0)
|
|
for _, col := range sortColumns(table.Columns) {
|
|
if col.Name == pk.Name {
|
|
continue
|
|
}
|
|
|
|
excluded := false
|
|
for _, excl := range config.ExcludedColumns {
|
|
if strings.EqualFold(col.Name, excl) {
|
|
excluded = true
|
|
break
|
|
}
|
|
}
|
|
if excluded {
|
|
continue
|
|
}
|
|
|
|
auditedColumns = append(auditedColumns, col)
|
|
}
|
|
|
|
// Build update condition
|
|
updateComparisons := make([]string, 0)
|
|
for _, col := range auditedColumns {
|
|
updateComparisons = append(updateComparisons,
|
|
fmt.Sprintf("old.%s IS DISTINCT FROM new.%s", quoteIdent(col.Name), quoteIdent(col.Name)))
|
|
}
|
|
updateCondition := strings.Join(updateComparisons, " OR ")
|
|
|
|
// Build update columns data
|
|
updateColumns := make([]AuditColumnData, 0)
|
|
for _, col := range auditedColumns {
|
|
isEncrypted := false
|
|
for _, enc := range config.EncryptedColumns {
|
|
if strings.EqualFold(col.Name, enc) {
|
|
isEncrypted = true
|
|
break
|
|
}
|
|
}
|
|
|
|
oldValue := fmt.Sprintf("old.%s::text", quoteIdent(col.Name))
|
|
newValue := fmt.Sprintf("new.%s::text", quoteIdent(col.Name))
|
|
|
|
if isEncrypted {
|
|
oldValue = "'****************'"
|
|
newValue = "'****************'"
|
|
}
|
|
|
|
updateColumns = append(updateColumns, AuditColumnData{
|
|
Name: col.Name,
|
|
OldValue: oldValue,
|
|
NewValue: newValue,
|
|
})
|
|
}
|
|
|
|
// Build delete columns data (same as update but only old values)
|
|
deleteColumns := make([]AuditColumnData, 0)
|
|
for _, col := range auditedColumns {
|
|
isEncrypted := false
|
|
for _, enc := range config.EncryptedColumns {
|
|
if strings.EqualFold(col.Name, enc) {
|
|
isEncrypted = true
|
|
break
|
|
}
|
|
}
|
|
|
|
oldValue := fmt.Sprintf("old.%s::text", quoteIdent(col.Name))
|
|
if isEncrypted {
|
|
oldValue = "'****************'"
|
|
}
|
|
|
|
deleteColumns = append(deleteColumns, AuditColumnData{
|
|
Name: col.Name,
|
|
OldValue: oldValue,
|
|
})
|
|
}
|
|
|
|
tablePrefix := "NULL"
|
|
if config.TablePrefix != "" {
|
|
tablePrefix = quote(config.TablePrefix)
|
|
}
|
|
|
|
return AuditFunctionData{
|
|
SchemaName: schemaName,
|
|
FunctionName: funcName,
|
|
TableName: table.Name,
|
|
TablePrefix: tablePrefix,
|
|
PrimaryKey: pk.Name,
|
|
AuditSchema: auditSchema,
|
|
UserFunction: userFunction,
|
|
AuditInsert: config.AuditInsert,
|
|
AuditUpdate: config.AuditUpdate,
|
|
AuditDelete: config.AuditDelete,
|
|
UpdateCondition: updateCondition,
|
|
UpdateColumns: updateColumns,
|
|
DeleteColumns: deleteColumns,
|
|
}
|
|
}
|