Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

gorethink

package module

Go to main page

Versions in this module

v3

v3.0.5

Sep 28, 2017

v3.0.4

Sep 4, 2017

v3.0.3

Sep 3, 2017

Changes in this version

+ var ErrQueryTimeout = errors.New("gorethink: query timeout")

type ExecOpts

+ Context context.Context

type RunOpts

+ Context context.Context

v3.0.2

Apr 17, 2017

v3.0.1

Jan 30, 2017

v3.0.0

Dec 6, 2016

Changes in this version

+ const ClusterConfigSystemTable

+ const CurrentIssuesSystemTable

+ const DBConfigSystemTable

+ const JobsSystemTable

+ const LogsSystemTable

+ const PermissionsSystemTable

+ const ServerConfigSystemTable

+ const ServerStatusSystemTable

+ const StatsSystemTable

+ const SystemDatabase

+ const TableConfigSystemTable

+ const TableStatusSystemTable

+ const UsersSystemTable

+ var April = constructRootTerm("April", p.Term_APRIL, []interface{}{}, map[string]interface{}{})

+ var August = constructRootTerm("August", p.Term_AUGUST, []interface{}{}, map[string]interface{}{})

+ var December = constructRootTerm("December", p.Term_DECEMBER, []interface{}{}, map[string]interface{}{})

+ var ErrConnectionClosed = errors.New("gorethink: the connection is closed")

+ var ErrEmptyResult = errors.New("The result does not contain any more rows")

+ var ErrInvalidNode = errors.New("invalid node")

+ var ErrNoConnections = errors.New("gorethink: no connections were available")

+ var ErrNoConnectionsStarted = errors.New("no connections were made when creating the session")

+ var ErrNoHosts = errors.New("no hosts provided")

+ var February = constructRootTerm("February", p.Term_FEBRUARY, []interface{}{}, map[string]interface{}{})

+ var Friday = constructRootTerm("Friday", p.Term_FRIDAY, []interface{}{}, map[string]interface{}{})

+ var January = constructRootTerm("January", p.Term_JANUARY, []interface{}{}, map[string]interface{}{})

+ var July = constructRootTerm("July", p.Term_JULY, []interface{}{}, map[string]interface{}{})

+ var June = constructRootTerm("June", p.Term_JUNE, []interface{}{}, map[string]interface{}{})

+ var Log *logrus.Logger

+ var March = constructRootTerm("March", p.Term_MARCH, []interface{}{}, map[string]interface{}{})

+ var MaxVal = constructRootTerm("MaxVal", p.Term_MAXVAL, []interface{}{}, map[string]interface{}{})

+ var May = constructRootTerm("May", p.Term_MAY, []interface{}{}, map[string]interface{}{})

+ var MinVal = constructRootTerm("MinVal", p.Term_MINVAL, []interface{}{}, map[string]interface{}{})

+ var Monday = constructRootTerm("Monday", p.Term_MONDAY, []interface{}{}, map[string]interface{}{})

+ var November = constructRootTerm("November", p.Term_NOVEMBER, []interface{}{}, map[string]interface{}{})

+ var October = constructRootTerm("October", p.Term_OCTOBER, []interface{}{}, map[string]interface{}{})

+ var Row = constructRootTerm("Doc", p.Term_IMPLICIT_VAR, []interface{}{}, map[string]interface{}{})

+ var Saturday = constructRootTerm("Saturday", p.Term_SATURDAY, []interface{}{}, map[string]interface{}{})

+ var September = constructRootTerm("September", p.Term_SEPTEMBER, []interface{}{}, map[string]interface{}{})

+ var Sunday = constructRootTerm("Sunday", p.Term_SUNDAY, []interface{}{}, map[string]interface{}{})

+ var Thursday = constructRootTerm("Thursday", p.Term_THURSDAY, []interface{}{}, map[string]interface{}{})

+ var Tuesday = constructRootTerm("Tuesday", p.Term_TUESDAY, []interface{}{}, map[string]interface{}{})

+ var Wednesday = constructRootTerm("Wednesday", p.Term_WEDNESDAY, []interface{}{}, map[string]interface{}{})

+ func IsConflictErr(err error) bool

+ func IsTypeErr(err error) bool

+ func SetTags(tags ...string)

+ func SetVerbose(verbose bool)

+ type BetweenOpts struct

+ Index interface{}

+ LeftBound interface{}

+ RightBound interface{}

+ type ChangeResponse struct

+ Error string

+ NewValue interface{}

+ OldValue interface{}

+ State string

+ type ChangesOpts struct

+ ChangefeedQueueSize interface{}

+ IncludeInitial interface{}

+ IncludeOffsets interface{}

+ IncludeStates interface{}

+ IncludeTypes interface{}

+ Squash interface{}

+ type CircleOpts struct

+ Fill interface{}

+ GeoSystem interface{}

+ NumVertices interface{}

+ Unit interface{}

+ type CloseOpts struct

+ NoReplyWait bool

+ type Cluster struct

+ func NewCluster(hosts []Host, opts *ConnectOpts) (*Cluster, error)

+ func (c *Cluster) AddSeeds(hosts []Host)

+ func (c *Cluster) Close(optArgs ...CloseOpts) error

+ func (c *Cluster) Exec(q Query) (err error)

+ func (c *Cluster) GetNextNode() (*Node, hostpool.HostPoolResponse, error)

+ func (c *Cluster) GetNodes() []*Node

+ func (c *Cluster) IsConnected() bool

+ func (c *Cluster) Query(q Query) (cursor *Cursor, err error)

+ func (c *Cluster) Server() (response ServerResponse, err error)

+ func (c *Cluster) SetInitialPoolCap(n int)

+ func (c *Cluster) SetMaxIdleConns(n int)

+ func (c *Cluster) SetMaxOpenConns(n int)

+ type ConnectOpts struct

+ Address string

+ Addresses []string

+ AuthKey string

+ Database string

+ DiscoverHosts bool

+ HandshakeVersion HandshakeVersion

+ HostDecayDuration time.Duration

+ InitialCap int

+ KeepAlivePeriod time.Duration

+ MaxIdle int

+ MaxOpen int

+ NodeRefreshInterval time.Duration

+ NumRetries int

+ Password string

+ ReadTimeout time.Duration

+ TLSConfig *tls.Config

+ Timeout time.Duration

+ UseJSONNumber bool

+ Username string

+ WriteTimeout time.Duration

+ type Connection struct

+ func NewConnection(address string, opts *ConnectOpts) (*Connection, error)

+ func (c *Connection) Close() error

+ func (c *Connection) Query(q Query) (*Response, *Cursor, error)

+ func (c *Connection) Server() (ServerResponse, error)

+ type Cursor struct

+ func (c *Cursor) All(result interface{}) error

+ func (c *Cursor) Close() error

+ func (c *Cursor) Err() error

+ func (c *Cursor) Interface() (interface{}, error)

+ func (c *Cursor) IsNil() bool

+ func (c *Cursor) Listen(channel interface{})

+ func (c *Cursor) Next(dest interface{}) bool

+ func (c *Cursor) NextResponse() ([]byte, bool)

+ func (c *Cursor) One(result interface{}) error

+ func (c *Cursor) Peek(dest interface{}) (bool, error)

+ func (c *Cursor) Profile() interface{}

+ func (c *Cursor) Skip()

+ func (c *Cursor) Type() string

+ type DeleteOpts struct

+ Durability interface{}

+ ReturnChanges interface{}

+ type DistanceOpts struct

+ GeoSystem interface{}

+ Unit interface{}

+ type DistinctOpts struct

+ Index interface{}

+ type DuringOpts struct

+ LeftBound interface{}

+ RightBound interface{}

+ type EqJoinOpts struct

+ Index interface{}

+ Ordered interface{}

+ type ExecOpts struct

+ ArrayLimit interface{}

+ BinaryFormat interface{}

+ DB interface{}

+ Db interface{}

+ Durability interface{}

+ FirstBatchScaledownFactor interface{}

+ GeometryFormat interface{}

+ GroupFormat interface{}

+ MaxBatchBytes interface{}

+ MaxBatchRows interface{}

+ MaxBatchSeconds interface{}

+ MinBatchRows interface{}

+ NoReply interface{}

+ Profile interface{}

+ TimeFormat interface{}

+ UseOutdated interface{}

+ type FilterOpts struct

+ Default interface{}

+ type FoldOpts struct

+ Emit interface{}

+ FinalEmit interface{}

+ type GetAllOpts struct

+ Index interface{}

+ type GetIntersectingOpts struct

+ Index interface{}

+ type GetNearestOpts struct

+ GeoSystem interface{}

+ Index interface{}

+ MaxDist interface{}

+ MaxResults interface{}

+ Unit interface{}

+ type GroupOpts struct

+ Index interface{}

+ Multi interface{}

+ type HTTPOpts struct

+ Auth interface{}

+ Data interface{}

+ Header interface{}

+ Method interface{}

+ Page interface{}

+ PageLimit interface{}

+ Params interface{}

+ Reattempts interface{}

+ Redirects interface{}

+ ResultFormat interface{}

+ Timeout interface{}

+ Verify interface{}

+ type HandshakeVersion int

+ const HandshakeV0_4

+ const HandshakeV1_0

+ type Host struct

+ Name string

+ Port int

+ func NewHost(name string, port int) Host

+ func (h Host) String() string

+ type ISO8601Opts struct

+ DefaultTimezone interface{}

+ type IndexCreateOpts struct

+ Geo interface{}

+ Multi interface{}

+ type IndexRenameOpts struct

+ Overwrite interface{}

+ type InsertOpts struct

+ Conflict interface{}

+ Durability interface{}

+ ReturnChanges interface{}

+ type JSOpts struct

+ Timeout interface{}

+ type MaxOpts struct

+ Index interface{}

+ type MinOpts struct

+ Index interface{}

+ type Mock struct

+ ExpectedQueries []*MockQuery

+ Queries []MockQuery

+ func NewMock(opts ...ConnectOpts) *Mock

+ func (m *Mock) AssertExecuted(t testingT, expectedQuery *MockQuery) bool

+ func (m *Mock) AssertExpectations(t testingT) bool

+ func (m *Mock) AssertNotExecuted(t testingT, expectedQuery *MockQuery) bool

+ func (m *Mock) AssertNumberOfExecutions(t testingT, expectedQuery *MockQuery, expectedExecutions int) bool

+ func (m *Mock) Exec(q Query) error

+ func (m *Mock) IsConnected() bool

+ func (m *Mock) On(t Term, opts ...map[string]interface{}) *MockQuery

+ func (m *Mock) Query(q Query) (*Cursor, error)

+ type MockQuery struct

+ BuiltQuery []byte

+ Error error

+ Query Query

+ Repeatability int

+ Response interface{}

+ WaitFor <-chan time.Time

+ func (mq *MockQuery) After(d time.Duration) *MockQuery

+ func (mq *MockQuery) On(t Term) *MockQuery

+ func (mq *MockQuery) Once() *MockQuery

+ func (mq *MockQuery) Return(response interface{}, err error) *MockQuery

+ func (mq *MockQuery) Times(i int) *MockQuery

+ func (mq *MockQuery) Twice() *MockQuery

+ func (mq *MockQuery) WaitUntil(w <-chan time.Time) *MockQuery

+ type Node struct

+ Host Host

+ ID string

+ func (n *Node) Close(optArgs ...CloseOpts) error

+ func (n *Node) Closed() bool

+ func (n *Node) Exec(q Query) (err error)

+ func (n *Node) NoReplyWait() error

+ func (n *Node) Query(q Query) (cursor *Cursor, err error)

+ func (n *Node) Server() (ServerResponse, error)

+ func (n *Node) SetInitialPoolCap(idleConns int)

+ func (n *Node) SetMaxIdleConns(idleConns int)

+ func (n *Node) SetMaxOpenConns(openConns int)

+ type OptArgs interface

+ type OrderByOpts struct

+ Index interface{}

+ type Pool struct

+ func NewPool(host Host, opts *ConnectOpts) (*Pool, error)

+ func (p *Pool) Close() error

+ func (p *Pool) Exec(q Query) error

+ func (p *Pool) Ping() error

+ func (p *Pool) Query(q Query) (*Cursor, error)

+ func (p *Pool) Server() (ServerResponse, error)

+ func (p *Pool) SetInitialPoolCap(n int)

+ func (p *Pool) SetMaxIdleConns(n int)

+ func (p *Pool) SetMaxOpenConns(n int)

+ type Query struct

+ Opts map[string]interface{}

+ Term *Term

+ Token int64

+ Type p.Query_QueryType

+ func (q *Query) Build() []interface{}

+ type QueryExecutor interface

+ Exec func(Query) error

+ IsConnected func() bool

+ Query func(Query) (*Cursor, error)

+ type RQLAuthError struct

+ func (e RQLAuthError) Error() string

+ func (e RQLAuthError) String() string

+ type RQLAvailabilityError struct

+ func (e RQLAvailabilityError) Error() string

+ func (e RQLAvailabilityError) String() string

+ type RQLClientError struct

+ func (e RQLClientError) Error() string

+ func (e RQLClientError) String() string

+ type RQLCompileError struct

+ func (e RQLCompileError) Error() string

+ func (e RQLCompileError) String() string

+ type RQLConnectionError struct

+ func (e RQLConnectionError) Error() string

+ func (e RQLConnectionError) String() string

+ type RQLDriverCompileError struct

+ func (e RQLDriverCompileError) Error() string

+ func (e RQLDriverCompileError) String() string

+ type RQLDriverError struct

+ func (e RQLDriverError) Error() string

+ func (e RQLDriverError) String() string

+ type RQLInternalError struct

+ func (e RQLInternalError) Error() string

+ func (e RQLInternalError) String() string

+ type RQLNonExistenceError struct

+ func (e RQLNonExistenceError) Error() string

+ func (e RQLNonExistenceError) String() string

+ type RQLOpFailedError struct

+ func (e RQLOpFailedError) Error() string

+ func (e RQLOpFailedError) String() string

+ type RQLOpIndeterminateError struct

+ func (e RQLOpIndeterminateError) Error() string

+ func (e RQLOpIndeterminateError) String() string

+ type RQLQueryLogicError struct

+ func (e RQLQueryLogicError) Error() string

+ func (e RQLQueryLogicError) String() string

+ type RQLResourceLimitError struct

+ func (e RQLResourceLimitError) Error() string

+ func (e RQLResourceLimitError) String() string

+ type RQLRuntimeError struct

+ func (e RQLRuntimeError) Error() string

+ func (e RQLRuntimeError) String() string

+ type RQLServerCompileError struct

+ func (e RQLServerCompileError) Error() string

+ func (e RQLServerCompileError) String() string

+ type RQLTimeoutError struct

+ func (e RQLTimeoutError) Error() string

+ func (e RQLTimeoutError) String() string

+ type RQLUserError struct

+ func (e RQLUserError) Error() string

+ func (e RQLUserError) String() string

+ type RandomOpts struct

+ Float interface{}

+ type ReconfigureOpts struct

+ DryRun interface{}

+ EmergencyRepair interface{}

+ NonVotingReplicaTags interface{}

+ PrimaryReplicaTag interface{}

+ Replicas interface{}

+ Shards interface{}

+ type ReplaceOpts struct

+ Durability interface{}

+ NonAtomic interface{}

+ ReturnChanges interface{}

+ type Response struct

+ Backtrace []interface{}

+ ErrorType p.Response_ErrorType

+ Notes []p.Response_ResponseNote

+ Profile interface{}

+ Responses []json.RawMessage

+ Token int64

+ Type p.Response_ResponseType

+ type RunOpts struct

+ ArrayLimit interface{}

+ BinaryFormat interface{}

+ DB interface{}

+ Db interface{}

+ Durability interface{}

+ FirstBatchScaledownFactor interface{}

+ GeometryFormat interface{}

+ GroupFormat interface{}

+ MaxBatchBytes interface{}

+ MaxBatchRows interface{}

+ MaxBatchSeconds interface{}

+ MinBatchRows interface{}

+ Profile interface{}

+ ReadMode interface{}

+ TimeFormat interface{}

+ UseOutdated interface{}

+ type ServerResponse struct

+ ID string

+ Name string

+ type Session struct

+ func Connect(opts ConnectOpts) (*Session, error)

+ func (s *Session) Close(optArgs ...CloseOpts) error

+ func (s *Session) Database() string

+ func (s *Session) Exec(q Query) error

+ func (s *Session) IsConnected() bool

+ func (s *Session) NoReplyWait() error

+ func (s *Session) Query(q Query) (*Cursor, error)

+ func (s *Session) Reconnect(optArgs ...CloseOpts) error

+ func (s *Session) Server() (ServerResponse, error)

+ func (s *Session) SetHosts(hosts []Host)

+ func (s *Session) SetInitialPoolCap(n int)

+ func (s *Session) SetMaxIdleConns(n int)

+ func (s *Session) SetMaxOpenConns(n int)

+ func (s *Session) Use(database string)

+ type SliceOpts struct

+ LeftBound interface{}

+ RightBound interface{}

+ type TableCreateOpts struct

+ Durability interface{}

+ NonVotingReplicaTags interface{}

+ PrimaryKey interface{}

+ PrimaryReplicaTag interface{}

+ Replicas interface{}

+ Shards interface{}

+ type TableOpts struct

+ IdentifierFormat interface{}

+ ReadMode interface{}

+ UseOutdated interface{}

+ type Term struct

+ func Add(args ...interface{}) Term

+ func And(args ...interface{}) Term

+ func Args(args ...interface{}) Term

+ func Asc(args ...interface{}) Term

+ func Avg(args ...interface{}) Term

+ func Binary(data interface{}) Term

+ func Branch(args ...interface{}) Term

+ func Ceil(args ...interface{}) Term

+ func Circle(point, radius interface{}, optArgs ...CircleOpts) Term

+ func Contains(args ...interface{}) Term

+ func Count(args ...interface{}) Term

+ func DB(args ...interface{}) Term

+ func DBCreate(args ...interface{}) Term

+ func DBDrop(args ...interface{}) Term

+ func DBList(args ...interface{}) Term

+ func Desc(args ...interface{}) Term

+ func Distance(point1, point2 interface{}, optArgs ...DistanceOpts) Term

+ func Distinct(arg interface{}, optArgs ...DistinctOpts) Term

+ func Div(args ...interface{}) Term

+ func Do(args ...interface{}) Term

+ func EpochTime(args ...interface{}) Term

+ func Eq(args ...interface{}) Term

+ func Error(args ...interface{}) Term

+ func Expr(val interface{}) Term

+ func Floor(args ...interface{}) Term

+ func Ge(args ...interface{}) Term

+ func GeoJSON(args ...interface{}) Term

+ func Group(fieldOrFunctions ...interface{}) Term

+ func GroupByIndex(index interface{}, fieldOrFunctions ...interface{}) Term

+ func Gt(args ...interface{}) Term

+ func HTTP(url interface{}, optArgs ...HTTPOpts) Term

+ func ISO8601(date interface{}, optArgs ...ISO8601Opts) Term

+ func JS(jssrc interface{}, optArgs ...JSOpts) Term

+ func JSON(args ...interface{}) Term

+ func Le(args ...interface{}) Term

+ func Line(args ...interface{}) Term

+ func Literal(args ...interface{}) Term

+ func Lt(args ...interface{}) Term

+ func Map(args ...interface{}) Term

+ func Max(args ...interface{}) Term

+ func MaxIndex(index interface{}, args ...interface{}) Term

+ func Min(args ...interface{}) Term

+ func MinIndex(index interface{}, args ...interface{}) Term

+ func MockAnything() Term

+ func Mod(args ...interface{}) Term

+ func Mul(args ...interface{}) Term

+ func MultiGroup(fieldOrFunctions ...interface{}) Term

+ func MultiGroupByIndex(index interface{}, fieldOrFunctions ...interface{}) Term

+ func Ne(args ...interface{}) Term

+ func Not(args ...interface{}) Term

+ func Now(args ...interface{}) Term

+ func Object(args ...interface{}) Term

+ func Or(args ...interface{}) Term

+ func Point(lon, lat interface{}) Term

+ func Polygon(args ...interface{}) Term

+ func Random(args ...interface{}) Term

+ func Range(args ...interface{}) Term

+ func RawQuery(q []byte) Term

+ func Round(args ...interface{}) Term

+ func Sub(args ...interface{}) Term

+ func Sum(args ...interface{}) Term

+ func Table(name interface{}, optArgs ...TableOpts) Term

+ func TableCreate(name interface{}, optArgs ...TableCreateOpts) Term

+ func TableDrop(args ...interface{}) Term

+ func TableList(args ...interface{}) Term

+ func Time(args ...interface{}) Term

+ func TypeOf(args ...interface{}) Term

+ func UUID(args ...interface{}) Term

+ func Union(args ...interface{}) Term

+ func UnionWithOpts(optArgs UnionOpts, args ...interface{}) Term

+ func Wait(optArgs ...WaitOpts) Term

+ func (t Term) Add(args ...interface{}) Term

+ func (t Term) And(args ...interface{}) Term

+ func (t Term) Append(args ...interface{}) Term

+ func (t Term) AtIndex(args ...interface{}) Term

+ func (t Term) Avg(args ...interface{}) Term

+ func (t Term) Between(lowerKey, upperKey interface{}, optArgs ...BetweenOpts) Term

+ func (t Term) Branch(args ...interface{}) Term

+ func (t Term) Build() (interface{}, error)

+ func (t Term) Ceil(args ...interface{}) Term

+ func (t Term) ChangeAt(args ...interface{}) Term

+ func (t Term) Changes(optArgs ...ChangesOpts) Term

+ func (t Term) CoerceTo(args ...interface{}) Term

+ func (t Term) ConcatMap(args ...interface{}) Term

+ func (t Term) Config() Term

+ func (t Term) Contains(args ...interface{}) Term

+ func (t Term) Count(args ...interface{}) Term

+ func (t Term) Date(args ...interface{}) Term

+ func (t Term) Day(args ...interface{}) Term

+ func (t Term) DayOfWeek(args ...interface{}) Term

+ func (t Term) DayOfYear(args ...interface{}) Term

+ func (t Term) Default(args ...interface{}) Term

+ func (t Term) Delete(optArgs ...DeleteOpts) Term

+ func (t Term) DeleteAt(args ...interface{}) Term

+ func (t Term) Difference(args ...interface{}) Term

+ func (t Term) Distance(point interface{}, optArgs ...DistanceOpts) Term

+ func (t Term) Distinct(optArgs ...DistinctOpts) Term

+ func (t Term) Div(args ...interface{}) Term

+ func (t Term) Do(args ...interface{}) Term

+ func (t Term) Downcase(args ...interface{}) Term

+ func (t Term) During(startTime, endTime interface{}, optArgs ...DuringOpts) Term

+ func (t Term) Eq(args ...interface{}) Term

+ func (t Term) EqJoin(left, right interface{}, optArgs ...EqJoinOpts) Term

+ func (t Term) Exec(s QueryExecutor, optArgs ...ExecOpts) error

+ func (t Term) Field(args ...interface{}) Term

+ func (t Term) Fill() Term

+ func (t Term) Filter(f interface{}, optArgs ...FilterOpts) Term

+ func (t Term) Floor(args ...interface{}) Term

+ func (t Term) Fold(base, fn interface{}, optArgs ...FoldOpts) Term

+ func (t Term) ForEach(args ...interface{}) Term

+ func (t Term) Ge(args ...interface{}) Term

+ func (t Term) Get(args ...interface{}) Term

+ func (t Term) GetAll(keys ...interface{}) Term

+ func (t Term) GetAllByIndex(index interface{}, keys ...interface{}) Term

+ func (t Term) GetIntersecting(args interface{}, optArgs ...GetIntersectingOpts) Term

+ func (t Term) GetNearest(point interface{}, optArgs ...GetNearestOpts) Term

+ func (t Term) Grant(args ...interface{}) Term

+ func (t Term) Group(fieldOrFunctions ...interface{}) Term

+ func (t Term) GroupByIndex(index interface{}, fieldOrFunctions ...interface{}) Term

+ func (t Term) Gt(args ...interface{}) Term

+ func (t Term) HasFields(args ...interface{}) Term

+ func (t Term) Hours(args ...interface{}) Term

+ func (t Term) InTimezone(args ...interface{}) Term

+ func (t Term) Includes(args ...interface{}) Term

+ func (t Term) IndexCreate(name interface{}, optArgs ...IndexCreateOpts) Term

+ func (t Term) IndexCreateFunc(name, indexFunction interface{}, optArgs ...IndexCreateOpts) Term

+ func (t Term) IndexDrop(args ...interface{}) Term

+ func (t Term) IndexList(args ...interface{}) Term

+ func (t Term) IndexRename(oldName, newName interface{}, optArgs ...IndexRenameOpts) Term

+ func (t Term) IndexStatus(args ...interface{}) Term

+ func (t Term) IndexWait(args ...interface{}) Term

+ func (t Term) Info(args ...interface{}) Term

+ func (t Term) InnerJoin(args ...interface{}) Term

+ func (t Term) Insert(arg interface{}, optArgs ...InsertOpts) Term

+ func (t Term) InsertAt(args ...interface{}) Term

+ func (t Term) Intersects(args ...interface{}) Term

+ func (t Term) IsEmpty(args ...interface{}) Term

+ func (t Term) Keys(args ...interface{}) Term

+ func (t Term) Le(args ...interface{}) Term

+ func (t Term) Limit(args ...interface{}) Term

+ func (t Term) Lt(args ...interface{}) Term

+ func (t Term) Map(args ...interface{}) Term

+ func (t Term) Match(args ...interface{}) Term

+ func (t Term) Max(args ...interface{}) Term

+ func (t Term) MaxIndex(index interface{}, args ...interface{}) Term

+ func (t Term) Merge(args ...interface{}) Term

+ func (t Term) Min(args ...interface{}) Term

+ func (t Term) MinIndex(index interface{}, args ...interface{}) Term

+ func (t Term) Minutes(args ...interface{}) Term

+ func (t Term) MockAnything() Term

+ func (t Term) Mod(args ...interface{}) Term

+ func (t Term) Month(args ...interface{}) Term

+ func (t Term) Mul(args ...interface{}) Term

+ func (t Term) MultiGroup(fieldOrFunctions ...interface{}) Term

+ func (t Term) MultiGroupByIndex(index interface{}, fieldOrFunctions ...interface{}) Term

+ func (t Term) Ne(args ...interface{}) Term

+ func (t Term) Not(args ...interface{}) Term

+ func (t Term) Nth(args ...interface{}) Term

+ func (t Term) OffsetsOf(args ...interface{}) Term

+ func (t Term) OptArgs(args interface{}) Term

+ func (t Term) Or(args ...interface{}) Term

+ func (t Term) OrderBy(args ...interface{}) Term

+ func (t Term) OuterJoin(args ...interface{}) Term

+ func (t Term) Pluck(args ...interface{}) Term

+ func (t Term) PolygonSub(args ...interface{}) Term

+ func (t Term) Prepend(args ...interface{}) Term

+ func (t Term) ReadAll(dest interface{}, s QueryExecutor, optArgs ...RunOpts) error

+ func (t Term) ReadOne(dest interface{}, s QueryExecutor, optArgs ...RunOpts) error

+ func (t Term) Rebalance() Term

+ func (t Term) Reconfigure(optArgs ...ReconfigureOpts) Term

+ func (t Term) Reduce(args ...interface{}) Term

+ func (t Term) Replace(arg interface{}, optArgs ...ReplaceOpts) Term

+ func (t Term) Round(args ...interface{}) Term

+ func (t Term) Run(s QueryExecutor, optArgs ...RunOpts) (*Cursor, error)

+ func (t Term) RunWrite(s QueryExecutor, optArgs ...RunOpts) (WriteResponse, error)

+ func (t Term) Sample(args ...interface{}) Term

+ func (t Term) Seconds(args ...interface{}) Term

+ func (t Term) SetDifference(args ...interface{}) Term

+ func (t Term) SetInsert(args ...interface{}) Term

+ func (t Term) SetIntersection(args ...interface{}) Term

+ func (t Term) SetUnion(args ...interface{}) Term

+ func (t Term) Skip(args ...interface{}) Term

+ func (t Term) Slice(args ...interface{}) Term

+ func (t Term) SpliceAt(args ...interface{}) Term

+ func (t Term) Split(args ...interface{}) Term

+ func (t Term) Status() Term

+ func (t Term) String() string

+ func (t Term) Sub(args ...interface{}) Term

+ func (t Term) Sum(args ...interface{}) Term

+ func (t Term) Sync(args ...interface{}) Term

+ func (t Term) Table(name interface{}, optArgs ...TableOpts) Term

+ func (t Term) TableCreate(name interface{}, optArgs ...TableCreateOpts) Term

+ func (t Term) TableDrop(args ...interface{}) Term

+ func (t Term) TableList(args ...interface{}) Term

+ func (t Term) TimeOfDay(args ...interface{}) Term

+ func (t Term) Timezone(args ...interface{}) Term

+ func (t Term) ToEpochTime(args ...interface{}) Term

+ func (t Term) ToGeoJSON(args ...interface{}) Term

+ func (t Term) ToISO8601(args ...interface{}) Term

+ func (t Term) ToJSON() Term

+ func (t Term) TypeOf(args ...interface{}) Term

+ func (t Term) Ungroup(args ...interface{}) Term

+ func (t Term) Union(args ...interface{}) Term

+ func (t Term) UnionWithOpts(optArgs UnionOpts, args ...interface{}) Term

+ func (t Term) Upcase(args ...interface{}) Term

+ func (t Term) Update(arg interface{}, optArgs ...UpdateOpts) Term

+ func (t Term) Values(args ...interface{}) Term

+ func (t Term) Wait(optArgs ...WaitOpts) Term

+ func (t Term) WithFields(args ...interface{}) Term

+ func (t Term) Without(args ...interface{}) Term

+ func (t Term) Year(args ...interface{}) Term

+ func (t Term) Zip(args ...interface{}) Term

+ type UnionOpts struct

+ Interleave interface{}

+ type UpdateOpts struct

+ Conflict interface{}

+ Durability interface{}

+ NonAtomic interface{}

+ ReturnChanges interface{}

+ type WaitOpts struct

+ Timeout interface{}

+ WaitFor interface{}

+ type WriteResponse struct

+ Changes []ChangeResponse

+ ConfigChanges []ChangeResponse

+ Created int

+ DBsCreated int

+ DBsDropped int

+ Deleted int

+ Dropped int

+ Errors int

+ FirstError string

+ GeneratedKeys []string

+ Inserted int

+ Renamed int

+ Replaced int

+ Skipped int

+ TablesCreated int

+ TablesDropped int

+ Unchanged int

+ Updated int

Other modules containing this package

gopkg.in/gorethink/gorethink.v0

gopkg.in/gorethink/gorethink.v1

gopkg.in/gorethink/gorethink.v2

gopkg.in/gorethink/gorethink.v4