generated_datastore.go

// Code generated by github.com/yssk22/go/generator DO NOT EDIT.
//
package example

import (
	"context"
	"time"

	"cloud.google.com/go/datastore"
	ds "github.com/yssk22/go/gcp/datastore"
	"github.com/yssk22/go/types"
	"github.com/yssk22/go/x/xerrors"
	"github.com/yssk22/go/x/xtime"
	"google.golang.org/api/iterator"
)

func (s *Entity) NewKey(ctx context.Context) *datastore.Key {
	key := ds.NewKey("Entity", s.ID)
	key.Namespace = ""
	return key
}

type EntityReplacer interface {
	Replace(*Entity, *Entity) *Entity
}

type EntityReplacerFunc func(*Entity, *Entity) *Entity

func (f EntityReplacerFunc) Replace(old *Entity, new *Entity) *Entity {
	return f(old, new)
}

type EntityKindClient struct {
	client *ds.Client
}

func NewEntityKindClient(client *ds.Client) *EntityKindClient {
	return &EntityKindClient{
		client: client,
	}
}

func (d *EntityKindClient) Get(ctx context.Context, key interface{}) (*datastore.Key, *Entity, error) {
	keys, ents, err := d.GetMulti(ctx, []interface{}{key})
	if err != nil {
		return nil, nil, err
	}
	return keys[0], ents[0], nil
}

func (d *EntityKindClient) MustGet(ctx context.Context, key interface{}) (*datastore.Key, *Entity) {
	k, v, e := d.Get(ctx, key)
	xerrors.MustNil(e)
	return k, v
}

func (d *EntityKindClient) GetMulti(ctx context.Context, keys interface{}) ([]*datastore.Key, []*Entity, error) {
	var err error
	var dsKeys []*datastore.Key
	var ents []*Entity
	if dsKeys, err = ds.NormalizeKeys(keys, "Entity", ""); err != nil {
		return nil, nil, xerrors.Wrap(err, "could not normalize keys: %v", keys)
	}
	size := len(dsKeys)
	if size == 0 {
		return nil, nil, nil
	}
	ents = make([]*Entity, size, size)
	if err = d.client.GetMulti(ctx, dsKeys, ents); err != nil {
		return nil, nil, err
	}
	return dsKeys, ents, nil
}

func (d *EntityKindClient) MustGetMulti(ctx context.Context, keys interface{}) ([]*datastore.Key, []*Entity) {
	k, v, e := d.GetMulti(ctx, keys)
	xerrors.MustNil(e)
	return k, v
}

func (d *EntityKindClient) Put(ctx context.Context, ent *Entity) (*datastore.Key, error) {
	keys, err := d.PutMulti(ctx, []*Entity{ent})
	if err != nil {
		return nil, err
	}
	return keys[0], nil
}

func (d *EntityKindClient) MustPut(ctx context.Context, ent *Entity) *datastore.Key {
	k, e := d.Put(ctx, ent)
	xerrors.MustNil(e)
	return k
}

func (d *EntityKindClient) PutMulti(ctx context.Context, ents []*Entity) ([]*datastore.Key, error) {
	var err error
	var size = len(ents)
	var dsKeys []*datastore.Key
	dsKeys = make([]*datastore.Key, size, size)
	if size == 0 {
		return nil, nil
	}
	_, hasBeforeSave := interface{}(ents[0]).(ds.BeforeSave)
	_, hasAfterSave := interface{}(ents[0]).(ds.AfterSave)

	if hasBeforeSave {
		for i := range ents {
			if err := interface{}(ents[i]).(ds.BeforeSave).BeforeSave(ctx); err != nil {
				return nil, err
			}
		}
	}

	for i := range ents {
		dsKeys[i] = ents[i].NewKey(ctx)
		ents[i].UpdatedAt = xtime.Now()
	}
	if dsKeys, err = d.client.PutMulti(ctx, dsKeys, ents); err != nil {
		return nil, err
	}

	if hasAfterSave {
		for i := range ents {
			if err := interface{}(ents[i]).(ds.AfterSave).AfterSave(ctx); err != nil {
				return nil, err
			}
		}
	}
	return dsKeys, nil
}

func (d *EntityKindClient) MustPutMulti(ctx context.Context, ents []*Entity) []*datastore.Key {
	keys, err := d.PutMulti(ctx, ents)
	xerrors.MustNil(err)
	return keys
}

func (d *EntityKindClient) Delete(ctx context.Context, key interface{}) (*datastore.Key, error) {
	keys, err := d.DeleteMulti(ctx, []interface{}{key})
	if err != nil {
		return nil, err
	}
	return keys[0], nil
}

func (d *EntityKindClient) MustDelete(ctx context.Context, key interface{}) *datastore.Key {
	k, e := d.Delete(ctx, key)
	xerrors.MustNil(e)
	return k
}

func (d *EntityKindClient) DeleteMulti(ctx context.Context, keys interface{}) ([]*datastore.Key, error) {
	var err error
	var dsKeys []*datastore.Key
	if dsKeys, err = ds.NormalizeKeys(keys, "Entity", ""); err != nil {
		return nil, xerrors.Wrap(err, "could not normalize keys: %v", keys)
	}
	size := len(dsKeys)
	if size == 0 {
		return nil, nil
	}
	if err = d.client.DeleteMulti(ctx, dsKeys); err != nil {
		return nil, xerrors.Wrap(err, "datastore error")
	}
	return dsKeys, nil
}

func (d *EntityKindClient) MustDeleteMulti(ctx context.Context, keys interface{}) []*datastore.Key {
	k, e := d.DeleteMulti(ctx, keys)
	xerrors.MustNil(e)
	return k
}

func (d *EntityKindClient) DeleteMatched(ctx context.Context, q *EntityQuery) ([]*datastore.Key, error) {
	keys, err := d.client.GetAll(ctx, q.query.KeysOnly(), nil)
	if err != nil {
		return nil, err
	}
	_, err = d.DeleteMulti(ctx, keys)
	if err != nil {
		return nil, err
	}
	return keys, nil
}

func (d *EntityKindClient) MustDeleteMatched(ctx context.Context, q *EntityQuery) []*datastore.Key {
	keys, err := d.DeleteMatched(ctx, q)
	xerrors.MustNil(err)
	return keys
}

func (d *EntityKindClient) Replace(ctx context.Context, ent *Entity, replacer EntityReplacer) (*datastore.Key, *Entity, error) {
	keys, ents, err := d.ReplaceMulti(ctx, []*Entity{ent}, replacer)
	if err != nil {
		return nil, ents[0], err
	}
	return keys[0], ents[0], err
}

func (d *EntityKindClient) MustReplace(ctx context.Context, ent *Entity, replacer EntityReplacer) (*datastore.Key, *Entity) {
	k, v, e := d.Replace(ctx, ent, replacer)
	xerrors.MustNil(e)
	return k, v
}

func (d *EntityKindClient) ReplaceMulti(ctx context.Context, ents []*Entity, replacer EntityReplacer) ([]*datastore.Key, []*Entity, error) {
	var size = len(ents)
	var dsKeys = make([]*datastore.Key, size, size)
	if size == 0 {
		return dsKeys, ents, nil
	}
	for i := range ents {
		dsKeys[i] = ents[i].NewKey(ctx)
	}
	_, existing, err := d.GetMulti(ctx, dsKeys)
	if err != nil {
		return nil, ents, err
	}
	for i, exist := range existing {
		if exist != nil {
			ents[i] = replacer.Replace(exist, ents[i])
		}
	}
	dsKeys, err = d.PutMulti(ctx, ents)
	return dsKeys, ents, err
}

func (d *EntityKindClient) MustReplaceMulti(ctx context.Context, ents []*Entity, replacer EntityReplacer) ([]*datastore.Key, []*Entity) {
	k, v, e := d.ReplaceMulti(ctx, ents, replacer)
	xerrors.MustNil(e)
	return k, v
}

type EntityQuery struct {
	query   *ds.Query
	viaKeys bool
}

func NewEntityQuery() *EntityQuery {
	return &EntityQuery{
		query:   ds.NewQuery("Entity").Namespace(""),
		viaKeys: false,
	}
}

func (d *EntityQuery) EqID(v string) *EntityQuery {
	d.query = d.query.Eq("ID", v)
	return d
}

func (d *EntityQuery) EqDigit(v int) *EntityQuery {
	d.query = d.query.Eq("Digit", v)
	return d
}

func (d *EntityQuery) EqDesc(v string) *EntityQuery {
	d.query = d.query.Eq("Desc", v)
	return d
}

func (d *EntityQuery) EqSliceType(v string) *EntityQuery {
	d.query = d.query.Eq("SliceType", v)
	return d
}

func (d *EntityQuery) EqBoolType(v bool) *EntityQuery {
	d.query = d.query.Eq("BoolType", v)
	return d
}

func (d *EntityQuery) EqFloatType(v float64) *EntityQuery {
	d.query = d.query.Eq("FloatType", v)
	return d
}

func (d *EntityQuery) EqCreatedAt(v time.Time) *EntityQuery {
	d.query = d.query.Eq("CreatedAt", v)
	return d
}

func (d *EntityQuery) EqUpdatedAt(v time.Time) *EntityQuery {
	d.query = d.query.Eq("UpdatedAt", v)
	return d
}

func (d *EntityQuery) EqCustomType(v types.RGB) *EntityQuery {
	d.query = d.query.Eq("CustomType", v)
	return d
}

func (d *EntityQuery) EqLocationLat(v float64) *EntityQuery {
	d.query = d.query.Eq("Location.Lat", v)
	return d
}

func (d *EntityQuery) EqLocationLng(v float64) *EntityQuery {
	d.query = d.query.Eq("Location.Lng", v)
	return d
}

func (d *EntityQuery) EqBeforeSaveDesc(v string) *EntityQuery {
	d.query = d.query.Eq("BeforeSaveDesc", v)
	return d
}

func (d *EntityQuery) EqAfterSaveDesc(v string) *EntityQuery {
	d.query = d.query.Eq("AfterSaveDesc", v)
	return d
}

func (d *EntityQuery) LtID(v string) *EntityQuery {
	d.query = d.query.Lt("ID", v)
	return d
}

func (d *EntityQuery) LtDigit(v int) *EntityQuery {
	d.query = d.query.Lt("Digit", v)
	return d
}

func (d *EntityQuery) LtDesc(v string) *EntityQuery {
	d.query = d.query.Lt("Desc", v)
	return d
}

func (d *EntityQuery) LtSliceType(v string) *EntityQuery {
	d.query = d.query.Lt("SliceType", v)
	return d
}

func (d *EntityQuery) LtBoolType(v bool) *EntityQuery {
	d.query = d.query.Lt("BoolType", v)
	return d
}

func (d *EntityQuery) LtFloatType(v float64) *EntityQuery {
	d.query = d.query.Lt("FloatType", v)
	return d
}

func (d *EntityQuery) LtCreatedAt(v time.Time) *EntityQuery {
	d.query = d.query.Lt("CreatedAt", v)
	return d
}

func (d *EntityQuery) LtUpdatedAt(v time.Time) *EntityQuery {
	d.query = d.query.Lt("UpdatedAt", v)
	return d
}

func (d *EntityQuery) LtCustomType(v types.RGB) *EntityQuery {
	d.query = d.query.Lt("CustomType", v)
	return d
}

func (d *EntityQuery) LtLocationLat(v float64) *EntityQuery {
	d.query = d.query.Lt("Location.Lat", v)
	return d
}

func (d *EntityQuery) LtLocationLng(v float64) *EntityQuery {
	d.query = d.query.Lt("Location.Lng", v)
	return d
}

func (d *EntityQuery) LtBeforeSaveDesc(v string) *EntityQuery {
	d.query = d.query.Lt("BeforeSaveDesc", v)
	return d
}

func (d *EntityQuery) LtAfterSaveDesc(v string) *EntityQuery {
	d.query = d.query.Lt("AfterSaveDesc", v)
	return d
}

func (d *EntityQuery) LeID(v string) *EntityQuery {
	d.query = d.query.Le("ID", v)
	return d
}

func (d *EntityQuery) LeDigit(v int) *EntityQuery {
	d.query = d.query.Le("Digit", v)
	return d
}

func (d *EntityQuery) LeDesc(v string) *EntityQuery {
	d.query = d.query.Le("Desc", v)
	return d
}

func (d *EntityQuery) LeSliceType(v string) *EntityQuery {
	d.query = d.query.Le("SliceType", v)
	return d
}

func (d *EntityQuery) LeBoolType(v bool) *EntityQuery {
	d.query = d.query.Le("BoolType", v)
	return d
}

func (d *EntityQuery) LeFloatType(v float64) *EntityQuery {
	d.query = d.query.Le("FloatType", v)
	return d
}

func (d *EntityQuery) LeCreatedAt(v time.Time) *EntityQuery {
	d.query = d.query.Le("CreatedAt", v)
	return d
}

func (d *EntityQuery) LeUpdatedAt(v time.Time) *EntityQuery {
	d.query = d.query.Le("UpdatedAt", v)
	return d
}

func (d *EntityQuery) LeCustomType(v types.RGB) *EntityQuery {
	d.query = d.query.Le("CustomType", v)
	return d
}

func (d *EntityQuery) LeLocationLat(v float64) *EntityQuery {
	d.query = d.query.Le("Location.Lat", v)
	return d
}

func (d *EntityQuery) LeLocationLng(v float64) *EntityQuery {
	d.query = d.query.Le("Location.Lng", v)
	return d
}

func (d *EntityQuery) LeBeforeSaveDesc(v string) *EntityQuery {
	d.query = d.query.Le("BeforeSaveDesc", v)
	return d
}

func (d *EntityQuery) LeAfterSaveDesc(v string) *EntityQuery {
	d.query = d.query.Le("AfterSaveDesc", v)
	return d
}

func (d *EntityQuery) GtID(v string) *EntityQuery {
	d.query = d.query.Gt("ID", v)
	return d
}

func (d *EntityQuery) GtDigit(v int) *EntityQuery {
	d.query = d.query.Gt("Digit", v)
	return d
}

func (d *EntityQuery) GtDesc(v string) *EntityQuery {
	d.query = d.query.Gt("Desc", v)
	return d
}

func (d *EntityQuery) GtSliceType(v string) *EntityQuery {
	d.query = d.query.Gt("SliceType", v)
	return d
}

func (d *EntityQuery) GtBoolType(v bool) *EntityQuery {
	d.query = d.query.Gt("BoolType", v)
	return d
}

func (d *EntityQuery) GtFloatType(v float64) *EntityQuery {
	d.query = d.query.Gt("FloatType", v)
	return d
}

func (d *EntityQuery) GtCreatedAt(v time.Time) *EntityQuery {
	d.query = d.query.Gt("CreatedAt", v)
	return d
}

func (d *EntityQuery) GtUpdatedAt(v time.Time) *EntityQuery {
	d.query = d.query.Gt("UpdatedAt", v)
	return d
}

func (d *EntityQuery) GtCustomType(v types.RGB) *EntityQuery {
	d.query = d.query.Gt("CustomType", v)
	return d
}

func (d *EntityQuery) GtLocationLat(v float64) *EntityQuery {
	d.query = d.query.Gt("Location.Lat", v)
	return d
}

func (d *EntityQuery) GtLocationLng(v float64) *EntityQuery {
	d.query = d.query.Gt("Location.Lng", v)
	return d
}

func (d *EntityQuery) GtBeforeSaveDesc(v string) *EntityQuery {
	d.query = d.query.Gt("BeforeSaveDesc", v)
	return d
}

func (d *EntityQuery) GtAfterSaveDesc(v string) *EntityQuery {
	d.query = d.query.Gt("AfterSaveDesc", v)
	return d
}

func (d *EntityQuery) GeID(v string) *EntityQuery {
	d.query = d.query.Ge("ID", v)
	return d
}

func (d *EntityQuery) GeDigit(v int) *EntityQuery {
	d.query = d.query.Ge("Digit", v)
	return d
}

func (d *EntityQuery) GeDesc(v string) *EntityQuery {
	d.query = d.query.Ge("Desc", v)
	return d
}

func (d *EntityQuery) GeSliceType(v string) *EntityQuery {
	d.query = d.query.Ge("SliceType", v)
	return d
}

func (d *EntityQuery) GeBoolType(v bool) *EntityQuery {
	d.query = d.query.Ge("BoolType", v)
	return d
}

func (d *EntityQuery) GeFloatType(v float64) *EntityQuery {
	d.query = d.query.Ge("FloatType", v)
	return d
}

func (d *EntityQuery) GeCreatedAt(v time.Time) *EntityQuery {
	d.query = d.query.Ge("CreatedAt", v)
	return d
}

func (d *EntityQuery) GeUpdatedAt(v time.Time) *EntityQuery {
	d.query = d.query.Ge("UpdatedAt", v)
	return d
}

func (d *EntityQuery) GeCustomType(v types.RGB) *EntityQuery {
	d.query = d.query.Ge("CustomType", v)
	return d
}

func (d *EntityQuery) GeLocationLat(v float64) *EntityQuery {
	d.query = d.query.Ge("Location.Lat", v)
	return d
}

func (d *EntityQuery) GeLocationLng(v float64) *EntityQuery {
	d.query = d.query.Ge("Location.Lng", v)
	return d
}

func (d *EntityQuery) GeBeforeSaveDesc(v string) *EntityQuery {
	d.query = d.query.Ge("BeforeSaveDesc", v)
	return d
}

func (d *EntityQuery) GeAfterSaveDesc(v string) *EntityQuery {
	d.query = d.query.Ge("AfterSaveDesc", v)
	return d
}

func (d *EntityQuery) NeID(v string) *EntityQuery {
	d.query = d.query.Ne("ID", v)
	return d
}

func (d *EntityQuery) NeDigit(v int) *EntityQuery {
	d.query = d.query.Ne("Digit", v)
	return d
}

func (d *EntityQuery) NeDesc(v string) *EntityQuery {
	d.query = d.query.Ne("Desc", v)
	return d
}

func (d *EntityQuery) NeSliceType(v string) *EntityQuery {
	d.query = d.query.Ne("SliceType", v)
	return d
}

func (d *EntityQuery) NeBoolType(v bool) *EntityQuery {
	d.query = d.query.Ne("BoolType", v)
	return d
}

func (d *EntityQuery) NeFloatType(v float64) *EntityQuery {
	d.query = d.query.Ne("FloatType", v)
	return d
}

func (d *EntityQuery) NeCreatedAt(v time.Time) *EntityQuery {
	d.query = d.query.Ne("CreatedAt", v)
	return d
}

func (d *EntityQuery) NeUpdatedAt(v time.Time) *EntityQuery {
	d.query = d.query.Ne("UpdatedAt", v)
	return d
}

func (d *EntityQuery) NeCustomType(v types.RGB) *EntityQuery {
	d.query = d.query.Ne("CustomType", v)
	return d
}

func (d *EntityQuery) NeLocationLat(v float64) *EntityQuery {
	d.query = d.query.Ne("Location.Lat", v)
	return d
}

func (d *EntityQuery) NeLocationLng(v float64) *EntityQuery {
	d.query = d.query.Ne("Location.Lng", v)
	return d
}

func (d *EntityQuery) NeBeforeSaveDesc(v string) *EntityQuery {
	d.query = d.query.Ne("BeforeSaveDesc", v)
	return d
}

func (d *EntityQuery) NeAfterSaveDesc(v string) *EntityQuery {
	d.query = d.query.Ne("AfterSaveDesc", v)
	return d
}

func (d *EntityQuery) AscID() *EntityQuery {
	d.query = d.query.Asc("ID")
	return d
}

func (d *EntityQuery) AscDigit() *EntityQuery {
	d.query = d.query.Asc("Digit")
	return d
}

func (d *EntityQuery) AscDesc() *EntityQuery {
	d.query = d.query.Asc("Desc")
	return d
}

func (d *EntityQuery) AscSliceType() *EntityQuery {
	d.query = d.query.Asc("SliceType")
	return d
}

func (d *EntityQuery) AscBoolType() *EntityQuery {
	d.query = d.query.Asc("BoolType")
	return d
}

func (d *EntityQuery) AscFloatType() *EntityQuery {
	d.query = d.query.Asc("FloatType")
	return d
}

func (d *EntityQuery) AscCreatedAt() *EntityQuery {
	d.query = d.query.Asc("CreatedAt")
	return d
}

func (d *EntityQuery) AscUpdatedAt() *EntityQuery {
	d.query = d.query.Asc("UpdatedAt")
	return d
}

func (d *EntityQuery) AscCustomType() *EntityQuery {
	d.query = d.query.Asc("CustomType")
	return d
}

func (d *EntityQuery) AscLocationLat() *EntityQuery {
	d.query = d.query.Asc("Location.Lat")
	return d
}

func (d *EntityQuery) AscLocationLng() *EntityQuery {
	d.query = d.query.Asc("Location.Lng")
	return d
}

func (d *EntityQuery) AscBeforeSaveDesc() *EntityQuery {
	d.query = d.query.Asc("BeforeSaveDesc")
	return d
}

func (d *EntityQuery) AscAfterSaveDesc() *EntityQuery {
	d.query = d.query.Asc("AfterSaveDesc")
	return d
}

func (d *EntityQuery) DescID() *EntityQuery {
	d.query = d.query.Desc("ID")
	return d
}

func (d *EntityQuery) DescDigit() *EntityQuery {
	d.query = d.query.Desc("Digit")
	return d
}

func (d *EntityQuery) DescDesc() *EntityQuery {
	d.query = d.query.Desc("Desc")
	return d
}

func (d *EntityQuery) DescSliceType() *EntityQuery {
	d.query = d.query.Desc("SliceType")
	return d
}

func (d *EntityQuery) DescBoolType() *EntityQuery {
	d.query = d.query.Desc("BoolType")
	return d
}

func (d *EntityQuery) DescFloatType() *EntityQuery {
	d.query = d.query.Desc("FloatType")
	return d
}

func (d *EntityQuery) DescCreatedAt() *EntityQuery {
	d.query = d.query.Desc("CreatedAt")
	return d
}

func (d *EntityQuery) DescUpdatedAt() *EntityQuery {
	d.query = d.query.Desc("UpdatedAt")
	return d
}

func (d *EntityQuery) DescCustomType() *EntityQuery {
	d.query = d.query.Desc("CustomType")
	return d
}

func (d *EntityQuery) DescLocationLat() *EntityQuery {
	d.query = d.query.Desc("Location.Lat")
	return d
}

func (d *EntityQuery) DescLocationLng() *EntityQuery {
	d.query = d.query.Desc("Location.Lng")
	return d
}

func (d *EntityQuery) DescBeforeSaveDesc() *EntityQuery {
	d.query = d.query.Desc("BeforeSaveDesc")
	return d
}

func (d *EntityQuery) DescAfterSaveDesc() *EntityQuery {
	d.query = d.query.Desc("AfterSaveDesc")
	return d
}

func (q *EntityQuery) Start(s string) *EntityQuery {
	q.query = q.query.Start(s)
	return q
}

func (q *EntityQuery) End(s string) *EntityQuery {
	q.query = q.query.End(s)
	return q
}

func (q *EntityQuery) Limit(n int) *EntityQuery {
	q.query = q.query.Limit(n)
	return q
}

func (q *EntityQuery) ViaKeys() *EntityQuery {
	q.viaKeys = true
	return q
}

func (d *EntityKindClient) GetAll(ctx context.Context, q *EntityQuery) ([]*datastore.Key, []Entity, error) {
	if q.viaKeys {
		keys, err := d.client.GetAll(ctx, q.query.KeysOnly(), nil)
		if err != nil {
			return nil, nil, err
		}
		ents := make([]*Entity, len(keys))
		err = d.client.GetMulti(ctx, keys, ents)
		if err != nil {
			return nil, nil, err
		}
		result := make([]Entity, 0)
		for _, e := range ents {
			if e != nil {
				result = append(result, *e)
			}
		}
		return keys, result, nil
	} else {
		var ent []Entity
		keys, err := d.client.GetAll(ctx, q.query, &ent)
		if err != nil {
			return nil, nil, err
		}
		return keys, ent, nil
	}
}

func (d *EntityKindClient) GetOne(ctx context.Context, q *EntityQuery) (*datastore.Key, *Entity, error) {
	keys, ents, err := d.GetAll(ctx, q.Limit(1))
	if err != nil {
		return nil, nil, err
	}
	if len(keys) == 0 {
		return nil, nil, nil
	}
	return keys[0], &(ents[0]), nil
}

func (d *EntityKindClient) MustGetAll(ctx context.Context, q *EntityQuery) ([]*datastore.Key, []Entity) {
	keys, ents, err := d.GetAll(ctx, q)
	xerrors.MustNil(err)
	return keys, ents
}

func (d *EntityKindClient) Count(ctx context.Context, q *EntityQuery) (int, error) {
	return d.client.Count(ctx, q.query)
}

func (d *EntityKindClient) MustCount(ctx context.Context, q *EntityQuery) int {
	c, err := d.Count(ctx, q)
	xerrors.MustNil(err)
	return c
}

func (d *EntityKindClient) Run(ctx context.Context, q *EntityQuery) (*EntityIterator, error) {
	iter, err := d.client.Run(ctx, q.query)
	if err != nil {
		return nil, err
	}
	return &EntityIterator{
		ctx:     ctx,
		iter:    iter,
		viaKeys: q.viaKeys,
		client:  d,
	}, err
}

func (d *EntityKindClient) MustRun(ctx context.Context, q *EntityQuery) *EntityIterator {
	iter, err := d.Run(ctx, q)
	xerrors.MustNil(err)
	return iter
}

func (d *EntityKindClient) RunAll(ctx context.Context, q *EntityQuery) ([]datastore.Key, []Entity, string, error) {
	iter, err := d.Run(ctx, q)
	if err != nil {
		return nil, nil, "", err
	}
	var keys []datastore.Key
	var ents []Entity
	for {
		key, ent, err := iter.Next()
		if err != nil {
			return nil, nil, "", err
		}
		if ent == nil {
			cursor, err := iter.iter.Cursor()
			if err != nil {
				return nil, nil, "", err
			}
			return keys, ents, cursor.String(), nil
		}
		keys = append(keys, *key)
		ents = append(ents, *ent)
	}
}

func (d *EntityKindClient) MustRunAll(ctx context.Context, q *EntityQuery) ([]datastore.Key, []Entity, string) {
	keys, ents, next, err := d.RunAll(ctx, q)
	xerrors.MustNil(err)
	return keys, ents, next
}

type EntityIterator struct {
	ctx     context.Context
	iter    *datastore.Iterator
	viaKeys bool
	client  *EntityKindClient
}

func (iter *EntityIterator) Cursor() (datastore.Cursor, error) {
	return iter.iter.Cursor()
}

func (iter *EntityIterator) MustCursor() datastore.Cursor {
	c, err := iter.iter.Cursor()
	xerrors.MustNil(err)
	return c
}

func (iter *EntityIterator) Next() (*datastore.Key, *Entity, error) {
	if iter.viaKeys {
		key, err := iter.iter.Next(nil)
		if err != nil {
			if err == iterator.Done {
				return nil, nil, nil
			}
			return nil, nil, err
		}
		_, ent, err := iter.client.Get(iter.ctx, key)
		if err != nil {
			return nil, nil, err
		}
		return key, ent, nil
	}
	var ent Entity
	key, err := iter.iter.Next(&ent)
	if err != nil {
		if err == iterator.Done {
			return nil, nil, nil
		}
		return nil, nil, err
	}
	return key, &ent, nil
}

func (iter *EntityIterator) MustNext() (*datastore.Key, *Entity) {
	key, ent, err := iter.Next()
	xerrors.MustNil(err)
	return key, ent
}