toolkit

type AttNum uint32

type Check DefaultConstraintDefinition

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

type Column struct {
	Idx               int    `json:"idx"`
	Name              string `json:"name"`
	TypeName          string `json:"type_name"`
	CanonicalTypeName string `json:"canonical_type_name"`
	TypeOid           Oid    `json:"type_oid"`
	Num               AttNum `json:"num"`
	NotNull           bool   `json:"not_null"`
	// Length - length of the attribute
	Length      int  `json:"length"`
	TypeLength  int  `json:"type_length"`
	IsGenerated bool `json:"is_generated"`
	// OverriddenTypeName - replacement of  original type. For instance override TEXT to INT2
	OverriddenTypeName string `json:"overridden_type_name"`
	OverriddenTypeOid  Oid    `json:"overridden_type_oid"`
	OverriddenTypeSize int    `json:"overridden_type_size"`
}

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 DatabaseTypeUnmarshaler func(driver *Driver, typeName string, v ParamsValue) (any, error)

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 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 DynamicModeProperties struct {
	SupportedTypes []string
	Unmarshal      DatabaseTypeUnmarshaler `json:"-"`
}

type DynamicParamValue struct {
	Column       string      `mapstructure:"column" json:"column,omitempty"`
	CastTo       string      `mapstructure:"cast_to" json:"cast_to,omitempty"`
	Template     string      `mapstructure:"template" json:"template,omitempty"`
	DefaultValue ParamsValue `mapstructure:"default_value" json:"default_value,omitempty"`
}

type DynamicParameter struct {
	// DynamicValue - The dynamic value settings that received from config
	DynamicValue *DynamicParamValue
	// contains filtered or unexported fields
}

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

type DynamicParameters map[string]*DynamicParamValue

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          *Parameters       `json:"parameters"`
	Types               []*Type           `json:"types"`
	ColumnsTypeOverride map[string]string `json:"columns_type_override"`
}

type NewRowDriverFunc func() RowDriver

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

type NullType string

type Oid int

type ParameterDefinition 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"`
	// LinkColumnParameter - 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
	LinkColumnParameter string `mapstructure:"link_column_parameter" json:"link_column_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"`
	// 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"`
	// DynamicModeProperties - shows that parameter support dynamic mode and contains allowed types and unmarshaler
	DynamicModeProperties *DynamicModeProperties
	// DefaultValue - default value of the parameter
	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"`
	// SupportTemplate - shows that parameter supports golang template and might be calculated dynamically
	SupportTemplate bool `mapstructure:"support_template" json:"support_template,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:"-"`
	// AllowedValues - slice of values which allowed to use
	AllowedValues []ParamsValue `mapstructure:"allowed_values" json:"allowed_values,omitempty"`
}

type ParameterValuer interface {
	Value()
}

type Parameterizer interface {
	Value() (value any, err error)
	RawValue() (rawValue ParamsValue, err error)
	Scan(dest any) (err error)
	GetDefinition() *ParameterDefinition
	IsDynamic() bool
	IsEmpty() (bool, error)
}

type Parameters struct {
	Static  StaticParameters  `json:"static,omitempty"`
	Dynamic DynamicParameters `json:"dynamic,omitempty"`
}

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 *ParameterDefinition, v ParamsValue) (ValidationWarnings, error)

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

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

type Reference struct {
	Idx    int
	Schema string
	Name   string
	// ReferencedKeys - list of foreign keys of current table
	ReferencedKeys []string
	IsNullable     bool
}

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 StaticParameter struct {

	// 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
	// contains filtered or unexported fields
}

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

type StaticParameters map[string]ParamsValue

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"`
	PrimaryKey []string  `json:"primary_key"`
	// RootPtSchema, RootPtName, RootPtOid - the first parent of the partitioned table
	RootPtSchema string       `json:"root_pt_schema"`
	RootPtName   string       `json:"root_pt_name"`
	RootPtOid    Oid          `json:"root_pt_oid"`
	Constraints  []Constraint `json:"-"`
}

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

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

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

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

type TriggerConstraint DefaultConstraintDefinition

type Tuple map[string]*Value

type Type struct {
	// Oid - pg_type.oid
	Oid Oid `json:"oid,omitempty"`
	// ChainOids - list of inherited types (oid) till the main base type
	ChainOids []Oid `json:"chain_oids,omitempty"`
	// ChainNames - list of inherited types (name) till the main base type
	ChainNames []string `json:"chain_names,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"`
	// RootBuiltInTypeOid - defines builtin type oid that might be used for decoding and encoding
	RootBuiltInTypeOid Oid `json:"root_built_in_type_oid,omitempty"`
	// RootBuiltInTypeOid - defines builtin type name that might be used for decoding and encoding
	RootBuiltInTypeName string `json:"root_built_in_type_name,omitempty"`
}

type TypeCastDefinition struct {
	Cast        TypeCastFunc
	InputTypes  []string
	OutputTypes []string
}

type TypeCastFunc func(driver *Driver, input []byte) (output []byte, err error)

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

type Unique DefaultConstraintDefinition

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

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

type ValidationWarnings []*ValidationWarning

type Value struct {
	Value  any
	IsNull bool
}

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