TODO

* add the ability for construct to take a seq of maps for a node entry, and then
when pointed to in edges have an edge created per node.

* start using transactions

* Add a (graph-event-channel [g]) which will publish an event any time the graph
is modified.

* Add a sum operator and query form

* figure out an error handling policy and right some helpers to
 - make it quick and easy to throw exceptions from query-plan builder
functions when bad arguments are passed
 - report on errors that occurred during query processing

 ** maybe pipelines?

* Query form (ala construct and query) to:
- update node/edge
- delete node/edge

* extend expressions to work on edge property predicates
 - path macro needs to do similar rebinding as the where macro

-----------

* recursive queries
* create a recur-query that will smartly be both local and remote
depending on whether it gets a proxy node as a result

------------

* implement recursive and iterative operators

----------------------------------------------------------

Move to records and a standard protocol for query.operators:

* Goal: standardize the interface and access to important operator info
  - dataflow dependencies for optimizing query plan
  - specific arguments by name for re-organizing operators, combining operators

methods:
* branch?
 - replaces the operator/op-branch-map
* plan version
* instance version

-------------------------------
Longer Term:
-------------------------------

* look into jiraph versioning mechanism

-----------

* represent queries using a query specification, rather than the query plan
operator tree

* query spec map:
 - paths
 - selections
 - expressions
 - property-loads (to load as we traverse)
 - projection

------------------
Minimized query plan:

* path(s)
* selection(s)
* properties to load
--
* sort
--
* limit, choose
--
* aggregate ops
--
* projection


-------------------------

Logging:
* logging via a log channel rather than via logjam directly