func (this *Unnest) processItem(item value.AnnotatedValue, context *Context) bool { ev, err := this.plan.Term().Expression().Evaluate(item, context) if err != nil { context.Error(errors.NewEvaluationError(err, "UNNEST path")) return false } actuals := ev.Actual() switch actuals.(type) { case []interface{}: case nil: actuals = []interface{}(nil) default: actuals = []interface{}{actuals} } acts := actuals.([]interface{}) if len(acts) == 0 { // Outer unnest return !this.plan.Term().Outer() || this.sendItem(item) } // Attach and send for i, act := range acts { var av value.AnnotatedValue if i < len(acts)-1 { av = value.NewAnnotatedValue(item.Copy()) } else { av = item } actv := value.NewAnnotatedValue(act) actv.SetAttachment("unnest_position", i) av.SetField(this.plan.Alias(), actv) if !this.sendItem(av) { return false } } return true }
func (this *IndexJoin) joinEntry(item value.AnnotatedValue, entry *datastore.IndexEntry, context *Context) (found, ok bool) { var jv value.AnnotatedValue covers := this.plan.Covers() if len(covers) == 0 { jv, ok = this.fetch(entry, context) if jv == nil || !ok { return jv != nil, ok } } else { jv = value.NewAnnotatedValue(nil) meta := map[string]interface{}{"id": entry.PrimaryKey} jv.SetAttachment("meta", meta) for i, c := range covers { jv.SetCover(c.Text(), entry.EntryKey[i]) } } joined := item.Copy().(value.AnnotatedValue) joined.SetField(this.plan.Term().Alias(), jv) return true, this.sendItem(joined) }
func (this *Join) processItem(item value.AnnotatedValue, context *Context) bool { kv, e := this.plan.Term().Keys().Evaluate(item, context) if e != nil { context.Error(errors.NewEvaluationError(e, "JOIN keys")) return false } actuals := kv.Actual() switch actuals.(type) { case []interface{}: case nil: actuals = []interface{}(nil) default: actuals = []interface{}{actuals} } acts := actuals.([]interface{}) if len(acts) == 0 { // Outer join return !this.plan.Outer() || this.sendItem(item) } // Build list of keys keys := make([]string, 0, len(acts)) for _, key := range acts { k := value.NewValue(key).Actual() switch k := k.(type) { case string: keys = append(keys, k) } } timer := time.Now() // Fetch pairs, errs := this.plan.Keyspace().Fetch(keys) this.duration += time.Since(timer) fetchOk := true for _, err := range errs { context.Error(err) if err.IsFatal() { fetchOk = false } } found := len(pairs) > 0 // Attach and send for i, pair := range pairs { joinItem := pair.Value var jv value.AnnotatedValue // Apply projection, if any projection := this.plan.Term().Projection() if projection != nil { projectedItem, e := projection.Evaluate(joinItem, context) if e != nil { context.Error(errors.NewEvaluationError(e, "join path")) return false } jv = value.NewAnnotatedValue(projectedItem) jv.SetAnnotations(joinItem) } else { jv = joinItem } var av value.AnnotatedValue if i < len(pairs)-1 { av = value.NewAnnotatedValue(item.Copy()) } else { av = item } av.SetField(this.plan.Term().Alias(), jv) if !this.sendItem(av) { return false } } return (found || !this.plan.Outer() || this.sendItem(item)) && fetchOk }