gremlindocs-side-effects.expected

node > // gremlindocs-side-effects
node > // See http://gremlindocs.com/#side-effect
node > 
node > // ### http://gremlindocs.com/#side-effect/aggregate
node > // Emits input, but adds input in collection, where provided closure processes input prior to
node > // insertion (greedy). In being "greedy", 'aggregate' will exhaust all the items that come to
node > // it from previous steps before emitting the next element.
node > x = new ArrayList
'[]'
node > g.V('id', '1').out().order('{it -> it.a.id <=> it.b.id}').aggregate(x).out().except(x)
[
  {
    _id: '5',
    _type: 'vertex',
    lang: 'java',
    name: 'ripple'
  }
]
node > x
'[v[2], v[3], v[4]]'
node > 
node > // ### http://gremlindocs.com/#side-effect/as
node > // Emits input, but names the previous step.
node > g.V().as('x').outE('knows').inV().has('age', T.gt, 30).back('x').property('age').order()
[
  29
]
node > 
node > // ### http://gremlindocs.com/#side-effect/groupby
node > // Emits input, but groups input after processing it by provided key-closure and value-closure.
node > // It is also possible to supply an optional reduce-closure.
node > g.V().order('{it -> it.a.id <=> it.b.id}').groupBy('{it -> it}', '{it -> it.out}').cap()
[
  {
    1: {
      _key: {
        _id: '1',
        _type: 'vertex',
        age: 29,
        name: 'marko'
      },
      _value: [
        {
          _id: '2',
          _type: 'vertex',
          age: 27,
          name: 'vadas'
        },
        {
          _id: '3',
          _type: 'vertex',
          lang: 'java',
          name: 'lop'
        },
        {
          _id: '4',
          _type: 'vertex',
          age: 32,
          name: 'josh'
        }
      ]
    },
    2: {
      _key: {
        _id: '2',
        _type: 'vertex',
        age: 27,
        name: 'vadas'
      },
      _value: [
      ]
    },
    3: {
      _key: {
        _id: '3',
        _type: 'vertex',
        lang: 'java',
        name: 'lop'
      },
      _value: [
      ]
    },
    4: {
      _key: {
        _id: '4',
        _type: 'vertex',
        age: 32,
        name: 'josh'
      },
      _value: [
        {
          _id: '3',
          _type: 'vertex',
          lang: 'java',
          name: 'lop'
        },
        {
          _id: '5',
          _type: 'vertex',
          lang: 'java',
          name: 'ripple'
        }
      ]
    },
    5: {
      _key: {
        _id: '5',
        _type: 'vertex',
        lang: 'java',
        name: 'ripple'
      },
      _value: [
      ]
    },
    6: {
      _key: {
        _id: '6',
        _type: 'vertex',
        age: 35,
        name: 'peter'
      },
      _value: [
        {
          _id: '3',
          _type: 'vertex',
          lang: 'java',
          name: 'lop'
        }
      ]
    }
  }
]
node > g.V().order('{it -> it.a.id <=> it.b.id}').groupBy('{it -> it}', '{it -> it.out}', '{it->it.size()}').cap()
[
  {
    1: {
      _key: {
        _id: '1',
        _type: 'vertex',
        age: 29,
        name: 'marko'
      },
      _value: 3
    },
    2: {
      _key: {
        _id: '2',
        _type: 'vertex',
        age: 27,
        name: 'vadas'
      },
      _value: 0
    },
    3: {
      _key: {
        _id: '3',
        _type: 'vertex',
        lang: 'java',
        name: 'lop'
      },
      _value: 0
    },
    4: {
      _key: {
        _id: '4',
        _type: 'vertex',
        age: 32,
        name: 'josh'
      },
      _value: 2
    },
    5: {
      _key: {
        _id: '5',
        _type: 'vertex',
        lang: 'java',
        name: 'ripple'
      },
      _value: 0
    },
    6: {
      _key: {
        _id: '6',
        _type: 'vertex',
        age: 35,
        name: 'peter'
      },
      _value: 1
    }
  }
]
node > m = new HashMap
'{}'
node > g.V().order('{it -> it.a.id <=> it.b.id}').groupBy(m, '{it -> it}', '{it -> it.out}')
[
  {
    _id: '1',
    _type: 'vertex',
    age: 29,
    name: 'marko'
  },
  {
    _id: '2',
    _type: 'vertex',
    age: 27,
    name: 'vadas'
  },
  {
    _id: '3',
    _type: 'vertex',
    lang: 'java',
    name: 'lop'
  },
  {
    _id: '4',
    _type: 'vertex',
    age: 32,
    name: 'josh'
  },
  {
    _id: '5',
    _type: 'vertex',
    lang: 'java',
    name: 'ripple'
  },
  {
    _id: '6',
    _type: 'vertex',
    age: 35,
    name: 'peter'
  }
]
node > // Normally, one can do the following command to see the contents of the HashMap.
node > // However, the order the HashMap is printed is not deterministic, so can't be used in a unit test.
node > // m
node > 
node > // ### http://gremlindocs.com/#side-effect/groupcount
node > // Emits input, but updates a map for each input, where closures provides generic map update.
node > m = new HashMap
'{}'
node > g.V().out().order('{it -> it.a.id <=> it.b.id}').groupCount(m)
[
  {
    _id: '2',
    _type: 'vertex',
    age: 27,
    name: 'vadas'
  },
  {
    _id: '3',
    _type: 'vertex',
    lang: 'java',
    name: 'lop'
  },
  {
    _id: '3',
    _type: 'vertex',
    lang: 'java',
    name: 'lop'
  },
  {
    _id: '3',
    _type: 'vertex',
    lang: 'java',
    name: 'lop'
  },
  {
    _id: '4',
    _type: 'vertex',
    age: 32,
    name: 'josh'
  },
  {
    _id: '5',
    _type: 'vertex',
    lang: 'java',
    name: 'ripple'
  }
]
node > // m
node > m = new HashMap
'{}'
node > g.V('id', '1').out().order('{it -> it.a.id <=> it.b.id}').groupCount(m, '{it->it}', '{it->it.b+1.0}').out().order('{it -> it.a.id <=> it.b.id}').groupCount(m, '{it->it}', '{it->it.b+0.5}')
[
  {
    _id: '3',
    _type: 'vertex',
    lang: 'java',
    name: 'lop'
  },
  {
    _id: '5',
    _type: 'vertex',
    lang: 'java',
    name: 'ripple'
  }
]
node > // m
node > 
node > // ### http://gremlindocs.com/#side-effect/optional
node > // Behaves similar to back except that it does not filter. It will go down a particular path and back
node > // up to where it left off. As such, its useful for yielding a side-effect down a particular branch.
node > g.V().as('x').outE('knows').inV().has('age', T.gt, 30).back('x')
[
  {
    _id: '1',
    _type: 'vertex',
    age: 29,
    name: 'marko'
  }
]
node > g.V().as('x').outE('knows').inV().has('age', T.gt, 30).optional('x')
[
  {
    _id: '1',
    _type: 'vertex',
    age: 29,
    name: 'marko'
  },
  {
    _id: '2',
    _type: 'vertex',
    age: 27,
    name: 'vadas'
  },
  {
    _id: '3',
    _type: 'vertex',
    lang: 'java',
    name: 'lop'
  },
  {
    _id: '4',
    _type: 'vertex',
    age: 32,
    name: 'josh'
  },
  {
    _id: '5',
    _type: 'vertex',
    lang: 'java',
    name: 'ripple'
  },
  {
    _id: '6',
    _type: 'vertex',
    age: 35,
    name: 'peter'
  }
]
node > 
node > // ### http://gremlindocs.com/#side-effect/sideeffect
node > // Actually, the example at gremlindocs.com can't be done here.
node > // But there is a good example of sideEffect at http://markorodriguez.com/2011/08/03/on-the-nature-of-pipes/
node > // Note that x stores the value of the iterator (a vertex) in the sideEffect step, and then x is used
node > // in the final filter step.
node > g.V('id', '1').sideEffect('{it -> x=it}')
[
  {
    _id: '1',
    _type: 'vertex',
    age: 29,
    name: 'marko'
  }
]
node > g.V('id', '1').sideEffect('{it -> x=it}').out('created')
[
  {
    _id: '3',
    _type: 'vertex',
    lang: 'java',
    name: 'lop'
  }
]
node > g.V('id', '1').sideEffect('{it -> x=it}').out('created').in('created')
[
  {
    _id: '1',
    _type: 'vertex',
    age: 29,
    name: 'marko'
  },
  {
    _id: '4',
    _type: 'vertex',
    age: 32,
    name: 'josh'
  },
  {
    _id: '6',
    _type: 'vertex',
    age: 35,
    name: 'peter'
  }
]
node > g.V('id', '1').sideEffect('{it -> x=it}').out('created').in('created').filter('{it -> it != x}')
[
  {
    _id: '4',
    _type: 'vertex',
    age: 32,
    name: 'josh'
  },
  {
    _id: '6',
    _type: 'vertex',
    age: 35,
    name: 'peter'
  }
]
node > 
node > // ### http://gremlindocs.com/#side-effect/store
node > // Emits input, but adds input to collection, where provided closure processes input prior to
node > // insertion (lazy). In being "lazy", 'store' will keep element as they are being requested.
node > x = new ArrayList
'[]'
node > g.V('id', '1').out().order('{it -> it.a.id <=> it.b.id}').store(x).map()
[
  {
    age: 27,
    name: 'vadas'
  },
  {
    age: 32,
    name: 'josh'
  },
  {
    lang: 'java',
    name: 'lop'
  }
]
node > x
'[v[2], v[3], v[4]]'
node > x = new ArrayList
'[]'
node > g.V('id', '1').out().order('{it -> it.a.id <=> it.b.id}').store(x).next(function (err, val) { })
node > // We'd like to immediately check the value of x here, but there is a race condition since
node > // the above statement uses an async callback. As a hack, we execute something else first
node > // and then check the value of x. This is not absolutely guaranteed to work, but should with very probability.
node > g.V().out().out().out().id()
[
]
node > // Ok, now check value of x
node > x
'[v[2]]'
node > 
node > // ### http://gremlindocs.com/#side-effect/table
node > // Emits input, but stores row of as values (constrained by column names if provided) in a table.
node > // Accepts an optional set of closures that are applied in round-robin fashion to each column of the table.
node > t = new g.Table
'[]'
node > g.V().order('{it -> it.a.id <=> it.b.id}').as('x').property('name').as('name').back('x').property('age').as('age').table(t)
[
  27,
  29,
  32,
  35,
  null,
  null
]
node > t
'[[x:v[1], name:marko, age:29], [x:v[2], name:vadas, age:27], [x:v[3], name:lop, age:null], [x:v[4], name:josh, age:32], [x:v[5], name:ripple, age:null], [x:v[6], name:peter, age:35]]'
node > t = new g.Table
'[]'
node > g.V().order('{it -> it.a.id <=> it.b.id}').has('age').as('x').property('name').as('name').back('x').property('age').as('age').table(t, '{it->it}', '{it->it}', '{it->it>30 ? "over thirty" : "under thirty"}')
[
  27,
  29,
  32,
  35
]
node > t
'[[x:v[1], name:marko, age:under thirty], [x:v[2], name:vadas, age:under thirty], [x:v[4], name:josh, age:over thirty], [x:v[6], name:peter, age:over thirty]]'
node > 
node > // ### http://gremlindocs.com/#side-effect/tree
node > // Emit input, but stores the tree formed by the traversal as a map. Accepts an optional set of closures
node > // to be applied in round-robin fashion over each level of the tree.
node > g.V('id', '1').out().out().tree().cap()
[
  {
    1: {
      _key: {
        _id: '1',
        _type: 'vertex',
        age: 29,
        name: 'marko'
      },
      _value: {
        4: {
          _key: {
            _id: '4',
            _type: 'vertex',
            age: 32,
            name: 'josh'
          },
          _value: {
            3: {
              _key: {
                _id: '3',
                _type: 'vertex',
                lang: 'java',
                name: 'lop'
              },
              _value: {
              }
            },
            5: {
              _key: {
                _id: '5',
                _type: 'vertex',
                lang: 'java',
                name: 'ripple'
              },
              _value: {
              }
            }
          }
        }
      }
    }
  }
]
node > 
node > 'goodbye'
'goodbye'
node >