query

package
v0.0.0-...-d65df50 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 29, 2016 License: BSD-2-Clause Imports: 8 Imported by: 7

Documentation

Index

Constants

View Source 
const (
	In      = "IN"
	Eq      = "="
	Gt      = ">"
	Lt      = "<"
	Between = "><"
	All     = "ALL"
)

Variables

View Source 
var DefaultPagingLimit = 100

This sets the deault limit for queries that don't have limit built into them

View Source 
var NoOrder = Ordering{Ascending: true}

Functions

This section is empty.

Types

type Change 

type Change struct {
	Property string      `bson:"property"`
	Value    interface{} `bson:"value"`
	Op       ChangeOp    `bson:"op"`
}

Change represents a single change in an UPDATE query- what property is being updated, how and to what value

func DelProperty 

func DelProperty(prop string) Change

DelProperty is an UPDATE change that deletes a single property from an entity

func Expire 

func Expire(ttl time.Duration) Change

func Increment 

func Increment(prop string, amount int64) Change

Incement returns a new Incr change for a property with a given integer value

func IncrementFloat 

func IncrementFloat(prop string, amount float64) Change

IncrementFloat returns a new Incr for a property with a given float value. Should be used only on float properties

func Set 

func Set(prop string, newVal interface{}) Change

Set returns a new SetOp change for a property to given value

func (Change) Validate 

func (c Change) Validate() error

Validate makes sure a change is sane - the op is supported , etc

type ChangeOp 

type ChangeOp string

ChangeOp is a wrapper to a string, making sure you don't accidentally put random strings into changes 

const (
	OpSet ChangeOp = "SET"
	// Delete an entire entity
	OpDel       ChangeOp = "DEL"
	OpExpire    ChangeOp = "EXP"
	OpIncrement ChangeOp = "INCR"
	OpSetAdd    ChangeOp = "SADD"
	OpSetDel    ChangeOp = "SDEL"
	OpMapSet    ChangeOp = "MSET"
	OpMapDel    ChangeOp = "MDEL"
	// Delete a single property of an entity
	OpPropDel ChangeOp = "PDEL"
	// noop is a special internal OP that is used for reindexing entities.
	// it is not valid in a client request
	Noop ChangeOp = "NOOP"
)

Constants for chanbge Ops

type DelQuery 

type DelQuery struct {
	Table   string  `bson:"table"`
	Filters Filters `bson:"filters"`
}

DelQuery represents a DEL request handled by the appropriate driver

func NewDelQuery 

func NewDelQuery(table string) *DelQuery

NewDelQuery creates a new query object for a given table

func (DelQuery) Validate 

func (q DelQuery) Validate() error

Validate performs a sanity check on a DelQuery and its filters

func (*DelQuery) Where 

func (q *DelQuery) Where(prop string, operator string, values ...interface{}) *DelQuery

Where adds a selection filter to the query to determine which entitie will be deleted. returns the query itself for use in builder-style syntax

type DelResponse 

type DelResponse struct {
	*Response
	Num int `bson:"num"`
}

DelResponse represents a response to a DEL query over the protocol, with the usual resonse properties, and the number of objects deleted

func NewDelResponse 

func NewDelResponse(err error, num int) *DelResponse

NewDelResponse creates a new response to be returned by the protocol with the given error and number of objects deleted

type Filter 

type Filter struct {
	Property string        `bson:"property"`
	Operator string        `bson:"op"`
	Values   []interface{} `bson:"values"`
}

func Equals 

func Equals(property string, value interface{}) Filter

func NewFilter 

func NewFilter(field, operator string, values ...interface{}) Filter

NewFilter creates a new filter for a property with a given operator and comparison values

func Range 

func Range(property string, min, max interface{}) Filter

func Within 

func Within(property string, values ...interface{}) Filter

func (Filter) Validate 

func (f Filter) Validate() error

Validate checks the filter for validity and returns an error if something is wrong with the filter

type Filters 

type Filters map[string]Filter

Fitlers is an abstraction over a map of filters for queries

func NewFilters 

func NewFilters(filters ...Filter) Filters

func (Filters) One 

func (f Filters) One() (Filter, bool)

If the map is just one filter, we return it and true. otherwise a zero filter and false

type GetQuery 

type GetQuery struct {
	Table      string   `bson:"table"`
	Properties []string `bson:"properties"`
	Filters    Filters  `bson:"filters"`
	Order      Ordering `bson:"order"`
	Paging     Paging   `bson:"paging"`
}

GetQuery describes and build a query to get objects from the database.

It includes the selection filters, ordering, paging and fields information.

It is serialized over the wire protocol and passed between the client and the server

func NewGetQuery 

func NewGetQuery(table string) *GetQuery

NewGetQuery creates a new GetQuery for the given table, with all the other prams. The query can be used in a building sequence to add more parameters to it

func (*GetQuery) All 

func (q *GetQuery) All() *GetQuery

func (*GetQuery) Fields 

func (q *GetQuery) Fields(props ...string) *GetQuery

Limit the GET query to a set of specific fields

func (*GetQuery) Filter 

func (q *GetQuery) Filter(prop, op string, values ...interface{}) *GetQuery

Filter adds a WHERE filter to the query. returns the query itself so it can be used in a building sequence.

func (*GetQuery) FilterBetween 

func (q *GetQuery) FilterBetween(prop string, min, max interface{}) *GetQuery

func (*GetQuery) FilterEq 

func (q *GetQuery) FilterEq(prop string, value interface{}) *GetQuery

func (*GetQuery) FilterIn 

func (q *GetQuery) FilterIn(prop string, values ...interface{}) *GetQuery

func (*GetQuery) Limit 

func (q *GetQuery) Limit(limit int) *GetQuery

Limit sets a limit for the number of results to get, assuming the offset is the first result. Use Page(offset, limit) for paging beyond the first resutls.

returns the query itself so it can be used in a building sequence.

func (GetQuery) Load 

func (q GetQuery) Load(c client.Client, dst interface{}) (int, error)

Load executes the query on the client c, and maps the returning results to a model object(s).

If you pass a pointer to a slice of objects, this slice will be filled with objects of this type.

If you pass a pointer to a single object, the result will be mapped to this object only. Note that if there are more than 1 results and you pass a single object, Load will return an error.

If the query hasn't succeeded we return its error. If there were no results but no error, the slice will be of size 0, and a given object will remain unchanged

func (*GetQuery) OrderBy 

func (q *GetQuery) OrderBy(prop string, mode SortMode) *GetQuery

OrderBy adds ordering information to the query's selection. If it is missing, We order by the index this query is based on. Both lexical and numeric ordering are supported (floats, ints or timestamps)

If an ordering directive is present, it must be either the sole property selection index, or the last property of it.

i.e. if you have a in index on (name, birth_date) you can order by birth_date only. This requires careful planning of the indexes :)

We do not allow unindexed ordering. If the order parameter is not the last or sole property of the seleciton index, the query fails

func (*GetQuery) Page 

func (q *GetQuery) Page(offset, limit int) *GetQuery

Page sets the paging parameters for the query. returns the query itself so it can be used in a building sequence.

func (GetQuery) String 

func (q GetQuery) String() string

String representation of a query in Json

func (GetQuery) Validate 

func (q GetQuery) Validate() error

Validate makes sure the query's parameters and filters are sane

type GetResponse 

type GetResponse struct {
	*Response
	Entities []schema.Entity `bson:"entities"`
	// the total number of entities matching this response, regardless of how many entities we've retrived
	Total int `bson:"total"`
}

func NewGetResponse 

func NewGetResponse(err error) *GetResponse

func NewGetResponseSize 

func NewGetResponseSize(err error, sizeHint int) *GetResponse

func (*GetResponse) AddEntity 

func (r *GetResponse) AddEntity(e schema.Entity)

func (GetResponse) MapEntities 

func (r GetResponse) MapEntities(dst interface{}) error

type Ordering 

type Ordering struct {
	By        string `bson:"by"`
	Ascending bool   `bson:"asc"`
}

func (Ordering) IsNil 

func (o Ordering) IsNil() bool

IsNil tells us whether an Ordering object actually contains any ordering directive or is just empty

func (Ordering) Validate 

func (o Ordering) Validate() error

type Paging 

type Paging struct {
	Offset int `bson:"offset"`
	Limit  int `bson:"limit"`
}

func (Paging) Validate 

func (p Paging) Validate() error

type PingQuery 

type PingQuery struct{}

func (PingQuery) Validate 

func (PingQuery) Validate() error

type PingResponse 

type PingResponse struct {
	*Response
}

func NewPingResponse 

func NewPingResponse() PingResponse

type PutQuery 

type PutQuery struct {
	Table    string          `bson:"table"`
	Entities []schema.Entity `bson:"entities"`
}

func NewPutQuery 

func NewPutQuery(table string) *PutQuery

func NewPutQuerySize 

func NewPutQuerySize(table string, capacity int) *PutQuery

func (*PutQuery) AddEntity 

func (q *PutQuery) AddEntity(e schema.Entity) *PutQuery

func (PutQuery) Validate 

func (q PutQuery) Validate() error

type PutResponse 

type PutResponse struct {
	*Response
	Ids []schema.Key `bson:"ids"`
}

func NewPutResponse 

func NewPutResponse(err error, ids ...schema.Key) *PutResponse

type Query 

type Query interface {
	Validate() error
}

Query is just the commmon interface for all queries. They must validate themselves

type QueryResult 

type QueryResult interface {
	Elapsed() time.Duration
	Err() error
}

type Response 

type Response struct {
	Time time.Duration `bson:"time"`

	Error *errors.Error `bson:"error"`
	// contains filtered or unexported fields
}

func NewResponse 

func NewResponse(err error) *Response

func (*Response) Done 

func (r *Response) Done()

func (*Response) Elapsed 

func (r *Response) Elapsed() time.Duration

func (*Response) Err 

func (r *Response) Err() error

func (*Response) String 

func (r *Response) String() string

type SortMode 

type SortMode string
const (
	ASC  SortMode = "ASC"
	DESC SortMode = "DESC"
)

type UpdateQuery 

type UpdateQuery struct {
	Table   string   `bson:"table"`
	Filters Filters  `bson:"filters"`
	Changes []Change `bson:"changes"`
}

UpdateQuery represents an UPDATE request sent to the server and processed by the relevant driver

func NewUpdateQuery 

func NewUpdateQuery(table string) *UpdateQuery

NewUpdateQuery initializes an update query for a given table

func (*UpdateQuery) DelProperty 

func (q *UpdateQuery) DelProperty(prop string) *UpdateQuery

DelProperty is an UPDATE change that deletes a single property from an entity

func (*UpdateQuery) Expire 

func (q *UpdateQuery) Expire(ttl time.Duration) *UpdateQuery

func (*UpdateQuery) Increment 

func (q *UpdateQuery) Increment(prop string, newVal int64) *UpdateQuery

func (*UpdateQuery) Set 

func (q *UpdateQuery) Set(prop string, newVal interface{}) *UpdateQuery

Set adds a SET op change to the query's change set

func (*UpdateQuery) Validate 

func (q *UpdateQuery) Validate() (err error)

Validate tests the query's parameter for validity (not against a schema - just that they are sane). If any problem is found it returns an error

func (*UpdateQuery) Where 

func (q *UpdateQuery) Where(prop string, operator string, values ...interface{}) *UpdateQuery

Where adds a selection filter indicating what entities will be updated

func (*UpdateQuery) WhereEquals 

func (q *UpdateQuery) WhereEquals(prop string, values ...interface{}) *UpdateQuery

WhereEquals creates an Eq filter on the query

func (*UpdateQuery) WhereId 

func (q *UpdateQuery) WhereId(ids ...interface{}) *UpdateQuery

WhereId creates a selection filter by primary ids

type UpdateResponse 

type UpdateResponse struct {
	*Response
	Num int `bson:"num"`
}

UpdateResponse is used to send a response back to clients to an update query. It includes the usual Response fields, and the number of entities affected by the update

func NewUpdateResponse 

func NewUpdateResponse(err error, num int) *UpdateResponse

NewUpdateResponse creates a new response object to send back to a client, with a given error and the number of entities updated

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.