c *Client

path string // path to query (collection)

parentPath string // path of the collection's parent (document)

collectionID string

selection []*pb.StructuredQuery_FieldReference

filters []*pb.StructuredQuery_Filter

orders []order

offset int32

limit *wrappers.Int32Value

limitToLast bool

startVals, endVals []interface{}

startDoc, endDoc *DocumentSnapshot

// Set startBefore to true when doc in startVals needs to be included in result

// Set endBefore to false when doc in endVals needs to be included in result

startBefore, endBefore bool

err error

// allDescendants indicates whether this query is for all collections

// that match the ID under the specified parentPath.

allDescendants bool

// readOptions specifies constraints for reading results from the query

// e.g. read time

readSettings *readSettings

var fps []FieldPath

for _, s := range paths {

fp, err := parseDotSeparatedString(s)

if err != nil {

q.err = err

return q

}

fps = append(fps, fp)

}

return q.SelectPaths(fps...)

if len(fieldPaths) == 0 {

ref, err := fref(FieldPath{DocumentID})

if err != nil {

q.err = err

return q

}

q.selection = []*pb.StructuredQuery_FieldReference{

ref,

}

} else {

q.selection = make([]*pb.StructuredQuery_FieldReference, len(fieldPaths))

for i, fieldPath := range fieldPaths {

ref, err := fref(fieldPath)

if err != nil {

q.err = err

return q

}

q.selection[i] = ref

}

}

return q

fp, err := parseDotSeparatedString(path)

if err != nil {

q.err = err

return q

}

return q.WherePath(fp, op, value)

return q.WhereEntity(PropertyPathFilter{

Path: fp,

Operator: op,

Value: value,

})

proto, err := ef.toProto()

if err != nil {

q.err = err

return q

}

q.filters = append(append([]*pb.StructuredQuery_Filter(nil), q.filters...), proto)

return q

fp, err := parseDotSeparatedString(path)

if err != nil {

q.err = err

return q

}

q.orders = append(q.copyOrders(), order{fieldPath: fp, dir: dir})

return q

q.limit = &wrappers.Int32Value{Value: trunc32(n)}

q.limitToLast = false

return q

q.limit = &wrappers.Int32Value{Value: trunc32(n)}

q.limitToLast = true

return q

q.startBefore = true

q.startVals, q.startDoc, q.err = q.processCursorArg("StartAt", docSnapshotOrFieldValues)

return q

q.startBefore = false

q.startVals, q.startDoc, q.err = q.processCursorArg("StartAfter", docSnapshotOrFieldValues)

return q

q.endBefore = false

q.endVals, q.endDoc, q.err = q.processCursorArg("EndAt", docSnapshotOrFieldValues)

return q

q.endBefore = true

q.endVals, q.endDoc, q.err = q.processCursorArg("EndBefore", docSnapshotOrFieldValues)

return q

for _, e := range docSnapshotOrFieldValues {

if ds, ok := e.(*DocumentSnapshot); ok {

if len(docSnapshotOrFieldValues) == 1 {

return nil, ds, nil

}

return nil, nil, fmt.Errorf("firestore: a document snapshot must be the only argument to %s", name)

}

}

return docSnapshotOrFieldValues, nil, nil

if q.limitToLast {

// Firestore service does not provide limit to last behaviour out of the box. This is a client-side concept

// So, flip order statements and cursors before posting a request. The response is flipped by other methods before returning to user

// E.g.

// If id of documents is 1, 2, 3, 4, 5, 6, 7 and query is (OrderBy(id, ASC), StartAt(2), EndAt(6), LimitToLast(3))

// request sent to server is (OrderBy(id, DESC), StartAt(6), EndAt(2), Limit(3))

for i := range q.orders {

if q.orders[i].dir == Asc {

q.orders[i].dir = Desc

} else {

q.orders[i].dir = Asc

}

}

if q.startBefore == q.endBefore && q.startCursorSpecified() && q.endCursorSpecified() {

// E.g. query.StartAt(2).EndBefore(6).LimitToLast(3).OrderBy(Asc) i.e. cursors are [2, 6)

// E.g. query.StartAfter(2).EndAt(6).LimitToLast(3).OrderBy(Asc) i.e. cursors are (2, 6]

q.startBefore, q.endBefore = !q.startBefore, !q.endBefore

} else if !q.startCursorSpecified() && q.endCursorSpecified() {

// E.g. query.EndAt(6).LimitToLast(3).OrderBy(Asc) i.e. cursors are (-inf, 6]

q.startBefore = !q.endBefore

q.endBefore = false

} else if q.startCursorSpecified() && !q.endCursorSpecified() {

// E.g. query.StartAt(2).LimitToLast(3).OrderBy(Asc) i.e. cursors are [2, inf)

q.endBefore = !q.startBefore

q.startBefore = false

}

// Swap cursors.

q.startVals, q.endVals = q.endVals, q.startVals

q.startDoc, q.endDoc = q.endDoc, q.startDoc

q.limitToLast = false

}

structuredQuery, err := q.toProto()

if err != nil {

return nil, err

}

p := &pb.RunQueryRequest{

Parent: q.parentPath,

QueryType: &pb.RunQueryRequest_StructuredQuery{StructuredQuery: structuredQuery},

}

return proto.Marshal(p)

runQueryRequest := pb.RunQueryRequest{}

err := proto.Unmarshal(bytes, &runQueryRequest)

if err != nil {

q.err = err

return q, err

}

return q.fromProto(&runQueryRequest)

return &AggregationQuery{

query: q,

}

// Ensure we are starting from an empty query, but with this client.

q = Query{c: q.c}

pbq := pbQuery.GetStructuredQuery()

if from := pbq.GetFrom(); len(from) > 0 {

if len(from) > 1 {

err := errors.New("can only deserialize query with exactly one collection selector")

q.err = err

return q, err

}

// collectionID string

q.collectionID = from[0].CollectionId

// allDescendants indicates whether this query is for all collections

// that match the ID under the specified parentPath.

q.allDescendants = from[0].AllDescendants

}

// path string // path to query (collection)

// parentPath string // path of the collection's parent (document)

parent := pbQuery.GetParent()

q.parentPath = parent

q.path = parent + "/" + q.collectionID

// startVals, endVals []interface{}

// startDoc, endDoc *DocumentSnapshot

// startBefore, endBefore bool

if startAt := pbq.GetStartAt(); startAt != nil {

if startAt.GetBefore() {

q.startBefore = true

}

for _, v := range startAt.GetValues() {

c, err := createFromProtoValue(v, q.c)

if err != nil {

q.err = err

return q, err

}

var newQ Query

if startAt.GetBefore() {

newQ = q.StartAt(c)

} else {

newQ = q.StartAfter(c)

}

q.startVals = append(q.startVals, newQ.startVals...)

}

}

if endAt := pbq.GetEndAt(); endAt != nil {

for _, v := range endAt.GetValues() {

c, err := createFromProtoValue(v, q.c)

if err != nil {

q.err = err

return q, err

}

var newQ Query

if endAt.GetBefore() {

newQ = q.EndBefore(c)

q.endBefore = true

} else {

newQ = q.EndAt(c)

}

q.endVals = append(q.endVals, newQ.endVals...)

}

}

// selection []*pb.StructuredQuery_FieldReference

if s := pbq.GetSelect(); s != nil {

q.selection = s.GetFields()

}

// filters []*pb.StructuredQuery_Filter

if w := pbq.GetWhere(); w != nil {

if cf := w.GetCompositeFilter(); cf != nil {

q.filters = cf.GetFilters()

} else {

q.filters = []*pb.StructuredQuery_Filter{w}

}

}

// orders []order

if orderBy := pbq.GetOrderBy(); orderBy != nil {

for _, v := range orderBy {

fp := v.GetField()

q.orders = append(q.orders, order{fieldReference: fp, dir: Direction(v.GetDirection())})

}

}

// offset int32

q.offset = pbq.GetOffset()

// limit *wrappers.Int32Value

if limit := pbq.GetLimit(); limit != nil {

q.limit = limit

}

// NOTE: limit to last isn't part of the proto, this is a client-side concept

// limitToLast bool

return q, q.err

if q.err != nil {

return nil, q.err

}

if q.collectionID == "" {

return nil, errors.New("firestore: query created without CollectionRef")

}

if q.startBefore {

if !q.startCursorSpecified() {

return nil, errors.New("firestore: StartAt/StartAfter must be called with at least one value")

}

}

if q.endBefore {

if !q.endCursorSpecified() {

return nil, errors.New("firestore: EndAt/EndBefore must be called with at least one value")

}

}

p := &pb.StructuredQuery{

From: []*pb.StructuredQuery_CollectionSelector{{

CollectionId: q.collectionID,

AllDescendants: q.allDescendants,

}},

Offset: q.offset,

Limit: q.limit,

}

if len(q.selection) > 0 {

p.Select = &pb.StructuredQuery_Projection{}

p.Select.Fields = q.selection

}

// If there is only filter, use it directly. Otherwise, construct

// a CompositeFilter.

if len(q.filters) == 1 {

pf := q.filters[0]

p.Where = pf

} else if len(q.filters) > 1 {

cf := &pb.StructuredQuery_CompositeFilter{

Op: pb.StructuredQuery_CompositeFilter_AND,

}

p.Where = &pb.StructuredQuery_Filter{

FilterType: &pb.StructuredQuery_Filter_CompositeFilter{

CompositeFilter: cf,

},

}

cf.Filters = append(cf.Filters, q.filters...)

}

orders := q.orders

if q.startDoc != nil || q.endDoc != nil {

orders = q.adjustOrders()

}

for _, ord := range orders {

po, err := ord.toProto()

if err != nil {

return nil, err

}

p.OrderBy = append(p.OrderBy, po)

}

cursor, err := q.toCursor(q.startVals, q.startDoc, q.startBefore, orders)

if err != nil {

return nil, err

}

p.StartAt = cursor

cursor, err = q.toCursor(q.endVals, q.endDoc, q.endBefore, orders)

if err != nil {

return nil, err

}

p.EndAt = cursor

return p, nil

// If the user is already ordering by document ID, don't change anything.

for _, ord := range q.orders {

if ord.isDocumentID() {

return q.orders

}

}

// If there are OrderBy clauses, append an OrderBy(DocumentID), using the direction of the last OrderBy clause.

if len(q.orders) > 0 {

return append(q.copyOrders(), order{

fieldPath: FieldPath{DocumentID},

dir: q.orders[len(q.orders)-1].dir,

})

}

// If there are no OrderBy clauses but there is an inequality, add an OrderBy clause

// for the field of the first inequality.

var orders []order

for _, f := range q.filters {

if fieldFilter := f.GetFieldFilter(); fieldFilter != nil {

if fieldFilter.Op != pb.StructuredQuery_FieldFilter_EQUAL {

fp := f.GetFieldFilter().Field

orders = []order{{fieldReference: fp, dir: Asc}}

break

}

}

}

// Add an ascending OrderBy(DocumentID).

return append(orders, order{fieldPath: FieldPath{DocumentID}, dir: Asc})

var vals []*pb.Value

var err error

if ds != nil {

vals, err = q.docSnapshotToCursorValues(ds, orders)

} else if len(fieldValues) != 0 {

vals, err = q.fieldValuesToCursorValues(fieldValues)

} else {

return nil, nil

}

if err != nil {

return nil, err

}

return &pb.Cursor{Values: vals, Before: before}, nil

if len(fieldValues) != len(q.orders) {

return nil, errors.New("firestore: number of field values in StartAt/StartAfter/EndAt/EndBefore does not match number of OrderBy fields")

}

vals := make([]*pb.Value, len(fieldValues))

var err error

for i, ord := range q.orders {

fval := fieldValues[i]

if ord.isDocumentID() {

// TODO(jba): error if document ref does not belong to the right collection.

switch docID := fval.(type) {

case string:

vals[i] = &pb.Value{ValueType: &pb.Value_ReferenceValue{q.path + "/" + docID}}

continue

case *DocumentRef:

// DocumentRef can be transformed in usual way.

default:

return nil, fmt.Errorf("firestore: expected doc ID for DocumentID field, got %T", fval)

}

}

var sawTransform bool

vals[i], sawTransform, err = toProtoValue(reflect.ValueOf(fval))

if err != nil {

return nil, err

}

if sawTransform {

return nil, errors.New("firestore: transforms disallowed in query value")

}

}

return vals, nil

vals := make([]*pb.Value, len(orders))

for i, ord := range orders {

if ord.isDocumentID() {

dp, qp := ds.Ref.Parent.Path, q.path

if !q.allDescendants && dp != qp {

return nil, fmt.Errorf("firestore: document snapshot for %s passed to query on %s", dp, qp)

}

vals[i] = &pb.Value{ValueType: &pb.Value_ReferenceValue{ds.Ref.Path}}

} else {

var val *pb.Value

var err error

if len(ord.fieldPath) > 0 {

val, err = valueAtPath(ord.fieldPath, ds.proto.Fields)

} else {

// parse the field reference field path so we can use it to look up

fp, err := parseDotSeparatedString(ord.fieldReference.FieldPath)

if err != nil {

return nil, err

}

val, err = valueAtPath(fp, ds.proto.Fields)

}

if err != nil {

return nil, err

}

vals[i] = val

}

}

return vals, nil

// Add implicit sorting by name, using the last specified direction.

lastDir := Asc

if len(q.orders) > 0 {

lastDir = q.orders[len(q.orders)-1].dir

}

orders := append(q.copyOrders(), order{fieldPath: []string{DocumentID}, dir: lastDir})

return func(d1, d2 *DocumentSnapshot) (int, error) {

for _, ord := range orders {

var cmp int

if ord.isDocumentID() {

cmp = compareReferences(d1.Ref.Path, d2.Ref.Path)

} else {

v1, err := valueAtPath(ord.fieldPath, d1.proto.Fields)

if err != nil {

return 0, err

}

v2, err := valueAtPath(ord.fieldPath, d2.proto.Fields)

if err != nil {

return 0, err

}

cmp = compareValues(v1, v2)

}

if cmp != 0 {

if ord.dir == Desc {

cmp = -cmp

}

return cmp, nil

}

}

return 0, nil

}

var pbFilters []*pb.StructuredQuery_Filter

for _, filter := range f.Filters {

pbFilter, err := filter.toProto()

if err != nil {

return nil, err

}

pbFilters = append(pbFilters, pbFilter)

}

cf := &pb.StructuredQuery_CompositeFilter{

Op: pb.StructuredQuery_CompositeFilter_OR,

}

cf.Filters = append(cf.Filters, pbFilters...)

return &pb.StructuredQuery_Filter{

FilterType: &pb.StructuredQuery_Filter_CompositeFilter{

CompositeFilter: cf,

},

}, nil

var pbFilters []*pb.StructuredQuery_Filter

for _, filter := range f.Filters {

pbFilter, err := filter.toProto()

if err != nil {

return nil, err

}

pbFilters = append(pbFilters, pbFilter)

}

cf := &pb.StructuredQuery_CompositeFilter{

Op: pb.StructuredQuery_CompositeFilter_AND,

}

cf.Filters = append(cf.Filters, pbFilters...)

return &pb.StructuredQuery_Filter{

FilterType: &pb.StructuredQuery_Filter_CompositeFilter{

CompositeFilter: cf,

},

}, nil

Path string

Operator string

Value interface{}

fp, err := parseDotSeparatedString(f.Path)

if err != nil {

return PropertyPathFilter{}, err

}

ppf := PropertyPathFilter{

Path: fp,

Operator: f.Operator,

Value: f.Value,

}

return ppf, nil

ppf, err := f.toPropertyPathFilter()

if err != nil {

return nil, err

}

return ppf.toProto()

Path FieldPath

Operator string

Value interface{}

if err := f.Path.validate(); err != nil {

return nil, err

}

if uop, ok := unaryOpFor(f.Value); ok {

if f.Operator != "==" {

return nil, fmt.Errorf("firestore: must use '==' when comparing %v", f.Value)

}

ref, err := fref(f.Path)

if err != nil {

return nil, err

}

return &pb.StructuredQuery_Filter{

FilterType: &pb.StructuredQuery_Filter_UnaryFilter{

UnaryFilter: &pb.StructuredQuery_UnaryFilter{

OperandType: &pb.StructuredQuery_UnaryFilter_Field{

Field: ref,

},

Op: uop,

},

},

}, nil

}

var op pb.StructuredQuery_FieldFilter_Operator

switch f.Operator {

case "<":

op = pb.StructuredQuery_FieldFilter_LESS_THAN

case "<=":

op = pb.StructuredQuery_FieldFilter_LESS_THAN_OR_EQUAL

case ">":

op = pb.StructuredQuery_FieldFilter_GREATER_THAN

case ">=":

op = pb.StructuredQuery_FieldFilter_GREATER_THAN_OR_EQUAL

case "==":

op = pb.StructuredQuery_FieldFilter_EQUAL

case "!=":

op = pb.StructuredQuery_FieldFilter_NOT_EQUAL

case "in":

op = pb.StructuredQuery_FieldFilter_IN

case "not-in":

op = pb.StructuredQuery_FieldFilter_NOT_IN

case "array-contains":

op = pb.StructuredQuery_FieldFilter_ARRAY_CONTAINS

case "array-contains-any":

op = pb.StructuredQuery_FieldFilter_ARRAY_CONTAINS_ANY

default:

return nil, fmt.Errorf("firestore: invalid operator %q", f.Operator)

}

val, sawTransform, err := toProtoValue(reflect.ValueOf(f.Value))

if err != nil {

return nil, err

}

if sawTransform {

return nil, errors.New("firestore: transforms disallowed in query value")

}

ref, err := fref(f.Path)

if err != nil {

return nil, err

}

return &pb.StructuredQuery_Filter{

FilterType: &pb.StructuredQuery_Filter_FieldFilter{

FieldFilter: &pb.StructuredQuery_FieldFilter{

Field: ref,

Op: op,

Value: val,

},

},

}, nil

switch {

case value == nil:

return pb.StructuredQuery_UnaryFilter_IS_NULL, true

case isNaN(value):

return pb.StructuredQuery_UnaryFilter_IS_NAN, true

default:

return pb.StructuredQuery_UnaryFilter_OPERATOR_UNSPECIFIED, false

}

switch x := x.(type) {

case float32:

return math.IsNaN(float64(x))

case float64:

return math.IsNaN(x)

default:

return false

}

fieldPath FieldPath

fieldReference *pb.StructuredQuery_FieldReference

dir Direction

if r.fieldReference != nil {

return r.fieldReference.GetFieldPath() == DocumentID

}

return len(r.fieldPath) == 1 && r.fieldPath[0] == DocumentID

if r.fieldReference != nil {

return &pb.StructuredQuery_Order{

Field: r.fieldReference,

Direction: pb.StructuredQuery_Direction(r.dir),

}, nil

}

field, err := fref(r.fieldPath)

if err != nil {

return nil, err

}

return &pb.StructuredQuery_Order{

Field: field,

Direction: pb.StructuredQuery_Direction(r.dir),

}, nil

err := fp.validate()

if err != nil {

return &pb.StructuredQuery_FieldReference{}, err

}

return &pb.StructuredQuery_FieldReference{FieldPath: fp.toServiceFieldPath()}, nil

if i > math.MaxInt32 {

i = math.MaxInt32

}

return int32(i)

return &DocumentIterator{

iter: newQueryDocumentIterator(withResourceHeader(ctx, q.c.path()), &q, nil, q.readSettings), q: &q,

}

iter docIterator

err error

q *Query