func (e Exp) GetAll(index string, values ...interface{}) Exp {
	return naryOperator(getAllKind, e, append(values, index)...)
}
GetAll retrieves all documents where the given value matches the requested
index.

Example usage (awesomeness is a secondary index defined as speed * strength):

var response []interface{}
err := r.Table("heroes").GetAll("awesomeness", 10).Run(session).All(&response)

Example response:

{
"strength": 2,
"name": "Storm",
"durability": 3,
"intelligence": 5,
"energy": 6,
"fighting": 5,
"real_name": "Ororo Munroe",
"speed": 5,
"id": "59d1ad55-a61e-49d9-a375-0fb014b0e6ea"
}
package rethinkgo
type Map map[string]interface{}
type List []interface{}
type expressionKind int
const (
	addKind expressionKind = iota
	allKind
	anyKind
	appendKind
	ascendingKind
	betweenKind
	branchKind
	changeAtKind
	coerceToKind
	concatMapKind
	containsKind
	countKind
	databaseCreateKind
	databaseDropKind
	databaseKind
	databaseListKind
	deleteAtKind
	deleteKind
	descendingKind
	differenceKind
	distinctKind
	divideKind
	defaultKind
	eqJoinKind
	equalityKind
	errorKind
	filterKind
	forEachKind
	funcallKind
	funcKind
	getAllKind
	getFieldKind
	getKind
	greaterThanKind
	greaterThanOrEqualKind
	groupByKind
	groupedMapReduceKind
	hasFieldsKind
	implicitVariableKind
	indexCreateKind
	indexDropKind
	indexesOfKind
	indexListKind
	inequalityKind
	infoKind
	innerJoinKind
	insertAtKind
	insertKind
	isEmptyKind
	javascriptKind
	jsonKind
	keysKind
	lessThanKind
	lessThanOrEqualKind
	limitKind
	logicalNotKind
	mapKind
	matchKind
	mergeKind
	moduloKind
	multiplyKind
	nthKind
	orderByKind
	outerJoinKind
	pluckKind
	prependKind
	reduceKind
	returnValuesKind
	replaceKind
	sampleKind
	setDifferenceKind
	setInsertKind
	setIntersectionKind
	setUnionKind
	skipKind
	sliceKind
	spliceAtKind
	subtractKind
	tableCreateKind
	tableDropKind
	tableKind
	tableListKind
	typeOfKind
	unionKind
	updateKind
	variableKind
	withFieldsKind
	withoutKind
	zipKind
	upsertKind
	atomicKind
	useOutdatedKind
	durabilityKind
	literalKind
)
func nullaryOperator(kind expressionKind) Exp {
	return Exp{kind: kind}
}
func naryOperator(kind expressionKind, operand interface{}, operands ...interface{}) Exp {
	args := []interface{}{operand}
	args = append(args, operands...)
	return Exp{kind: kind, args: args}
}
func stringsToInterfaces(strings []string) []interface{} {
	interfaces := make([]interface{}, len(strings))
	for i, v := range strings {
		interfaces[i] = interface{}(v)
	}
	return interfaces
}
func funcWrapper(f interface{}, arity int) Exp {
	return naryOperator(funcKind, f, arity)
}
type Exp struct {  
	args []interface{}
	kind expressionKind
}
var Row = Exp{kind: implicitVariableKind}
func Expr(value interface{}) Exp {
	v, ok := value.(Exp)  
	if ok {
		return v
	}
	return naryOperator(literalKind, value)
}
func Json(value string) Exp {
	return naryOperator(jsonKind, value)
}
func Js(body string) Exp {
	return naryOperator(javascriptKind, body)
}
func JsWithTimeout(body string, timeout float64) Exp {
	return naryOperator(javascriptKind, body, timeout)
}
func RuntimeError(message string) Exp {
	return Exp{kind: errorKind, args: List{message}}
}
func Branch(test, trueBranch, falseBranch interface{}) Exp {
	return naryOperator(branchKind, test, trueBranch, falseBranch)
}
func (e Exp) Get(key interface{}) Exp {
	return naryOperator(getKind, e, key)
}