octosql: github.com/cube2222/octosql/storage/redis Index | Files

package redis

import "github.com/cube2222/octosql/storage/redis"

Index

Package Files

datasource.go key_extract.go

Constants

const (
    DefaultKeys resultType = iota
    True
    False
)

Variables

var ErrNotFound = errors.New("redis key not found")

func GetNewRecord Uses

func GetNewRecord(client *redis.Client, keyName, key, alias string) (*execution.Record, error)

func NewDataSourceBuilderFactory Uses

func NewDataSourceBuilderFactory(dbKey string) physical.DataSourceBuilderFactory

NewDataSourceBuilderFactory creates a new datasource builder factory for a redis database. dbKey is the name for hard-coded key alias used in future formulas for redis queries

func NewDataSourceBuilderFactoryFromConfig Uses

func NewDataSourceBuilderFactoryFromConfig(dbConfig map[string]interface{}) (physical.DataSourceBuilderFactory, error)

NewDataSourceBuilderFactoryFromConfig creates a data source builder factory using the configuration.

type And Uses

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

Just like logical operator, the form is like: (formula1 AND formula2) getAllKeys returns intersection of 2 key sets

func NewAnd Uses

func NewAnd(left, right KeyFormula) *And

type Constant Uses

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

Just as with logical constant getAllKeys returns empty map for 'false' (so that AND have empty intersection and doesn't have any impact on OR's union) for 'true' it also returns empty map (no effect on OR), but we need a type condition in AND struct

func NewConstant Uses

func NewConstant(value bool) *Constant

type DataSource Uses

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

func (*DataSource) Get Uses

func (ds *DataSource) Get(ctx context.Context, variables octosql.Variables) (execution.RecordStream, error)

type EntireDatabaseStream Uses

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

func (*EntireDatabaseStream) Close Uses

func (rs *EntireDatabaseStream) Close() error

func (*EntireDatabaseStream) Next Uses

func (rs *EntireDatabaseStream) Next(ctx context.Context) (*execution.Record, error)

type Equal Uses

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

The equivalent form is: ("key" = child), where "key" is alias for extracted key from redis database getAllKeys returns expression value of 'child' (only if it's of string type - the only acceptable in redis)

func NewEqual Uses

func NewEqual(child execution.Expression) *Equal

type In Uses

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

func NewIn Uses

func NewIn(child execution.Expression) *In

type KeyFormula Uses

type KeyFormula interface {
    // contains filtered or unexported methods
}

Formula build from physical.Formula, so that it accepts formulas for redis database Also, getAllKeys returns all keys, that will be subject of HGetAll

func NewKeyFormula Uses

func NewKeyFormula(formula physical.Formula, key, alias string, matCtx *physical.MaterializationContext) (KeyFormula, error)

type KeySpecificStream Uses

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

func (*KeySpecificStream) Close Uses

func (rs *KeySpecificStream) Close() error

func (*KeySpecificStream) Next Uses

func (rs *KeySpecificStream) Next(ctx context.Context) (*execution.Record, error)

type Or Uses

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

Just like logical operator, the form is like: (formula1 OR formula2) getAllKeys returns union of 2 key sets

func NewOr Uses

func NewOr(left, right KeyFormula) *Or

Package redis imports 10 packages (graph) and is imported by 1 packages. Updated 2019-12-09. Refresh now. Tools for package owners.