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
}