func (this *PrimaryScan) scanPrimaryChunk(context *Context, parent value.Value, chunkSize int, indexEntry *datastore.IndexEntry) *datastore.IndexEntry {
conn, _ := datastore.NewSizedIndexConnection(int64(chunkSize), context)
conn.SetPrimary()
defer notifyConn(conn.StopChannel()) // Notify index that I have stopped
var duration time.Duration
timer := time.Now()
defer context.AddPhaseTime("scan", time.Since(timer)-duration)
go this.scanChunk(context, conn, chunkSize, indexEntry)
var entry, lastEntry *datastore.IndexEntry
ok := true
nitems := 0
for ok {
select {
case <-this.stopChannel:
return nil
default:
}
select {
case entry, ok = <-conn.EntryChannel():
t := time.Now()
if ok {
cv := value.NewScopeValue(make(map[string]interface{}), parent)
av := value.NewAnnotatedValue(cv)
av.SetAttachment("meta", map[string]interface{}{"id": entry.PrimaryKey})
ok = this.sendItem(av)
lastEntry = entry
nitems++
}
duration += time.Since(t)
case <-this.stopChannel:
return nil
}
}
logging.Debugp("Primary index chunked scan", logging.Pair{"chunkSize", nitems}, logging.Pair{"lastKey", lastEntry})
return lastEntry
}
func (this *PrimaryScan) newIndexConnection(context *Context) *datastore.IndexConnection {
var conn *datastore.IndexConnection
// Use keyspace count to create a sized index connection
keyspace := this.plan.Keyspace()
size, err := keyspace.Count()
if err == nil {
if size <= 0 {
size = 1
}
conn, err = datastore.NewSizedIndexConnection(size, context)
conn.SetPrimary()
}
// Use non-sized API and log error
if err != nil {
conn = datastore.NewIndexConnection(context)
conn.SetPrimary()
logging.Errorp("PrimaryScan.newIndexConnection ", logging.Pair{"error", err})
}
return conn
}