/*
Marshals input into byte array.
*/
func (this *SetTerm) MarshalJSON() ([]byte, error) {
r := map[string]interface{}{"type": "setTerm"}
r["path"] = expression.NewStringer().Visit(this.path)
r["value"] = expression.NewStringer().Visit(this.value)
r["updateFor"] = this.updateFor
return json.Marshal(r)
}
func (this *Set) MarshalJSON() ([]byte, error) {
r := map[string]interface{}{"#operator": "Set"}
s := make([]interface{}, 0, len(this.node.Terms()))
for _, term := range this.node.Terms() {
t := make(map[string]interface{})
t["path"] = expression.NewStringer().Visit(term.Path())
t["expr"] = expression.NewStringer().Visit(term.Value())
s = append(s, t)
}
r["set_terms"] = s
return json.Marshal(r)
}
/*
Marshals the input keyspace into a byte array.
*/
func (this *KeyspaceTerm) MarshalJSON() ([]byte, error) {
r := map[string]interface{}{"type": "keyspaceTerm"}
r["as"] = this.as
if this.keys != nil {
r["keys"] = expression.NewStringer().Visit(this.keys)
}
r["namespace"] = this.namespace
r["keyspace"] = this.keyspace
if this.projection != nil {
r["projection"] = expression.NewStringer().Visit(this.projection)
}
return json.Marshal(r)
}
func (this *InitialGroup) MarshalJSON() ([]byte, error) {
r := map[string]interface{}{"#operator": "InitialGroup"}
keylist := make([]string, 0, len(this.keys))
for _, key := range this.keys {
keylist = append(keylist, expression.NewStringer().Visit(key))
}
r["group_keys"] = keylist
s := make([]interface{}, 0, len(this.aggregates))
for _, agg := range this.aggregates {
s = append(s, expression.NewStringer().Visit(agg))
}
r["aggregates"] = s
return json.Marshal(r)
}
func (this *InitialProject) MarshalJSON() ([]byte, error) {
r := map[string]interface{}{"#operator": "InitialProject"}
if this.projection.Distinct() {
r["distinct"] = this.projection.Distinct()
}
if this.projection.Raw() {
r["raw"] = this.projection.Raw()
}
s := make([]interface{}, 0, len(this.terms))
for _, term := range this.terms {
t := make(map[string]interface{})
if term.Result().Star() {
t["star"] = term.Result().Star()
}
if term.Result().As() != "" {
t["as"] = term.Result().As()
}
expr := term.Result().Expression()
if expr != nil {
t["expr"] = expression.NewStringer().Visit(expr)
}
s = append(s, t)
}
r["result_terms"] = s
return json.Marshal(r)
}
func indexKeyToIndexKeyStringArray(key expression.Expressions) []string {
rv := make([]string, len(key))
for i, kp := range key {
rv[i] = expression.NewStringer().Visit(kp)
}
return rv
}
func Test2iCondition(t *testing.T) {
whereKey := index.Condition()
v := expression.NewStringer().Visit(whereKey)
if v != "(30 < `age`)" {
t.Fatalf("failed Condition() - %v, expected (30 < `age`)", v)
}
}
func Test2iSeekKey(t *testing.T) {
equalKey := index.SeekKey()
if len(equalKey) != 1 {
t.Fatalf("failed SeekKey() - %v, expected 1", len(equalKey))
} else if v := expression.NewStringer().Visit(equalKey[0]); v != "`gender`" {
t.Fatalf("failed SeekKey() - %v, expected `gender`", v)
}
}
/*
Marshals input receiver into byte array.
*/
func (this *CreateIndex) MarshalJSON() ([]byte, error) {
r := map[string]interface{}{"type": "createIndex"}
r["keyspaceRef"] = this.keyspace
r["name"] = this.name
if this.partition != nil {
r["partition"] = expression.NewStringer().Visit(this.partition)
}
if this.where != nil {
r["where"] = expression.NewStringer().Visit(this.where)
}
r["using"] = this.using
if this.with != nil {
r["with"] = this.with
}
return json.Marshal(r)
}
func Test2iRangeKey(t *testing.T) {
rangeKey := index.RangeKey()
if len(rangeKey) != 1 {
t.Fatalf("failed RangeKey() - %v, expected 1", len(rangeKey))
} else if v := expression.NewStringer().Visit(rangeKey[0]); v != "`name`" {
t.Fatalf("failed RangeKey() - %v, expected `name`")
}
}
/*
Marshals input into byte array.
*/
func (this *UpdateFor) MarshalJSON() ([]byte, error) {
r := map[string]interface{}{"type": "updateFor"}
r["bindings"] = this.bindings
if this.when != nil {
r["when"] = expression.NewStringer().Visit(this.when)
}
return json.Marshal(r)
}
/*
Marshals input unnest terms into byte array.
*/
func (this *Unnest) MarshalJSON() ([]byte, error) {
r := map[string]interface{}{"type": "unnest"}
r["left"] = this.left
r["as"] = this.as
r["outer"] = this.outer
if this.expr != nil {
r["expr"] = expression.NewStringer().Visit(this.expr)
}
return json.Marshal(r)
}
/*
Marshal input ResultTerm into byte array.
*/
func (this *ResultTerm) MarshalJSON() ([]byte, error) {
r := map[string]interface{}{"type": "resultTerm"}
r["alias"] = this.alias
r["as"] = this.as
if this.expr != nil {
r["expr"] = expression.NewStringer().Visit(this.expr)
}
r["star"] = this.star
return json.Marshal(r)
}
func (this *Merge) MarshalJSON() ([]byte, error) {
r := map[string]interface{}{"#operator": "Merge"}
r["keyspace"] = this.keyspace.Name()
r["namespace"] = this.keyspace.NamespaceId()
r["keyspaceRef"] = this.ref
r["key"] = expression.NewStringer().Visit(this.key)
r["update"] = this.update
r["delete"] = this.delete
r["insert"] = this.insert
return json.Marshal(r)
}
func (this *Fetch) MarshalJSON() ([]byte, error) {
r := map[string]interface{}{"#operator": "Fetch"}
if this.term.Projection() != nil {
r["projection"] = expression.NewStringer().Visit(this.term.Projection())
}
r["namespace"] = this.term.Namespace()
r["keyspace"] = this.term.Keyspace()
if this.term.As() != "" {
r["as"] = this.term.As()
}
return json.Marshal(r)
}
func (this *Unnest) MarshalJSON() ([]byte, error) {
r := map[string]interface{}{"#operator": "Unnest"}
if this.term.Outer() {
r["outer"] = this.term.Outer()
}
r["expr"] = expression.NewStringer().Visit(this.term.Expression())
if this.alias != "" {
r["as"] = this.alias
}
return json.Marshal(r)
}
func (this *Join) MarshalJSON() ([]byte, error) {
r := map[string]interface{}{"#operator": "Join"}
r["namespace"] = this.term.Namespace()
r["keyspace"] = this.term.Keyspace()
r["on_keys"] = expression.NewStringer().Visit(this.term.Keys())
if this.outer {
r["outer"] = this.outer
}
if this.term.As() != "" {
r["as"] = this.term.As()
}
return json.Marshal(r)
}
func (this *Unset) MarshalJSON() ([]byte, error) {
r := map[string]interface{}{"#operator": "Unset"}
s := make([]interface{}, 0, len(this.node.Terms()))
for _, term := range this.node.Terms() {
t := make(map[string]interface{})
t["path"] = expression.NewStringer().Visit(term.Path())
// FIXME
//t["expr"] = expression.NewStringer().Visit(term.UpdateFor().Bindings())
t["expr"] = "FIXME"
s = append(s, t)
}
r["unset_terms"] = s
return json.Marshal(r)
}
func (this *Order) MarshalJSON() ([]byte, error) {
r := map[string]interface{}{"#operator": "Order"}
/* generate sort terms */
s := make([]interface{}, 0, len(this.terms))
for _, term := range this.terms {
q := make(map[string]interface{})
q["expr"] = expression.NewStringer().Visit(term.Expression())
if term.Descending() {
q["desc"] = term.Descending()
}
s = append(s, q)
}
r["sort_terms"] = s
return json.Marshal(r)
}
func collectAggregates(aggs map[string]algebra.Aggregate, exprs ...expression.Expression) {
stringer := expression.NewStringer()
for _, expr := range exprs {
agg, ok := expr.(algebra.Aggregate)
if ok {
str := stringer.Visit(agg)
aggs[str] = agg
}
_, ok = expr.(*algebra.Subquery)
if !ok {
children := expr.Children()
if len(children) > 0 {
collectAggregates(aggs, children...)
}
}
}
}
func (idx *viewIndex) putDesignDoc() error {
var view cb.ViewDefinition
view.Map = idx.ddoc.mapfn
var put ddocJSON
put.Views = make(map[string]cb.ViewDefinition)
put.Views[idx.name] = view
put.IndexChecksum = idx.ddoc.checksum()
put.IndexOn = make([]string, len(idx.on))
for idx, expr := range idx.on {
put.IndexOn[idx] = expression.NewStringer().Visit(expr)
}
if err := idx.keyspace.cbbucket.PutDDoc(idx.DDocName(), &put); err != nil {
return err
}
var saved *ddocJSON = nil
var err error = nil
// give the PUT some time to register
for i := 0; i < 3; i++ {
if i > 1 {
time.Sleep(time.Duration(i*3) * time.Second)
}
saved, err = getDesignDoc(idx.keyspace, idx.DDocName())
if err == nil {
break
}
}
if err != nil {
return errors.New("Creating index '" + idx.name + "' failed: " + err.Error())
}
if saved.IndexChecksum != idx.ddoc.checksum() {
return errors.New("Checksum mismatch after creating index '" + idx.name + "'")
}
return nil
}
func (this *KeyScan) MarshalJSON() ([]byte, error) {
r := map[string]interface{}{"#operator": "KeyScan"}
r["keys"] = expression.NewStringer().Visit(this.keys)
return json.Marshal(r)
}
func (this *Filter) MarshalJSON() ([]byte, error) {
r := map[string]interface{}{"#operator": "Filter"}
r["condition"] = expression.NewStringer().Visit(this.cond)
return json.Marshal(r)
}
func (this *Limit) MarshalJSON() ([]byte, error) {
r := map[string]interface{}{"#operator": "Limit"}
r["expr"] = expression.NewStringer().Visit(this.expr)
return json.Marshal(r)
}
