aggro

type AlphabeticalSortable ¶

type AlphabeticalSortable bool

AlphabeticalSortable is a simple sorter that sorts alphabetically in the direction of the boolean, true meaning ascending and false being descending.

func (sortable *AlphabeticalSortable) Less(a, b *ResultBucket) bool

type BooleanCell ¶

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

BooleanCell implements the Cell{} interface.

func (cell *BooleanCell) FieldDefinition() *Field

func (cell *BooleanCell) IsMetricable(m measurer) bool

func (cell *BooleanCell) MeasurableCell() MeasurableCell

func (cell *BooleanCell) Value() interface{}

type Bucket ¶

type Bucket struct {
	Bucket          *Bucket
	Field           *Field
	DatetimeOptions *DatetimeBucketOptions
	Sort            *SortOptions
	RangeOptions    *RangeBucketOptions
}

Bucket defines how to compare and group data which is then aggregated on.

type Cell ¶

type Cell interface {
	FieldDefinition() *Field
	IsMetricable(m measurer) bool
	MeasurableCell() MeasurableCell
}

Cell represents data and configuration for each of our *Table.Fields.

type Dataset ¶

type Dataset struct {
	Table *Table
	Rows  []map[string]Cell
}

Dataset holds our *Table representation of *Fields and its matching Cell data.

func (set *Dataset) AddRows(rows ...map[string]interface{}) error

func (set *Dataset) Run(query *Query) (*Resultset, error)

type DatetimeBucketOptions ¶

type DatetimeBucketOptions struct {
	// Start will, if provided, ensure buckets start at this date.
	Start *time.Time
	// End will, if provided, ensure buckets continue to this date.
	End *time.Time
	// What interval period are the results to be bucketed at.
	Period DatetimePeriod
	// Datetimes should be bucketed based on the date in this location.
	Location *time.Location
}

DatetimeBucketOptions provides additional configuration for datetime bucketing.

type DatetimeCell ¶

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

DatetimeCell implements the Cell interface.

func (cell *DatetimeCell) FieldDefinition() *Field

func (cell *DatetimeCell) IsMetricable(m measurer) bool

func (cell *DatetimeCell) MeasurableCell() MeasurableCell

func (cell *DatetimeCell) Value() interface{}

func (cell *DatetimeCell) ValueForPeriod(period DatetimePeriod, location *time.Location) (string, error)

type DatetimePeriod ¶

type DatetimePeriod string

DatetimePeriod provides a string type to represent a date bucketing period.

const (
	Year    DatetimePeriod = "year"
	Quarter DatetimePeriod = "quarter"
	Month   DatetimePeriod = "month"
	Week    DatetimePeriod = "week"
	Day     DatetimePeriod = "hour"
)

type Field ¶

type Field struct {
	Name string
	Type string
}

Field represents an individual Field within our Dataset.Table.

type MeasurableCell ¶

type MeasurableCell interface {
	Value() interface{}
}

MeasurableCell returns the cells MeasurableCell{}.

type Metric ¶

type Metric struct {
	Type  string
	Field string
}

Metric represents a type of measurement to be applied to our dataset.

type NumberCell ¶

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

NumberCell implements the Cell interface.

func (cell *NumberCell) FieldDefinition() *Field

func (cell *NumberCell) IsMetricable(m measurer) bool

func (cell *NumberCell) MeasurableCell() MeasurableCell

func (cell *NumberCell) Value() interface{}

func (cell *NumberCell) ValueForPeriod(period []interface{}) (string, error)

type NumericalSortable ¶

type NumericalSortable bool

NumericalSortable is a simple sorter that sorts numerically in the direction of the boolean, true meaning ascending and false being descending.

func (sortable *NumericalSortable) Less(a, b *ResultBucket) bool

type Query ¶

type Query struct {
	Bucket  *Bucket
	Metrics []Metric
}

Query represents the bucketing and aggregate metrics that should be run.

type RangeBucketOptions ¶

type RangeBucketOptions struct {
	Period []interface{}
}

RangeBucketOptions provides additional configuration for custom range bucketing.

type ResultBucket ¶

type ResultBucket struct {
	Value   string                 `json:"value"`
	Metrics map[string]interface{} `json:"metrics"`
	Buckets []*ResultBucket        `json:"buckets"`
	// contains filtered or unexported fields
}

ResultBucket represents recursively built metrics for our tablular data.

type ResultTable ¶

type ResultTable struct {
	Rows         [][]map[string]interface{} `json:"rows"`
	RowTitles    [][]string                 `json:"row_titles"`
	ColumnTitles [][]string                 `json:"column_titles"`
}

ResultTable represents a Resultset split into row / columns at a depth.

func Tabulate(results *Resultset, depth int) (*ResultTable, error)

type Resultset ¶

type Resultset struct {
	Errors      []error         `json:"errors"`
	Buckets     []*ResultBucket `json:"buckets"`
	Composition []interface{}   `json:"-"`
}

Resultset represents a complete set of result buckets and any associated errors.

type SortOptions ¶

type SortOptions struct {
	Type   string
	Metric string
	Desc   bool
}

SortOptions represent how this Bucket should be sorted.

type Sortable ¶

type Sortable interface {
	Less(a, b *ResultBucket) bool
}

Sortable provides an interface that various sorters can implement to compare two result buckets. This enables access to both the value and any metrics that the query may have contained.

type StringCell ¶

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

StringCell implements the Cell{} interface.

func (cell *StringCell) FieldDefinition() *Field

func (cell *StringCell) IsMetricable(m measurer) bool

func (cell *StringCell) MeasurableCell() MeasurableCell

func (cell *StringCell) Value() interface{}

type Table ¶

type Table struct {
	Fields []Field
}