analytics

Documentation

Index

• Variables
• func DefaultValidate(query Query, schemas map[string]SchemaDefinition) error
• func ProcessRows(rows *sql.Rows, query Query) ([]map[string]interface{}, error)
• func ScanRows(rows *sql.Rows) ([]map[string]interface{}, error)
• type DimensionDefinition
• type Filter
• type MeasureDefinition
• type MeasureFilter
• type Meta
• type Query
  • func (q *Query) GetDefaultTimezone() string
  • func (q *Query) GetLimit() int
  • func (q *Query) GetOffset() int
  • func (q *Query) HasTimeDimensions() bool
  • func (q *Query) Query(ctx context.Context, db *sql.DB, schema SchemaDefinition) (*Response, error)
  • func (q *Query) ToSQL(schema SchemaDefinition) (string, []interface{}, error)
  • func (q *Query) Validate(schemas map[string]SchemaDefinition) error
• type Response
• type SQLBuilder
  • func NewSQLBuilder() *SQLBuilder
  • func (sb *SQLBuilder) BuildSQL(query Query, schema SchemaDefinition) (string, []interface{}, error)
• type SchemaDefinition
• type TimeDimension
• type ValidateFunc

Variables

var (
	ErrInvalidSchema          = errors.New("invalid schema")
	ErrUnsupportedMeasure     = errors.New("unsupported measure")
	ErrUnsupportedDimension   = errors.New("unsupported dimension")
	ErrUnsupportedGranularity = errors.New("unsupported granularity")
	ErrUnsupportedOperator    = errors.New("unsupported operator")
	ErrInvalidTimezone        = errors.New("invalid timezone")
)

Functions

func DefaultValidate

func DefaultValidate(query Query, schemas map[string]SchemaDefinition) error

DefaultValidate provides the default validation logic for analytics queries

func ProcessRows

func ProcessRows(rows *sql.Rows, query Query) ([]map[string]interface{}, error)

ProcessRows scans SQL rows and fills time series gaps if the query has time dimensions

func ScanRows

func ScanRows(rows *sql.Rows) ([]map[string]interface{}, error)

ScanRows scans SQL rows and converts them to a slice of maps for JSON serialization

Types

type DimensionDefinition

type DimensionDefinition struct {
	Type        string `json:"type" valid:"in(string|number|time)"`
	Title       string `json:"title"`
	SQL         string `json:"sql,omitempty"`
	Description string `json:"description"`
}

DimensionDefinition defines an analytics dimension

type Filter

type Filter struct {
	Member   string   `json:"member" valid:"required"`
	Operator string   `` /* 202-byte string literal not displayed */
	Values   []string `json:"values"`
}

Filter represents a query filter

type MeasureDefinition

type MeasureDefinition struct {
	Type        string          `json:"type" valid:"in(count|sum|avg|min|max)"`
	Title       string          `json:"title"`
	SQL         string          `json:"sql,omitempty"`
	Description string          `json:"description"`
	Filters     []MeasureFilter `json:"filters,omitempty"`
}

MeasureDefinition defines an analytics measure

type MeasureFilter

type MeasureFilter struct {
	SQL string `json:"sql"`
}

MeasureFilter defines a filter condition for measures (Cube.js compatible)

type Meta

type Meta struct {
	Total         int           `json:"total"`
	ExecutionTime time.Duration `json:"executionTime"`
	Query         string        `json:"query"`
	Params        []interface{} `json:"params"`
}

Meta contains metadata about the query execution

type Query

type Query struct {
	Schema         string            `json:"schema" valid:"required"`
	Measures       []string          `json:"measures" valid:"required"`
	Dimensions     []string          `json:"dimensions"`
	Timezone       *string           `json:"timezone,omitempty"`
	TimeDimensions []TimeDimension   `json:"timeDimensions,omitempty"`
	Filters        []Filter          `json:"filters,omitempty"`
	Limit          *int              `json:"limit,omitempty"`
	Offset         *int              `json:"offset,omitempty"`
	Order          map[string]string `json:"order,omitempty"`
}

Query represents a Cube.js-style analytics query

func (*Query) GetDefaultTimezone

func (q *Query) GetDefaultTimezone() string

GetDefaultTimezone returns the default timezone for queries

func (*Query) GetLimit

func (q *Query) GetLimit() int

GetLimit returns the query limit or default

func (*Query) GetOffset

func (q *Query) GetOffset() int

GetOffset returns the query offset or default

func (*Query) HasTimeDimensions

func (q *Query) HasTimeDimensions() bool

HasTimeDimensions returns true if the query has time dimensions

func (*Query) Query

func (q *Query) Query(ctx context.Context, db *sql.DB, schema SchemaDefinition) (*Response, error)

Query executes the analytics query against the database and returns an analytics response

func (*Query) ToSQL

func (q *Query) ToSQL(schema SchemaDefinition) (string, []interface{}, error)

ToSQL is a convenience method on Query to build SQL using the default builder

func (*Query) Validate

func (q *Query) Validate(schemas map[string]SchemaDefinition) error

Validate validates the analytics query using the default validation logic

type Response

type Response struct {
	Data []map[string]interface{} `json:"data"`
	Meta Meta                     `json:"meta"`
}

Response represents the response from an analytics query

type SQLBuilder

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

SQLBuilder provides methods to convert analytics queries to SQL

func NewSQLBuilder

func NewSQLBuilder() *SQLBuilder

NewSQLBuilder creates a new SQL builder with PostgreSQL placeholder format

func (*SQLBuilder) BuildSQL

func (sb *SQLBuilder) BuildSQL(query Query, schema SchemaDefinition) (string, []interface{}, error)

BuildSQL converts an analytics Query to SQL using the provided schema definition

type SchemaDefinition

type SchemaDefinition struct {
	Name       string                         `json:"name"`
	Measures   map[string]MeasureDefinition   `json:"measures"`
	Dimensions map[string]DimensionDefinition `json:"dimensions"`
}

SchemaDefinition defines the structure of an analytics schema

type TimeDimension

type TimeDimension struct {
	Dimension   string     `json:"dimension" valid:"required"`
	Granularity string     `json:"granularity" valid:"required,in(hour|day|week|month|year)"`
	DateRange   *[2]string `json:"dateRange,omitempty"`
}

TimeDimension represents time-based grouping

type ValidateFunc

type ValidateFunc func(query Query, schemas map[string]SchemaDefinition) error

ValidateFunc is a function type for validating queries against schema definitions