config

Documentation

Index

• Variables
• type CombinedSettings
  • func Combine(conf Config, pkg SQL) CombinedSettings
• type Config
  • func ParseConfig(rd io.Reader) (Config, error)
• type Engine
• type Gen
• type GenGo
• type GenKotlin
• type Override
  • func (o *Override) Parse() error
• type Paths
  • func (p *Paths) UnmarshalJSON(data []byte) error
  • func (p *Paths) UnmarshalYAML(unmarshal func(interface{}) error) error
• type SQL
• type SQLGen
• type SQLGo
• type SQLKotlin
• type V1GenerateSettings
  • func (c *V1GenerateSettings) Translate() Config
  • func (c *V1GenerateSettings) ValidateGlobalOverrides() error

Variables

var ErrKotlinNoOutPath = errors.New("no output path")

var ErrMissingEngine = errors.New("unknown engine")

var ErrMissingVersion = errors.New("no version number")

var ErrNoPackageName = errors.New("missing package name")

var ErrNoPackagePath = errors.New("missing package path")

var ErrNoPackages = errors.New("no packages")

var ErrUnknownEngine = errors.New("invalid engine")

var ErrUnknownVersion = errors.New("invalid version number")

Types

type CombinedSettings

type CombinedSettings struct {
	Global    Config
	Package   SQL
	Go        SQLGo
	Kotlin    SQLKotlin
	Rename    map[string]string
	Overrides []Override
}

func Combine

func Combine(conf Config, pkg SQL) CombinedSettings

type Config

type Config struct {
	Version string `json:"version" yaml:"version"`
	SQL     []SQL  `json:"sql" yaml:"sql"`
	Gen     Gen    `json:"overrides,omitempty" yaml:"overrides"`
}

func ParseConfig

func ParseConfig(rd io.Reader) (Config, error)

type Engine

type Engine string

const (
	EngineMySQL      Engine = "mysql"
	EnginePostgreSQL Engine = "postgresql"

	// Experimental engines
	EngineXLemon    Engine = "_lemon"
	EngineXDolphin  Engine = "_dolphin"
	EngineXElephant Engine = "_elephant"
)

type Gen

type Gen struct {
	Go     *GenGo     `json:"go,omitempty" yaml:"go"`
	Kotlin *GenKotlin `json:"kotlin,omitempty" yaml:"kotlin"`
}

type GenGo

type GenGo struct {
	Overrides []Override        `json:"overrides,omitempty" yaml:"overrides"`
	Rename    map[string]string `json:"rename,omitempty" yaml:"rename"`
}

type GenKotlin

type GenKotlin struct {
	Rename map[string]string `json:"rename,omitempty" yaml:"rename"`
}

type Override

type Override struct {
	// name of the golang type to use, e.g. `github.com/segmentio/ksuid.KSUID`
	GoType string `json:"go_type" yaml:"go_type"`

	// fully qualified name of the Go type, e.g. `github.com/segmentio/ksuid.KSUID`
	DBType                  string `json:"db_type" yaml:"db_type"`
	Deprecated_PostgresType string `json:"postgres_type" yaml:"postgres_type"`

	// for global overrides only when two different engines are in use
	Engine Engine `json:"engine,omitempty" yaml:"engine"`

	// True if the GoType should override if the maching postgres type is nullable
	Null bool `json:"null" yaml:"null"`

	// fully qualified name of the column, e.g. `accounts.id`
	Column string `json:"column" yaml:"column"`

	ColumnName  string
	Table       pg.FQN
	GoTypeName  string
	GoPackage   string
	GoBasicType bool
}

func (*Override) Parse

func (o *Override) Parse() error

type Paths

type Paths []string

func (*Paths) UnmarshalJSON

func (p *Paths) UnmarshalJSON(data []byte) error

func (*Paths) UnmarshalYAML

func (p *Paths) UnmarshalYAML(unmarshal func(interface{}) error) error

type SQL

type SQL struct {
	Engine  Engine `json:"engine,omitempty" yaml:"engine"`
	Schema  Paths  `json:"schema" yaml:"schema"`
	Queries Paths  `json:"queries" yaml:"queries"`
	Gen     SQLGen `json:"gen" yaml:"gen"`
}

type SQLGen

type SQLGen struct {
	Go     *SQLGo     `json:"go,omitempty" yaml:"go"`
	Kotlin *SQLKotlin `json:"kotlin,omitempty" yaml:"kotlin"`
}

type SQLGo

type SQLGo struct {
	EmitInterface       bool              `json:"emit_interface" yaml:"emit_interface"`
	EmitJSONTags        bool              `json:"emit_json_tags" yaml:"emit_json_tags"`
	EmitPreparedQueries bool              `json:"emit_prepared_queries" yaml:"emit_prepared_queries":`
	Package             string            `json:"package" yaml:"package"`
	Out                 string            `json:"out" yaml:"out"`
	Overrides           []Override        `json:"overrides,omitempty" yaml:"overrides"`
	Rename              map[string]string `json:"rename,omitempty" yaml:"rename"`
}

type SQLKotlin

type SQLKotlin struct {
	Package string `json:"package" yaml:"package"`
	Out     string `json:"out" yaml:"out"`
}

type V1GenerateSettings

type V1GenerateSettings struct {
	Version   string              `json:"version" yaml:"version"`
	Packages  []v1PackageSettings `json:"packages" yaml:"packages"`
	Overrides []Override          `json:"overrides,omitempty" yaml:"overrides,omitempty"`
	Rename    map[string]string   `json:"rename,omitempty" yaml:"rename,omitempty"`
}

func (*V1GenerateSettings) Translate

func (c *V1GenerateSettings) Translate() Config

func (*V1GenerateSettings) ValidateGlobalOverrides

func (c *V1GenerateSettings) ValidateGlobalOverrides() error