ir

package
v1.7.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 16, 2026 License: Apache-2.0 Imports: 12 Imported by: 0

README

IR (Intermediate Representation) Package

Go Reference Go Report Card

The ir package provides an Intermediate Representation for PostgreSQL database schemas. It introspects live databases using PostgreSQL system catalogs and provides normalized schema representations.

Installation

go get github.com/pgplex/pgschema

Then import the ir package:

import "github.com/pgplex/pgschema/ir"

Usage

Introspecting Live Database
import (
    "context"
    "database/sql"
    "github.com/pgplex/pgschema/ir"
    _ "github.com/lib/pq"
)

// Connect to database
db, err := sql.Open("postgres", "postgresql://user:pass@localhost/dbname?sslmode=disable")
if err != nil {
    log.Fatal(err)
}
defer db.Close()

// Create inspector with no ignore config
inspector := ir.NewInspector(db, nil)

// Build IR from database for "public" schema
ctx := context.Background()
schema, err := inspector.BuildIR(ctx, "public")
if err != nil {
    log.Fatal(err)
}

// Access normalized schema data
if publicSchema, ok := schema.GetSchema("public"); ok {
    fmt.Printf("Found %d tables\n", len(publicSchema.Tables))
}
Working with Schema Objects

The IR package provides strongly-typed representations of PostgreSQL objects:

  • Tables: Columns, constraints, indexes, triggers, RLS policies
  • Views: View definitions and dependencies
  • Functions: Parameters, return types, language
  • Procedures: Parameters and language
  • Types: Enums, composites, domains
  • Sequences: Start, increment, min/max values
Comparing Schemas
// Compare two schemas to identify differences
oldSchema := // ... parse or introspect old schema
newSchema := // ... parse or introspect new schema

// The main pgschema tool provides diff functionality
// See github.com/pgplex/pgschema/internal/diff for implementation

Key Features

  • Database Introspection: Query live databases using optimized SQL queries
  • Normalization: Consistent representation from PostgreSQL system catalogs
  • Rich Type System: Full support for PostgreSQL data types and constraints
  • Concurrent Safe: Thread-safe access to schema data structures
  • Embedded Testing: Use embedded PostgreSQL for testing without Docker (see ParseSQLForTest in testutil.go)

Schema Object Types

Tables
type Table struct {
    Schema       string
    Name         string
    Type         TableType // BASE_TABLE, VIEW, etc.
    Columns      []*Column
    Constraints  map[string]*Constraint
    Indexes      map[string]*Index
    Triggers     map[string]*Trigger
    RLSEnabled   bool
    Policies     map[string]*RLSPolicy
    // ...
}
Functions
type Function struct {
    Schema     string
    Name       string
    Arguments  []*Parameter
    Returns    string
    Language   string
    Body       string
    // ...
}
Views
type View struct {
    Schema     string
    Name       string
    Definition string
    Columns    []*Column
    // ...
}

Generated SQL Queries

The package includes pre-generated SQL queries in queries/ for database introspection:

import "github.com/pgplex/pgschema/ir/queries"

q := queries.New(db)
tables, err := q.GetTables(ctx, "public")

Testing

# Run all tests (uses embedded PostgreSQL, no Docker required)
go test -v ./...

# Skip integration tests (faster)
go test -short -v ./...

Compatibility

  • Go: 1.24.0+
  • PostgreSQL: 14, 15, 16, 17, 18

License

Same as the parent pgschema project.

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func IsBuiltInType 

func IsBuiltInType(typeName string) bool

IsBuiltInType checks if a type name is a PostgreSQL built-in type. This is used to determine if type conversions need explicit USING clauses (e.g., text -> custom_enum requires USING, but integer -> bigint does not)

func IsTextLikeType 

func IsTextLikeType(typeName string) bool

IsTextLikeType checks if a type is a text-like type (text, varchar, char, etc.) This is used to determine if type conversions need explicit USING clauses

func QualifyEntityNameWithQuotes 

func QualifyEntityNameWithQuotes(entitySchema, entityName, targetSchema string) string

QualifyEntityNameWithQuotes returns the properly qualified and quoted entity name

func QuoteIdentifier 

func QuoteIdentifier(identifier string) string

QuoteIdentifier adds quotes to an identifier if needed

Types

type Aggregate 

type Aggregate struct {
	Schema                   string `json:"schema"`
	Name                     string `json:"name"`
	ReturnType               string `json:"return_type"`
	TransitionFunction       string `json:"transition_function"`
	TransitionFunctionSchema string `json:"transition_function_schema,omitempty"`
	StateType                string `json:"state_type"`
	InitialCondition         string `json:"initial_condition,omitempty"`
	FinalFunction            string `json:"final_function,omitempty"`
	FinalFunctionSchema      string `json:"final_function_schema,omitempty"`
	Comment                  string `json:"comment,omitempty"`
}

Aggregate represents a database aggregate function

type Column 

type Column struct {
	Name          string    `json:"name"`
	Position      int       `json:"position"` // ordinal_position
	DataType      string    `json:"data_type"`
	IsNullable    bool      `json:"is_nullable"`
	DefaultValue  *string   `json:"default_value,omitempty"`
	MaxLength     *int      `json:"max_length,omitempty"`
	Precision     *int      `json:"precision,omitempty"`
	Scale         *int      `json:"scale,omitempty"`
	Comment       string    `json:"comment,omitempty"`
	Identity      *Identity `json:"identity,omitempty"`
	GeneratedExpr *string   `json:"generated_expr,omitempty"` // Expression for generated columns
	IsGenerated   bool      `json:"is_generated,omitempty"`   // True if this is a generated column
}

Column represents a table column

func (*Column) GetObjectName 

func (c *Column) GetObjectName() string

type ColumnPrivilege 

type ColumnPrivilege struct {
	TableName       string   `json:"table_name"`        // table containing the columns
	Columns         []string `json:"columns"`           // columns for this grant (sorted alphabetically)
	Grantee         string   `json:"grantee"`           // role name or "PUBLIC"
	Privileges      []string `json:"privileges"`        // SELECT, INSERT, UPDATE, REFERENCES only
	WithGrantOption bool     `json:"with_grant_option"` // Can grantee grant to others?
}

ColumnPrivilege represents a column-level privilege grant on a table Column-level grants allow fine-grained access control on specific columns rather than the entire table. Stored in pg_attribute.attacl.

func (*ColumnPrivilege) GetFullKey 

func (cp *ColumnPrivilege) GetFullKey() string

GetFullKey returns a unique identifier including grant option. Use this when you need to distinguish between the same privilege with different grant options.

func (*ColumnPrivilege) GetObjectKey 

func (cp *ColumnPrivilege) GetObjectKey() string

GetObjectKey returns a unique identifier for the column privilege. MUST include sorted columns - two grants on same table/role with different columns are different objects.

func (*ColumnPrivilege) GetObjectName 

func (cp *ColumnPrivilege) GetObjectName() string

GetObjectName returns the table name for the column privilege

type Constraint 

type Constraint struct {
	Schema              string              `json:"schema"`
	Table               string              `json:"table"`
	Name                string              `json:"name"`
	Type                ConstraintType      `json:"type"`
	Columns             []*ConstraintColumn `json:"columns"`
	ReferencedSchema    string              `json:"referenced_schema,omitempty"`
	ReferencedTable     string              `json:"referenced_table,omitempty"`
	ReferencedColumns   []*ConstraintColumn `json:"referenced_columns,omitempty"`
	CheckClause         string              `json:"check_clause,omitempty"`
	ExclusionDefinition string              `json:"exclusion_definition,omitempty"` // Full EXCLUDE definition from pg_get_constraintdef()
	DeleteRule          string              `json:"delete_rule,omitempty"`
	UpdateRule          string              `json:"update_rule,omitempty"`
	Deferrable          bool                `json:"deferrable,omitempty"`
	InitiallyDeferred   bool                `json:"initially_deferred,omitempty"`
	IsValid             bool                `json:"is_valid,omitempty"`
	Comment             string              `json:"comment,omitempty"`
}

Constraint represents a table constraint

func (*Constraint) GetObjectName 

func (c *Constraint) GetObjectName() string

type ConstraintColumn 

type ConstraintColumn struct {
	Name     string `json:"name"`
	Position int    `json:"position"` // ordinal_position within the constraint
}

ConstraintColumn represents a column within a constraint with its position

type ConstraintType 

type ConstraintType string

ConstraintType represents different types of database constraints 

const (
	ConstraintTypePrimaryKey ConstraintType = "PRIMARY_KEY"
	ConstraintTypeUnique     ConstraintType = "UNIQUE"
	ConstraintTypeForeignKey ConstraintType = "FOREIGN_KEY"
	ConstraintTypeCheck      ConstraintType = "CHECK"
	ConstraintTypeExclusion  ConstraintType = "EXCLUSION"
)

type DefaultPrivilege 

type DefaultPrivilege struct {
	OwnerRole       string                     `json:"owner_role"`        // Role that owns the default privilege
	ObjectType      DefaultPrivilegeObjectType `json:"object_type"`       // TABLES, SEQUENCES, FUNCTIONS, TYPES
	Grantee         string                     `json:"grantee"`           // Role name or "PUBLIC"
	Privileges      []string                   `json:"privileges"`        // SELECT, INSERT, UPDATE, etc.
	WithGrantOption bool                       `json:"with_grant_option"` // Can grantee grant to others?
}

DefaultPrivilege represents an ALTER DEFAULT PRIVILEGES setting

func (*DefaultPrivilege) GetObjectName 

func (d *DefaultPrivilege) GetObjectName() string

GetObjectName returns a unique identifier for the default privilege

type DefaultPrivilegeObjectType 

type DefaultPrivilegeObjectType string

DefaultPrivilegeObjectType represents the object type for default privileges 

const (
	DefaultPrivilegeObjectTypeTables    DefaultPrivilegeObjectType = "TABLES"
	DefaultPrivilegeObjectTypeSequences DefaultPrivilegeObjectType = "SEQUENCES"
	DefaultPrivilegeObjectTypeFunctions DefaultPrivilegeObjectType = "FUNCTIONS"
	DefaultPrivilegeObjectTypeTypes     DefaultPrivilegeObjectType = "TYPES"
)

type DependencyType 

type DependencyType string

DependencyType represents different types of database object dependencies 

const (
	DependencyTypeTable    DependencyType = "TABLE"
	DependencyTypeView     DependencyType = "VIEW"
	DependencyTypeFunction DependencyType = "FUNCTION"
	DependencyTypeSequence DependencyType = "SEQUENCE"
)

type DomainConstraint 

type DomainConstraint struct {
	Name       string `json:"name"`
	Definition string `json:"definition"`
}

DomainConstraint represents a constraint on a domain

type Function 

type Function struct {
	Schema            string       `json:"schema"`
	Name              string       `json:"name"`
	Definition        string       `json:"definition"`
	ReturnType        string       `json:"return_type"`
	Language          string       `json:"language"`
	Parameters        []*Parameter `json:"parameters,omitempty"`
	Comment           string       `json:"comment,omitempty"`
	Volatility        string       `json:"volatility,omitempty"`          // IMMUTABLE, STABLE, VOLATILE
	IsStrict          bool         `json:"is_strict,omitempty"`           // STRICT or null behavior
	IsSecurityDefiner bool         `json:"is_security_definer,omitempty"` // SECURITY DEFINER
	IsLeakproof       bool         `json:"is_leakproof,omitempty"`        // LEAKPROOF
	Parallel          string       `json:"parallel,omitempty"`            // SAFE, UNSAFE, RESTRICTED
	SearchPath        string       `json:"search_path,omitempty"`         // SET search_path value
	Dependencies      []string     `json:"dependencies,omitempty"`        // Function keys (name(args)) this function depends on
}

Function represents a database function

func (*Function) GetArguments 

func (f *Function) GetArguments() string

GetArguments returns the function arguments string (types only) for function identification. This is built dynamically from the Parameters array to ensure it uses normalized types. Per PostgreSQL DROP FUNCTION syntax, only input parameters are included (IN, INOUT, VARIADIC).

func (*Function) GetObjectName 

func (f *Function) GetObjectName() string

type IR 

type IR struct {
	Metadata Metadata           `json:"metadata"`
	Schemas  map[string]*Schema `json:"schemas"` // schema_name -> Schema
	// contains filtered or unexported fields
}

IR represents the complete database schema intermediate representation

func NewIR 

func NewIR() *IR

NewIR creates a new empty catalog IR

func (*IR) CreateSchema 

func (c *IR) CreateSchema(name string) *Schema

CreateSchema creates a new schema with the given name. If the schema already exists, it returns the existing schema.

func (*IR) GetOrCreateSchema 

func (c *IR) GetOrCreateSchema(name string) *Schema

GetOrCreateSchema gets or creates a database schema by name with thread safety. This is an exported version of the internal getOrCreateSchema method.

func (*IR) GetSchema 

func (c *IR) GetSchema(name string) (*Schema, bool)

GetSchema retrieves a schema by name with thread safety. Returns the schema and true if found, or nil and false if not found.

type Identity 

type Identity struct {
	Generation string `json:"generation,omitempty"` // "ALWAYS" or "BY DEFAULT"
	Start      *int64 `json:"start,omitempty"`
	Increment  *int64 `json:"increment,omitempty"`
	Maximum    *int64 `json:"maximum,omitempty"`
	Minimum    *int64 `json:"minimum,omitempty"`
	Cycle      bool   `json:"cycle,omitempty"`
}

Identity represents PostgreSQL identity column configuration

type IgnoreConfig 

type IgnoreConfig struct {
	Tables     []string `toml:"tables,omitempty"`
	Views      []string `toml:"views,omitempty"`
	Functions  []string `toml:"functions,omitempty"`
	Procedures []string `toml:"procedures,omitempty"`
	Types      []string `toml:"types,omitempty"`
	Sequences  []string `toml:"sequences,omitempty"`
}

IgnoreConfig represents the configuration for ignoring database objects

func (*IgnoreConfig) ShouldIgnoreFunction 

func (c *IgnoreConfig) ShouldIgnoreFunction(functionName string) bool

ShouldIgnoreFunction checks if a function should be ignored based on the patterns

func (*IgnoreConfig) ShouldIgnoreProcedure 

func (c *IgnoreConfig) ShouldIgnoreProcedure(procedureName string) bool

ShouldIgnoreProcedure checks if a procedure should be ignored based on the patterns

func (*IgnoreConfig) ShouldIgnoreSequence 

func (c *IgnoreConfig) ShouldIgnoreSequence(sequenceName string) bool

ShouldIgnoreSequence checks if a sequence should be ignored based on the patterns

func (*IgnoreConfig) ShouldIgnoreTable 

func (c *IgnoreConfig) ShouldIgnoreTable(tableName string) bool

ShouldIgnoreTable checks if a table should be ignored based on the patterns

func (*IgnoreConfig) ShouldIgnoreType 

func (c *IgnoreConfig) ShouldIgnoreType(typeName string) bool

ShouldIgnoreType checks if a type should be ignored based on the patterns

func (*IgnoreConfig) ShouldIgnoreView 

func (c *IgnoreConfig) ShouldIgnoreView(viewName string) bool

ShouldIgnoreView checks if a view should be ignored based on the patterns

type Index 

type Index struct {
	Schema       string         `json:"schema"`
	Table        string         `json:"table"`
	Name         string         `json:"name"`
	Type         IndexType      `json:"type"`
	Method       string         `json:"method"` // btree, hash, gin, gist, etc.
	Columns      []*IndexColumn `json:"columns"`
	IsPartial    bool           `json:"is_partial"`      // has a WHERE clause
	IsExpression bool           `json:"is_expression"`   // functional/expression index
	Where        string         `json:"where,omitempty"` // partial index condition
	Comment      string         `json:"comment,omitempty"`
}

Index represents a database index

func (*Index) GetObjectName 

func (i *Index) GetObjectName() string

type IndexColumn 

type IndexColumn struct {
	Name      string `json:"name"`
	Position  int    `json:"position"`
	Direction string `json:"direction,omitempty"` // ASC, DESC
	Operator  string `json:"operator,omitempty"`  // operator class
}

IndexColumn represents a column within an index

type IndexType 

type IndexType string

IndexType represents different types of database indexes 

const (
	IndexTypeRegular IndexType = "REGULAR"
	IndexTypePrimary IndexType = "PRIMARY"
	IndexTypeUnique  IndexType = "UNIQUE"
)

type Inspector 

type Inspector struct {
	// contains filtered or unexported fields
}

Inspector builds IR from database queries

func NewInspector 

func NewInspector(db *sql.DB, ignoreConfig *IgnoreConfig) *Inspector

NewInspector creates a new schema inspector with optional ignore configuration

func (*Inspector) BuildIR 

func (i *Inspector) BuildIR(ctx context.Context, targetSchema string) (*IR, error)

BuildIR builds the schema IR from the database for a specific schema

type LikeClause 

type LikeClause struct {
	SourceSchema string `json:"source_schema"`
	SourceTable  string `json:"source_table"`
	Options      string `json:"options"` // e.g., "INCLUDING ALL" or "INCLUDING DEFAULTS EXCLUDING INDEXES"
}

LikeClause represents a LIKE clause in CREATE TABLE statement

type Metadata 

type Metadata struct {
	DatabaseVersion string `json:"database_version"`
}

Metadata contains information about the schema dump

type Parameter 

type Parameter struct {
	Name         string  `json:"name"`
	DataType     string  `json:"data_type"`
	Mode         string  `json:"mode"` // IN, OUT, INOUT
	Position     int     `json:"position"`
	DefaultValue *string `json:"default_value,omitempty"`
}

Parameter represents a function parameter

type PolicyCommand 

type PolicyCommand string

PolicyCommand represents the command for which the policy applies 

const (
	PolicyCommandAll    PolicyCommand = "ALL"
	PolicyCommandSelect PolicyCommand = "SELECT"
	PolicyCommandInsert PolicyCommand = "INSERT"
	PolicyCommandUpdate PolicyCommand = "UPDATE"
	PolicyCommandDelete PolicyCommand = "DELETE"
)

type Privilege 

type Privilege struct {
	ObjectType      PrivilegeObjectType `json:"object_type"`       // TABLE, VIEW, SEQUENCE, FUNCTION, PROCEDURE, TYPE
	ObjectName      string              `json:"object_name"`       // table name or function signature
	Grantee         string              `json:"grantee"`           // role name or "PUBLIC"
	Privileges      []string            `json:"privileges"`        // [SELECT, INSERT, UPDATE, ...] or [EXECUTE] or [USAGE]
	WithGrantOption bool                `json:"with_grant_option"` // Can grantee grant to others?
}

Privilege represents an explicit privilege grant on a schema object

func (*Privilege) GetFullKey 

func (p *Privilege) GetFullKey() string

GetFullKey returns a unique identifier including WithGrantOption. Use this when you need to distinguish between the same privilege with different grant options.

func (*Privilege) GetObjectKey 

func (p *Privilege) GetObjectKey() string

GetObjectKey returns a unique identifier for the privilege (object + grantee) Note: This intentionally excludes WithGrantOption so that privilege modifications (e.g., adding or removing GRANT OPTION) are detected as modifications, not as separate add/drop operations.

func (*Privilege) GetObjectName 

func (p *Privilege) GetObjectName() string

GetObjectName returns the object name for the privilege

type PrivilegeObjectType 

type PrivilegeObjectType string

PrivilegeObjectType represents the object type for explicit privilege grants 

const (
	PrivilegeObjectTypeTable     PrivilegeObjectType = "TABLE"
	PrivilegeObjectTypeView      PrivilegeObjectType = "VIEW"
	PrivilegeObjectTypeSequence  PrivilegeObjectType = "SEQUENCE"
	PrivilegeObjectTypeFunction  PrivilegeObjectType = "FUNCTION"
	PrivilegeObjectTypeProcedure PrivilegeObjectType = "PROCEDURE"
	PrivilegeObjectTypeType      PrivilegeObjectType = "TYPE"
)

type Procedure 

type Procedure struct {
	Schema     string       `json:"schema"`
	Name       string       `json:"name"`
	Definition string       `json:"definition"`
	Language   string       `json:"language"`
	Parameters []*Parameter `json:"parameters,omitempty"`
	Comment    string       `json:"comment,omitempty"`
}

Procedure represents a database procedure

func (*Procedure) GetArguments 

func (p *Procedure) GetArguments() string

GetArguments returns the procedure arguments string (types only) for procedure identification. This is built dynamically from the Parameters array to ensure it uses normalized types. Per PostgreSQL DROP PROCEDURE syntax, only input parameters are included (IN, INOUT, VARIADIC).

func (*Procedure) GetObjectName 

func (p *Procedure) GetObjectName() string

type RLSPolicy 

type RLSPolicy struct {
	Schema     string        `json:"schema"`
	Table      string        `json:"table"`
	Name       string        `json:"name"`
	Command    PolicyCommand `json:"command"` // SELECT, INSERT, UPDATE, DELETE, ALL
	Permissive bool          `json:"permissive"`
	Roles      []string      `json:"roles,omitempty"`
	Using      string        `json:"using,omitempty"`      // USING expression
	WithCheck  string        `json:"with_check,omitempty"` // WITH CHECK expression
	Comment    string        `json:"comment,omitempty"`
}

RLSPolicy represents a Row Level Security policy

func (*RLSPolicy) GetObjectName 

func (p *RLSPolicy) GetObjectName() string

type RevokedDefaultPrivilege 

type RevokedDefaultPrivilege struct {
	ObjectType PrivilegeObjectType `json:"object_type"` // FUNCTION, PROCEDURE, TYPE
	ObjectName string              `json:"object_name"` // function signature or type name
	Privileges []string            `json:"privileges"`  // [EXECUTE] or [USAGE]
}

RevokedDefaultPrivilege represents an explicit revoke of a default PUBLIC privilege This is used to track when default PUBLIC grants (e.g., EXECUTE on functions) are revoked

func (*RevokedDefaultPrivilege) GetObjectKey 

func (r *RevokedDefaultPrivilege) GetObjectKey() string

GetObjectKey returns a unique identifier for the revoked default privilege

func (*RevokedDefaultPrivilege) GetObjectName 

func (r *RevokedDefaultPrivilege) GetObjectName() string

GetObjectName returns the object name for the revoked default privilege

type Schema 

type Schema struct {
	Name  string `json:"name"`
	Owner string `json:"owner"` // Schema owner
	// Note: Indexes, Triggers, and RLS Policies are stored at table level (Table.Indexes, Table.Triggers, Table.Policies)
	Tables                   map[string]*Table          `json:"tables"`                               // table_name -> Table
	Views                    map[string]*View           `json:"views"`                                // view_name -> View
	Functions                map[string]*Function       `json:"functions"`                            // function_name -> Function
	Procedures               map[string]*Procedure      `json:"procedures"`                           // procedure_name -> Procedure
	Aggregates               map[string]*Aggregate      `json:"aggregates"`                           // aggregate_name -> Aggregate
	Sequences                map[string]*Sequence       `json:"sequences"`                            // sequence_name -> Sequence
	Types                    map[string]*Type           `json:"types"`                                // type_name -> Type
	DefaultPrivileges        []*DefaultPrivilege        `json:"default_privileges,omitempty"`         // Default privileges for future objects
	Privileges               []*Privilege               `json:"privileges,omitempty"`                 // Explicit privilege grants on objects
	ColumnPrivileges         []*ColumnPrivilege         `json:"column_privileges,omitempty"`          // Column-level privilege grants
	RevokedDefaultPrivileges []*RevokedDefaultPrivilege `json:"revoked_default_privileges,omitempty"` // Explicit revokes of default PUBLIC privileges
	// contains filtered or unexported fields
}

Schema represents a single database schema (namespace)

func (*Schema) GetAggregate 

func (s *Schema) GetAggregate(name string) (*Aggregate, bool)

GetAggregate retrieves an aggregate from the schema with thread safety

func (*Schema) GetFunction 

func (s *Schema) GetFunction(name string) (*Function, bool)

GetFunction retrieves a function from the schema with thread safety

func (*Schema) GetProcedure 

func (s *Schema) GetProcedure(name string) (*Procedure, bool)

GetProcedure retrieves a procedure from the schema with thread safety

func (*Schema) GetSequence 

func (s *Schema) GetSequence(name string) (*Sequence, bool)

GetSequence retrieves a sequence from the schema with thread safety

func (*Schema) GetTable 

func (s *Schema) GetTable(name string) (*Table, bool)

GetTable retrieves a table from the schema with thread safety

func (*Schema) GetType 

func (s *Schema) GetType(name string) (*Type, bool)

GetType retrieves a type from the schema with thread safety

func (*Schema) GetView 

func (s *Schema) GetView(name string) (*View, bool)

GetView retrieves a view from the schema with thread safety

func (*Schema) SetAggregate 

func (s *Schema) SetAggregate(name string, aggregate *Aggregate)

SetAggregate sets an aggregate in the schema with thread safety

func (*Schema) SetFunction 

func (s *Schema) SetFunction(name string, function *Function)

SetFunction sets a function in the schema with thread safety

func (*Schema) SetProcedure 

func (s *Schema) SetProcedure(name string, procedure *Procedure)

SetProcedure sets a procedure in the schema with thread safety

func (*Schema) SetSequence 

func (s *Schema) SetSequence(name string, sequence *Sequence)

SetSequence sets a sequence in the schema with thread safety

func (*Schema) SetTable 

func (s *Schema) SetTable(name string, table *Table)

SetTable sets a table in the schema with thread safety

func (*Schema) SetType 

func (s *Schema) SetType(name string, typ *Type)

SetType sets a type in the schema with thread safety

func (*Schema) SetView 

func (s *Schema) SetView(name string, view *View)

SetView sets a view in the schema with thread safety

type Sequence 

type Sequence struct {
	Schema        string `json:"schema"`
	Name          string `json:"name"`
	DataType      string `json:"data_type"`
	StartValue    int64  `json:"start_value"`
	MinValue      *int64 `json:"min_value,omitempty"`
	MaxValue      *int64 `json:"max_value,omitempty"`
	Increment     int64  `json:"increment"`
	CycleOption   bool   `json:"cycle_option"`
	Cache         *int64 `json:"cache,omitempty"`
	OwnedByTable  string `json:"owned_by_table,omitempty"`
	OwnedByColumn string `json:"owned_by_column,omitempty"`
	Comment       string `json:"comment,omitempty"`
}

Sequence represents a database sequence

func (*Sequence) GetObjectName 

func (s *Sequence) GetObjectName() string

type Table 

type Table struct {
	Schema            string                 `json:"schema"`
	Name              string                 `json:"name"`
	Type              TableType              `json:"type"`                  // BASE_TABLE, VIEW, etc.
	IsExternal        bool                   `json:"is_external,omitempty"` // True if table is externally managed (e.g., in ignored schemas)
	Columns           []*Column              `json:"columns"`
	Constraints       map[string]*Constraint `json:"constraints"` // constraint_name -> Constraint
	Indexes           map[string]*Index      `json:"indexes"`     // index_name -> Index
	Triggers          map[string]*Trigger    `json:"triggers"`    // trigger_name -> Trigger
	RLSEnabled        bool                   `json:"rls_enabled"`
	RLSForced         bool                   `json:"rls_forced"`
	Policies          map[string]*RLSPolicy  `json:"policies"` // policy_name -> RLSPolicy
	Dependencies      []TableDependency      `json:"dependencies"`
	Comment           string                 `json:"comment,omitempty"`
	IsPartitioned     bool                   `json:"is_partitioned"`
	PartitionStrategy string                 `json:"partition_strategy,omitempty"` // RANGE, LIST, HASH
	PartitionKey      string                 `json:"partition_key,omitempty"`      // Column(s) used for partitioning
	LikeClauses       []LikeClause           `json:"like_clauses,omitempty"`       // LIKE clauses in CREATE TABLE
}

Table represents a database table

func (*Table) GetObjectName 

func (t *Table) GetObjectName() string

GetObjectName implementations for DiffSource interface

type TableDependency 

type TableDependency struct {
	Schema string         `json:"schema"`
	Name   string         `json:"name"`
	Type   DependencyType `json:"type"`
}

TableDependency represents a dependency between database objects

type TableType 

type TableType string

TableType represents different types of table objects 

const (
	TableTypeBase TableType = "BASE_TABLE"
	TableTypeView TableType = "VIEW"
	TableTypeTemp TableType = "TEMPORARY"
)

type Trigger 

type Trigger struct {
	Schema            string         `json:"schema"`
	Table             string         `json:"table"`
	Name              string         `json:"name"`
	Timing            TriggerTiming  `json:"timing"` // BEFORE, AFTER, INSTEAD OF
	Events            []TriggerEvent `json:"events"` // INSERT, UPDATE, DELETE
	Level             TriggerLevel   `json:"level"`  // ROW, STATEMENT
	Function          string         `json:"function"`
	Condition         string         `json:"condition,omitempty"` // WHEN condition
	Comment           string         `json:"comment,omitempty"`
	IsConstraint      bool           `json:"is_constraint,omitempty"`      // Whether this is a constraint trigger
	Deferrable        bool           `json:"deferrable,omitempty"`         // Can be deferred until end of transaction
	InitiallyDeferred bool           `json:"initially_deferred,omitempty"` // Whether deferred by default
	OldTable          string         `json:"old_table,omitempty"`          // REFERENCING OLD TABLE AS name
	NewTable          string         `json:"new_table,omitempty"`          // REFERENCING NEW TABLE AS name
}

Trigger represents a database trigger

func (*Trigger) GetObjectName 

func (t *Trigger) GetObjectName() string

type TriggerEvent 

type TriggerEvent string

TriggerEvent represents the event that triggers the trigger 

const (
	TriggerEventInsert   TriggerEvent = "INSERT"
	TriggerEventUpdate   TriggerEvent = "UPDATE"
	TriggerEventDelete   TriggerEvent = "DELETE"
	TriggerEventTruncate TriggerEvent = "TRUNCATE"
)

type TriggerLevel 

type TriggerLevel string

TriggerLevel represents the level at which the trigger fires 

const (
	TriggerLevelRow       TriggerLevel = "ROW"
	TriggerLevelStatement TriggerLevel = "STATEMENT"
)

type TriggerTiming 

type TriggerTiming string

TriggerTiming represents the timing of trigger execution 

const (
	TriggerTimingBefore    TriggerTiming = "BEFORE"
	TriggerTimingAfter     TriggerTiming = "AFTER"
	TriggerTimingInsteadOf TriggerTiming = "INSTEAD OF"
)

type Type 

type Type struct {
	Schema      string              `json:"schema"`
	Name        string              `json:"name"`
	Kind        TypeKind            `json:"kind"`
	Comment     string              `json:"comment,omitempty"`
	EnumValues  []string            `json:"enum_values,omitempty"` // For ENUM types
	Columns     []*TypeColumn       `json:"columns,omitempty"`     // For composite types
	BaseType    string              `json:"base_type,omitempty"`   // For DOMAIN types
	NotNull     bool                `json:"not_null,omitempty"`    // For DOMAIN types
	Default     string              `json:"default,omitempty"`     // For DOMAIN types
	Constraints []*DomainConstraint `json:"constraints,omitempty"` // For DOMAIN types
}

Type represents a PostgreSQL user-defined type

func (*Type) GetObjectName 

func (t *Type) GetObjectName() string

type TypeColumn 

type TypeColumn struct {
	Name     string `json:"name"`
	DataType string `json:"data_type"`
	Position int    `json:"position"`
}

TypeColumn represents a column in a composite type

type TypeKind 

type TypeKind string

TypeKind represents the kind of PostgreSQL type 

const (
	TypeKindEnum      TypeKind = "ENUM"
	TypeKindComposite TypeKind = "COMPOSITE"
	TypeKindDomain    TypeKind = "DOMAIN"
)

type View 

type View struct {
	Schema       string              `json:"schema"`
	Name         string              `json:"name"`
	Definition   string              `json:"definition"`
	Comment      string              `json:"comment,omitempty"`
	Materialized bool                `json:"materialized,omitempty"`
	Indexes      map[string]*Index   `json:"indexes,omitempty"`  // For materialized views only
	Triggers     map[string]*Trigger `json:"triggers,omitempty"` // For INSTEAD OF triggers on views
}

View represents a database view

func (*View) GetObjectName 

func (v *View) GetObjectName() string

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.