func (this *Fetch) UnmarshalJSON(body []byte) error { var _unmarshalled struct { _ string `json:"#operator"` Proj string `json:"projection"` Names string `json:"namespace"` Keys string `json:"keyspace"` As string `json:"as"` } var proj_expr expression.Path err := json.Unmarshal(body, &_unmarshalled) if err != nil { return err } if _unmarshalled.Proj != "" { expr, err := parser.Parse(_unmarshalled.Proj) if err != nil { return err } _proj_expr, is_path := expr.(expression.Path) if !is_path { return fmt.Errorf("Fetch.UnmarshalJSON: cannot resolve path expression from %s", _unmarshalled.Proj) } proj_expr = _proj_expr } this.term = algebra.NewKeyspaceTerm(_unmarshalled.Names, _unmarshalled.Keys, proj_expr, _unmarshalled.As, nil, nil) this.keyspace, err = datastore.GetKeyspace(_unmarshalled.Names, _unmarshalled.Keys) return err }
func (this *Join) UnmarshalJSON(body []byte) error { var _unmarshalled struct { _ string `json:"#operator"` Names string `json:"namespace"` Keys string `json:"keyspace"` On string `json:"on_keys"` Outer bool `json:"outer"` As string `json:"as"` } var keys_expr expression.Expression err := json.Unmarshal(body, &_unmarshalled) if err != nil { return err } if _unmarshalled.On != "" { keys_expr, err = parser.Parse(_unmarshalled.On) if err != nil { return err } } this.outer = _unmarshalled.Outer this.term = algebra.NewKeyspaceTerm(_unmarshalled.Names, _unmarshalled.Keys, nil, _unmarshalled.As, keys_expr, nil) this.keyspace, err = datastore.GetKeyspace(_unmarshalled.Names, _unmarshalled.Keys) return err }
func (this *IndexScan) UnmarshalJSON(body []byte) error { var _unmarshalled struct { _ string `json:"#operator"` Index string `json:"index"` Namespace string `json:"namespace"` Keyspace string `json:"keyspace"` Using datastore.IndexType `json:"using"` Spans Spans `json:"spans"` Distinct bool `json:"distinct"` Limit string `json:"limit"` Covers []string `json:"covers"` } err := json.Unmarshal(body, &_unmarshalled) if err != nil { return err } k, err := datastore.GetKeyspace(_unmarshalled.Namespace, _unmarshalled.Keyspace) if err != nil { return err } this.term = algebra.NewKeyspaceTerm( _unmarshalled.Namespace, _unmarshalled.Keyspace, nil, "", nil, nil) this.spans = _unmarshalled.Spans this.distinct = _unmarshalled.Distinct if _unmarshalled.Limit != "" { this.limit, err = parser.Parse(_unmarshalled.Limit) if err != nil { return err } } if _unmarshalled.Covers != nil { this.covers = make(expression.Covers, len(_unmarshalled.Covers)) for i, c := range _unmarshalled.Covers { expr, err := parser.Parse(c) if err != nil { return err } this.covers[i] = expression.NewCover(expr) } } indexer, err := k.Indexer(_unmarshalled.Using) if err != nil { return err } this.index, err = indexer.IndexByName(_unmarshalled.Index) return err }
func (this *PrimaryScan) UnmarshalJSON(body []byte) error { var _unmarshalled struct { _ string `json:"#operator"` Index string `json:"index"` Names string `json:"namespace"` Keys string `json:"keyspace"` Using datastore.IndexType `json:"using"` Limit string `json:"limit"` } err := json.Unmarshal(body, &_unmarshalled) if err != nil { return err } if _unmarshalled.Limit != "" { this.limit, err = parser.Parse(_unmarshalled.Limit) if err != nil { return err } } this.keyspace, err = datastore.GetKeyspace(_unmarshalled.Names, _unmarshalled.Keys) if err != nil { return err } this.term = algebra.NewKeyspaceTerm( _unmarshalled.Names, _unmarshalled.Keys, nil, "", nil, nil) indexer, err := this.keyspace.Indexer(_unmarshalled.Using) if err != nil { return err } index, err := indexer.IndexByName(_unmarshalled.Index) if err != nil { return err } primary, ok := index.(datastore.PrimaryIndex) if ok { this.index = primary return nil } return fmt.Errorf("Unable to unmarshal %s as primary index.", _unmarshalled.Index) }
func (this *builder) beginMutate(keyspace datastore.Keyspace, ksref *algebra.KeyspaceRef, keys expression.Expression, indexes algebra.IndexRefs, limit expression.Expression, isDelete bool) error { ksref.SetDefaultNamespace(this.namespace) term := algebra.NewKeyspaceTerm(ksref.Namespace(), ksref.Keyspace(), nil, ksref.As(), keys, indexes) this.children = make([]plan.Operator, 0, 8) this.subChildren = make([]plan.Operator, 0, 8) if this.where != nil { limit = nil } scan, err := this.selectScan(keyspace, term, limit) if err != nil { return err } this.children = append(this.children, scan) if this.coveringScan != nil { coverer := expression.NewCoverer(this.coveringScan.Covers()) err = this.cover.MapExpressions(coverer) if err != nil { return err } if this.where != nil { this.where, err = coverer.Map(this.where) if err != nil { return err } } } else { var fetch plan.Operator if isDelete && this.where == nil && isKeyScan(scan) { fetch = plan.NewDummyFetch(keyspace, term) } else { fetch = plan.NewFetch(keyspace, term) } this.subChildren = append(this.subChildren, fetch) } if this.where != nil { this.subChildren = append(this.subChildren, plan.NewFilter(this.where)) } return nil }
func (this *IndexNest) UnmarshalJSON(body []byte) error { var _unmarshalled struct { _ string `json:"#operator"` Names string `json:"namespace"` Keys string `json:"keyspace"` On string `json:"on_key"` Outer bool `json:"outer"` As string `json:"as"` For string `json:"for"` Scan struct { Index string `json:"index"` Using datastore.IndexType `json:"using"` Covers []string `json:"covers"` } `json:"scan"` } err := json.Unmarshal(body, &_unmarshalled) if err != nil { return err } var keys_expr expression.Expression if _unmarshalled.On != "" { keys_expr, err = parser.Parse(_unmarshalled.On) if err != nil { return err } } this.outer = _unmarshalled.Outer this.keyFor = _unmarshalled.For this.idExpr = expression.NewField( expression.NewMeta(expression.NewIdentifier(this.keyFor)), expression.NewFieldName("id", false)) this.term = algebra.NewKeyspaceTerm(_unmarshalled.Names, _unmarshalled.Keys, nil, _unmarshalled.As, keys_expr, nil) this.keyspace, err = datastore.GetKeyspace(_unmarshalled.Names, _unmarshalled.Keys) if err != nil { return err } indexer, err := this.keyspace.Indexer(_unmarshalled.Scan.Using) if err != nil { return err } this.index, err = indexer.IndexByName(_unmarshalled.Scan.Index) if err != nil { return err } if _unmarshalled.Scan.Covers != nil { this.covers = make(expression.Covers, len(_unmarshalled.Scan.Covers)) for i, c := range _unmarshalled.Scan.Covers { expr, err := parser.Parse(c) if err != nil { return err } this.covers[i] = expression.NewCover(expr) } } return nil }