schema

type BrokenEventError ¶ added in v0.19.0

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

BrokenEventError is an error that occurs when an event doesn't have

all required information in order to be processed.

func NewBrokenEventError(message string) *BrokenEventError

func (e *BrokenEventError) Error() string

func (e *BrokenEventError) IsRetryable() bool

type BrokenSessionError ¶ added in v0.19.0

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

BrokenSessionError is an error that occurs when a session is invalid.

func NewBrokenSessionError(message string) *BrokenSessionError

func (e *BrokenSessionError) Error() string

func (e *BrokenSessionError) IsRetryable() bool

type Column ¶

type Column interface {
	Docs() Documentation
	Implements() Interface
	DependsOn() []DependsOnEntry
}

Column represents a column with metadata and dependencies.

func ToGenericColumns[T Column](columns []T) []Column

type Columns ¶

type Columns struct {
	Session            []SessionColumn
	Event              []EventColumn
	SessionScopedEvent []SessionScopedEventColumn
}

Columns groups the column sources for a table layout

func NewColumns(session []SessionColumn, event []EventColumn, sessionScoped []SessionScopedEventColumn) Columns

func Sorted(columns Columns, ordering OrderKeeper) Columns

func (c Columns) Copy() Columns

type ColumnsRegistry ¶

type ColumnsRegistry interface {
	Get(propertyID string) (Columns, error)
}

ColumnsRegistry is a registry of columns for different properties.

func NewColumnsMerger(registries []ColumnsRegistry) ColumnsRegistry

func NewStaticColumnsRegistry(columns map[string]Columns, defaultColumns Columns) ColumnsRegistry

type D8AColumnWriteError ¶ added in v0.19.0

type D8AColumnWriteError interface {
	Error() string
	IsRetryable() bool
}

type DependencySorter ¶

type DependencySorter struct{}

DependencySorter provides topological sorting functionality for columns with dependencies.

func NewDependencySorter() *DependencySorter

func (s *DependencySorter) SortAllColumns(columns Columns) (Columns, error)

func (s *DependencySorter) SortEventColumns(columns []EventColumn) ([]EventColumn, error)

func (s *DependencySorter) SortSessionColumns(columns []SessionColumn) ([]SessionColumn, error)

type DependsOnEntry ¶

type DependsOnEntry struct {
	Interface        InterfaceID
	GreaterOrEqualTo Version
	LessThan         Version
}

DependsOnEntry represents a dependency requirement for a column.

type Documentation ¶ added in v0.9.0

type Documentation struct {
	ColumnName  string
	Type        *arrow.Field
	DisplayName string
	InterfaceID string
	Description string
}

Documentation represents the documentation for a column.

type Event ¶

type Event struct {
	BoundHit *hits.Hit
	Metadata map[string]any
	Values   map[string]any

	IsBroken     bool
	BrokenReason string
}

Event represents a test event with bound hit and all hits.

func NewEvent(boundHit *hits.Hit) *Event

func (e *Event) WithValueKey(key string, value any) *Event

type EventColumn ¶

type EventColumn interface {
	Column
	Write(event *Event) D8AColumnWriteError
}

EventColumn represents a column that can be written to during event processing.

type Guard ¶

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

Guard ensures that warehouse tables have the correct schema and columns.

func NewGuard(
	warehouseRegistry warehouse.Registry,
	columnsColumns ColumnsRegistry,
	layout LayoutRegistry,
	ordering OrderKeeper,
) *Guard

func (m *Guard) EnsureTables(
	propertyID string,
) error

type Interface ¶

type Interface struct {
	ID      InterfaceID
	Version Version
	Field   *arrow.Field
}

Interface represents a virtual column, with given name, version and a field (including column name and type) Various parts of the system may then provide implementations of this interface. As example you can use something like "event_type". You may centrally define an abstract column interface, and then provide implementations in the protocols, which may have different understanding of what really means "event_type".

type InterfaceID ¶

type InterfaceID string

InterfaceID represents a unique identifier for a column.

type InterfaceOrdering ¶ added in v0.10.0

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

InterfaceOrdering maintains the order of column interfaces based on their definition position in structs.

func NewInterfaceDefinitionOrderKeeper(structs ...any) *InterfaceOrdering

func (o *InterfaceOrdering) GetOrder(id InterfaceID) int

type Layout ¶

type Layout interface {
	Tables(columns Columns) []WithName
	ToRows(columns Columns, sessions ...*Session) ([]TableRows, error)
}

Layout is the interface for a table layout, implementations take control over the final schema and dictate the format of writing the session data to the table.

func NewEmbeddedSessionColumnsLayout(
	eventsTableName string,
	sessionColumnsPrefix string,
) Layout

type LayoutRegistry ¶

type LayoutRegistry interface {
	Get(propertyID string) (Layout, error)
}

LayoutRegistry is a registry of layouts for different properties.

func NewStaticLayoutRegistry(layouts map[string]Layout, defaultLayout Layout) LayoutRegistry

type OrderKeeper ¶ added in v0.10.1

type OrderKeeper interface {
	GetOrder(id InterfaceID) int
}

OrderKeeper is a interface that can be used to get the order of a given interface ID.

func NewNoParticicularOrderKeeper() OrderKeeper

type RetryableError ¶ added in v0.19.0

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

func NewRetryableError(message string) *RetryableError

func (e *RetryableError) Error() string

func (e *RetryableError) IsRetryable() bool

type Session ¶

type Session struct {
	PropertyID string
	Metadata   map[string]any

	Events []*Event
	Values map[string]any

	IsBroken     bool
	BrokenReason string
}

Session represents a session with events and values.

func NewSession(events []*Event) *Session

type SessionColumn ¶

type SessionColumn interface {
	Column
	Write(session *Session) D8AColumnWriteError
}

SessionColumn represents a column that can be written to during session processing.

type SessionScopedEventColumn ¶ added in v0.2.0

type SessionScopedEventColumn interface {
	Column
	Write(session *Session, i int) D8AColumnWriteError
}

SessionScopedEventColumn represents a column computed with session scope that writes per-event values while having access to the whole session. It complements EventColumn and SessionColumn without changing their semantics.

type TableRows ¶

type TableRows struct {
	Table string
	Rows  []map[string]any
}

TableRows are a collection of rows with a table to write them to

type Version ¶

type Version string // semver

Version represents a semantic version string for a column.

type WithName ¶

type WithName struct {
	Schema *arrow.Schema
	Table  string
}

WithName adds a table name to the schema