route/vendor/github.com/GoRethink/gorethink/query_transformation.go

194 lines
6.8 KiB
Go
Raw Normal View History

2017-01-22 17:36:44 +00:00
package gorethink
import p "gopkg.in/gorethink/gorethink.v2/ql2"
// Map transform each element of the sequence by applying the given mapping
// function. It takes two arguments, a sequence and a function of type
// `func (r.Term) interface{}`.
//
// For example this query doubles each element in an array:
//
// r.Map([]int{1,3,6}, func (row r.Term) interface{} {
// return row.Mul(2)
// })
func Map(args ...interface{}) Term {
if len(args) > 0 {
args = append(args[:len(args)-1], funcWrap(args[len(args)-1]))
}
return constructRootTerm("Map", p.Term_MAP, args, map[string]interface{}{})
}
// Map transforms each element of the sequence by applying the given mapping
// function. It takes one argument of type `func (r.Term) interface{}`.
//
// For example this query doubles each element in an array:
//
// r.Expr([]int{1,3,6}).Map(func (row r.Term) interface{} {
// return row.Mul(2)
// })
func (t Term) Map(args ...interface{}) Term {
if len(args) > 0 {
args = append(args[:len(args)-1], funcWrap(args[len(args)-1]))
}
return constructMethodTerm(t, "Map", p.Term_MAP, args, map[string]interface{}{})
}
// WithFields takes a sequence of objects and a list of fields. If any objects in the
// sequence don't have all of the specified fields, they're dropped from the
// sequence. The remaining objects have the specified fields plucked out.
// (This is identical to `HasFields` followed by `Pluck` on a sequence.)
func (t Term) WithFields(args ...interface{}) Term {
return constructMethodTerm(t, "WithFields", p.Term_WITH_FIELDS, args, map[string]interface{}{})
}
// ConcatMap concatenates one or more elements into a single sequence using a
// mapping function. ConcatMap works in a similar fashion to Map, applying the
// given function to each element in a sequence, but it will always return a
// single sequence.
func (t Term) ConcatMap(args ...interface{}) Term {
return constructMethodTerm(t, "ConcatMap", p.Term_CONCAT_MAP, funcWrapArgs(args), map[string]interface{}{})
}
// OrderByOpts contains the optional arguments for the OrderBy term
type OrderByOpts struct {
Index interface{} `gorethink:"index,omitempty"`
}
func (o OrderByOpts) toMap() map[string]interface{} {
return optArgsToMap(o)
}
// OrderBy sorts the sequence by document values of the given key(s). To specify
// the ordering, wrap the attribute with either r.Asc or r.Desc (defaults to
// ascending).
//
// Sorting without an index requires the server to hold the sequence in memory,
// and is limited to 100,000 documents (or the setting of the ArrayLimit option
// for run). Sorting with an index can be done on arbitrarily large tables, or
// after a between command using the same index.
func (t Term) OrderBy(args ...interface{}) Term {
var opts = map[string]interface{}{}
// Look for options map
if len(args) > 0 {
if possibleOpts, ok := args[len(args)-1].(OrderByOpts); ok {
opts = possibleOpts.toMap()
args = args[:len(args)-1]
}
}
for k, arg := range args {
if t, ok := arg.(Term); !(ok && (t.termType == p.Term_DESC || t.termType == p.Term_ASC)) {
args[k] = funcWrap(arg)
}
}
return constructMethodTerm(t, "OrderBy", p.Term_ORDER_BY, args, opts)
}
// Desc is used by the OrderBy term to specify the ordering to be descending.
func Desc(args ...interface{}) Term {
return constructRootTerm("Desc", p.Term_DESC, funcWrapArgs(args), map[string]interface{}{})
}
// Asc is used by the OrderBy term to specify that the ordering be ascending (the
// default).
func Asc(args ...interface{}) Term {
return constructRootTerm("Asc", p.Term_ASC, funcWrapArgs(args), map[string]interface{}{})
}
// Skip skips a number of elements from the head of the sequence.
func (t Term) Skip(args ...interface{}) Term {
return constructMethodTerm(t, "Skip", p.Term_SKIP, args, map[string]interface{}{})
}
// Limit ends the sequence after the given number of elements.
func (t Term) Limit(args ...interface{}) Term {
return constructMethodTerm(t, "Limit", p.Term_LIMIT, args, map[string]interface{}{})
}
// SliceOpts contains the optional arguments for the Slice term
type SliceOpts struct {
LeftBound interface{} `gorethink:"left_bound,omitempty"`
RightBound interface{} `gorethink:"right_bound,omitempty"`
}
func (o SliceOpts) toMap() map[string]interface{} {
return optArgsToMap(o)
}
// Slice trims the sequence to within the bounds provided.
func (t Term) Slice(args ...interface{}) Term {
var opts = map[string]interface{}{}
// Look for options map
if len(args) > 0 {
if possibleOpts, ok := args[len(args)-1].(SliceOpts); ok {
opts = possibleOpts.toMap()
args = args[:len(args)-1]
}
}
return constructMethodTerm(t, "Slice", p.Term_SLICE, args, opts)
}
// AtIndex gets a single field from an object or the nth element from a sequence.
func (t Term) AtIndex(args ...interface{}) Term {
return constructMethodTerm(t, "AtIndex", p.Term_BRACKET, args, map[string]interface{}{})
}
// Nth gets the nth element from a sequence.
func (t Term) Nth(args ...interface{}) Term {
return constructMethodTerm(t, "Nth", p.Term_NTH, args, map[string]interface{}{})
}
// OffsetsOf gets the indexes of an element in a sequence. If the argument is a
// predicate, get the indexes of all elements matching it.
func (t Term) OffsetsOf(args ...interface{}) Term {
return constructMethodTerm(t, "OffsetsOf", p.Term_OFFSETS_OF, funcWrapArgs(args), map[string]interface{}{})
}
// IsEmpty tests if a sequence is empty.
func (t Term) IsEmpty(args ...interface{}) Term {
return constructMethodTerm(t, "IsEmpty", p.Term_IS_EMPTY, args, map[string]interface{}{})
}
// UnionOpts contains the optional arguments for the Slice term
type UnionOpts struct {
Interleave interface{} `gorethink:"interleave,omitempty"`
}
func (o UnionOpts) toMap() map[string]interface{} {
return optArgsToMap(o)
}
// Union concatenates two sequences.
func Union(args ...interface{}) Term {
return constructRootTerm("Union", p.Term_UNION, args, map[string]interface{}{})
}
// Union concatenates two sequences.
func (t Term) Union(args ...interface{}) Term {
return constructMethodTerm(t, "Union", p.Term_UNION, args, map[string]interface{}{})
}
// UnionWithOpts like Union concatenates two sequences however allows for optional
// arguments to be passed.
func UnionWithOpts(optArgs UnionOpts, args ...interface{}) Term {
return constructRootTerm("Union", p.Term_UNION, args, optArgs.toMap())
}
// UnionWithOpts like Union concatenates two sequences however allows for optional
// arguments to be passed.
func (t Term) UnionWithOpts(optArgs UnionOpts, args ...interface{}) Term {
return constructMethodTerm(t, "Union", p.Term_UNION, args, optArgs.toMap())
}
// Sample selects a given number of elements from a sequence with uniform random
// distribution. Selection is done without replacement.
func (t Term) Sample(args ...interface{}) Term {
return constructMethodTerm(t, "Sample", p.Term_SAMPLE, args, map[string]interface{}{})
}