toolkit

type AttNum uint32

type Check DefaultConstraintDefinition

type Cmd struct {
	*cobra.Command
	// contains filtered or unexported fields
}

type Column struct {
	Name        string `json:"name"`
	TypeName    string `json:"type_name"`
	TypeOid     Oid    `json:"type_oid"`
	Num         AttNum `json:"num"`
	NotNull     bool   `json:"not_null"`
	Length      int    `json:"length"`
	Idx         int    `json:"idx"`
	IsGenerated bool   `json:"is_generated"`
}

type ColumnProperties struct {
	// Nullable - shows that transformer can produce NULL value for the column. Togather with Affected shows that
	// this parameter may generate null values and write it in this column. It only plays with Affected
	Nullable bool `mapstructure:"nullable" json:"nullable,omitempty"`
	// Unique - shows that transformer guarantee that every transformer call the value will be unique. It only plays
	// with Affected
	Unique bool `mapstructure:"unique" json:"unique,omitempty"`
	// Unique - defines max length of the value. It only plays with Affected. Togather with Affected shows
	// that values will not exceed the length of the column. It only plays with Affected
	MaxLength int `mapstructure:"max_length" json:"max_length,omitempty"`
	// Affected - shows assigned column name will be affected after the transformation
	Affected bool `mapstructure:"affected" json:"affected,omitempty"`
	// AllowedTypes - defines all the allowed column types in textual format. If not assigned (nil) then any
	// of the types is valid
	// TODO: AllowedTypes has a problem if we set int and our column is int2, then it cause an error though
	//		 it is workable case. Decide how to define subtype or type "aliases" references.
	//		 Also it has problem with custom type naming because it has schema name and type name. It might be better
	//		 to describe types with {{ schemaName }}.{{ typeName }}, but then we have to implement types classes
	//		 (such as textual, digits, etc.)
	AllowedTypes []string `mapstructure:"allowed_types" json:"allowed_types,omitempty"`
	// SkipOriginalData - Is transformer require original data or not
	SkipOriginalData bool `mapstructure:"skip_original_data" json:"skip_original_data,omitempty"`
	// TODO: Implement SkipOnNull
	// SkipOnNull - transformation for column with NULL is not expected
	SkipOnNull bool `mapstructure:"skip_on_null" json:"skip_on_null"`
}

type Constraint interface {
	IsAffected(column *Column, columnProperties *ColumnProperties) (w ValidationWarnings)
	Type() string
}

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

type DatabaseSchema []*Table

type DefaultConstraintDefinition struct {
	// Schema - constraint schema name
	Schema string `json:"schema"`
	// Name - constraint name
	Name string `json:"name"`
	// Oid - Constraint oid in pg_constraint
	Oid Oid `json:"oid"`
	// Columns - columns involved into constraint
	Columns []AttNum `json:"columns,omitempty"`
	// Definition - real textual constraint definition
	Definition string `json:"definition,omitempty"`
}

type Definition struct {
	Name             string             `json:"name"`
	Description      string             `json:"description"`
	Parameters       []*Parameter       `json:"parameters"`
	Validate         bool               `json:"validate"`
	ExpectedExitCode int                `json:"expected_exit_code"`
	Driver           *DriverParams      `json:"driver"`
	New              NewTransformerFunc `json:"-"`
}

type DiffNode struct {
	Event     string            `json:"event,omitempty"`
	Signature map[string]string `json:"signature,omitempty"`
}

type Driver struct {
	Table         *Table
	TypeMapPool   []*pgtype.Map
	SharedTypeMap *pgtype.Map
	// ColumnMap - map column name to Column object
	ColumnMap map[string]*Column
	// AttrIdxMap - the number of attribute in tuple
	AttrIdxMap map[string]int
	// CustomTypes - list of custom types used in tables
	CustomTypes []*Type
	// contains filtered or unexported fields
}

type DriverParams struct {
	Name                 string `json:"name"`
	JsonDataFormat       string `json:"json_data_format,omitempty"`
	JsonAttributesFormat string `json:"json_attributes_format,omitempty"`
	CsvAttributesFormat  string `json:"csv_attributes_format,omitempty"`
}

type Exclusion DefaultConstraintDefinition

type ForeignKey struct {
	DefaultConstraintDefinition
	// ReferencedTable - table that has primary key definition on that discovering table is referencing
	ReferencedTable LinkedTable `json:"referencedTable,omitempty"`
}

type InteractionApi interface {
	// SetWriter - assign writer
	SetWriter(w io.Writer)
	// SetReader - assign reader
	SetReader(r io.Reader)
	// GetRowDriverFromRecord - get from toolkit.Record all the required attributes as a toolkit.RowDriver instance
	GetRowDriverFromRecord(r *Record) (RowDriver, error)
	// SetRowDriverToRecord - set transformed toolkit.RowDriver to the toolkit.Record
	SetRowDriverToRecord(rd RowDriver, r *Record) error
	// Encode - write encoded data with \n symbol in the end into io.Writer
	Encode(ctx context.Context, row RowDriver) error
	// Decode - read data with new line from io.Reader and encode to toolkit.RowDriver
	Decode(ctx context.Context) (RowDriver, error)
	// Clean - clean cached Record
	Clean()
}

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

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

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

type LinkedTable struct {
	// Schema - table schema name
	Schema string `json:"schema"`
	// Name - table name
	Name string `json:"name"`
	// Oid - table oid
	Oid Oid `json:"oid"`
	// Constraint - linked table constraint
	Constraint Constraint `json:"constraint,omitempty"`
}

type Meta struct {
	Table               *Table            `json:"table"`
	Parameters          Params            `json:"parameters"`
	Types               []*Type           `json:"types"`
	ColumnTypeOverrides map[string]string `json:"column_type_overrides"`
}

type NewRowDriverFunc func() RowDriver

type NewTransformerFunc func(ctx context.Context, driver *Driver, parameters map[string]*Parameter) (
	Transformer, ValidationWarnings, error,
)

type Oid int

type Parameter struct {
	// Name - name of the parameter. Must be unique in the whole Transformer parameters slice
	Name string `mapstructure:"name" json:"name"`
	// Description - description of the parameter. Should contain the brief info about parameter
	Description string `mapstructure:"description" json:"description"`
	// Required - shows that parameter is required, and we expect we have to receive this value from config.
	// Event when DefaultValue is defined it will case error
	Required bool `mapstructure:"required" json:"required"`
	// IsColumn - shows is this parameter column related. If so ColumnProperties must be defined and assigned
	// otherwise it may cause an unhandled behaviour
	IsColumn bool `mapstructure:"is_column" json:"is_column"`
	// IsColumnContainer - describe is parameter container map or list with multiple columns inside. It allows us to
	IsColumnContainer bool `mapstructure:"is_column_container" json:"is_column_container"`
	// LinkParameter - link with parameter with provided name. This is required if performing raw value encoding
	// depends on the provided column type and/or relies on the database Driver
	LinkParameter string `mapstructure:"link_parameter" json:"link_parameter,omitempty"`
	// CastDbType - name of PostgreSQL type that would be used for Decoding raw value to the real go type. Is this
	// type does not exist will cause an error
	CastDbType string `mapstructure:"cast_db_type" json:"cast_db_type,omitempty"`
	// DefaultValue - default value of the parameter. Must be variable pointer and have the same type
	// as in ExpectedType
	DefaultValue ParamsValue `mapstructure:"default_value" json:"default_value,omitempty"`
	// ColumnProperties - detail info about expected column properties that may help to diagnose the table schema
	// and perform validation procedure Plays only with IsColumn
	ColumnProperties *ColumnProperties `mapstructure:"column_properties" json:"column_properties,omitempty"`
	// GlobalEnvVariable - the nane of the global environment variable that can be used on empty input
	GetFromGlobalEnvVariable string `mapstructure:"get_from_global_env_variable" json:"get_from_global_env_variable,omitempty"`
	// Unmarshaller - unmarshal function for the parameter raw data []byte. Using by default json.Unmarshal function
	Unmarshaller Unmarshaller `json:"-"`
	// RawValueValidator - raw value validator function that performs assertion and cause ValidationWarnings if it
	// has violations
	RawValueValidator RawValueValidator `json:"-"`
	// LinkedParameter - column-like parameter that has been linked during parsing procedure. Warning, do not
	// assign it manually, if you don't know the consequences
	LinkedColumnParameter *Parameter `json:"-"`
	// Column - column of the table that was assigned in the parsing procedure according to provided column name in
	// parameter value. In this case value has textual column name
	Column *Column `json:"-"`
	// ExpectedType - expected type of the provided variable during scanning procedure. It must be pointer on the
	// variable
	Driver *Driver `mapstructure:"-" json:"-"`
	// contains filtered or unexported fields
}

type Params map[string]ParamsValue

type ParamsValue []byte

type PrimaryKey struct {
	DefaultConstraintDefinition
	References []*LinkedTable
}

type RawRecord map[int]*RawValue

type RawRecordAttrs map[string]*RawValue

type RawRecordAttrsText map[string]*RawValueStr

type RawRecordCsv struct {
	Data []string
	// contains filtered or unexported fields
}

type RawRecordStr map[int]*RawValueStr

type RawRecordText []byte

type RawValue struct {
	Data   []byte `json:"d"`
	IsNull bool   `json:"n"`
}

type RawValueStr struct {
	Data   *string `json:"d"`
	IsNull bool    `json:"n"`
}

type RawValueValidator func(p *Parameter, v ParamsValue) (ValidationWarnings, error)

type Record struct {
	Driver *Driver
	Row    RowDriver
	// contains filtered or unexported fields
}

type RowDriver interface {
	// GetColumn - get raw []byte value by column idx
	GetColumn(idx int) (*RawValue, error)
	// SetColumn - set RawValue value by column idx to the current row
	SetColumn(idx int, v *RawValue) error
	// Encode - encode the whole row to the []byte representation of RowDriver. It would be CSV
	// line or JSON object, etc.
	Encode() ([]byte, error)
	// Decode - decode []bytes to RowDriver instance
	Decode([]byte) error
	// Length - count of attributes in the row
	Length() int
	// Clean - clean the state
	Clean()
}

type Table struct {
	Schema      string       `json:"schema"`
	Name        string       `json:"name"`
	Oid         Oid          `json:"oid"`
	Columns     []*Column    `json:"columns"`
	Kind        string       `json:"kind"`
	Parent      Oid          `json:"parent"`
	Children    []Oid        `json:"children"`
	Size        int64        `json:"size"`
	Constraints []Constraint `json:"-"`
}

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

type Trace struct {
	SchemaName      string `json:"schemaName,omitempty"`
	TableName       string `json:"tableName,omitempty"`
	TransformerName string `json:"transformerName,omitempty"`
	ParameterName   string `json:"parameterName,omitempty"`
	Msg             string `json:"msg,omitempty"`
}

type Transformer interface {
	Validate(ctx context.Context) (ValidationWarnings, error)
	Transform(ctx context.Context, r *Record) error
}

type TriggerConstraint DefaultConstraintDefinition

type Tuple map[string]*Value

type Type struct {
	// Oid - pg_type.oid
	Oid Oid `json:"oid,omitempty"`
	// Chain - list of inherited types till the main base type
	Chain []Oid `json:"chain,omitempty"`
	// Schema - type schema name
	Schema string `json:"schema,omitempty"`
	// Name - (pg_type.typname) type name
	Name string `json:"name,omitempty"`
	// Length - (pg_type.typelen) for a fixed-size type, typlen is the number of bytes in the internal representation of the type.
	// But for a variable-length type, typlen is negative. -1 indicates a “varlena” type (one that has a length
	// word), -2 indicates a null-terminated C string.
	Length int `json:"length,omitempty"`
	// Kind - (pg_type.typtype) type of type
	Kind rune `json:"kind,omitempty"`
	// ComposedRelation - (pg_type.typrelid) if composite type reference to the table that defines the structure
	ComposedRelation Oid `json:"composed_relation,omitempty"`
	// ElementType - (pg_type.typelem) references to the item of the array type
	ElementType Oid `json:"element_type,omitempty"`
	// ArrayType - (pg_type.typarray) references to the array type
	ArrayType Oid `json:"array_type,omitempty"`
	// NotNull - (pg_type.typnotnull) shows is this type nullable. For domains only
	NotNull bool `json:"not_null,omitempty"`
	// BaseType - (pg_type.typbasetype) references to the base type
	BaseType Oid `json:"base_type,omitempty"`
	//Check - definition of check constraint
	Check *Check `json:"check,omitempty"`
	// RootBuiltInType - defines builtin type oid that might be used for decoding and encoding
	RootBuiltInType Oid `json:"root_built_in_type,omitempty"`
}

type Unique DefaultConstraintDefinition

type Unmarshaller func(parameter *Parameter, driver *Driver, src ParamsValue) (any, error)

type ValidationWarning struct {
	Msg      string         `json:"msg,omitempty"`
	Severity string         `json:"severity,omitempty"`
	Trace    *Trace         `json:"trace,omitempty"`
	Meta     map[string]any `json:"meta,omitempty"`
	Hash     string         `json:"hash"`
}

type ValidationWarnings []*ValidationWarning

type Value struct {
	Value  any
	IsNull bool
}