Esempio n. 1
0
// This kind of iterator expects to last more than 60s, which is when a regular datastore
// iterator will timeout (it thinks its view of the world is too stale)
// Instead, we just grab all the keys up front, and than instantiate them one at a time.
func (db FlightDB) LongIterWith(q *datastore.Query, flightProcFunc func(*f.Flight)) error {
	keys, err := q.KeysOnly().GetAll(db.C, nil)
	if err != nil {
		return err
	}

	for _, key := range keys {
		blob := f.FrozenFlight{}

		if err := datastore.Get(db.C, key, &blob); err != nil {
			return err
		}

		if flight, err := blob.Thaw(); err != nil {
			return err
		} else {
			//flight.EnterUTC,flight.LeaveUTC = flight.Track.TimesInBox(sfo.KBoxSnarfingCatchment)
			flight.SetDatastoreKey(key.Encode())

			flightProcFunc(flight)
		}
	}

	return nil
}
Esempio n. 2
0
func GetAllKeys(c appengine.Context, q *ds.Query, limit int) ([]*ds.Key, ds.Cursor, bool, error) {
	it := q.KeysOnly().Limit(limit + 1).Run(c)

	keys := make([]*ds.Key, 0, limit)
	hasMore := true
	for i := 0; i < limit; i++ {
		key, err := it.Next(nil)
		if err == ds.Done {
			hasMore = false
			break
		} else if err != nil {
			return nil, ds.Cursor{}, false, err
		}
		keys = append(keys, key)
	}

	cursor, _ := it.Cursor()
	if hasMore {
		if _, err := it.Next(nil); err != nil {
			hasMore = false
		}
	}

	return keys, cursor, hasMore, nil
}
Esempio n. 3
0
func (db FlightDB) countByQuery(q *datastore.Query) (int, error) {
	q2 := q.KeysOnly()

	keys, err := q2.GetAll(db.C, nil)
	if err != nil {
		return 0, err
	}

	return len(keys), nil
}
Esempio n. 4
0
File: db.go Progetto: pimienta/appgo
// USE:  keys,ok := db.SelectKeys(qry)
func (db *Manager) SelectKeys(qry *datastore.Query) ([]string, bool) {
	recs := new(interface{})
	keys, err := qry.KeysOnly().GetAll(db.Context, recs)
	skeys := []string{}
	if err == nil {
		for k := range keys {
			skeys = append(skeys, keys[k].StringID())
		}
	}
	return skeys, err == nil
}
Esempio n. 5
0
func GetPage(c appengine.Context, query *datastore.Query, limit int, keysOnly bool, dst interface{}) (*Page, error) {
	var dv reflect.Value
	var mat multiArgType
	var elemType reflect.Type

	if !keysOnly {
		dv = reflect.ValueOf(dst)
		if dv.Kind() != reflect.Ptr || dv.IsNil() {
			return nil, datastore.ErrInvalidEntityType
		}
		dv = dv.Elem()
		mat, elemType = checkMultiArg(dv)
		if mat == multiArgTypeInvalid || mat == multiArgTypeInterface {
			return nil, datastore.ErrInvalidEntityType
		}
	}

	var keys []*datastore.Key
	var cursor datastore.Cursor

	query = query.Limit(limit + 1)
	if keysOnly {
		query = query.KeysOnly()
	}
	t := query.Run(c)
	more := true
	for i := 0; i < limit; i++ {
		var ev reflect.Value
		if !keysOnly {
			ev = reflect.New(elemType)
		}
		k, err := t.Next(ev.Interface())
		if err == datastore.Done {
			more = false
			break
		}
		if err != nil {
			return nil, err
		}
		if !keysOnly {
			if mat != multiArgTypeStructPtr {
				ev = ev.Elem()
			}
			dv.Set(reflect.Append(dv, ev))
		}
		keys = append(keys, k)
	}

	if more {
		var err error
		cursor, err = t.Cursor()
		if err != nil {
			return nil, err
		}
		var ei interface{}
		if !keysOnly {
			ei = reflect.New(elemType).Interface()
		}
		_, err = t.Next(ei)
		if err == datastore.Done {
			more = false
		}
	}

	return &Page{
		Keys:  keys,
		Start: cursor,
		More:  more,
	}, nil
}