gorethink.v0: gopkg.in/dancannon/gorethink.v0 Index | Examples | Files | Directories

package gorethink

import "gopkg.in/dancannon/gorethink.v0"

Package gorethink implements a Go driver for RethinkDB

Current version: v0.7.2 (RethinkDB v2.0) For more in depth information on how to use RethinkDB check out the API docs at http://rethinkdb.com/api

Code:

package main

import (
    "fmt"
    "log"
    "os"

    r "github.com/dancannon/gorethink"
)

var session *r.Session
var url, authKey string

func init() {
    // Needed for wercker. By default url is "localhost:28015"
    url = os.Getenv("RETHINKDB_URL")
    if url == "" {
        url = "localhost:28015"
    }

    // Needed for running tests for RethinkDB with a non-empty authkey
    authKey = os.Getenv("RETHINKDB_AUTHKEY")
}

func main() {
    session, err := r.Connect(r.ConnectOpts{
        Address: url,
        AuthKey: authKey,
    })
    if err != nil {
        log.Fatalf("Error connecting to DB: %s", err)
    }

    res, err := r.Expr("Hello World").Run(session)
    if err != nil {
        log.Fatalln(err.Error())
    }

    var response string
    err = res.One(&response)
    if err != nil {
        log.Fatalln(err.Error())
    }

    fmt.Println(response)
}

Index

Examples

Package Files

buffer.go cluster.go connection.go connection_helper.go cursor.go doc.go errors.go gorethink.go host.go node.go pool.go pool_conn.go pseudotypes.go query.go query_admin.go query_aggregation.go query_control.go query_db.go query_geospatial.go query_join.go query_manipulation.go query_math.go query_select.go query_string.go query_table.go query_time.go query_transformation.go query_write.go session.go utils.go

Variables

var (
    ErrNoHosts              = errors.New("no hosts provided")
    ErrNoConnectionsStarted = errors.New("no connections were made when creating the session")
    ErrHostQueryFailed      = errors.New("unable to populate hosts")
    ErrInvalidNode          = errors.New("invalid node")
    ErrClusterClosed        = errors.New("cluster closed")

    ErrNoConnections    = errors.New("gorethink: no connections were available")
    ErrConnectionClosed = errors.New("gorethink: the connection is closed")

    ErrBusyBuffer = errors.New("Busy buffer")
)
var (
    // MinVal represents the smallest possible value RethinkDB can store
    MinVal = constructRootTerm("MinVal", p.Term_MINVAL, []interface{}{}, map[string]interface{}{})
    // MaxVal represents the smallest possible value RethinkDB can store
    MaxVal = constructRootTerm("MaxVal", p.Term_MAXVAL, []interface{}{}, map[string]interface{}{})
)
var (
    // Days
    Monday    = constructRootTerm("Monday", p.Term_MONDAY, []interface{}{}, map[string]interface{}{})
    Tuesday   = constructRootTerm("Tuesday", p.Term_TUESDAY, []interface{}{}, map[string]interface{}{})
    Wednesday = constructRootTerm("Wednesday", p.Term_WEDNESDAY, []interface{}{}, map[string]interface{}{})
    Thursday  = constructRootTerm("Thursday", p.Term_THURSDAY, []interface{}{}, map[string]interface{}{})
    Friday    = constructRootTerm("Friday", p.Term_FRIDAY, []interface{}{}, map[string]interface{}{})
    Saturday  = constructRootTerm("Saturday", p.Term_SATURDAY, []interface{}{}, map[string]interface{}{})
    Sunday    = constructRootTerm("Sunday", p.Term_SUNDAY, []interface{}{}, map[string]interface{}{})

    // Months
    January   = constructRootTerm("January", p.Term_JANUARY, []interface{}{}, map[string]interface{}{})
    February  = constructRootTerm("February", p.Term_FEBRUARY, []interface{}{}, map[string]interface{}{})
    March     = constructRootTerm("March", p.Term_MARCH, []interface{}{}, map[string]interface{}{})
    April     = constructRootTerm("April", p.Term_APRIL, []interface{}{}, map[string]interface{}{})
    May       = constructRootTerm("May", p.Term_MAY, []interface{}{}, map[string]interface{}{})
    June      = constructRootTerm("June", p.Term_JUNE, []interface{}{}, map[string]interface{}{})
    July      = constructRootTerm("July", p.Term_JULY, []interface{}{}, map[string]interface{}{})
    August    = constructRootTerm("August", p.Term_AUGUST, []interface{}{}, map[string]interface{}{})
    September = constructRootTerm("September", p.Term_SEPTEMBER, []interface{}{}, map[string]interface{}{})
    October   = constructRootTerm("October", p.Term_OCTOBER, []interface{}{}, map[string]interface{}{})
    November  = constructRootTerm("November", p.Term_NOVEMBER, []interface{}{}, map[string]interface{}{})
    December  = constructRootTerm("December", p.Term_DECEMBER, []interface{}{}, map[string]interface{}{})
)
var ErrBadConn = errors.New("gorethink: bad connection")

ErrBadConn should be returned by a connection operation to signal to the pool that a driver.Conn is in a bad state (such as the server having earlier closed the connection) and the pool should retry on a new connection.

To prevent duplicate operations, ErrBadConn should NOT be returned if there's a possibility that the database server might have performed the operation. Even if the server sends back an error, you shouldn't return ErrBadConn.

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

Error constants

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

Returns the currently visited document.

func SetVerbose Uses

func SetVerbose(verbose bool)

SetVerbose allows the driver logging level to be set. If true is passed then the log level is set to Debug otherwise it defaults to Info.

type BetweenOpts Uses

type BetweenOpts struct {
    Index      interface{} `gorethink:"index,omitempty"`
    LeftBound  interface{} `gorethink:"left_bound,omitempty"`
    RightBound interface{} `gorethink:"right_bound,omitempty"`
}

type ChangesOpts Uses

type ChangesOpts struct {
    Squash        interface{} `gorethink:"squash,omitempty"`
    IncludeStates interface{} `gorethink:"include_states,omitempty"`
}

type CircleOpts Uses

type CircleOpts struct {
    NumVertices interface{} `gorethink:"num_vertices,omitempty"`
    GeoSystem   interface{} `gorethink:"geo_system,omitempty"`
    Unit        interface{} `gorethink:"unit,omitempty"`
    Fill        interface{} `gorethink:"fill,omitempty"`
}

CircleOpts describes the optional arguments for a Circle operation

type CloseOpts Uses

type CloseOpts struct {
    NoReplyWait bool `gorethink:"noreplyWait,omitempty"`
}

CloseOpts allows calls to the Close function to be configured.

type Cluster Uses

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

A Cluster represents a connection to a RethinkDB cluster, a cluster is created by the Session and should rarely be created manually.

The cluster keeps track of all nodes in the cluster and if requested can listen for cluster changes and start tracking a new node if one appears. Currently nodes are removed from the pool if they become unhealthy (100 failed queries). This should hopefully soon be replaced by a backoff system.

func NewCluster Uses

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

NewCluster creates a new cluster by connecting to the given hosts.

func (*Cluster) AddSeeds Uses

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

AddSeeds adds new seed hosts to the cluster.

func (*Cluster) Close Uses

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

Close closes the cluster

func (*Cluster) Exec Uses

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

Exec executes a ReQL query using the cluster to connect to the database

func (*Cluster) GetHealthyNodes Uses

func (c *Cluster) GetHealthyNodes() []*Node

GetHealthyNodes returns a list of all healthy nodes in the cluster

func (*Cluster) GetNodes Uses

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

GetNodes returns a list of all nodes in the cluster

func (*Cluster) GetRandomNode Uses

func (c *Cluster) GetRandomNode() (*Node, error)

GetRandomNode returns a random node on the cluster TODO(dancannon) replace with hostpool

func (*Cluster) IsConnected Uses

func (c *Cluster) IsConnected() bool

IsConnected returns true if cluster has nodes and is not already closed.

func (*Cluster) Query Uses

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

Query executes a ReQL query using the cluster to connect to the database

func (*Cluster) SetMaxIdleConns Uses

func (c *Cluster) SetMaxIdleConns(n int)

SetMaxIdleConns sets the maximum number of connections in the idle connection pool.

func (*Cluster) SetMaxOpenConns Uses

func (c *Cluster) SetMaxOpenConns(n int)

SetMaxOpenConns sets the maximum number of open connections to the database.

type ConnectOpts Uses

type ConnectOpts struct {
    Address   string        `gorethink:"address,omitempty"`
    Addresses []string      `gorethink:"addresses,omitempty"`
    Database  string        `gorethink:"database,omitempty"`
    AuthKey   string        `gorethink:"authkey,omitempty"`
    Timeout   time.Duration `gorethink:"timeout,omitempty"`
    TLSConfig *tls.Config   `gorethink:"tlsconfig,omitempty"`

    MaxIdle int `gorethink:"max_idle,omitempty"`
    MaxOpen int `gorethink:"max_open,omitempty"`

    // DiscoverHosts is used to enable host discovery, when true the driver
    // will attempt to discover any new nodes added to the cluster and then
    // start sending queries to these new nodes.
    DiscoverHosts bool `gorethink:"discover_hosts,omitempty"`
    // NodeRefreshInterval is used to determine how often the driver should
    // refresh the status of a node.
    NodeRefreshInterval time.Duration `gorethink:"node_refresh_interval,omitempty"`
}

ConnectOpts is used to specify optional arguments when connecting to a cluster.

type Connection Uses

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

Connection is a connection to a rethinkdb database. Connection is not thread safe and should only be accessed be a single goroutine

func NewConnection Uses

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

NewConnection creates a new connection to the database server

func (*Connection) Close Uses

func (c *Connection) Close() error

Close closes the underlying net.Conn

func (*Connection) Query Uses

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

type Cursor Uses

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

Cursor is the result of a query. Its cursor starts before the first row of the result set. A Cursor is not thread safe and should only be accessed by a single goroutine at any given time. Use Next to advance through the rows:

cursor, err := query.Run(session)
...
defer cursor.Close()

var response interface{}
for cursor.Next(&response) {
    ...
}
err = cursor.Err() // get any error encountered during iteration
...

func (*Cursor) All Uses

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

All retrieves all documents from the result set into the provided slice and closes the cursor.

The result argument must necessarily be the address for a slice. The slice may be nil or previously allocated.

Also note that you are able to reuse the same variable multiple times as `All` zeroes the value before scanning in the result. It also attempts to reuse the existing slice without allocating any more space by either resizing or returning a selection of the slice if necessary.

func (*Cursor) Close Uses

func (c *Cursor) Close() error

Close closes the cursor, preventing further enumeration. If the end is encountered, the cursor is closed automatically. Close is idempotent.

func (*Cursor) Err Uses

func (c *Cursor) Err() error

Err returns nil if no errors happened during iteration, or the actual error otherwise.

func (*Cursor) IsNil Uses

func (c *Cursor) IsNil() bool

IsNil tests if the current row is nil.

func (*Cursor) Listen Uses

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

Listen listens for rows from the database and sends the result onto the given channel. The type that the row is scanned into is determined by the element type of the channel.

Also note that this function returns immediately.

cursor, err := r.Expr([]int{1,2,3}).Run(session)
if err != nil {
    panic(err)
}

ch := make(chan int)
cursor.Listen(ch)
<- ch // 1
<- ch // 2
<- ch // 3

func (*Cursor) Next Uses

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

Next retrieves the next document from the result set, blocking if necessary. This method will also automatically retrieve another batch of documents from the server when the current one is exhausted, or before that in background if possible.

Next returns true if a document was successfully unmarshalled onto result, and false at the end of the result set or if an error happened. When Next returns false, the Err method should be called to verify if there was an error during iteration.

Also note that you are able to reuse the same variable multiple times as `Next` zeroes the value before scanning in the result.

func (*Cursor) One Uses

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

One retrieves a single document from the result set into the provided slice and closes the cursor.

Also note that you are able to reuse the same variable multiple times as `One` zeroes the value before scanning in the result.

func (*Cursor) Profile Uses

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

Profile returns the information returned from the query profiler.

func (*Cursor) Type Uses

func (c *Cursor) Type() string

Type returns the cursor type (by default "Cursor")

type DeleteOpts Uses

type DeleteOpts struct {
    Durability    interface{} `gorethink:"durability,omitempty"`
    ReturnChanges interface{} `gorethink:"return_changes,omitempty"`
}

type DistanceOpts Uses

type DistanceOpts struct {
    GeoSystem interface{} `gorethink:"geo_system,omitempty"`
    Unit      interface{} `gorethink:"unit,omitempty"`
}

DistanceOpts describes the optional arguments for a Distance operation

type DistinctOpts Uses

type DistinctOpts struct {
    Index interface{} `gorethink:"index,omitempty"`
}

type DuringOpts Uses

type DuringOpts struct {
    LeftBound  interface{} `gorethink:"left_bound,omitempty"`
    RightBound interface{} `gorethink:"right_bound,omitempty"`
}

type EqJoinOpts Uses

type EqJoinOpts struct {
    Index interface{} `gorethink:"index,omitempty"`
}

type ExecOpts Uses

type ExecOpts struct {
    Db             interface{} `gorethink:"db,omitempty"`
    Profile        interface{} `gorethink:"profile,omitempty"`
    UseOutdated    interface{} `gorethink:"use_outdated,omitempty"`
    ArrayLimit     interface{} `gorethink:"array_limit,omitempty"`
    TimeFormat     interface{} `gorethink:"time_format,omitempty"`
    GroupFormat    interface{} `gorethink:"group_format,omitempty"`
    BinaryFormat   interface{} `gorethink:"binary_format,omitempty"`
    GeometryFormat interface{} `gorethink:"geometry_format,omitempty"`

    MinBatchRows              interface{} `gorethink:"min_batch_rows,omitempty"`
    MaxBatchRows              interface{} `gorethink:"max_batch_rows,omitempty"`
    MaxBatchBytes             interface{} `gorethink:"max_batch_bytes,omitempty"`
    MaxBatchSeconds           interface{} `gorethink:"max_batch_seconds,omitempty"`
    FirstBatchScaledownFactor interface{} `gorethink:"first_batch_scaledown_factor,omitempty"`

    NoReply interface{} `gorethink:"noreply,omitempty"`
}

ExecOpts inherits its options from RunOpts, the only difference is the addition of the NoReply field.

When NoReply is true it causes the driver not to wait to receive the result and return immediately.

type FilterOpts Uses

type FilterOpts struct {
    Default interface{} `gorethink:"default,omitempty"`
}

type GetIntersectingOpts Uses

type GetIntersectingOpts struct {
    Index interface{} `gorethink:"index,omitempty"`
}

GetIntersectingOpts describes the optional arguments for a GetIntersecting operation

type GetNearestOpts Uses

type GetNearestOpts struct {
    Index      interface{} `gorethink:"index,omitempty"`
    MaxResults interface{} `gorethink:"max_results,omitempty"`
    MaxDist    interface{} `gorethink:"max_dist,omitempty"`
    Unit       interface{} `gorethink:"unit,omitempty"`
    GeoSystem  interface{} `gorethink:"geo_system,omitempty"`
}

GetIntersectingOpts describes the optional arguments for a GetIntersecting operation

type Host Uses

type Host struct {
    Name string
    Port int
}

Host name and port of server

func NewHost Uses

func NewHost(name string, port int) Host

NewHost create a new Host

func (Host) String Uses

func (h Host) String() string

Returns host address (name:port)

type HttpOpts Uses

type HttpOpts struct {
    // General Options
    Timeout      interface{} `gorethink:"timeout,omitempty"`
    Reattempts   interface{} `gorethink:"reattempts,omitempty"`
    Redirects    interface{} `gorethink:"redirect,omitempty"`
    Verify       interface{} `gorethink:"verify,omitempty"`
    ResultFormat interface{} `gorethink:"resul_format,omitempty"`

    // Request Options
    Method interface{} `gorethink:"method,omitempty"`
    Auth   interface{} `gorethink:"auth,omitempty"`
    Params interface{} `gorethink:"params,omitempty"`
    Header interface{} `gorethink:"header,omitempty"`
    Data   interface{} `gorethink:"data,omitempty"`

    // Pagination
    Page      interface{} `gorethink:"page,omitempty"`
    PageLimit interface{} `gorethink:"page_limit,omitempty"`
}

type ISO8601Opts Uses

type ISO8601Opts struct {
    DefaultTimezone interface{} `gorethink:"default_timezone,omitempty"`
}

type IndexCreateOpts Uses

type IndexCreateOpts struct {
    Multi interface{} `gorethink:"multi,omitempty"`
    Geo   interface{} `gorethink:"geo,omitempty"`
}

type IndexRenameOpts Uses

type IndexRenameOpts struct {
    Overwrite interface{} `gorethink:"overwrite,omitempty"`
}

type InsertOpts Uses

type InsertOpts struct {
    Durability    interface{} `gorethink:"durability,omitempty"`
    ReturnChanges interface{} `gorethink:"return_changes,omitempty"`
    CacheSize     interface{} `gorethink:"cache_size,omitempty"`
    Conflict      interface{} `gorethink:"conflict,omitempty"`
}

type Node Uses

type Node struct {
    ID   string
    Host Host
    // contains filtered or unexported fields
}

Node represents a database server in the cluster

func (*Node) Close Uses

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

Close closes the session

func (*Node) Closed Uses

func (n *Node) Closed() bool

Closed returns true if the node is closed

func (*Node) DecrementHealth Uses

func (n *Node) DecrementHealth()

DecrementHealth decreases the nodes health by 1 (the nodes health starts at 100)

func (*Node) Exec Uses

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

Exec executes a ReQL query using this nodes connection pool.

func (*Node) IsHealthy Uses

func (n *Node) IsHealthy() bool

IsHealthy checks the nodes health by ensuring that the health counter is above 0.

func (*Node) NoReplyWait Uses

func (n *Node) NoReplyWait() error

NoReplyWait ensures that previous queries with the noreply flag have been processed by the server. Note that this guarantee only applies to queries run on the given connection

func (*Node) Query Uses

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

Query executes a ReQL query using this nodes connection pool.

func (*Node) Refresh Uses

func (n *Node) Refresh()

Refresh attempts to connect to the node and check that it is still connected to the cluster.

If an error occurred or the node is no longer connected then the nodes health is decrease, if there were no issues then the node is marked as being healthy.

func (*Node) ResetHealth Uses

func (n *Node) ResetHealth()

ResetHealth sets the nodes health back to 100 (fully healthy)

func (*Node) SetMaxIdleConns Uses

func (n *Node) SetMaxIdleConns(idleConns int)

SetMaxIdleConns sets the maximum number of connections in the idle connection pool.

func (*Node) SetMaxOpenConns Uses

func (n *Node) SetMaxOpenConns(openConns int)

SetMaxOpenConns sets the maximum number of open connections to the database.

type OptArgs Uses

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

type OrderByOpts Uses

type OrderByOpts struct {
    Index interface{} `gorethink:"index,omitempty"`
}

type Pool Uses

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

A Pool is used to store a pool of connections to a single RethinkDB server

func NewPool Uses

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

NewPool creates a new connection pool for the given host

func (*Pool) Close Uses

func (p *Pool) Close() error

Close closes the database, releasing any open resources.

It is rare to Close a Pool, as the Pool handle is meant to be long-lived and shared between many goroutines.

func (*Pool) Exec Uses

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

Exec executes a query without waiting for any response.

func (*Pool) Ping Uses

func (p *Pool) Ping() error

Ping verifies a connection to the database is still alive, establishing a connection if necessary.

func (*Pool) Query Uses

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

Query executes a query and waits for the response

func (*Pool) SetMaxIdleConns Uses

func (p *Pool) SetMaxIdleConns(n int)

SetMaxIdleConns sets the maximum number of connections in the idle connection pool.

If MaxOpenConns is greater than 0 but less than the new MaxIdleConns then the new MaxIdleConns will be reduced to match the MaxOpenConns limit

If n <= 0, no idle connections are retained.

func (*Pool) SetMaxOpenConns Uses

func (p *Pool) SetMaxOpenConns(n int)

SetMaxOpenConns sets the maximum number of open connections to the database.

If MaxIdleConns is greater than 0 and the new MaxOpenConns is less than MaxIdleConns, then MaxIdleConns will be reduced to match the new MaxOpenConns limit

If n <= 0, then there is no limit on the number of open connections. The default is 0 (unlimited).

type Query Uses

type Query struct {
    Type  p.Query_QueryType
    Token int64
    Term  *Term
    Opts  map[string]interface{}
}

type RandomOpts Uses

type RandomOpts struct {
    Float interface{} `gorethink:"float,omitempty"`
}

type ReconfigureOpts Uses

type ReconfigureOpts struct {
    Shards     interface{} `gorethink:"shards,omitempty"`
    Replicas   interface{} `gorethink:"replicas,omitempty"`
    PrimaryTag interface{} `gorethink:"primary_replicas_tag,omitempty"`
    DryRun     interface{} `gorethink:"dry_run,omitempty"`
}

type ReplaceOpts Uses

type ReplaceOpts struct {
    Durability    interface{} `gorethink:"durability,omitempty"`
    ReturnChanges interface{} `gorethink:"return_changes,omitempty"`
    NotAtomic     interface{} `gorethink:"non_atomic,omitempty"`
}

type Response Uses

type Response struct {
    Token     int64
    Type      p.Response_ResponseType   `json:"t"`
    Notes     []p.Response_ResponseNote `json:"n"`
    Responses []json.RawMessage         `json:"r"`
    Backtrace []interface{}             `json:"b"`
    Profile   interface{}               `json:"p"`
}

type RqlClientError Uses

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

func (RqlClientError) Error Uses

func (e RqlClientError) Error() string

func (RqlClientError) String Uses

func (e RqlClientError) String() string

type RqlCompileError Uses

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

func (RqlCompileError) Error Uses

func (e RqlCompileError) Error() string

func (RqlCompileError) String Uses

func (e RqlCompileError) String() string

type RqlConnectionError Uses

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

func (RqlConnectionError) Error Uses

func (e RqlConnectionError) Error() string

func (RqlConnectionError) String Uses

func (e RqlConnectionError) String() string

type RqlDriverError Uses

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

func (RqlDriverError) Error Uses

func (e RqlDriverError) Error() string

func (RqlDriverError) String Uses

func (e RqlDriverError) String() string

type RqlRuntimeError Uses

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

func (RqlRuntimeError) Error Uses

func (e RqlRuntimeError) Error() string

func (RqlRuntimeError) String Uses

func (e RqlRuntimeError) String() string

type RunOpts Uses

type RunOpts struct {
    Db             interface{} `gorethink:"db,omitempty"`
    Profile        interface{} `gorethink:"profile,omitempty"`
    UseOutdated    interface{} `gorethink:"use_outdated,omitempty"`
    ArrayLimit     interface{} `gorethink:"array_limit,omitempty"`
    TimeFormat     interface{} `gorethink:"time_format,omitempty"`
    GroupFormat    interface{} `gorethink:"group_format,omitempty"`
    BinaryFormat   interface{} `gorethink:"binary_format,omitempty"`
    GeometryFormat interface{} `gorethink:"geometry_format,omitempty"`

    MinBatchRows              interface{} `gorethink:"min_batch_rows,omitempty"`
    MaxBatchRows              interface{} `gorethink:"max_batch_rows,omitempty"`
    MaxBatchBytes             interface{} `gorethink:"max_batch_bytes,omitempty"`
    MaxBatchSeconds           interface{} `gorethink:"max_batch_seconds,omitempty"`
    FirstBatchScaledownFactor interface{} `gorethink:"first_batch_scaledown_factor,omitempty"`
}

type Session Uses

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

A Session represents a connection to a RethinkDB cluster and should be used when executing queries.

func Connect Uses

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

Connect creates a new database session. To view the available connection options see ConnectOpts.

By default maxIdle and maxOpen are set to 1: passing values greater than the default (e.g. MaxIdle: "10", MaxOpen: "20") will provide a pool of re-usable connections.

Basic connection example:

session, err := r.Connect(r.ConnectOpts{
	Host: "localhost:28015",
	Database: "test",
	AuthKey:  "14daak1cad13dj",
})

Cluster connection example:

session, err := r.Connect(r.ConnectOpts{
	Hosts: []string{"localhost:28015", "localhost:28016"},
	Database: "test",
	AuthKey:  "14daak1cad13dj",
})

func (*Session) Close Uses

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

Close closes the session

func (*Session) Exec Uses

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

Exec executes a ReQL query using the session to connect to the database

func (*Session) NoReplyWait Uses

func (s *Session) NoReplyWait() error

NoReplyWait ensures that previous queries with the noreply flag have been processed by the server. Note that this guarantee only applies to queries run on the given connection

func (*Session) Query Uses

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

Query executes a ReQL query using the session to connect to the database

func (*Session) Reconnect Uses

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

Reconnect closes and re-opens a session.

func (*Session) SetHosts Uses

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

SetHosts resets the hosts used when connecting to the RethinkDB cluster

func (*Session) SetMaxIdleConns Uses

func (s *Session) SetMaxIdleConns(n int)

SetMaxIdleConns sets the maximum number of connections in the idle connection pool.

func (*Session) SetMaxOpenConns Uses

func (s *Session) SetMaxOpenConns(n int)

SetMaxOpenConns sets the maximum number of open connections to the database.

func (*Session) Use Uses

func (s *Session) Use(database string)

Use changes the default database used

type SliceOpts Uses

type SliceOpts struct {
    LeftBound  interface{} `gorethink:"left_bound,omitempty"`
    RightBound interface{} `gorethink:"right_bound,omitempty"`
}

type TableCreateOpts Uses

type TableCreateOpts struct {
    PrimaryKey interface{} `gorethink:"primary_key,omitempty"`
    Durability interface{} `gorethink:"durability,omitempty"`
    CacheSize  interface{} `gorethink:"cache_size,omitempty"`
    DataCenter interface{} `gorethink:"datacenter,omitempty"`
}

type TableOpts Uses

type TableOpts struct {
    UseOutdated      interface{} `gorethink:"use_outdated,omitempty"`
    IdentifierFormat interface{} `gorethink:"identifier_format,omitempty"`
}

type Term Uses

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

func Add Uses

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

Add sums two numbers or concatenates two arrays.

func And Uses

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

And performs a logical and on two values.

func Args Uses

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

Args is a special term usd to splice an array of arguments into another term. This is useful when you want to call a varadic term such as GetAll with a set of arguments provided at runtime.

func Asc Uses

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

func Binary Uses

func Binary(data interface{}) Term

Binary encapsulates binary data within a query.

func Branch Uses

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

Evaluate one of two control paths based on the value of an expression. branch is effectively an if renamed due to language constraints.

The type of the result is determined by the type of the branch that gets executed.

func Circle Uses

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

Circle constructs a circular line or polygon. A circle in RethinkDB is a polygon or line approximating a circle of a given radius around a given center, consisting of a specified number of vertices (default 32).

func Db Uses

func Db(args ...interface{}) Term

Reference a database.

func DbCreate Uses

func DbCreate(args ...interface{}) Term

Create a database. A RethinkDB database is a collection of tables, similar to relational databases.

If successful, the operation returns an object: {created: 1}. If a database with the same name already exists the operation throws RqlRuntimeError.

Note: that you can only use alphanumeric characters and underscores for the database name.

func DbDrop Uses

func DbDrop(args ...interface{}) Term

Drop a database. The database, all its tables, and corresponding data will be deleted.

If successful, the operation returns the object {dropped: 1}. If the specified database doesn't exist a RqlRuntimeError is thrown.

func DbList Uses

func DbList(args ...interface{}) Term

List all database names in the system.

func Desc Uses

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

func Distance Uses

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

Distance calculates the Haversine distance between two points. At least one of the geometry objects specified must be a point.

func Div Uses

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

Div divides two numbers.

func Do Uses

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

Evaluate the expr in the context of one or more value bindings. The type of the result is the type of the value returned from expr.

func EpochTime Uses

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

Returns a time object based on seconds since epoch

func Eq Uses

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

Eq returns true if two values are equal.

func Error Uses

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

Throw a runtime error. If called with no arguments inside the second argument to `default`, re-throw the current error.

func Expr Uses

func Expr(val interface{}) Term

Expr converts any value to an expression. Internally it uses the `json` module to convert any literals, so any type annotations or methods understood by that module can be used. If the value cannot be converted, an error is returned at query .Run(session) time.

If you want to call expression methods on an object that is not yet an expression, this is the function you want.

func Ge Uses

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

Ge returns true if the first value is greater than or equal to the second.

func Geojson Uses

func Geojson(args ...interface{}) Term

Geojson converts a GeoJSON object to a ReQL geometry object.

func Gt Uses

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

Gt returns true if the first value is greater than the second.

func Http Uses

func Http(url interface{}, optArgs ...HttpOpts) Term

Parse a JSON string on the server.

func ISO8601 Uses

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

Returns a time object based on an ISO8601 formatted date-time string

Optional arguments (see http://www.rethinkdb.com/api/#js:dates_and_times-iso8601 for more information): "default_timezone" (string)

func Js Uses

func Js(jssrc interface{}) Term

Create a JavaScript expression.

func Json Uses

func Json(args ...interface{}) Term

Parse a JSON string on the server.

func Le Uses

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

Le returns true if the first value is less than or equal to the second.

func Line Uses

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

Line constructs a geometry object of type Line. The line can be specified in one of two ways:

- Two or more two-item arrays, specifying longitude and latitude numbers of
 the line's vertices;
- Two or more Point objects specifying the line's vertices.

func Literal Uses

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

func Lt Uses

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

Lt returns true if the first value is less than the second.

func Map Uses

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

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 Mod Uses

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

Mod divides two numbers and returns the remainder.

func Mul Uses

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

Mul multiplies two numbers.

func Ne Uses

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

Ne returns true if two values are not equal.

func Not Uses

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

Not performs a logical not on a value.

func Now Uses

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

Returns a time object representing the current time in UTC

func Object Uses

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

Creates an object from a list of key-value pairs, where the keys must be strings.

func Or Uses

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

Or performs a logical or on two values.

func Point Uses

func Point(lon, lat interface{}) Term

Point constructs a geometry object of type Point. The point is specified by two floating point numbers, the longitude (−180 to 180) and latitude (−90 to 90) of the point on a perfect sphere.

func Polygon Uses

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

Polygon constructs a geometry object of type Polygon. The Polygon can be specified in one of two ways:

- Three or more two-item arrays, specifying longitude and latitude numbers of the polygon's vertices;
- Three or more Point objects specifying the polygon's vertices.

func Range Uses

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

Range generates a stream of sequential integers in a specified range. It accepts 0, 1, or 2 arguments, all of which should be numbers.

func Sub Uses

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

Sub subtracts two numbers.

func Table Uses

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

Select all documents in a table. This command can be chained with other commands to do further processing on the data.

Optional arguments (see http://www.rethinkdb.com/api/#js:selecting_data-table for more information): "use_outdated" (boolean - defaults to false)

func Time Uses

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

Create a time object for a specific time

func UUID Uses

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

UUID returns a UUID (universally unique identifier), a string that can be used as a unique ID.

func Wait Uses

func Wait(optArgs ...WaitOpts) Term

Wait for a table or all the tables in a database to be ready. A table may be temporarily unavailable after creation, rebalancing or reconfiguring. The wait command blocks until the given table (or database) is fully up to date.

func (Term) Add Uses

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

Add sums two numbers or concatenates two arrays.

func (Term) And Uses

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

And performs a logical and on two values.

func (Term) Append Uses

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

Append a value to an array.

func (Term) AtIndex Uses

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

AtIndex gets a single field from an object or the nth element from a sequence.

func (Term) Avg Uses

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

Averages all the elements of a sequence. If called with a field name, averages all the values of that field in the sequence, skipping elements of the sequence that lack that field. If called with a function, calls that function on every element of the sequence and averages the results, skipping elements of the sequence where that function returns null or a non-existence error.

func (Term) Between Uses

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

Get all documents between two keys. Accepts three optional arguments: `index`, `left_bound`, and `right_bound`. If `index` is set to the name of a secondary index, `between` will return all documents where that index's value is in the specified range (it uses the primary key by default). `left_bound` or `right_bound` may be set to `open` or `closed` to indicate whether or not to include that endpoint of the range (by default, `left_bound` is closed and `right_bound` is open).

func (Term) ChangeAt Uses

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

Change a value in an array at a given index. Returns the modified array.

func (Term) Changes Uses

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

Takes a table and returns an infinite stream of objects representing changes to that table. Whenever an insert, delete, update or replace is performed on the table, an object of the form {old_val:..., new_val:...} will be added to the stream. For an insert, old_val will be null, and for a delete, new_val will be null.

func (Term) CoerceTo Uses

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

Converts a value of one type into another.

You can convert: a selection, sequence, or object into an ARRAY, an array of pairs into an OBJECT, and any DATUM into a STRING.

func (Term) ConcatMap Uses

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

Flattens a sequence of arrays returned by the mapping function into a single sequence.

func (Term) Config Uses

func (t Term) Config() Term

Config can be used to read and/or update the configurations for individual tables or databases.

func (Term) Contains Uses

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

Returns whether or not a sequence contains all the specified values, or if functions are provided instead, returns whether or not a sequence contains values matching all the specified functions.

func (Term) Count Uses

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

Count the number of elements in the sequence. With a single argument, count the number of elements equal to it. If the argument is a function, it is equivalent to calling filter before count.

func (Term) Date Uses

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

Return a new time object only based on the day, month and year (ie. the same day at 00:00).

func (Term) Day Uses

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

Return the day of a time object as a number between 1 and 31.

func (Term) DayOfWeek Uses

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

Return the day of week of a time object as a number between 1 and 7 (following ISO 8601 standard). For your convenience, the terms r.Monday(), r.Tuesday() etc. are defined and map to the appropriate integer.

func (Term) DayOfYear Uses

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

Return the day of the year of a time object as a number between 1 and 366 (following ISO 8601 standard).

func (Term) Default Uses

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

Handle non-existence errors. Tries to evaluate and return its first argument. If an error related to the absence of a value is thrown in the process, or if its first argument returns null, returns its second argument. (Alternatively, the second argument may be a function which will be called with either the text of the non-existence error or null.)

func (Term) Delete Uses

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

Delete one or more documents from a table. The optional argument return_changes will return the old value of the row you're deleting when set to true (only valid for single-row deletes). The optional argument durability with value 'hard' or 'soft' will override the table or query's default durability setting.

func (Term) DeleteAt Uses

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

Remove an element from an array at a given index. Returns the modified array.

func (Term) Difference Uses

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

Remove the elements of one array from another array.

func (Term) Distance Uses

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

Distance calculates the Haversine distance between two points. At least one of the geometry objects specified must be a point.

func (Term) Distinct Uses

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

Remove duplicate elements from the sequence.

func (Term) Div Uses

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

Div divides two numbers.

func (Term) Do Uses

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

Evaluate the expr in the context of one or more value bindings. The type of the result is the type of the value returned from expr.

func (Term) Downcase Uses

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

Downcases a string.

func (Term) During Uses

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

Returns true if a time is between two other times (by default, inclusive for the start, exclusive for the end).

Optional arguments (see http://www.rethinkdb.com/api/#js:dates_and_times-during for more information): "left_bound" and "right_bound" ("open" for exclusive or "closed" for inclusive)

func (Term) Eq Uses

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

Eq returns true if two values are equal.

func (Term) EqJoin Uses

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

An efficient join that looks up elements in the right table by primary key.

Optional arguments: "index" (string - name of the index to use in right table instead of the primary key)

func (Term) Exec Uses

func (t Term) Exec(s *Session, optArgs ...ExecOpts) error

Exec runs the query but does not return the result. Exec will still wait for the response to be received unless the NoReply field is true.

err := r.Db("database").Table("table").Insert(doc).Exec(sess, r.ExecOpts{
	NoReply: true,
})

func (Term) Field Uses

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

Get a single field from an object. If called on a sequence, gets that field from every object in the sequence, skipping objects that lack it.

func (Term) Fill Uses

func (t Term) Fill() Term

Fill converts a Line object into a Polygon object. If the last point does not specify the same coordinates as the first point, polygon will close the polygon by connecting them

func (Term) Filter Uses

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

Get all the documents for which the given predicate is true.

Filter can be called on a sequence, selection, or a field containing an array of elements. The return type is the same as the type on which the function was called on. The body of every filter is wrapped in an implicit `.default(false)`, and the default value can be changed by passing the optional argument `default`. Setting this optional argument to `r.error()` will cause any non-existence errors to abort the filter.

func (Term) ForEach Uses

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

ForEach loops over a sequence, evaluating the given write query for each element.

It takes one argument of type `func (r.Term) interface{}`, for example clones a table:

r.Table("table").ForEach(func (row r.Term) interface{} {
    return r.Table("new_table").Insert(row)
})

func (Term) Ge Uses

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

Ge returns true if the first value is greater than or equal to the second.

func (Term) Get Uses

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

Get a document by primary key. If nothing was found, RethinkDB will return a nil value.

func (Term) GetAll Uses

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

Get all documents where the given value matches the value of the primary index.

func (Term) GetAllByIndex Uses

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

Get all documents where the given value matches the value of the requested index.

func (Term) GetIntersecting Uses

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

GetIntersecting gets all documents where the given geometry object intersects the geometry object of the requested geospatial index.

func (Term) GetNearest Uses

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

GetNearest gets all documents where the specified geospatial index is within a certain distance of the specified point (default 100 kilometers).

func (Term) Group Uses

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

Takes a stream and partitions it into multiple groups based on the fields or functions provided. Commands chained after group will be

called on each of these grouped sub-streams, producing grouped data.

func (Term) GroupByIndex Uses

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

Takes a stream and partitions it into multiple groups based on the fields or functions provided. Commands chained after group will be called on each of these grouped sub-streams, producing grouped data.

func (Term) Gt Uses

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

Gt returns true if the first value is greater than the second.

func (Term) HasFields Uses

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

Test if an object has all of the specified fields. An object has a field if it has the specified key and that key maps to a non-null value. For instance,

the object `{'a':1,'b':2,'c':null}` has the fields `a` and `b`.

func (Term) Hours Uses

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

Return the hour in a time object as a number between 0 and 23.

func (Term) InTimezone Uses

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

Returns a new time object with a different time zone. While the time stays the same, the results returned by methods such as hours() will change since they take the timezone into account. The timezone argument has to be of the ISO 8601 format.

func (Term) Includes Uses

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

Includes tests whether a geometry object is completely contained within another. When applied to a sequence of geometry objects, includes acts as a filter, returning a sequence of objects from the sequence that include the argument.

func (Term) IndexCreate Uses

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

Create a new secondary index on this table.

A multi index can be created by passing an optional multi argument. Multi indexes

functions should return arrays and allow you to query based on whether a value
is present in the returned array. The example would allow us to get heroes who
possess a specific ability (the field 'abilities' is an array).

func (Term) IndexCreateFunc Uses

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

Create a new secondary index on this table based on the value of the function passed.

A compound index can be created by returning an array of values to use as the secondary index key.

func (Term) IndexDrop Uses

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

Delete a previously created secondary index of this table.

func (Term) IndexList Uses

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

List all the secondary indexes of this table.

func (Term) IndexRename Uses

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

IndexRename renames an existing secondary index on a table. If the optional argument overwrite is specified as True, a previously existing index with the new name will be deleted and the index will be renamed. If overwrite is False (the default) an error will be raised if the new index name already exists.

func (Term) IndexStatus Uses

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

Get the status of the specified indexes on this table, or the status of all indexes on this table if no indexes are specified.

func (Term) IndexWait Uses

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

Wait for the specified indexes on this table to be ready, or for all indexes on this table to be ready if no indexes are specified.

func (Term) Info Uses

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

Get information about a RQL value.

func (Term) InnerJoin Uses

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

Returns the inner product of two sequences (e.g. a table, a filter result) filtered by the predicate. The query compares each row of the left sequence with each row of the right sequence to find all pairs of rows which satisfy the predicate. When the predicate is satisfied, each matched pair of rows of both sequences are combined into a result row.

func (Term) Insert Uses

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

Insert JSON documents into a table. Accepts a single JSON document or an array of documents. You may also pass the optional argument durability with value 'hard' or 'soft', to override the table or query's default durability setting, or the optional argument return_changes, which will return the value of the row you're inserting when set to true.

table.Insert(map[string]interface{}{"name": "Joe", "email": "joe@example.com"}).RunWrite(sess)
table.Insert([]interface{}{map[string]interface{}{"name": "Joe"}, map[string]interface{}{"name": "Paul"}}).RunWrite(sess)

func (Term) InsertAt Uses

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

Insert a value in to an array at a given index. Returns the modified array.

func (Term) Intersects Uses

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

Intersects tests whether two geometry objects intersect with one another. When applied to a sequence of geometry objects, intersects acts as a filter, returning a sequence of objects from the sequence that intersect with the argument.

func (Term) IsEmpty Uses

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

Test if a sequence is empty.

func (Term) Keys Uses

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

Return an array containing all of the object's keys.

func (Term) Le Uses

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

Le returns true if the first value is less than or equal to the second.

func (Term) Limit Uses

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

End the sequence after the given number of elements.

func (Term) Lt Uses

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

Lt returns true if the first value is less than the second.

func (Term) Map Uses

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

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 (Term) Match Uses

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

Match against a regular expression. Returns a match object containing the matched string, that string's start/end position, and the capture groups.

Expr("id:0,name:mlucy,foo:bar").Match("name:(\\w+)").Field("groups").Nth(0).Field("str")

func (Term) Max Uses

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

Finds the maximum of a sequence. If called with a field name, finds the element of that sequence with the largest value in that field. If called with a function, calls that function on every element of the sequence and returns the element which produced the largest value, ignoring any elements where the function returns null or produces a non-existence error.

func (Term) MaxIndex Uses

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

Finds the maximum of a sequence. If called with a field name, finds the element of that sequence with the largest value in that field. If called with a function, calls that function on every element of the sequence and returns the element which produced the largest value, ignoring any elements where the function returns null or produces a non-existence error.

func (Term) Merge Uses

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

Merge two objects together to construct a new object with properties from both. Gives preference to attributes from other when there is a conflict.

func (Term) Min Uses

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

Finds the minimum of a sequence. If called with a field name, finds the element of that sequence with the smallest value in that field. If called with a function, calls that function on every element of the sequence and returns the element which produced the smallest value, ignoring any elements where the function returns null or produces a non-existence error.

func (Term) MinIndex Uses

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

Finds the minimum of a sequence. If called with a field name, finds the element of that sequence with the smallest value in that field. If called with a function, calls that function on every element of the sequence and returns the element which produced the smallest value, ignoring any elements where the function returns null or produces a non-existence error.

func (Term) Minutes Uses

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

Return the minute in a time object as a number between 0 and 59.

func (Term) Mod Uses

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

Mod divides two numbers and returns the remainder.

func (Term) Month Uses

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

Return the month of a time object as a number between 1 and 12. For your convenience, the terms r.January(), r.February() etc. are defined and map to the appropriate integer.

func (Term) Mul Uses

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

Mul multiplies two numbers.

func (Term) Ne Uses

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

Ne returns true if two values are not equal.

func (Term) Not Uses

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

Not performs a logical not on a value.

func (Term) Nth Uses

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

Nth gets the nth element from a sequence.

func (Term) OffsetsOf Uses

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

Get the indexes of an element in a sequence. If the argument is a predicate, get the indexes of all elements matching it.

func (Term) Or Uses

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

Or performs a logical or on two values.

func (Term) OrderBy Uses

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

Sort the sequence by document values of the given key(s). To specify the index to use for ordering us a last argument in the following form:

OrderByOpts{Index: "index-name"}

OrderBy defaults to ascending ordering. To explicitly specify the ordering, wrap the attribute with either Asc or Desc.

query.OrderBy("name")
query.OrderBy(Asc("name"))
query.OrderBy(Desc("name"))

func (Term) OuterJoin Uses

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

Computes a left outer join by retaining each row in the left table even if no match was found in the right table.

func (Term) Pluck Uses

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

Plucks out one or more attributes from either an object or a sequence of objects (projection).

func (Term) PolygonSub Uses

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

PolygonSub "punches a hole" out of the parent polygon using the polygon passed to the function.

polygon1.PolygonSub(polygon2) -> polygon

In the example above polygon2 must be completely contained within polygon1 and must have no holes itself (it must not be the output of polygon_sub itself).

func (Term) Prepend Uses

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

Prepend a value to an array.

func (Term) Random Uses

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

Generate a random number between the given bounds. If no arguments are given, the result will be a floating-point number in the range [0,1).

When passing a single argument, r.random(x), the result will be in the range [0,x), and when passing two arguments, r.random(x,y), the range is [x,y). If x and y are equal, an error will occur, unless generating a floating-point number, for which x will be returned.

Note: The last argument given will always be the 'open' side of the range, but when generating a floating-point number, the 'open' side may be less than the 'closed' side.

func (Term) Rebalance Uses

func (t Term) Rebalance() Term

Rebalance rebalances the shards of a table. When called on a database, all the tables in that database will be rebalanced.

func (Term) Reconfigure Uses

func (t Term) Reconfigure(opts ReconfigureOpts) Term

Reconfigure a table's sharding and replication.

func (Term) Reduce Uses

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

Reduce produces a single value from a sequence through repeated application of a reduction function

It takes one argument of type `func (r.Term, r.Term) interface{}`, for example this query sums all elements in an array:

r.Expr([]int{1,3,6}).Reduce(func (left, right r.Term) interface{} {
    return left.Add(right)
})

func (Term) Replace Uses

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

Replace documents in a table. Accepts a JSON document or a RQL expression, and replaces the original document with the new one. The new document must have the same primary key as the original document. The optional argument durability with value 'hard' or 'soft' will override the table or query's default durability setting. The optional argument return_changes will return the old and new values of the row you're modifying when set to true (only valid for single-row replacements). The optional argument non_atomic lets you permit non-atomic updates.

func (Term) Run Uses

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

Run runs a query using the given connection.

	rows, err := query.Run(sess)
	if err != nil {
		// error
	}

 var doc MyDocumentType
	for rows.Next(&doc) {
     // Do something with document
	}

func (Term) RunWrite Uses

func (t Term) RunWrite(s *Session, optArgs ...RunOpts) (WriteResponse, error)

RunWrite runs a query using the given connection but unlike Run automatically scans the result into a variable of type WriteResponss. This function should be used if you are running a write query (such as Insert, Update, TableCreate, etc...)

res, err := r.Db("database").Table("table").Insert(doc).RunWrite(sess)

func (Term) Sample Uses

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

Select a given number of elements from a sequence with uniform random distribution. Selection is done without replacement.

func (Term) Seconds Uses

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

Return the seconds in a time object as a number between 0 and 59.999 (double precision).

func (Term) SetDifference Uses

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

Remove the elements of one array from another and return them as a set (an array with distinct values).

func (Term) SetInsert Uses

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

Add a value to an array and return it as a set (an array with distinct values).

func (Term) SetIntersection Uses

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

Intersect two arrays returning values that occur in both of them as a set (an array with distinct values).

func (Term) SetUnion Uses

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

Add a several values to an array and return it as a set (an array with distinct values).

func (Term) Skip Uses

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

Skip a number of elements from the head of the sequence.

func (Term) Slice Uses

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

Trim the sequence to within the bounds provided.

func (Term) SpliceAt Uses

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

Insert several values in to an array at a given index. Returns the modified array.

func (Term) Split Uses

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

Splits a string into substrings. Splits on whitespace when called with no arguments. When called with a separator, splits on that separator. When called with a separator and a maximum number of splits, splits on that separator at most max_splits times. (Can be called with null as the separator if you want to split on whitespace while still specifying max_splits.)

Mimics the behavior of Python's string.split in edge cases, except for splitting on the empty string, which instead produces an array of single-character strings.

func (Term) Status Uses

func (t Term) Status() Term

Status return the status of a table

func (Term) String Uses

func (t Term) String() string

String returns a string representation of the query tree

func (Term) Sub Uses

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

Sub subtracts two numbers.

func (Term) Sum Uses

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

Sums all the elements of a sequence. If called with a field name, sums all the values of that field in the sequence, skipping elements of the sequence that lack that field. If called with a function, calls that function on every element of the sequence and sums the results, skipping elements of the sequence where that function returns null or a non-existence error.

func (Term) Sync Uses

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

Sync ensures that writes on a given table are written to permanent storage. Queries that specify soft durability (Durability: "soft") do not give such guarantees, so sync can be used to ensure the state of these queries. A call to sync does not return until all previous writes to the table are persisted.

func (Term) Table Uses

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

Select all documents in a table. This command can be chained with other commands to do further processing on the data.

Optional arguments (see http://www.rethinkdb.com/api/#js:selecting_data-table for more information): "use_outdated" (boolean - defaults to false)

func (Term) TableCreate Uses

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

Create a table. A RethinkDB table is a collection of JSON documents.

If successful, the operation returns an object: {created: 1}. If a table with the same name already exists, the operation throws RqlRuntimeError.

Note: that you can only use alphanumeric characters and underscores for the table name.

r.Db("database").TableCreate("table", "durability", "soft").Run(sess)

func (Term) TableDrop Uses

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

Drop a table. The table and all its data will be deleted.

If successful, the operation returns an object: {dropped: 1}. If the specified table doesn't exist a RqlRuntimeError is thrown.

func (Term) TableList Uses

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

List all table names in a database.

func (Term) TimeOfDay Uses

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

Return the number of seconds elapsed since the beginning of the day stored in the time object.

func (Term) Timezone Uses

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

Returns the timezone of the time object

func (Term) ToEpochTime Uses

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

Convert a time object to its epoch time.

func (Term) ToGeojson Uses

func (t Term) ToGeojson(args ...interface{}) Term

ToGeojson converts a ReQL geometry object to a GeoJSON object.

func (Term) ToISO8601 Uses

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

Convert a time object to its iso 8601 format.

func (Term) ToJSON Uses

func (t Term) ToJSON() Term

Gets the type of a value.

func (Term) TypeOf Uses

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

Gets the type of a value.

func (Term) Ungroup Uses

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

func (Term) Union Uses

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

Concatenate two sequences.

func (Term) Upcase Uses

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

Upcases a string.

func (Term) Update Uses

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

Update JSON documents in a table. Accepts a JSON document, a RQL expression, or a combination of the two. The optional argument durability with value 'hard' or 'soft' will override the table or query's default durability setting. The optional argument return_changes will return the old and new values of the row you're modifying when set to true (only valid for single-row updates). The optional argument non_atomic lets you permit non-atomic updates.

func (Term) Wait Uses

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

Wait for a table or all the tables in a database to be ready. A table may be temporarily unavailable after creation, rebalancing or reconfiguring. The wait command blocks until the given table (or database) is fully up to date.

func (Term) WithFields Uses

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

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 (Term) Without Uses

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

The opposite of pluck; takes an object or a sequence of objects, and returns them with the specified paths removed.

func (Term) Year Uses

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

Return the year of a time object.

func (Term) Zip Uses

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

Used to 'zip' up the result of a join by merging the 'right' fields into 'left' fields of each member of the sequence.

type UpdateOpts Uses

type UpdateOpts struct {
    Durability    interface{} `gorethink:"durability,omitempty"`
    ReturnChanges interface{} `gorethink:"return_changes,omitempty"`
    NotAtomic     interface{} `gorethink:"non_atomic,omitempty"`
}

type WaitOpts Uses

type WaitOpts struct {
    WaitFor interface{} `gorethink:"wait_for,omitempty"`
    Timeout interface{} `gorethink:"timeout,omitempty"`
}

type WriteChanges Uses

type WriteChanges struct {
    NewValue interface{} `gorethink:"new_val"`
    OldValue interface{} `gorethink:"old_val"`
}

type WriteResponse Uses

type WriteResponse struct {
    Errors        int            `gorethink:"errors"`
    Inserted      int            `gorethink:"inserted"`
    Updated       int            `gorethink:"updadte"`
    Unchanged     int            `gorethink:"unchanged"`
    Replaced      int            `gorethink:"replaced"`
    Renamed       int            `gorethink:"renamed"`
    Skipped       int            `gorethink:"skipped"`
    Deleted       int            `gorethink:"deleted"`
    Created       int            `gorethink:"created"`
    DBsCreated    int            `gorethink:"dbs_created"`
    TablesCreated int            `gorethink:"tables_created"`
    Dropped       int            `gorethink:"dropped"`
    DBsDropped    int            `gorethink:"dbs_dropped"`
    TablesDropped int            `gorethink:"tables_dropped"`
    GeneratedKeys []string       `gorethink:"generated_keys"`
    FirstError    string         `gorethink:"first_error"` // populated if Errors > 0
    ConfigChanges []WriteChanges `gorethink:"config_changes"`
    Changes       []WriteChanges
}

Directories

PathSynopsis
encoding
ql2
types

Package gorethink imports 24 packages (graph). Updated 2016-07-17. Refresh now. Tools for package owners.