Merge lp:~flacoste/storm/bug-360846 into lp:storm

[Francis J. Lacoste]

[Francis J. Lacoste (flacoste)]

Hi storm developers,

In Launchpad, we are encountering an error which isn't recognized as a disconnection error (and thus should trigger the reconnection code).

Since I didn't see tests for the existing ones, I didn't bother adding one.

[James Henstridge (jamesh)]

> Hi storm developers,
>
> In Launchpad, we are encountering an error which isn't recognized as a
> disconnection error (and thus should trigger the reconnection code).
>
> Since I didn't see tests for the existing ones, I didn't bother adding one.

This branch doesn't apply to Storm's trunk. It looks like you're missing about 8 months of development in the version of Storm Launchpad is using. There have been important bug fixes in that time (e.g. bug 276690), so you should seriously consider upgrading.

Looking at the diff against Launchpad's version of Storm, the change looks worth merging although it lacks a test.

IIRC, this message only occurs if you try to use the connection a second time after libpq reports that the connection was lost. Storm should be catching the first message just fine, so this probably indicates that there was some use of the underlying connection object outside of Storm that reported the initial error. You'd probably need to do the same sort of thing to test it.

review: Needs Resubmitting

[Francis J. Lacoste (flacoste)]

On Thursday 07 May 2009, James Henstridge wrote:
> Review: Resubmit
>
> > Hi storm developers,
> >
> > In Launchpad, we are encountering an error which isn't recognized as a
> > disconnection error (and thus should trigger the reconnection code).
> >
> > Since I didn't see tests for the existing ones, I didn't bother adding
> > one.
>
> This branch doesn't apply to Storm's trunk. It looks like you're missing
> about 8 months of development in the version of Storm Launchpad is using.
> There have been important bug fixes in that time (e.g. bug 276690), so you
> should seriously consider upgrading.
>
> Looking at the diff against Launchpad's version of Storm, the change looks
> worth merging although it lacks a test.
>
> IIRC, this message only occurs if you try to use the connection a second
> time after libpq reports that the connection was lost. Storm should be
> catching the first message just fine, so this probably indicates that there
> was some use of the underlying connection object outside of Storm that
> reported the initial error. You'd probably need to do the same sort of
> thing to test it.

I didn't found tests for the existing functionality. Are there any? I don't
mean the general reconnecting facility, but about which errors are caught. To
me this is simply another kind of these errors.

--
Francis J. Lacoste
<email address hidden>

Unmerged revisions

122. By Francis J. Lacoste on 2009-05-06

InterfaceError: connection already closed should trigger a reconnection.

121. By Launchpad PQM Bot on 2009-04-23

[rs=salgado] Backport ISQLObjectResultSet to IResultSet adapter from
 trunk.

120. By Launchpad PQM Bot on 2008-07-30

[r=flacoste][!log] Pull changes from storm's trunk.

119. By Launchpad PQM Bot on 2008-07-03

[r=flacoste][release-critical=joey] Implementation of Store.reset
 (from radix), which we're going to use after every request

118. By Launchpad PQM Bot on 2008-06-25

[r=thumper] Implement SQLObjectResultSet.__contains__()

117. By Launchpad PQM Bot on 2008-06-21

[rs=jamesh] merge Storm trunk and ~jamesh/storm/slots

116. By Launchpad PQM Bot on 2008-06-19

[rs=jamesh] merge Gustavo's need-for-speed-revenge branch. Renable
 ZStormTest.test_wb_reset test. Disable event emission in Store.flush()

115. By Launchpad PQM Bot on 2008-06-18

[rs=jamesh] merge Storm trunk to rocketfuel

114. By Launchpad PQM Bot on 2008-06-18

[r=jamesh][!log] Disable an intermittently failing test in the storm
 suite. See bug 240801.

113. By Launchpad PQM Bot on 2008-06-07

[r=jamesh] adjust PostgresConnection.is_disconnection_error() to
 accept some forms that weren't being caught

=== modified file 'Makefile'
--- Makefile	2008-11-19 18:22:29 +0000
+++ Makefile	2009-05-06 21:20:15 +0000
@@ -1,3 +1,4 @@
+<<<<<<< TREE
 PYTHON ?= python
 
 TEST_COMMAND = $(PYTHON) test
@@ -28,3 +29,29 @@
 	find . -name "*~" -type f -exec rm -f {} \;
 
 .PHONY: all build test
+=======
+PYTHON = python
+
+TEST_COMMAND = $(PYTHON) test
+
+STORM_POSTGRES_URI = postgres:storm_test
+STORM_POSTGRES_HOST_URI = postgres://localhost/storm_test
+STORM_MYSQL_URI = mysql:storm_test
+STORM_MYSQL_HOST_URI = mysql://localhost/storm_test
+
+export STORM_POSTGRES_URI
+export STORM_POSTGRES_HOST_URI
+export STORM_MYSQL_URI
+export STORM_MYSQL_HOST_URI
+
+all: build
+
+build:
+	$(PYTHON) setup.py build_ext -i
+
+check: build
+	# Run the tests once with cextensions and once without them.
+	$(TEST_COMMAND) && STORM_CEXTENSIONS=1 $(TEST_COMMAND)
+
+.PHONY: all build test
+>>>>>>> MERGE-SOURCE
 
=== modified file 'NEWS'
--- NEWS	2009-03-18 07:11:14 +0000
+++ NEWS	2009-05-06 21:20:15 +0000
@@ -1,3 +1,4 @@
+<<<<<<< TREE
 0.15 (2009-XX-XX)
 =================
 
@@ -67,6 +68,17 @@
    the "GROUP BY" and "HAVING" statements.
  - Change tests/store to keep the connection during the tests to make it
    faster.
+=======
+0.13 (2008-XX-XX)
+=================
+
+Improvements
+------------
+ - Add group_by/having methods on ResultSet objects, to allow access to
+   the "GROUP BY" and "HAVING" statements.
+ - Change tests/store to keep the connection during the tests to make it
+   faster.
+>>>>>>> MERGE-SOURCE
  - Implemented support for plugging generic "tracers".  Statement
    debugging is now implemented using a tracer, and easily enabled
    with storm.tracer.debug(True) (storm.database.DEBUG = True is gone).
@@ -76,6 +88,7 @@
    the property.  The value assigned to the property is the result
    of the validator, so the original value should be returned if
    changing it isn't intended.
+<<<<<<< TREE
  - Expressions can be passed to Store.find() as well as classes.  This
    makes it possible to request individual columns from a table,
    computed expressions or aggregates.
@@ -97,6 +110,26 @@
    zope.interface and transaction packages installed.  This makes it
    easier to reuse the per-thread store management and global
    transaction handling from other web frameworks.
+=======
+ - Expressions can be passed to Store.find() as well as classes.  This
+   makes it possible to request individual columns from a table,
+   computed expressions or aggregates.
+ - Objects will be flushed in the order they become dirty by default.
+   This means that generally the order in which Python operations are
+   performed will be used to define the order in which flushes are done,
+   which is generally the most expected.
+ - The cextensions module was fixed, optimized, and improved.  It's now
+   built by default, but to actually enable it the environment variable
+   STORM_CEXTENSIONS=1 must be defined at runtime.  The module will
+   likely be enabled by default on a future release.
+ - ClassAlias will now cache all explicitly named aliases, to prevent
+   the cost of rebuilding it.
+ - Result sets and reference sets now have a __contains__() method.
+   While code like "item in set" was previously possible, it involved
+   iterating over the result set, which is expensive for large
+   databases.
+
+>>>>>>> MERGE-SOURCE
 
 Bug fixes
 ---------
@@ -115,10 +148,15 @@
    previously raise OrderLoopError.
  - If the remote object in a back reference is removed, the reference
    will now be broken.
+<<<<<<< TREE
  - Fixed a race condition when two threads try to initialize the
    ClassInfo for a given class at the same time.
  - Improve handling of AUTO INCREMENT columns in the MySQL backend to
    remove an unnecessary query when adding objects to a store.
+=======
+ - Fixed a race condition when two threads try to initialize the
+   ClassInfo for a given class at the same time.
+>>>>>>> MERGE-SOURCE
 
 
 0.12 (2008-01-28)
 
=== modified file 'storm/__init__.py'
--- storm/__init__.py	2009-01-09 17:40:25 +0000
+++ storm/__init__.py	2009-05-06 21:20:16 +0000
@@ -19,10 +19,17 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
+<<<<<<< TREE
 import os
 
 
 version = "0.14"
+=======
+import os
+
+
+version = "0.12"
+>>>>>>> MERGE-SOURCE
 version_info = tuple([int(x) for x in version.split(".")])
 
 
 
=== modified file 'storm/cextensions.c'
--- storm/cextensions.c	2009-02-09 16:59:07 +0000
+++ storm/cextensions.c	2009-05-06 21:20:16 +0000
@@ -165,86 +165,165 @@
 
     initialized = 1;
 
-    /* Import objects from storm module */
-    module = PyImport_ImportModule("storm");
-    if (!module)
-        return 0;
-
-    Undef = PyObject_GetAttrString(module, "Undef");
-    if (!Undef)
-        return 0;
-
-    Py_DECREF(module);
-
-    /* Import objects from storm.variables module */
-    module = PyImport_ImportModule("storm.variables");
-    if (!module)
-        return 0;
-
-    raise_none_error = PyObject_GetAttrString(module, "raise_none_error");
-    if (!raise_none_error)
-        return 0;
-
-    LazyValue = PyObject_GetAttrString(module, "LazyValue");
-    if (!LazyValue)
-        return 0;
-
-    Py_DECREF(module);
-
-    /* Import objects from storm.info module */
-    module = PyImport_ImportModule("storm.info");
-    if (!module)
-        return 0;
-
-    get_cls_info = PyObject_GetAttrString(module, "get_cls_info");
-    if (!get_cls_info)
-        return 0;
-
-    Py_DECREF(module);
-
-    /* Import objects from storm.event module */
-    module = PyImport_ImportModule("storm.event");
-    if (!module)
-        return 0;
-
-    EventSystem = PyObject_GetAttrString(module, "EventSystem");
-    if (!EventSystem)
-        return 0;
-
-    Py_DECREF(module);
-
-    /* Import objects from storm.expr module */
-    module = PyImport_ImportModule("storm.expr");
-    if (!module)
-        return 0;
-
-    SQLRaw = PyObject_GetAttrString(module, "SQLRaw");
-    if (!SQLRaw)
-        return 0;
-
-    SQLToken = PyObject_GetAttrString(module, "SQLToken");
-    if (!SQLToken)
-        return 0;
-
-    State = PyObject_GetAttrString(module, "State");
-    if (!State)
-        return 0;
-
-    CompileError = PyObject_GetAttrString(module, "CompileError");
-    if (!CompileError)
-        return 0;
-
-    Py_DECREF(module);
-
-    /* A few frequently used objects which are part of the fast path. */
-
-    parenthesis_format = PyUnicode_DecodeASCII("(%s)", 4, "strict");
-    default_compile_join = PyUnicode_DecodeASCII(", ", 2, "strict");
+<<<<<<< TREE
+    /* Import objects from storm module */
+    module = PyImport_ImportModule("storm");
+    if (!module)
+        return 0;
+
+    Undef = PyObject_GetAttrString(module, "Undef");
+    if (!Undef)
+        return 0;
+
+    Py_DECREF(module);
+
+    /* Import objects from storm.variables module */
+    module = PyImport_ImportModule("storm.variables");
+    if (!module)
+        return 0;
+
+    raise_none_error = PyObject_GetAttrString(module, "raise_none_error");
+    if (!raise_none_error)
+        return 0;
+
+    LazyValue = PyObject_GetAttrString(module, "LazyValue");
+    if (!LazyValue)
+        return 0;
+
+    Py_DECREF(module);
+
+    /* Import objects from storm.info module */
+    module = PyImport_ImportModule("storm.info");
+    if (!module)
+        return 0;
+
+    get_cls_info = PyObject_GetAttrString(module, "get_cls_info");
+    if (!get_cls_info)
+        return 0;
+
+    Py_DECREF(module);
+
+    /* Import objects from storm.event module */
+    module = PyImport_ImportModule("storm.event");
+    if (!module)
+        return 0;
+
+    EventSystem = PyObject_GetAttrString(module, "EventSystem");
+    if (!EventSystem)
+        return 0;
+
+    Py_DECREF(module);
+
+    /* Import objects from storm.expr module */
+    module = PyImport_ImportModule("storm.expr");
+    if (!module)
+        return 0;
+
+    SQLRaw = PyObject_GetAttrString(module, "SQLRaw");
+    if (!SQLRaw)
+        return 0;
+
+    SQLToken = PyObject_GetAttrString(module, "SQLToken");
+    if (!SQLToken)
+        return 0;
+
+    State = PyObject_GetAttrString(module, "State");
+    if (!State)
+        return 0;
+
+    CompileError = PyObject_GetAttrString(module, "CompileError");
+    if (!CompileError)
+        return 0;
+
+    Py_DECREF(module);
+
+    /* A few frequently used objects which are part of the fast path. */
+
+    parenthesis_format = PyUnicode_DecodeASCII("(%s)", 4, "strict");
+    default_compile_join = PyUnicode_DecodeASCII(", ", 2, "strict");
+=======
+    /* Import objects from storm module */
+    module = PyImport_ImportModule("storm");
+    if (!module)
+        return 0;
+
+    Undef = PyObject_GetAttrString(module, "Undef");
+    if (!Undef)
+        return 0;
+
+    Py_DECREF(module);
+
+    /* Import objects from storm.variables module */
+    module = PyImport_ImportModule("storm.variables");
+    if (!module)
+        return 0;
+
+    raise_none_error = PyObject_GetAttrString(module, "raise_none_error");
+    if (!raise_none_error)
+        return 0;
+
+    LazyValue = PyObject_GetAttrString(module, "LazyValue");
+    if (!LazyValue)
+        return 0;
+
+    Py_DECREF(module);
+
+    /* Import objects from storm.info module */
+    module = PyImport_ImportModule("storm.info");
+    if (!module)
+        return 0;
+    
+    get_cls_info = PyObject_GetAttrString(module, "get_cls_info");
+    if (!get_cls_info)
+        return 0;
+
+    Py_DECREF(module);
+
+    /* Import objects from storm.event module */
+    module = PyImport_ImportModule("storm.event");
+    if (!module)
+        return 0;
+
+    EventSystem = PyObject_GetAttrString(module, "EventSystem");
+    if (!EventSystem)
+        return 0;
+
+    Py_DECREF(module);
+
+    /* Import objects from storm.expr module */
+    module = PyImport_ImportModule("storm.expr");
+    if (!module)
+        return 0;
+
+    SQLRaw = PyObject_GetAttrString(module, "SQLRaw");
+    if (!SQLRaw)
+        return 0;
+
+    SQLToken = PyObject_GetAttrString(module, "SQLToken");
+    if (!SQLToken)
+        return 0;
+
+    State = PyObject_GetAttrString(module, "State");
+    if (!State)
+        return 0;
+
+    CompileError = PyObject_GetAttrString(module, "CompileError");
+    if (!CompileError)
+        return 0;
+
+    Py_DECREF(module);
+
+    /* A few frequently used objects which are part of the fast path. */
+
+    parenthesis_format = PyUnicode_DecodeASCII("(%s)", 4, "strict");
+    default_compile_join = PyUnicode_DecodeASCII(", ", 2, "strict");
+>>>>>>> MERGE-SOURCE
 
     return 1;
 }
 
 
+<<<<<<< TREE
 static int
 EventSystem_init(EventSystemObject *self, PyObject *args, PyObject *kwargs)
 {
@@ -554,6 +633,317 @@
 };
 
 
+=======
+static int
+EventSystem_init(EventSystemObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = {"owner", NULL};
+    PyObject *owner;
+    int result = -1;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O", kwlist, &owner))
+        return -1;
+
+    /* self._owner_ref = weakref.ref(owner) */
+    self->_owner_ref = PyWeakref_NewRef(owner, NULL);
+    if (self->_owner_ref) {
+        /* self._hooks = {} */
+        self->_hooks = PyDict_New();
+        if (self->_hooks) {
+            result = 0;
+        }
+    }
+
+    return result;
+}
+
+static int
+EventSystem_traverse(EventSystemObject *self, visitproc visit, void *arg)
+{
+    Py_VISIT(self->_owner_ref);
+    Py_VISIT(self->_hooks);
+    return 0;
+}
+
+static int
+EventSystem_clear(EventSystemObject *self)
+{
+    Py_CLEAR(self->_owner_ref);
+    Py_CLEAR(self->_hooks);
+    return 0;
+}
+
+static void
+EventSystem_dealloc(EventSystemObject *self)
+{
+    EventSystem_clear(self);
+    self->ob_type->tp_free((PyObject *)self);
+}
+
+static PyObject *
+EventSystem_hook(EventSystemObject *self, PyObject *args)
+{
+    PyObject *result = NULL;
+    PyObject *name, *callback, *data;
+
+    if (PyTuple_GET_SIZE(args) < 2) {
+        PyErr_SetString(PyExc_TypeError, "Invalid number of arguments");
+        return NULL;
+    }
+
+    name = PyTuple_GET_ITEM(args, 0);
+    callback = PyTuple_GET_ITEM(args, 1);
+    data = PyTuple_GetSlice(args, 2, PyTuple_GET_SIZE(args));
+    if (data) {
+        /*
+           callbacks = self._hooks.get(name)
+           if callbacks is None:
+               self._hooks.setdefault(name, set()).add((callback, data))
+           else:
+               callbacks.add((callback, data))
+        */
+        PyObject *callbacks = PyDict_GetItem(self->_hooks, name);
+        if (!PyErr_Occurred()) {
+            if (callbacks == NULL) {
+                callbacks = PySet_New(NULL);
+                if (callbacks &&
+                    PyDict_SetItem(self->_hooks, name, callbacks) == -1) {
+                    Py_DECREF(callbacks);
+                    callbacks = NULL;
+                }
+            } else {
+                Py_INCREF(callbacks);
+            }
+            if (callbacks) {
+                PyObject *tuple = PyTuple_New(2);
+                if (tuple) {
+                    Py_INCREF(callback);
+                    PyTuple_SET_ITEM(tuple, 0, callback);
+                    Py_INCREF(data);
+                    PyTuple_SET_ITEM(tuple, 1, data);
+                    if (PySet_Add(callbacks, tuple) != -1) {
+                        Py_INCREF(Py_None);
+                        result = Py_None;
+                    }
+                    Py_DECREF(tuple);
+                }
+                Py_DECREF(callbacks);
+            }
+        }
+        Py_DECREF(data);
+    }
+
+    return result;
+}
+
+static PyObject *
+EventSystem_unhook(EventSystemObject *self, PyObject *args)
+{
+    PyObject *result = NULL;
+    PyObject *name, *callback, *data;
+
+    if (PyTuple_GET_SIZE(args) < 2) {
+        PyErr_SetString(PyExc_TypeError, "Invalid number of arguments");
+        return NULL;
+    }
+
+    name = PyTuple_GET_ITEM(args, 0);
+    callback = PyTuple_GET_ITEM(args, 1);
+    data = PyTuple_GetSlice(args, 2, PyTuple_GET_SIZE(args));
+    if (data) {
+        /* 
+           callbacks = self._hooks.get(name)
+           if callbacks is not None:
+               callbacks.discard((callback, data))
+        */
+        PyObject *callbacks = PyDict_GetItem(self->_hooks, name);
+        if (callbacks) {
+            PyObject *tuple = PyTuple_New(2);
+            if (tuple) {
+                Py_INCREF(callback);
+                PyTuple_SET_ITEM(tuple, 0, callback);
+                Py_INCREF(data);
+                PyTuple_SET_ITEM(tuple, 1, data);
+                if (PySet_Discard(callbacks, tuple) != -1) {
+                    Py_INCREF(Py_None);
+                    result = Py_None;
+                }
+                Py_DECREF(tuple);
+            }
+        } else if (!PyErr_Occurred()) {
+            Py_INCREF(Py_None);
+            result = Py_None;
+        }
+        Py_DECREF(data);
+    }
+
+    return result;
+}
+
+static PyObject *
+EventSystem__do_emit_call(PyObject *callback, PyObject *owner,
+                          PyObject *args, PyObject *data)
+{
+    /* return callback(owner, *(args+data)) */
+    PyObject *result = NULL;
+    PyObject *tuple = PyTuple_New(PyTuple_GET_SIZE(args) +
+                                  PyTuple_GET_SIZE(data) + 1);
+    if (tuple) {
+        Py_ssize_t i, tuple_i;
+
+        Py_INCREF(owner);
+        PyTuple_SET_ITEM(tuple, 0, owner);
+        tuple_i = 1;
+        for (i = 0; i != PyTuple_GET_SIZE(args); i++) {
+            PyObject *item = PyTuple_GET_ITEM(args, i);
+            Py_INCREF(item);
+            PyTuple_SET_ITEM(tuple, tuple_i++, item);
+        }
+        for (i = 0; i != PyTuple_GET_SIZE(data); i++) {
+            PyObject *item = PyTuple_GET_ITEM(data, i);
+            Py_INCREF(item);
+            PyTuple_SET_ITEM(tuple, tuple_i++, item);
+        }
+        result = PyObject_Call(callback, tuple, NULL);
+        Py_DECREF(tuple);
+    }
+    return result;
+}
+
+static PyObject *
+EventSystem_emit(EventSystemObject *self, PyObject *all_args)
+{
+    PyObject *result = NULL;
+    PyObject *name, *args;
+
+    if (PyTuple_GET_SIZE(all_args) == 0) {
+        PyErr_SetString(PyExc_TypeError, "Invalid number of arguments");
+        return NULL;
+    }
+
+    /* XXX In the following code we trust on the format inserted by
+     *     the hook() method.  If it's hacked somehow, it may blow up. */
+
+    name = PyTuple_GET_ITEM(all_args, 0);
+    args = PyTuple_GetSlice(all_args, 1, PyTuple_GET_SIZE(all_args));
+    if (args) {
+        /* owner = self._owner_ref() */
+        PyObject *owner = PyWeakref_GET_OBJECT(self->_owner_ref);
+        /* if owner is not None: */
+        if (owner != Py_None) {
+            /* callbacks = self._hooks.get(name) */
+            PyObject *callbacks = PyDict_GetItem(self->_hooks, name);
+            Py_INCREF(owner);
+            /* if callbacks: */
+            if (callbacks && PySet_GET_SIZE(callbacks) != 0) {
+                /* for callback, data in tuple(callbacks): */
+                PyObject *sequence = \
+                    PySequence_Fast(callbacks, "callbacks object isn't a set");
+                if (sequence) {
+                    int failed = 0;
+                    Py_ssize_t i;
+                    for (i = 0; i != PySequence_Fast_GET_SIZE(sequence); i++) {
+                        PyObject *item = PySequence_Fast_GET_ITEM(sequence, i);
+                        PyObject *callback = PyTuple_GET_ITEM(item, 0);
+                        PyObject *data = PyTuple_GET_ITEM(item, 1);
+                        PyObject *res;
+                        /* 
+                           if callback(owner, *(args+data)) is False:
+                               callbacks.discard((callback, data))
+                        */
+                        res = EventSystem__do_emit_call(callback, owner,
+                                                        args, data);
+                        Py_XDECREF(res);
+                        if (res == NULL ||
+                            (res == Py_False &&
+                             PySet_Discard(callbacks, item) == -1)) {
+                            failed = 1;
+                            break;
+                        }
+                    }
+                    if (!failed) {
+                        Py_INCREF(Py_None);
+                        result = Py_None;
+                    }
+                    Py_DECREF(sequence);
+                }
+            } else if (!PyErr_Occurred()) {
+                Py_INCREF(Py_None);
+                result = Py_None;
+            }
+            Py_DECREF(owner);
+        } else {
+            Py_INCREF(Py_None);
+            result = Py_None;
+        }
+        Py_DECREF(args);
+    }
+
+    return result;
+}
+
+
+static PyMethodDef EventSystem_methods[] = {
+    {"hook", (PyCFunction)EventSystem_hook, METH_VARARGS, NULL},
+    {"unhook", (PyCFunction)EventSystem_unhook, METH_VARARGS, NULL},
+    {"emit", (PyCFunction)EventSystem_emit, METH_VARARGS, NULL},
+    {NULL, NULL}
+};
+
+#define OFFSETOF(x) offsetof(EventSystemObject, x)
+static PyMemberDef EventSystem_members[] = {
+    {"_object_ref", T_OBJECT, OFFSETOF(_owner_ref), READONLY, 0},
+    {"_hooks", T_OBJECT, OFFSETOF(_hooks), READONLY, 0},
+    {NULL}
+};
+#undef OFFSETOF
+
+statichere PyTypeObject EventSystem_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,            /*ob_size*/
+    "storm.variables.EventSystem",    /*tp_name*/
+    sizeof(EventSystemObject), /*tp_basicsize*/
+    0,            /*tp_itemsize*/
+    (destructor)EventSystem_dealloc, /*tp_dealloc*/
+    0,            /*tp_print*/
+    0,            /*tp_getattr*/
+    0,            /*tp_setattr*/
+    0,            /*tp_compare*/
+    0,          /*tp_repr*/
+    0,            /*tp_as_number*/
+    0,            /*tp_as_sequence*/
+    0,            /*tp_as_mapping*/
+    0,                      /*tp_hash*/
+    0,                      /*tp_call*/
+    0,                      /*tp_str*/
+    PyObject_GenericGetAttr,/*tp_getattro*/
+    PyObject_GenericSetAttr,/*tp_setattro*/
+    0,                      /*tp_as_buffer*/
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, /*tp_flags*/
+    0,                      /*tp_doc*/
+    (traverseproc)EventSystem_traverse,  /*tp_traverse*/
+    (inquiry)EventSystem_clear,          /*tp_clear*/
+    0,                      /*tp_richcompare*/
+    0,                      /*tp_weaklistoffset*/
+    0,                      /*tp_iter*/
+    0,                      /*tp_iternext*/
+    EventSystem_methods,        /*tp_methods*/
+    EventSystem_members,        /*tp_members*/
+    0,                      /*tp_getset*/
+    0,                      /*tp_base*/
+    0,                      /*tp_dict*/
+    0,                      /*tp_descr_get*/
+    0,                      /*tp_descr_set*/
+    0,                      /*tp_dictoffset*/
+    (initproc)EventSystem_init, /*tp_init*/
+    PyType_GenericAlloc,    /*tp_alloc*/
+    PyType_GenericNew,      /*tp_new*/
+    PyObject_GC_Del,        /*tp_free*/
+    0,                      /*tp_is_gc*/
+};
+
+
+>>>>>>> MERGE-SOURCE
 static PyObject *
 Variable_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 {
@@ -1150,670 +1540,1337 @@
 
 
 static PyObject *
-Compile__update_cache(CompileObject *self, PyObject *args);
-
-static int
-Compile_init(CompileObject *self, PyObject *args, PyObject *kwargs)
-{
-    static char *kwlist[] = {"parent", NULL};
-
-    PyObject *parent = Py_None;
-
-    PyObject *module = NULL;
-    PyObject *WeakKeyDictionary = NULL;
-
-    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O", kwlist, &parent))
-        return -1;
-
-    /*
-       self._local_dispatch_table = {}
-       self._local_precedence = {}
-       self._local_reserved_words = {}
-       self._dispatch_table = {}
-       self._precedence = {}
-       self._reserved_words = {}
-    */
-    CATCH(NULL, self->_local_dispatch_table = PyDict_New());
-    CATCH(NULL, self->_local_precedence = PyDict_New());
-    CATCH(NULL, self->_local_reserved_words = PyDict_New());
-    CATCH(NULL, self->_dispatch_table = PyDict_New());
-    CATCH(NULL, self->_precedence = PyDict_New());
-    CATCH(NULL, self->_reserved_words = PyDict_New());
-
-    /* self._children = WeakKeyDictionary() */
-    CATCH(NULL, module = PyImport_ImportModule("weakref"));
-    CATCH(NULL, WeakKeyDictionary = \
-                    PyObject_GetAttrString(module, "WeakKeyDictionary"));
-    Py_CLEAR(module);
-    CATCH(NULL, self->_children = \
-                    PyObject_CallFunctionObjArgs(WeakKeyDictionary, NULL));
-    Py_CLEAR(WeakKeyDictionary);
-
-    /* self._parents = [] */
-    CATCH(NULL, self->_parents = PyList_New(0));
-
-    /* if parent: */
-    if (parent != Py_None) {
-        PyObject *tmp;
-
-        /* self._parents.extend(parent._parents) */
-        CompileObject *parent_object = (CompileObject *)parent;
-        CATCH(-1, PyList_SetSlice(self->_parents, 0, 0,
-                                  parent_object->_parents));
-
-        /* self._parents.append(parent) */
-        CATCH(-1, PyList_Append(self->_parents, parent));
-
-        /* parent._children[self] = True */
-        CATCH(-1, PyObject_SetItem(parent_object->_children,
-                                   (PyObject *)self, Py_True));
-
-        /* self._update_cache() */
-        CATCH(NULL, tmp = Compile__update_cache(self, NULL));
-        Py_DECREF(tmp);
-    }
-
-    return 0;
-
-error:
-    Py_XDECREF(module);
-    Py_XDECREF(WeakKeyDictionary);
-    return -1;
-}
-
-static int
-Compile_traverse(CompileObject *self, visitproc visit, void *arg)
-{
-    Py_VISIT(self->_local_dispatch_table);
-    Py_VISIT(self->_local_precedence);
-    Py_VISIT(self->_local_reserved_words);
-    Py_VISIT(self->_dispatch_table);
-    Py_VISIT(self->_precedence);
-    Py_VISIT(self->_reserved_words);
-    Py_VISIT(self->_children);
-    Py_VISIT(self->_parents);
-    return 0;
-}
-
-static int
-Compile_clear(CompileObject *self)
-{
-    if (self->__weakreflist)
-        PyObject_ClearWeakRefs((PyObject *)self);
-    Py_CLEAR(self->_local_dispatch_table);
-    Py_CLEAR(self->_local_precedence);
-    Py_CLEAR(self->_local_reserved_words);
-    Py_CLEAR(self->_dispatch_table);
-    Py_CLEAR(self->_precedence);
-    Py_CLEAR(self->_reserved_words);
-    Py_CLEAR(self->_children);
-    Py_CLEAR(self->_parents);
-    return 0;
-}
-
-static void
-Compile_dealloc(CompileObject *self)
-{
-    Compile_clear(self);
-    self->ob_type->tp_free((PyObject *)self);
-}
-
-static PyObject *
-Compile__update_cache(CompileObject *self, PyObject *args)
-{
-    PyObject *iter = NULL;
-    PyObject *child = NULL;
-    Py_ssize_t size;
-    int i;
-
-    /* for parent in self._parents: */
-    size = PyList_GET_SIZE(self->_parents);
-    for (i = 0; i != size; i++) {
-        CompileObject *parent = \
-            (CompileObject *)PyList_GET_ITEM(self->_parents, i);
-        /* self._dispatch_table.update(parent._local_dispatch_table) */
-        CATCH(-1, PyDict_Update(self->_dispatch_table,
-                                parent->_local_dispatch_table));
-        /* self._precedence.update(parent._local_precedence) */
-        CATCH(-1, PyDict_Update(self->_precedence,
-                                parent->_local_precedence));
-        /* self._reserved_words.update(parent._local_reserved_words) */
-        CATCH(-1, PyDict_Update(self->_reserved_words,
-                                parent->_local_reserved_words));
-    }
-    /* self._dispatch_table.update(self._local_dispatch_table) */
-    CATCH(-1, PyDict_Update(self->_dispatch_table,
-                            self->_local_dispatch_table));
-    /* self._precedence.update(self._local_precedence) */
-    CATCH(-1, PyDict_Update(self->_precedence, self->_local_precedence));
-    /* self._reserved_words.update(self._local_reserved_words) */
-    CATCH(-1, PyDict_Update(self->_reserved_words,
-                            self->_local_reserved_words));
-
-    /* for child in self._children: */
-    CATCH(NULL, iter = PyObject_GetIter(self->_children));
-    while((child = PyIter_Next(iter))) {
-        PyObject *tmp;
-
-        /* child._update_cache() */
-        CATCH(NULL, tmp = Compile__update_cache((CompileObject *)child, NULL));
-        Py_DECREF(tmp);
-        Py_DECREF(child);
-    }
-    if (PyErr_Occurred())
-        goto error;
-    Py_CLEAR(iter);
-
-    Py_RETURN_NONE;
-
-error:
-    Py_XDECREF(child);
-    Py_XDECREF(iter);
-    return NULL;
-}
-
-static PyObject *
-Compile_when(CompileObject *self, PyObject *types)
-{
-    PyObject *result = NULL;
-    PyObject *module = PyImport_ImportModule("storm.expr");
-    if (module) {
-        PyObject *_when = PyObject_GetAttrString(module, "_when");
-        if (_when) {
-            result = PyObject_CallFunctionObjArgs(_when, self, types, NULL);
-            Py_DECREF(_when);
-        }
-        Py_DECREF(module);
-    }
-    return result;
-}
-
-static PyObject *
-Compile_add_reserved_words(CompileObject *self, PyObject *words)
-{
-    PyObject *lower_word = NULL;
-    PyObject *iter = NULL;
-    PyObject *word = NULL;
-    PyObject *tmp;
-
-    /* self._local_reserved_words.update((word.lower(), True)
-                                         for word in words) */
-    CATCH(NULL, iter = PyObject_GetIter(words));
-    while ((word = PyIter_Next(iter))) {
-        CATCH(NULL, lower_word = PyObject_CallMethod(word, "lower", NULL));
-        CATCH(-1, PyDict_SetItem(self->_local_reserved_words,
-                                 lower_word, Py_True));
-        Py_CLEAR(lower_word);
-        Py_DECREF(word);
-    }
-    if (PyErr_Occurred())
-        goto error;
-    Py_CLEAR(iter);
-
-    /* self._update_cache() */
-    CATCH(NULL, tmp = Compile__update_cache(self, NULL));
-    Py_DECREF(tmp);
-
-    Py_RETURN_NONE;
-
-error:
-    Py_XDECREF(lower_word);
-    Py_XDECREF(word);
-    Py_XDECREF(iter);
-    return NULL;
-}
-
-static PyObject *
-Compile_remove_reserved_words(CompileObject *self, PyObject *words)
-{
-    PyObject *lower_word = NULL;
-    PyObject *word = NULL;
-    PyObject *iter = NULL;
-    PyObject *tmp;
-
-    /* self._local_reserved_words.update((word.lower(), None)
-                                         for word in words) */
-    CATCH(NULL, iter = PyObject_GetIter(words));
-    while ((word = PyIter_Next(iter))) {
-        CATCH(NULL, lower_word = PyObject_CallMethod(word, "lower", NULL));
-        CATCH(-1, PyDict_SetItem(self->_local_reserved_words,
-                                 lower_word, Py_None));
-        Py_CLEAR(lower_word);
-        Py_DECREF(word);
-    }
-    if (PyErr_Occurred())
-        goto error;
-    Py_CLEAR(iter);
-
-    /* self._update_cache() */
-    CATCH(NULL, tmp = Compile__update_cache(self, NULL));
-    Py_DECREF(tmp);
-
-    Py_RETURN_NONE;
-
-error:
-    Py_XDECREF(lower_word);
-    Py_XDECREF(word);
-    Py_XDECREF(iter);
-    return NULL;
-}
-
-static PyObject *
-Compile_is_reserved_word(CompileObject *self, PyObject *word)
-{
-    PyObject *lower_word = NULL;
-    PyObject *result = Py_False;
-    PyObject *item;
-
-    /* return self._reserved_words.get(word.lower()) is not None */
-    CATCH(NULL, lower_word = PyObject_CallMethod(word, "lower", NULL));
-    item = PyDict_GetItem(self->_reserved_words, lower_word);
-    if (item == NULL && PyErr_Occurred()) {
-        goto error;
-    } else if (item != NULL && item != Py_None) {
-        result = Py_True;
-    }
-    Py_DECREF(lower_word);
-    Py_INCREF(result);
-    return result;
-
-error:
-    Py_XDECREF(lower_word);
-    return NULL;
-}
-
-staticforward PyTypeObject Compile_Type;
-
-static PyObject *
-Compile_create_child(CompileObject *self, PyObject *args)
-{
-    /* return self.__class__(self) */
-    return PyObject_CallFunctionObjArgs((PyObject *)self->ob_type, self, NULL);
-}
-
-static PyObject *
-Compile_get_precedence(CompileObject *self, PyObject *type)
-{
-    /* return self._precedence.get(type, MAX_PRECEDENCE) */
-    PyObject *result = PyDict_GetItem(self->_precedence, type);
-    if (result == NULL && !PyErr_Occurred()) {
-        /* That should be MAX_PRECEDENCE, defined in expr.py */
-        return PyInt_FromLong(1000);
-    }
-    Py_INCREF(result);
-    return result;
-}
-
-static PyObject *
-Compile_set_precedence(CompileObject *self, PyObject *args)
-{
-    Py_ssize_t size = PyTuple_GET_SIZE(args);
-    PyObject *precedence = NULL;
-    PyObject *tmp;
-    int i;
-
-    if (size < 2) {
-        PyErr_SetString(PyExc_TypeError,
-                        "set_precedence() takes at least 2 arguments.");
-        return NULL;
-    }
-
-    /* for type in types: */
-    precedence = PyTuple_GET_ITEM(args, 0);
-    for (i = 1; i != size; i++) {
-        PyObject *type = PyTuple_GET_ITEM(args, i);
-        /* self._local_precedence[type] = precedence */
-        CATCH(-1, PyDict_SetItem(self->_local_precedence, type, precedence));
-    }
-
-    /* self._update_cache() */
-    CATCH(NULL, tmp = Compile__update_cache(self, NULL));
-    Py_DECREF(tmp);
-
-    Py_RETURN_NONE;
-error:
-    return NULL;
-}
-
-PyObject *
-Compile_single(CompileObject *self,
-               PyObject *expr, PyObject *state, PyObject *outer_precedence)
-{
-    PyObject *inner_precedence = NULL;
-    PyObject *statement = NULL;
-
-    /* cls = expr.__class__ */
-    PyObject *cls = (PyObject *)expr->ob_type;
-
-    /*
-       dispatch_table = self._dispatch_table
-       if cls in dispatch_table:
-           handler = dispatch_table[cls]
-       else:
-    */
-    PyObject *handler = PyDict_GetItem(self->_dispatch_table, cls);
-    if (!handler) {
-        PyObject *mro;
-        Py_ssize_t size, i;
-
-        if (PyErr_Occurred())
-            goto error;
-
-        /* for mro_cls in cls.__mro__: */
-        mro = expr->ob_type->tp_mro;
-        size = PyTuple_GET_SIZE(mro);
-        for (i = 0; i != size; i++) {
-            PyObject *mro_cls = PyTuple_GET_ITEM(mro, i);
-            /*
-               if mro_cls in dispatch_table:
-                   handler = dispatch_table[mro_cls]
-                   break
-            */
-            handler = PyDict_GetItem(self->_dispatch_table, mro_cls);
-            if (handler)
-                break;
-
-            if (PyErr_Occurred())
-                goto error;
-        }
-        /* else: */
-        if (i == size) {
-            /*
-               raise CompileError("Don't know how to compile type %r of %r"
-                                  % (expr.__class__, expr))
-            */
-            PyObject *repr = PyObject_Repr(expr);
-            if (repr) {
-                PyErr_Format(CompileError,
-                             "Don't know how to compile type %s of %s",
-                             expr->ob_type->tp_name, PyString_AS_STRING(repr));
-                Py_DECREF(repr);
-            }
-            goto error;
-        }
-    }
-
-    /*
-       inner_precedence = state.precedence = \
-                          self._precedence.get(cls, MAX_PRECEDENCE)
-    */
-    CATCH(NULL, inner_precedence = Compile_get_precedence(self, cls));
-    CATCH(-1, PyObject_SetAttrString(state, "precedence", inner_precedence));
-
-    /* statement = handler(self, expr, state) */
-    CATCH(NULL, statement = PyObject_CallFunctionObjArgs(handler, self, expr,
-                                                         state, NULL));
-
-    /* if inner_precedence < outer_precedence: */
-    if (PyObject_Compare(inner_precedence, outer_precedence) == -1) {
-        PyObject *args, *tmp;
-
-        if (PyErr_Occurred())
-            goto error;
-
-        /* return "(%s)" % statement */
-        CATCH(NULL, args = PyTuple_Pack(1, statement));
-        tmp = PyUnicode_Format(parenthesis_format, args);
-        Py_DECREF(args);
-        CATCH(NULL, tmp);
-        Py_DECREF(statement);
-        statement = tmp;
-    }
-
-    Py_DECREF(inner_precedence);
-
-    return statement;
-
-error:
-    Py_XDECREF(inner_precedence);
-    Py_XDECREF(statement);
-
-    return NULL;
-}
-
-PyObject *
-Compile_one_or_many(CompileObject *self, PyObject *expr, PyObject *state,
-                    PyObject *join, int raw, int token)
-{
-    PyObject *outer_precedence = NULL;
-    PyObject *compiled = NULL;
-    PyObject *sequence = NULL;
-    PyObject *statement = NULL;
-    Py_ssize_t size, i;
-
-    Py_INCREF(expr);
-
-    /*
-      expr_type = type(expr)
-      if (expr_type is SQLRaw or
-          raw and (expr_type is str or expr_type is unicode)):
-          return expr
-    */
-    if ((PyObject *)expr->ob_type == SQLRaw ||
-        (raw && (PyString_CheckExact(expr) || PyUnicode_CheckExact(expr)))) {
-        /* Pass our reference on. */
-        return expr;
-    }
-
-    /*
-       if token and (expr_type is str or expr_type is unicode):
-           expr = SQLToken(expr)
-    */
-    if (token && (PyString_CheckExact(expr) || PyUnicode_CheckExact(expr))) {
-        PyObject *tmp;
-        CATCH(NULL, tmp = PyObject_CallFunctionObjArgs(SQLToken, expr, NULL));
-        Py_DECREF(expr);
-        expr = tmp;
-    }
-
-    /*
-       if state is None:
-           state = State()
-    */
-    /* That's done in Compile__call__ just once. */
-
-    /* outer_precedence = state.precedence */
-    CATCH(NULL, outer_precedence = PyObject_GetAttrString(state, "precedence"));
-    /* if expr_type is tuple or expr_type is list: */
-    if (PyTuple_CheckExact(expr) || PyList_CheckExact(expr)) {
-        /* compiled = [] */
-        CATCH(NULL, compiled = PyList_New(0));
-
-        /* for subexpr in expr: */
-        sequence = PySequence_Fast(expr, "This can't actually fail! ;-)");
-        size = PySequence_Fast_GET_SIZE(sequence);
-        for (i = 0; i != size; i++) {
-            PyObject *subexpr = PySequence_Fast_GET_ITEM(sequence, i);
-            /*
-               subexpr_type = type(subexpr)
-               if subexpr_type is SQLRaw or raw and (subexpr_type is str or
-                                                     subexpr_type is unicode):
-            */
-            if ((PyObject *)subexpr->ob_type == (PyObject *)SQLRaw ||
-                (raw && (PyString_CheckExact(subexpr) ||
-                         PyUnicode_CheckExact(subexpr)))) {
-                /* statement = subexpr */
-                Py_INCREF(subexpr);
-                statement = subexpr;
-            /* elif subexpr_type is tuple or subexpr_type is list: */
-            } else if (PyTuple_CheckExact(subexpr) ||
-                       PyList_CheckExact(subexpr)) {
-                /* state.precedence = outer_precedence */
-                CATCH(-1, PyObject_SetAttrString(state, "precedence",
-                                                 outer_precedence));
-                /* statement = self(subexpr, state, join, raw, token) */
-                CATCH(NULL,
-                      statement = Compile_one_or_many(self, subexpr, state,
-                                                      join, raw, token));
-            /* else: */
-            } else {
-                /*
-                   if token and (subexpr_type is unicode or
-                                 subexpr_type is str):
-                */
-                if (token && (PyUnicode_CheckExact(subexpr) ||
-                              PyString_CheckExact(subexpr))) {
-                    /* subexpr = SQLToken(subexpr) */
-                    CATCH(NULL,
-                          subexpr = PyObject_CallFunctionObjArgs(SQLToken,
-                                                                 subexpr,
-                                                                 NULL));
-                } else {
-                    Py_INCREF(subexpr);
-                }
-
-                /*
-                   statement = self._compile_single(subexpr, state,
-                                                    outer_precedence)
-                */
-                statement = Compile_single(self, subexpr, state,
-                                           outer_precedence);
-                Py_DECREF(subexpr);
-                CATCH(NULL, statement);
-            }
-
-            /* compiled.append(statement) */
-            CATCH(-1, PyList_Append(compiled, statement));
-            Py_CLEAR(statement);
-        }
-        Py_CLEAR(sequence);
-
-        /* statement = join.join(compiled) */
-        CATCH(NULL, statement = PyUnicode_Join(join, compiled));
-        Py_CLEAR(compiled);
-    } else {
-        /* statement = self._compile_single(expr, state, outer_precedence) */
-        CATCH(NULL, statement = Compile_single(self, expr, state,
-                                               outer_precedence));
-    }
-
-    /* state.precedence = outer_precedence */
-    CATCH(-1, PyObject_SetAttrString(state, "precedence", outer_precedence));
-    Py_CLEAR(outer_precedence);
-
-    Py_DECREF(expr);
-
-    return statement;
-
-error:
-    Py_XDECREF(expr);
-    Py_XDECREF(outer_precedence);
-    Py_XDECREF(compiled);
-    Py_XDECREF(sequence);
-    Py_XDECREF(statement);
-
-    return NULL;
-}
-
-static PyObject *
-Compile__call__(CompileObject *self, PyObject *args, PyObject *kwargs)
-{
-    static char *kwlist[] = {"expr", "state", "join", "raw", "token", NULL};
-    PyObject *expr = NULL;
-    PyObject *state = Py_None;
-    PyObject *join;
-    char raw = 0;
-    char token = 0;
-
-    PyObject *result = NULL;
-
-    if (!initialize_globals())
-        return NULL;
-
-    join = default_compile_join;
-
-    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OSbb", kwlist,
-                                     &expr, &state, &join, &raw, &token)) {
-        return NULL;
-    }
-
-    if (state == Py_None) {
-        state = PyObject_CallFunctionObjArgs(State, NULL);
-    } else {
-        Py_INCREF(state);
-    }
-    if (state) {
-        result = Compile_one_or_many(self, expr, state, join, raw, token);
-        Py_DECREF(state);
-    }
-    return result;
-}
-
-
-static PyMethodDef Compile_methods[] = {
-    {"_update_cache", (PyCFunction)Compile__update_cache, METH_NOARGS, NULL},
-    {"when", (PyCFunction)Compile_when, METH_VARARGS, NULL},
-    {"add_reserved_words", (PyCFunction)Compile_add_reserved_words,
-        METH_O, NULL},
-    {"remove_reserved_words", (PyCFunction)Compile_remove_reserved_words,
-        METH_O, NULL},
-    {"is_reserved_word", (PyCFunction)Compile_is_reserved_word, METH_O, NULL},
-    {"create_child", (PyCFunction)Compile_create_child, METH_NOARGS, NULL},
-    {"get_precedence", (PyCFunction)Compile_get_precedence, METH_O, NULL},
-    {"set_precedence", (PyCFunction)Compile_set_precedence, METH_VARARGS, NULL},
-    {NULL, NULL}
-};
-
-#define OFFSETOF(x) offsetof(CompileObject, x)
-static PyMemberDef Compile_members[] = {
-    {"_local_dispatch_table", T_OBJECT, OFFSETOF(_local_dispatch_table), 0, 0},
-    {"_local_precedence", T_OBJECT, OFFSETOF(_local_precedence), 0, 0},
-    {"_local_reserved_words", T_OBJECT, OFFSETOF(_local_reserved_words), 0, 0},
-    {"_dispatch_table", T_OBJECT, OFFSETOF(_dispatch_table), 0, 0},
-    {"_precedence", T_OBJECT, OFFSETOF(_precedence), 0, 0},
-    {"_reserved_words", T_OBJECT, OFFSETOF(_reserved_words), 0, 0},
-    {"_children", T_OBJECT, OFFSETOF(_children), 0, 0},
-    {"_parents", T_OBJECT, OFFSETOF(_parents), 0, 0},
-    {NULL}
-};
-#undef OFFSETOF
-
-statichere PyTypeObject Compile_Type = {
-    PyObject_HEAD_INIT(NULL)
-    0,            /*ob_size*/
-    "storm.variables.Compile",    /*tp_name*/
-    sizeof(CompileObject), /*tp_basicsize*/
-    0,            /*tp_itemsize*/
-    (destructor)Compile_dealloc, /*tp_dealloc*/
-    0,            /*tp_print*/
-    0,            /*tp_getattr*/
-    0,            /*tp_setattr*/
-    0,            /*tp_compare*/
-    0,          /*tp_repr*/
-    0,            /*tp_as_number*/
-    0,            /*tp_as_sequence*/
-    0,            /*tp_as_mapping*/
-    0,                      /*tp_hash*/
-    (ternaryfunc)Compile__call__, /*tp_call*/
-    0,                      /*tp_str*/
-    PyObject_GenericGetAttr,/*tp_getattro*/
-    PyObject_GenericSetAttr,/*tp_setattro*/
-    0,                      /*tp_as_buffer*/
-    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, /*tp_flags*/
-    0,                      /*tp_doc*/
-    (traverseproc)Compile_traverse,  /*tp_traverse*/
-    (inquiry)Compile_clear,          /*tp_clear*/
-    0,                      /*tp_richcompare*/
-    offsetof(CompileObject, __weakreflist), /*tp_weaklistoffset*/
-    0,                      /*tp_iter*/
-    0,                      /*tp_iternext*/
-    Compile_methods,        /*tp_methods*/
-    Compile_members,        /*tp_members*/
-    0,                      /*tp_getset*/
-    0,                      /*tp_base*/
-    0,                      /*tp_dict*/
-    0,                      /*tp_descr_get*/
-    0,                      /*tp_descr_set*/
-    0,                      /*tp_dictoffset*/
-    (initproc)Compile_init, /*tp_init*/
-    PyType_GenericAlloc,    /*tp_alloc*/
-    PyType_GenericNew,      /*tp_new*/
-    PyObject_GC_Del,        /*tp_free*/
-    0,                      /*tp_is_gc*/
-};
-
-
-static PyObject *
+<<<<<<< TREE
+Compile__update_cache(CompileObject *self, PyObject *args);
+
+static int
+Compile_init(CompileObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = {"parent", NULL};
+
+    PyObject *parent = Py_None;
+
+    PyObject *module = NULL;
+    PyObject *WeakKeyDictionary = NULL;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O", kwlist, &parent))
+        return -1;
+
+    /*
+       self._local_dispatch_table = {}
+       self._local_precedence = {}
+       self._local_reserved_words = {}
+       self._dispatch_table = {}
+       self._precedence = {}
+       self._reserved_words = {}
+    */
+    CATCH(NULL, self->_local_dispatch_table = PyDict_New());
+    CATCH(NULL, self->_local_precedence = PyDict_New());
+    CATCH(NULL, self->_local_reserved_words = PyDict_New());
+    CATCH(NULL, self->_dispatch_table = PyDict_New());
+    CATCH(NULL, self->_precedence = PyDict_New());
+    CATCH(NULL, self->_reserved_words = PyDict_New());
+
+    /* self._children = WeakKeyDictionary() */
+    CATCH(NULL, module = PyImport_ImportModule("weakref"));
+    CATCH(NULL, WeakKeyDictionary = \
+                    PyObject_GetAttrString(module, "WeakKeyDictionary"));
+    Py_CLEAR(module);
+    CATCH(NULL, self->_children = \
+                    PyObject_CallFunctionObjArgs(WeakKeyDictionary, NULL));
+    Py_CLEAR(WeakKeyDictionary);
+
+    /* self._parents = [] */
+    CATCH(NULL, self->_parents = PyList_New(0));
+
+    /* if parent: */
+    if (parent != Py_None) {
+        PyObject *tmp;
+
+        /* self._parents.extend(parent._parents) */
+        CompileObject *parent_object = (CompileObject *)parent;
+        CATCH(-1, PyList_SetSlice(self->_parents, 0, 0,
+                                  parent_object->_parents));
+
+        /* self._parents.append(parent) */
+        CATCH(-1, PyList_Append(self->_parents, parent));
+
+        /* parent._children[self] = True */
+        CATCH(-1, PyObject_SetItem(parent_object->_children,
+                                   (PyObject *)self, Py_True));
+
+        /* self._update_cache() */
+        CATCH(NULL, tmp = Compile__update_cache(self, NULL));
+        Py_DECREF(tmp);
+    }
+
+    return 0;
+
+error:
+    Py_XDECREF(module);
+    Py_XDECREF(WeakKeyDictionary);
+    return -1;
+}
+
+static int
+Compile_traverse(CompileObject *self, visitproc visit, void *arg)
+{
+    Py_VISIT(self->_local_dispatch_table);
+    Py_VISIT(self->_local_precedence);
+    Py_VISIT(self->_local_reserved_words);
+    Py_VISIT(self->_dispatch_table);
+    Py_VISIT(self->_precedence);
+    Py_VISIT(self->_reserved_words);
+    Py_VISIT(self->_children);
+    Py_VISIT(self->_parents);
+    return 0;
+}
+
+static int
+Compile_clear(CompileObject *self)
+{
+    if (self->__weakreflist)
+        PyObject_ClearWeakRefs((PyObject *)self);
+    Py_CLEAR(self->_local_dispatch_table);
+    Py_CLEAR(self->_local_precedence);
+    Py_CLEAR(self->_local_reserved_words);
+    Py_CLEAR(self->_dispatch_table);
+    Py_CLEAR(self->_precedence);
+    Py_CLEAR(self->_reserved_words);
+    Py_CLEAR(self->_children);
+    Py_CLEAR(self->_parents);
+    return 0;
+}
+
+static void
+Compile_dealloc(CompileObject *self)
+{
+    Compile_clear(self);
+    self->ob_type->tp_free((PyObject *)self);
+}
+
+static PyObject *
+Compile__update_cache(CompileObject *self, PyObject *args)
+{
+    PyObject *iter = NULL;
+    PyObject *child = NULL;
+    Py_ssize_t size;
+    int i;
+
+    /* for parent in self._parents: */
+    size = PyList_GET_SIZE(self->_parents);
+    for (i = 0; i != size; i++) {
+        CompileObject *parent = \
+            (CompileObject *)PyList_GET_ITEM(self->_parents, i);
+        /* self._dispatch_table.update(parent._local_dispatch_table) */
+        CATCH(-1, PyDict_Update(self->_dispatch_table,
+                                parent->_local_dispatch_table));
+        /* self._precedence.update(parent._local_precedence) */
+        CATCH(-1, PyDict_Update(self->_precedence,
+                                parent->_local_precedence));
+        /* self._reserved_words.update(parent._local_reserved_words) */
+        CATCH(-1, PyDict_Update(self->_reserved_words,
+                                parent->_local_reserved_words));
+    }
+    /* self._dispatch_table.update(self._local_dispatch_table) */
+    CATCH(-1, PyDict_Update(self->_dispatch_table,
+                            self->_local_dispatch_table));
+    /* self._precedence.update(self._local_precedence) */
+    CATCH(-1, PyDict_Update(self->_precedence, self->_local_precedence));
+    /* self._reserved_words.update(self._local_reserved_words) */
+    CATCH(-1, PyDict_Update(self->_reserved_words,
+                            self->_local_reserved_words));
+
+    /* for child in self._children: */
+    CATCH(NULL, iter = PyObject_GetIter(self->_children));
+    while((child = PyIter_Next(iter))) {
+        PyObject *tmp;
+
+        /* child._update_cache() */
+        CATCH(NULL, tmp = Compile__update_cache((CompileObject *)child, NULL));
+        Py_DECREF(tmp);
+        Py_DECREF(child);
+    }
+    if (PyErr_Occurred())
+        goto error;
+    Py_CLEAR(iter);
+
+    Py_RETURN_NONE;
+
+error:
+    Py_XDECREF(child);
+    Py_XDECREF(iter);
+    return NULL;
+}
+
+static PyObject *
+Compile_when(CompileObject *self, PyObject *types)
+{
+    PyObject *result = NULL;
+    PyObject *module = PyImport_ImportModule("storm.expr");
+    if (module) {
+        PyObject *_when = PyObject_GetAttrString(module, "_when");
+        if (_when) {
+            result = PyObject_CallFunctionObjArgs(_when, self, types, NULL);
+            Py_DECREF(_when);
+        }
+        Py_DECREF(module);
+    }
+    return result;
+}
+
+static PyObject *
+Compile_add_reserved_words(CompileObject *self, PyObject *words)
+{
+    PyObject *lower_word = NULL;
+    PyObject *iter = NULL;
+    PyObject *word = NULL;
+    PyObject *tmp;
+
+    /* self._local_reserved_words.update((word.lower(), True)
+                                         for word in words) */
+    CATCH(NULL, iter = PyObject_GetIter(words));
+    while ((word = PyIter_Next(iter))) {
+        CATCH(NULL, lower_word = PyObject_CallMethod(word, "lower", NULL));
+        CATCH(-1, PyDict_SetItem(self->_local_reserved_words,
+                                 lower_word, Py_True));
+        Py_CLEAR(lower_word);
+        Py_DECREF(word);
+    }
+    if (PyErr_Occurred())
+        goto error;
+    Py_CLEAR(iter);
+
+    /* self._update_cache() */
+    CATCH(NULL, tmp = Compile__update_cache(self, NULL));
+    Py_DECREF(tmp);
+
+    Py_RETURN_NONE;
+
+error:
+    Py_XDECREF(lower_word);
+    Py_XDECREF(word);
+    Py_XDECREF(iter);
+    return NULL;
+}
+
+static PyObject *
+Compile_remove_reserved_words(CompileObject *self, PyObject *words)
+{
+    PyObject *lower_word = NULL;
+    PyObject *word = NULL;
+    PyObject *iter = NULL;
+    PyObject *tmp;
+
+    /* self._local_reserved_words.update((word.lower(), None)
+                                         for word in words) */
+    CATCH(NULL, iter = PyObject_GetIter(words));
+    while ((word = PyIter_Next(iter))) {
+        CATCH(NULL, lower_word = PyObject_CallMethod(word, "lower", NULL));
+        CATCH(-1, PyDict_SetItem(self->_local_reserved_words,
+                                 lower_word, Py_None));
+        Py_CLEAR(lower_word);
+        Py_DECREF(word);
+    }
+    if (PyErr_Occurred())
+        goto error;
+    Py_CLEAR(iter);
+
+    /* self._update_cache() */
+    CATCH(NULL, tmp = Compile__update_cache(self, NULL));
+    Py_DECREF(tmp);
+
+    Py_RETURN_NONE;
+
+error:
+    Py_XDECREF(lower_word);
+    Py_XDECREF(word);
+    Py_XDECREF(iter);
+    return NULL;
+}
+
+static PyObject *
+Compile_is_reserved_word(CompileObject *self, PyObject *word)
+{
+    PyObject *lower_word = NULL;
+    PyObject *result = Py_False;
+    PyObject *item;
+
+    /* return self._reserved_words.get(word.lower()) is not None */
+    CATCH(NULL, lower_word = PyObject_CallMethod(word, "lower", NULL));
+    item = PyDict_GetItem(self->_reserved_words, lower_word);
+    if (item == NULL && PyErr_Occurred()) {
+        goto error;
+    } else if (item != NULL && item != Py_None) {
+        result = Py_True;
+    }
+    Py_DECREF(lower_word);
+    Py_INCREF(result);
+    return result;
+
+error:
+    Py_XDECREF(lower_word);
+    return NULL;
+}
+
+staticforward PyTypeObject Compile_Type;
+
+static PyObject *
+Compile_create_child(CompileObject *self, PyObject *args)
+{
+    /* return self.__class__(self) */
+    return PyObject_CallFunctionObjArgs((PyObject *)self->ob_type, self, NULL);
+}
+
+static PyObject *
+Compile_get_precedence(CompileObject *self, PyObject *type)
+{
+    /* return self._precedence.get(type, MAX_PRECEDENCE) */
+    PyObject *result = PyDict_GetItem(self->_precedence, type);
+    if (result == NULL && !PyErr_Occurred()) {
+        /* That should be MAX_PRECEDENCE, defined in expr.py */
+        return PyInt_FromLong(1000);
+    }
+    Py_INCREF(result);
+    return result;
+}
+
+static PyObject *
+Compile_set_precedence(CompileObject *self, PyObject *args)
+{
+    Py_ssize_t size = PyTuple_GET_SIZE(args);
+    PyObject *precedence = NULL;
+    PyObject *tmp;
+    int i;
+
+    if (size < 2) {
+        PyErr_SetString(PyExc_TypeError,
+                        "set_precedence() takes at least 2 arguments.");
+        return NULL;
+    }
+
+    /* for type in types: */
+    precedence = PyTuple_GET_ITEM(args, 0);
+    for (i = 1; i != size; i++) {
+        PyObject *type = PyTuple_GET_ITEM(args, i);
+        /* self._local_precedence[type] = precedence */
+        CATCH(-1, PyDict_SetItem(self->_local_precedence, type, precedence));
+    }
+
+    /* self._update_cache() */
+    CATCH(NULL, tmp = Compile__update_cache(self, NULL));
+    Py_DECREF(tmp);
+
+    Py_RETURN_NONE;
+error:
+    return NULL;
+}
+
+PyObject *
+Compile_single(CompileObject *self,
+               PyObject *expr, PyObject *state, PyObject *outer_precedence)
+{
+    PyObject *inner_precedence = NULL;
+    PyObject *statement = NULL;
+
+    /* cls = expr.__class__ */
+    PyObject *cls = (PyObject *)expr->ob_type;
+
+    /*
+       dispatch_table = self._dispatch_table
+       if cls in dispatch_table:
+           handler = dispatch_table[cls]
+       else:
+    */
+    PyObject *handler = PyDict_GetItem(self->_dispatch_table, cls);
+    if (!handler) {
+        PyObject *mro;
+        Py_ssize_t size, i;
+
+        if (PyErr_Occurred())
+            goto error;
+
+        /* for mro_cls in cls.__mro__: */
+        mro = expr->ob_type->tp_mro;
+        size = PyTuple_GET_SIZE(mro);
+        for (i = 0; i != size; i++) {
+            PyObject *mro_cls = PyTuple_GET_ITEM(mro, i);
+            /*
+               if mro_cls in dispatch_table:
+                   handler = dispatch_table[mro_cls]
+                   break
+            */
+            handler = PyDict_GetItem(self->_dispatch_table, mro_cls);
+            if (handler)
+                break;
+
+            if (PyErr_Occurred())
+                goto error;
+        }
+        /* else: */
+        if (i == size) {
+            /*
+               raise CompileError("Don't know how to compile type %r of %r"
+                                  % (expr.__class__, expr))
+            */
+            PyObject *repr = PyObject_Repr(expr);
+            if (repr) {
+                PyErr_Format(CompileError,
+                             "Don't know how to compile type %s of %s",
+                             expr->ob_type->tp_name, PyString_AS_STRING(repr));
+                Py_DECREF(repr);
+            }
+            goto error;
+        }
+    }
+
+    /*
+       inner_precedence = state.precedence = \
+                          self._precedence.get(cls, MAX_PRECEDENCE)
+    */
+    CATCH(NULL, inner_precedence = Compile_get_precedence(self, cls));
+    CATCH(-1, PyObject_SetAttrString(state, "precedence", inner_precedence));
+
+    /* statement = handler(self, expr, state) */
+    CATCH(NULL, statement = PyObject_CallFunctionObjArgs(handler, self, expr,
+                                                         state, NULL));
+
+    /* if inner_precedence < outer_precedence: */
+    if (PyObject_Compare(inner_precedence, outer_precedence) == -1) {
+        PyObject *args, *tmp;
+
+        if (PyErr_Occurred())
+            goto error;
+
+        /* return "(%s)" % statement */
+        CATCH(NULL, args = PyTuple_Pack(1, statement));
+        tmp = PyUnicode_Format(parenthesis_format, args);
+        Py_DECREF(args);
+        CATCH(NULL, tmp);
+        Py_DECREF(statement);
+        statement = tmp;
+    }
+
+    Py_DECREF(inner_precedence);
+
+    return statement;
+
+error:
+    Py_XDECREF(inner_precedence);
+    Py_XDECREF(statement);
+
+    return NULL;
+}
+
+PyObject *
+Compile_one_or_many(CompileObject *self, PyObject *expr, PyObject *state,
+                    PyObject *join, int raw, int token)
+{
+    PyObject *outer_precedence = NULL;
+    PyObject *compiled = NULL;
+    PyObject *sequence = NULL;
+    PyObject *statement = NULL;
+    Py_ssize_t size, i;
+
+    Py_INCREF(expr);
+
+    /*
+      expr_type = type(expr)
+      if (expr_type is SQLRaw or
+          raw and (expr_type is str or expr_type is unicode)):
+          return expr
+    */
+    if ((PyObject *)expr->ob_type == SQLRaw ||
+        (raw && (PyString_CheckExact(expr) || PyUnicode_CheckExact(expr)))) {
+        /* Pass our reference on. */
+        return expr;
+    }
+
+    /*
+       if token and (expr_type is str or expr_type is unicode):
+           expr = SQLToken(expr)
+    */
+    if (token && (PyString_CheckExact(expr) || PyUnicode_CheckExact(expr))) {
+        PyObject *tmp;
+        CATCH(NULL, tmp = PyObject_CallFunctionObjArgs(SQLToken, expr, NULL));
+        Py_DECREF(expr);
+        expr = tmp;
+    }
+
+    /*
+       if state is None:
+           state = State()
+    */
+    /* That's done in Compile__call__ just once. */
+
+    /* outer_precedence = state.precedence */
+    CATCH(NULL, outer_precedence = PyObject_GetAttrString(state, "precedence"));
+    /* if expr_type is tuple or expr_type is list: */
+    if (PyTuple_CheckExact(expr) || PyList_CheckExact(expr)) {
+        /* compiled = [] */
+        CATCH(NULL, compiled = PyList_New(0));
+
+        /* for subexpr in expr: */
+        sequence = PySequence_Fast(expr, "This can't actually fail! ;-)");
+        size = PySequence_Fast_GET_SIZE(sequence);
+        for (i = 0; i != size; i++) {
+            PyObject *subexpr = PySequence_Fast_GET_ITEM(sequence, i);
+            /*
+               subexpr_type = type(subexpr)
+               if subexpr_type is SQLRaw or raw and (subexpr_type is str or
+                                                     subexpr_type is unicode):
+            */
+            if ((PyObject *)subexpr->ob_type == (PyObject *)SQLRaw ||
+                (raw && (PyString_CheckExact(subexpr) ||
+                         PyUnicode_CheckExact(subexpr)))) {
+                /* statement = subexpr */
+                Py_INCREF(subexpr);
+                statement = subexpr;
+            /* elif subexpr_type is tuple or subexpr_type is list: */
+            } else if (PyTuple_CheckExact(subexpr) ||
+                       PyList_CheckExact(subexpr)) {
+                /* state.precedence = outer_precedence */
+                CATCH(-1, PyObject_SetAttrString(state, "precedence",
+                                                 outer_precedence));
+                /* statement = self(subexpr, state, join, raw, token) */
+                CATCH(NULL,
+                      statement = Compile_one_or_many(self, subexpr, state,
+                                                      join, raw, token));
+            /* else: */
+            } else {
+                /*
+                   if token and (subexpr_type is unicode or
+                                 subexpr_type is str):
+                */
+                if (token && (PyUnicode_CheckExact(subexpr) ||
+                              PyString_CheckExact(subexpr))) {
+                    /* subexpr = SQLToken(subexpr) */
+                    CATCH(NULL,
+                          subexpr = PyObject_CallFunctionObjArgs(SQLToken,
+                                                                 subexpr,
+                                                                 NULL));
+                } else {
+                    Py_INCREF(subexpr);
+                }
+
+                /*
+                   statement = self._compile_single(subexpr, state,
+                                                    outer_precedence)
+                */
+                statement = Compile_single(self, subexpr, state,
+                                           outer_precedence);
+                Py_DECREF(subexpr);
+                CATCH(NULL, statement);
+            }
+
+            /* compiled.append(statement) */
+            CATCH(-1, PyList_Append(compiled, statement));
+            Py_CLEAR(statement);
+        }
+        Py_CLEAR(sequence);
+
+        /* statement = join.join(compiled) */
+        CATCH(NULL, statement = PyUnicode_Join(join, compiled));
+        Py_CLEAR(compiled);
+    } else {
+        /* statement = self._compile_single(expr, state, outer_precedence) */
+        CATCH(NULL, statement = Compile_single(self, expr, state,
+                                               outer_precedence));
+    }
+
+    /* state.precedence = outer_precedence */
+    CATCH(-1, PyObject_SetAttrString(state, "precedence", outer_precedence));
+    Py_CLEAR(outer_precedence);
+
+    Py_DECREF(expr);
+
+    return statement;
+
+error:
+    Py_XDECREF(expr);
+    Py_XDECREF(outer_precedence);
+    Py_XDECREF(compiled);
+    Py_XDECREF(sequence);
+    Py_XDECREF(statement);
+
+    return NULL;
+}
+
+static PyObject *
+Compile__call__(CompileObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = {"expr", "state", "join", "raw", "token", NULL};
+    PyObject *expr = NULL;
+    PyObject *state = Py_None;
+    PyObject *join;
+    char raw = 0;
+    char token = 0;
+
+    PyObject *result = NULL;
+
+    if (!initialize_globals())
+        return NULL;
+
+    join = default_compile_join;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OSbb", kwlist,
+                                     &expr, &state, &join, &raw, &token)) {
+        return NULL;
+    }
+
+    if (state == Py_None) {
+        state = PyObject_CallFunctionObjArgs(State, NULL);
+    } else {
+        Py_INCREF(state);
+    }
+    if (state) {
+        result = Compile_one_or_many(self, expr, state, join, raw, token);
+        Py_DECREF(state);
+    }
+    return result;
+}
+
+
+static PyMethodDef Compile_methods[] = {
+    {"_update_cache", (PyCFunction)Compile__update_cache, METH_NOARGS, NULL},
+    {"when", (PyCFunction)Compile_when, METH_VARARGS, NULL},
+    {"add_reserved_words", (PyCFunction)Compile_add_reserved_words,
+        METH_O, NULL},
+    {"remove_reserved_words", (PyCFunction)Compile_remove_reserved_words,
+        METH_O, NULL},
+    {"is_reserved_word", (PyCFunction)Compile_is_reserved_word, METH_O, NULL},
+    {"create_child", (PyCFunction)Compile_create_child, METH_NOARGS, NULL},
+    {"get_precedence", (PyCFunction)Compile_get_precedence, METH_O, NULL},
+    {"set_precedence", (PyCFunction)Compile_set_precedence, METH_VARARGS, NULL},
+    {NULL, NULL}
+};
+
+#define OFFSETOF(x) offsetof(CompileObject, x)
+static PyMemberDef Compile_members[] = {
+    {"_local_dispatch_table", T_OBJECT, OFFSETOF(_local_dispatch_table), 0, 0},
+    {"_local_precedence", T_OBJECT, OFFSETOF(_local_precedence), 0, 0},
+    {"_local_reserved_words", T_OBJECT, OFFSETOF(_local_reserved_words), 0, 0},
+    {"_dispatch_table", T_OBJECT, OFFSETOF(_dispatch_table), 0, 0},
+    {"_precedence", T_OBJECT, OFFSETOF(_precedence), 0, 0},
+    {"_reserved_words", T_OBJECT, OFFSETOF(_reserved_words), 0, 0},
+    {"_children", T_OBJECT, OFFSETOF(_children), 0, 0},
+    {"_parents", T_OBJECT, OFFSETOF(_parents), 0, 0},
+    {NULL}
+};
+#undef OFFSETOF
+
+statichere PyTypeObject Compile_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,            /*ob_size*/
+    "storm.variables.Compile",    /*tp_name*/
+    sizeof(CompileObject), /*tp_basicsize*/
+    0,            /*tp_itemsize*/
+    (destructor)Compile_dealloc, /*tp_dealloc*/
+    0,            /*tp_print*/
+    0,            /*tp_getattr*/
+    0,            /*tp_setattr*/
+    0,            /*tp_compare*/
+    0,          /*tp_repr*/
+    0,            /*tp_as_number*/
+    0,            /*tp_as_sequence*/
+    0,            /*tp_as_mapping*/
+    0,                      /*tp_hash*/
+    (ternaryfunc)Compile__call__, /*tp_call*/
+    0,                      /*tp_str*/
+    PyObject_GenericGetAttr,/*tp_getattro*/
+    PyObject_GenericSetAttr,/*tp_setattro*/
+    0,                      /*tp_as_buffer*/
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, /*tp_flags*/
+    0,                      /*tp_doc*/
+    (traverseproc)Compile_traverse,  /*tp_traverse*/
+    (inquiry)Compile_clear,          /*tp_clear*/
+    0,                      /*tp_richcompare*/
+    offsetof(CompileObject, __weakreflist), /*tp_weaklistoffset*/
+    0,                      /*tp_iter*/
+    0,                      /*tp_iternext*/
+    Compile_methods,        /*tp_methods*/
+    Compile_members,        /*tp_members*/
+    0,                      /*tp_getset*/
+    0,                      /*tp_base*/
+    0,                      /*tp_dict*/
+    0,                      /*tp_descr_get*/
+    0,                      /*tp_descr_set*/
+    0,                      /*tp_dictoffset*/
+    (initproc)Compile_init, /*tp_init*/
+    PyType_GenericAlloc,    /*tp_alloc*/
+    PyType_GenericNew,      /*tp_new*/
+    PyObject_GC_Del,        /*tp_free*/
+    0,                      /*tp_is_gc*/
+};
+
+
+static PyObject *
+=======
+Compile__update_cache(CompileObject *self, PyObject *args);
+
+static int
+Compile_init(CompileObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = {"parent", NULL};
+
+    PyObject *parent = Py_None;
+
+    PyObject *module = NULL;
+    PyObject *WeakKeyDictionary = NULL;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O", kwlist, &parent))
+        return -1;
+
+    /*
+       self._local_dispatch_table = {}
+       self._local_precedence = {}
+       self._local_reserved_words = {}
+       self._dispatch_table = {}
+       self._precedence = {}
+       self._reserved_words = {}
+    */
+    CATCH(NULL, self->_local_dispatch_table = PyDict_New());
+    CATCH(NULL, self->_local_precedence = PyDict_New());
+    CATCH(NULL, self->_local_reserved_words = PyDict_New());
+    CATCH(NULL, self->_dispatch_table = PyDict_New());
+    CATCH(NULL, self->_precedence = PyDict_New());
+    CATCH(NULL, self->_reserved_words = PyDict_New());
+
+    /* self._children = WeakKeyDictionary() */
+    CATCH(NULL, module = PyImport_ImportModule("weakref"));
+    CATCH(NULL, WeakKeyDictionary = \
+                    PyObject_GetAttrString(module, "WeakKeyDictionary"));
+    Py_CLEAR(module);
+    CATCH(NULL, self->_children = \
+                    PyObject_CallFunctionObjArgs(WeakKeyDictionary, NULL));
+    Py_CLEAR(WeakKeyDictionary);
+
+    /* self._parents = [] */
+    CATCH(NULL, self->_parents = PyList_New(0));
+
+    /* if parent: */
+    if (parent != Py_None) {
+        PyObject *tmp;
+
+        /* self._parents.extend(parent._parents) */
+        CompileObject *parent_object = (CompileObject *)parent;
+        CATCH(-1, PyList_SetSlice(self->_parents, 0, 0,
+                                  parent_object->_parents));
+
+        /* self._parents.append(parent) */
+        CATCH(-1, PyList_Append(self->_parents, parent));
+
+        /* parent._children[self] = True */
+        CATCH(-1, PyObject_SetItem(parent_object->_children,
+                                   (PyObject *)self, Py_True));
+
+        /* self._update_cache() */
+        CATCH(NULL, tmp = Compile__update_cache(self, NULL));
+        Py_DECREF(tmp);
+    }
+
+    return 0;
+
+error:
+    Py_XDECREF(module);
+    Py_XDECREF(WeakKeyDictionary);
+    return -1;
+}
+
+static int
+Compile_traverse(CompileObject *self, visitproc visit, void *arg)
+{
+    Py_VISIT(self->_local_dispatch_table);
+    Py_VISIT(self->_local_precedence);
+    Py_VISIT(self->_local_reserved_words);
+    Py_VISIT(self->_dispatch_table);
+    Py_VISIT(self->_precedence);
+    Py_VISIT(self->_reserved_words);
+    Py_VISIT(self->_children);
+    Py_VISIT(self->_parents);
+    return 0;
+}
+
+static int
+Compile_clear(CompileObject *self)
+{
+    if (self->__weakreflist)
+        PyObject_ClearWeakRefs((PyObject *)self);
+    Py_CLEAR(self->_local_dispatch_table);
+    Py_CLEAR(self->_local_precedence);
+    Py_CLEAR(self->_local_reserved_words);
+    Py_CLEAR(self->_dispatch_table);
+    Py_CLEAR(self->_precedence);
+    Py_CLEAR(self->_reserved_words);
+    Py_CLEAR(self->_children);
+    Py_CLEAR(self->_parents);
+    return 0;
+}
+
+static void
+Compile_dealloc(CompileObject *self)
+{
+    Compile_clear(self);
+    self->ob_type->tp_free((PyObject *)self);
+}
+
+static PyObject *
+Compile__update_cache(CompileObject *self, PyObject *args)
+{
+    PyObject *iter = NULL;
+    PyObject *child = NULL;
+    Py_ssize_t size;
+    int i;
+
+    /* for parent in self._parents: */
+    size = PyList_GET_SIZE(self->_parents);
+    for (i = 0; i != size; i++) {
+        CompileObject *parent = \
+            (CompileObject *)PyList_GET_ITEM(self->_parents, i);
+        /* self._dispatch_table.update(parent._local_dispatch_table) */
+        CATCH(-1, PyDict_Update(self->_dispatch_table,
+                                parent->_local_dispatch_table));
+        /* self._precedence.update(parent._local_precedence) */
+        CATCH(-1, PyDict_Update(self->_precedence,
+                                parent->_local_precedence));
+        /* self._reserved_words.update(parent._local_reserved_words) */
+        CATCH(-1, PyDict_Update(self->_reserved_words,
+                                parent->_local_reserved_words));
+    }
+    /* self._dispatch_table.update(self._local_dispatch_table) */
+    CATCH(-1, PyDict_Update(self->_dispatch_table,
+                            self->_local_dispatch_table));
+    /* self._precedence.update(self._local_precedence) */
+    CATCH(-1, PyDict_Update(self->_precedence, self->_local_precedence));
+    /* self._reserved_words.update(self._local_reserved_words) */
+    CATCH(-1, PyDict_Update(self->_reserved_words,
+                            self->_local_reserved_words));
+
+    /* for child in self._children: */
+    CATCH(NULL, iter = PyObject_GetIter(self->_children));
+    while((child = PyIter_Next(iter))) {
+        PyObject *tmp;
+
+        /* child._update_cache() */
+        CATCH(NULL, tmp = Compile__update_cache((CompileObject *)child, NULL));
+        Py_DECREF(tmp);
+        Py_DECREF(child);
+    }
+    if (PyErr_Occurred())
+        goto error;
+    Py_CLEAR(iter);
+
+    Py_RETURN_NONE;
+
+error:
+    Py_XDECREF(child);
+    Py_XDECREF(iter);
+    return NULL;
+}
+
+static PyObject *
+Compile_when(CompileObject *self, PyObject *types)
+{
+    PyObject *result = NULL;
+    PyObject *module = PyImport_ImportModule("storm.expr");
+    if (module) {
+        PyObject *_when = PyObject_GetAttrString(module, "_when");
+        if (_when) {
+            result = PyObject_CallFunctionObjArgs(_when, self, types, NULL);
+            Py_DECREF(_when);
+        }
+        Py_DECREF(module);
+    }
+    return result;    
+}
+
+static PyObject *
+Compile_add_reserved_words(CompileObject *self, PyObject *words)
+{
+    PyObject *lower_word = NULL;
+    PyObject *iter = NULL;
+    PyObject *word = NULL;
+    PyObject *tmp;
+
+    /* self._local_reserved_words.update((word.lower(), True)
+                                         for word in words) */
+    CATCH(NULL, iter = PyObject_GetIter(words));
+    while ((word = PyIter_Next(iter))) {
+        CATCH(NULL, lower_word = PyObject_CallMethod(word, "lower", NULL));
+        CATCH(-1, PyDict_SetItem(self->_local_reserved_words,
+                                 lower_word, Py_True));
+        Py_CLEAR(lower_word);
+        Py_DECREF(word);
+    }
+    if (PyErr_Occurred())
+        goto error;
+    Py_CLEAR(iter);
+
+    /* self._update_cache() */
+    CATCH(NULL, tmp = Compile__update_cache(self, NULL));
+    Py_DECREF(tmp);
+
+    Py_RETURN_NONE;
+
+error:
+    Py_XDECREF(lower_word);
+    Py_XDECREF(word);
+    Py_XDECREF(iter);
+    return NULL;
+}
+
+static PyObject *
+Compile_remove_reserved_words(CompileObject *self, PyObject *words)
+{
+    PyObject *lower_word = NULL;
+    PyObject *word = NULL;
+    PyObject *iter = NULL;
+    PyObject *tmp;
+
+    /* self._local_reserved_words.update((word.lower(), None)
+                                         for word in words) */
+    CATCH(NULL, iter = PyObject_GetIter(words));
+    while ((word = PyIter_Next(iter))) {
+        CATCH(NULL, lower_word = PyObject_CallMethod(word, "lower", NULL));
+        CATCH(-1, PyDict_SetItem(self->_local_reserved_words,
+                                 lower_word, Py_None));
+        Py_CLEAR(lower_word);
+        Py_DECREF(word);
+    }
+    if (PyErr_Occurred())
+        goto error;
+    Py_CLEAR(iter);
+
+    /* self._update_cache() */
+    CATCH(NULL, tmp = Compile__update_cache(self, NULL));
+    Py_DECREF(tmp);
+
+    Py_RETURN_NONE;
+
+error:
+    Py_XDECREF(lower_word);
+    Py_XDECREF(word);
+    Py_XDECREF(iter);
+    return NULL;
+}
+
+static PyObject *
+Compile_is_reserved_word(CompileObject *self, PyObject *word)
+{
+    PyObject *lower_word = NULL;
+    PyObject *result = Py_False;
+    PyObject *item;
+
+    /* return self._reserved_words.get(word.lower()) is not None */
+    CATCH(NULL, lower_word = PyObject_CallMethod(word, "lower", NULL));
+    item = PyDict_GetItem(self->_reserved_words, lower_word);
+    if (item == NULL && PyErr_Occurred()) {
+        goto error; 
+    } else if (item != NULL && item != Py_None) {
+        result = Py_True;
+    }
+    Py_DECREF(lower_word);
+    Py_INCREF(result);
+    return result;
+
+error:
+    Py_XDECREF(lower_word);
+    return NULL;
+}
+
+staticforward PyTypeObject Compile_Type;
+
+static PyObject *
+Compile_create_child(CompileObject *self, PyObject *args)
+{
+    /* return self.__class__(self) */
+    return PyObject_CallFunctionObjArgs((PyObject *)self->ob_type, self, NULL);
+}
+
+static PyObject *
+Compile_get_precedence(CompileObject *self, PyObject *type)
+{
+    /* return self._precedence.get(type, MAX_PRECEDENCE) */
+    PyObject *result = PyDict_GetItem(self->_precedence, type);
+    if (result == NULL && !PyErr_Occurred()) {
+        /* That should be MAX_PRECEDENCE, defined in expr.py */
+        return PyInt_FromLong(1000);
+    }
+    Py_INCREF(result);
+    return result;
+}
+
+static PyObject *
+Compile_set_precedence(CompileObject *self, PyObject *args)
+{
+    Py_ssize_t size = PyTuple_GET_SIZE(args);
+    PyObject *precedence = NULL;
+    PyObject *tmp;
+    int i;
+
+    if (size < 2) {
+        PyErr_SetString(PyExc_TypeError,
+                        "set_precedence() takes at least 2 arguments.");
+        return NULL;
+    }
+
+    /* for type in types: */
+    precedence = PyTuple_GET_ITEM(args, 0);
+    for (i = 1; i != size; i++) {
+        PyObject *type = PyTuple_GET_ITEM(args, i);
+        /* self._local_precedence[type] = precedence */
+        CATCH(-1, PyDict_SetItem(self->_local_precedence, type, precedence));
+    }
+
+    /* self._update_cache() */
+    CATCH(NULL, tmp = Compile__update_cache(self, NULL));
+    Py_DECREF(tmp);
+
+    Py_RETURN_NONE;
+error:
+    return NULL;
+}
+
+PyObject *
+Compile_single(CompileObject *self,
+               PyObject *expr, PyObject *state, PyObject *outer_precedence)
+{
+    PyObject *inner_precedence = NULL;
+    PyObject *statement = NULL;
+
+    /* cls = expr.__class__ */
+    PyObject *cls = (PyObject *)expr->ob_type;
+
+    /*
+       dispatch_table = self._dispatch_table
+       if cls in dispatch_table:
+           handler = dispatch_table[cls]
+       else:
+    */
+    PyObject *handler = PyDict_GetItem(self->_dispatch_table, cls);
+    if (!handler) {
+        PyObject *mro;
+        Py_ssize_t size, i;
+
+        if (PyErr_Occurred())
+            goto error;
+
+        /* for mro_cls in cls.__mro__: */
+        mro = expr->ob_type->tp_mro;
+        size = PyTuple_GET_SIZE(mro);
+        for (i = 0; i != size; i++) {
+            PyObject *mro_cls = PyTuple_GET_ITEM(mro, i);
+            /*
+               if mro_cls in dispatch_table:
+                   handler = dispatch_table[mro_cls]
+                   break
+            */
+            handler = PyDict_GetItem(self->_dispatch_table, mro_cls);
+            if (handler)
+                break;
+
+            if (PyErr_Occurred())
+                goto error;
+        }
+        /* else: */
+        if (i == size) {
+            /*
+               raise CompileError("Don't know how to compile type %r of %r"
+                                  % (expr.__class__, expr))
+            */
+            PyObject *repr = PyObject_Repr(expr);
+            if (repr) {
+                PyErr_Format(CompileError,
+                             "Don't know how to compile type %s of %s",
+                             expr->ob_type->tp_name, PyString_AS_STRING(repr));
+                Py_DECREF(repr);
+            }
+            goto error;
+        }
+    }
+
+    /*
+       inner_precedence = state.precedence = \
+                          self._precedence.get(cls, MAX_PRECEDENCE)
+    */
+    CATCH(NULL, inner_precedence = Compile_get_precedence(self, cls));
+    CATCH(-1, PyObject_SetAttrString(state, "precedence", inner_precedence));
+
+    /* statement = handler(self, expr, state) */
+    CATCH(NULL, statement = PyObject_CallFunctionObjArgs(handler, self, expr,
+                                                         state, NULL));
+
+    /* if inner_precedence < outer_precedence: */
+    if (PyObject_Compare(inner_precedence, outer_precedence) == -1) {
+        PyObject *args, *tmp;
+
+        if (PyErr_Occurred())
+            goto error;
+
+        /* return "(%s)" % statement */
+        CATCH(NULL, args = PyTuple_Pack(1, statement));
+        tmp = PyUnicode_Format(parenthesis_format, args);
+        Py_DECREF(args);
+        CATCH(NULL, tmp);
+        Py_DECREF(statement);
+        statement = tmp;
+    }
+
+    Py_DECREF(inner_precedence);
+
+    return statement;
+
+error:
+    Py_XDECREF(inner_precedence);
+    Py_XDECREF(statement);
+
+    return NULL;
+}
+
+PyObject *
+Compile_one_or_many(CompileObject *self, PyObject *expr, PyObject *state,
+                    PyObject *join, int raw, int token)
+{
+    PyObject *outer_precedence = NULL;
+    PyObject *compiled = NULL;
+    PyObject *sequence = NULL;
+    PyObject *statement = NULL;
+    Py_ssize_t size, i;
+
+    Py_INCREF(expr);
+
+    /*
+      expr_type = type(expr)
+      if (expr_type is SQLRaw or
+          raw and (expr_type is str or expr_type is unicode)):
+          return expr
+    */  
+    if ((PyObject *)expr->ob_type == SQLRaw ||
+        (raw && (PyString_CheckExact(expr) || PyUnicode_CheckExact(expr)))) {
+        /* Pass our reference on. */
+        return expr;
+    }
+
+    /*
+       if token and (expr_type is str or expr_type is unicode):
+           expr = SQLToken(expr)
+    */
+    if (token && (PyString_CheckExact(expr) || PyUnicode_CheckExact(expr))) {
+        PyObject *tmp;
+        CATCH(NULL, tmp = PyObject_CallFunctionObjArgs(SQLToken, expr, NULL));
+        Py_DECREF(expr);
+        expr = tmp;
+    }
+
+    /*
+       if state is None:
+           state = State()
+    */
+    /* That's done in Compile__call__ just once. */
+
+    /* outer_precedence = state.precedence */
+    CATCH(NULL, outer_precedence = PyObject_GetAttrString(state, "precedence"));
+    /* if expr_type is tuple or expr_type is list: */
+    if (PyTuple_CheckExact(expr) || PyList_CheckExact(expr)) {
+        /* compiled = [] */
+        CATCH(NULL, compiled = PyList_New(0));
+
+        /* for subexpr in expr: */
+        sequence = PySequence_Fast(expr, "This can't actually fail! ;-)");
+        size = PySequence_Fast_GET_SIZE(sequence);
+        for (i = 0; i != size; i++) {
+            PyObject *subexpr = PySequence_Fast_GET_ITEM(sequence, i);
+            /*
+               subexpr_type = type(subexpr)
+               if subexpr_type is SQLRaw or raw and (subexpr_type is str or
+                                                     subexpr_type is unicode):
+            */
+            if ((PyObject *)subexpr->ob_type == (PyObject *)SQLRaw ||
+                (raw && (PyString_CheckExact(subexpr) ||
+                         PyUnicode_CheckExact(subexpr)))) {
+                /* statement = subexpr */
+                Py_INCREF(subexpr);
+                statement = subexpr;
+            /* elif subexpr_type is tuple or subexpr_type is list: */
+            } else if (PyTuple_CheckExact(subexpr) ||
+                       PyList_CheckExact(subexpr)) {
+                /* state.precedence = outer_precedence */
+                CATCH(-1, PyObject_SetAttrString(state, "precedence",
+                                                 outer_precedence));
+                /* statement = self(subexpr, state, join, raw, token) */
+                CATCH(NULL,
+                      statement = Compile_one_or_many(self, subexpr, state,
+                                                      join, raw, token));
+            /* else: */
+            } else {
+                /*
+                   if token and (subexpr_type is unicode or
+                                 subexpr_type is str):
+                */
+                if (token && (PyUnicode_CheckExact(subexpr) ||
+                              PyString_CheckExact(subexpr))) {
+                    /* subexpr = SQLToken(subexpr) */
+                    CATCH(NULL,
+                          subexpr = PyObject_CallFunctionObjArgs(SQLToken,
+                                                                 subexpr,
+                                                                 NULL));
+                } else {
+                    Py_INCREF(subexpr);
+                }
+
+                /* 
+                   statement = self._compile_single(subexpr, state,
+                                                    outer_precedence)
+                */
+                statement = Compile_single(self, subexpr, state,
+                                           outer_precedence);
+                Py_DECREF(subexpr);
+                CATCH(NULL, statement);
+            }
+            
+            /* compiled.append(statement) */
+            CATCH(-1, PyList_Append(compiled, statement));
+            Py_CLEAR(statement);
+        }
+        Py_CLEAR(sequence);
+
+        /* statement = join.join(compiled) */
+        CATCH(NULL, statement = PyUnicode_Join(join, compiled));
+        Py_CLEAR(compiled);
+    } else {
+        /* statement = self._compile_single(expr, state, outer_precedence) */
+        CATCH(NULL, statement = Compile_single(self, expr, state,
+                                               outer_precedence));
+    }
+
+    /* state.precedence = outer_precedence */
+    CATCH(-1, PyObject_SetAttrString(state, "precedence", outer_precedence));
+    Py_CLEAR(outer_precedence);
+
+    Py_DECREF(expr);
+
+    return statement;
+
+error:
+    Py_XDECREF(expr);
+    Py_XDECREF(outer_precedence);
+    Py_XDECREF(compiled);
+    Py_XDECREF(sequence);
+    Py_XDECREF(statement);
+
+    return NULL;
+}
+
+static PyObject *
+Compile__call__(CompileObject *self, PyObject *args, PyObject *kwargs)
+{
+    static char *kwlist[] = {"expr", "state", "join", "raw", "token", NULL};
+    PyObject *expr = NULL;
+    PyObject *state = Py_None;
+    PyObject *join;
+    char raw = 0;
+    char token = 0;
+
+    PyObject *result = NULL;
+
+    if (!initialize_globals())
+        return NULL;
+
+    join = default_compile_join;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OSbb", kwlist,
+                                     &expr, &state, &join, &raw, &token)) {
+        return NULL;
+    }
+
+    if (state == Py_None) {
+        state = PyObject_CallFunctionObjArgs(State, NULL);
+    } else {
+        Py_INCREF(state);
+    }
+    if (state) {
+        result = Compile_one_or_many(self, expr, state, join, raw, token);
+        Py_DECREF(state);
+    }
+    return result;
+}
+
+
+static PyMethodDef Compile_methods[] = {
+    {"_update_cache", (PyCFunction)Compile__update_cache, METH_NOARGS, NULL},
+    {"when", (PyCFunction)Compile_when, METH_VARARGS, NULL},
+    {"add_reserved_words", (PyCFunction)Compile_add_reserved_words,
+        METH_O, NULL},
+    {"remove_reserved_words", (PyCFunction)Compile_remove_reserved_words,
+        METH_O, NULL},
+    {"is_reserved_word", (PyCFunction)Compile_is_reserved_word, METH_O, NULL},
+    {"create_child", (PyCFunction)Compile_create_child, METH_NOARGS, NULL},
+    {"get_precedence", (PyCFunction)Compile_get_precedence, METH_O, NULL},
+    {"set_precedence", (PyCFunction)Compile_set_precedence, METH_VARARGS, NULL},
+    {NULL, NULL}
+};
+
+#define OFFSETOF(x) offsetof(CompileObject, x)
+static PyMemberDef Compile_members[] = {
+    {"_local_dispatch_table", T_OBJECT, OFFSETOF(_local_dispatch_table), 0, 0},
+    {"_local_precedence", T_OBJECT, OFFSETOF(_local_precedence), 0, 0},
+    {"_local_reserved_words", T_OBJECT, OFFSETOF(_local_reserved_words), 0, 0},
+    {"_dispatch_table", T_OBJECT, OFFSETOF(_dispatch_table), 0, 0},
+    {"_precedence", T_OBJECT, OFFSETOF(_precedence), 0, 0},
+    {"_reserved_words", T_OBJECT, OFFSETOF(_reserved_words), 0, 0},
+    {"_children", T_OBJECT, OFFSETOF(_children), 0, 0},
+    {"_parents", T_OBJECT, OFFSETOF(_parents), 0, 0},
+    {NULL}
+};
+#undef OFFSETOF
+
+statichere PyTypeObject Compile_Type = {
+    PyObject_HEAD_INIT(NULL)
+    0,            /*ob_size*/
+    "storm.variables.Compile",    /*tp_name*/
+    sizeof(CompileObject), /*tp_basicsize*/
+    0,            /*tp_itemsize*/
+    (destructor)Compile_dealloc, /*tp_dealloc*/
+    0,            /*tp_print*/
+    0,            /*tp_getattr*/
+    0,            /*tp_setattr*/
+    0,            /*tp_compare*/
+    0,          /*tp_repr*/
+    0,            /*tp_as_number*/
+    0,            /*tp_as_sequence*/
+    0,            /*tp_as_mapping*/
+    0,                      /*tp_hash*/
+    (ternaryfunc)Compile__call__, /*tp_call*/
+    0,                      /*tp_str*/
+    PyObject_GenericGetAttr,/*tp_getattro*/
+    PyObject_GenericSetAttr,/*tp_setattro*/
+    0,                      /*tp_as_buffer*/
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, /*tp_flags*/
+    0,                      /*tp_doc*/
+    (traverseproc)Compile_traverse,  /*tp_traverse*/
+    (inquiry)Compile_clear,          /*tp_clear*/
+    0,                      /*tp_richcompare*/
+    offsetof(CompileObject, __weakreflist), /*tp_weaklistoffset*/
+    0,                      /*tp_iter*/
+    0,                      /*tp_iternext*/
+    Compile_methods,        /*tp_methods*/
+    Compile_members,        /*tp_members*/
+    0,                      /*tp_getset*/
+    0,                      /*tp_base*/
+    0,                      /*tp_dict*/
+    0,                      /*tp_descr_get*/
+    0,                      /*tp_descr_set*/
+    0,                      /*tp_dictoffset*/
+    (initproc)Compile_init, /*tp_init*/
+    PyType_GenericAlloc,    /*tp_alloc*/
+    PyType_GenericNew,      /*tp_new*/
+    PyObject_GC_Del,        /*tp_free*/
+    0,                      /*tp_is_gc*/
+};
+
+
+static PyObject *
+>>>>>>> MERGE-SOURCE
 ObjectInfo__emit_object_deleted(ObjectInfoObject *self, PyObject *args)
 {
     /* self.event.emit("object-deleted") */
 
=== modified file 'storm/database.py'
=== modified file 'storm/databases/postgres.py'
--- storm/databases/postgres.py	2008-08-18 19:44:51 +0000
+++ storm/databases/postgres.py	2009-05-06 21:20:16 +0000
@@ -36,7 +36,7 @@
 from storm.variables import Variable, ListVariable, RawStrVariable
 from storm.database import Database, Connection, Result
 from storm.exceptions import (
-    install_exceptions, DatabaseError, DatabaseModuleError,
+    install_exceptions, DatabaseError, DatabaseModuleError, InterfaceError,
     OperationalError, ProgrammingError, TimeoutError)
 from storm.tracer import TimeoutTracer
 
@@ -285,18 +285,28 @@
                 yield param
 
     def is_disconnection_error(self, exc):
-        if not isinstance(exc, (OperationalError, ProgrammingError)):
+        if not isinstance(
+            exc, (InterfaceError, OperationalError, ProgrammingError)):
             return False
 
         # XXX: 2007-09-17 jamesh
         # I have no idea why I am seeing the last exception message
         # after upgrading to Gutsy.
         msg = str(exc)
-        return ("server closed the connection unexpectedly" in msg or
-                "could not connect to server" in msg or
-                "no connection to the server" in msg or
-                "connection not open" in msg or
-                "losed the connection unexpectedly" in msg)
+<<<<<<< TREE
+        return ("server closed the connection unexpectedly" in msg or
+                "could not connect to server" in msg or
+                "no connection to the server" in msg or
+                "connection not open" in msg or
+                "losed the connection unexpectedly" in msg)
+=======
+        return ("server closed the connection unexpectedly" in msg or
+                "could not connect to server" in msg or
+                "no connection to the server" in msg or
+                "connection not open" in msg or
+                "connection already closed" in msg or
+                "losed the connection unexpectedly" in msg)
+>>>>>>> MERGE-SOURCE
 
 
 class Postgres(Database):
 
=== modified file 'storm/properties.py'
=== modified file 'storm/references.py'
=== modified file 'storm/sqlobject.py'
--- storm/sqlobject.py	2008-11-05 18:37:41 +0000
+++ storm/sqlobject.py	2009-05-06 21:20:16 +0000
@@ -552,8 +552,13 @@
         return item in result_set
 
     def __nonzero__(self):
+<<<<<<< TREE
         result_set = self._without_prejoins()._result_set
         return not result_set.is_empty()
+=======
+        result_set = self._without_prejoins()._result_set
+        return result_set.any() is not None
+>>>>>>> MERGE-SOURCE
 
     def count(self):
         result_set = self._without_prejoins()._result_set
 
=== modified file 'storm/store.py'
--- storm/store.py	2009-02-16 10:44:31 +0000
+++ storm/store.py	2009-05-06 21:20:16 +0000
@@ -36,7 +36,8 @@
     Union, Except, Intersect, Alias, SetExpr)
 from storm.exceptions import (
     WrongStoreError, NotFlushedError, OrderLoopError, UnorderedError,
-    NotOneError, FeatureError, CompileError, LostObjectError, ClassInfoError)
+    NotOneError, FeatureError, CompileError, LostObjectError, ClassInfoError,
+    ExprError)
 from storm import Undef
 from storm.cache import Cache
 from storm.event import EventSystem
@@ -439,7 +440,18 @@
         normal flushing times are insufficient, such as when you want to
         make sure a database trigger gets run at a particular time.
         """
+<<<<<<< TREE
         self._event.emit("flush")
+=======
+        # XXX 2008-06-19 jamesh bug=241267:
+        # This loop takes up 75% of flush()'s runtime in our tests,
+        # and probably more in cases with more live objects.  As we
+        # don't use any property types that require the event, I've
+        # temporarily disabled it.
+
+        ##for obj_info in self._iter_alive():
+        ##    obj_info.event.emit("flush")
+>>>>>>> MERGE-SOURCE
 
         # The _dirty list may change under us while we're running
         # the flush hooks, so we cannot just simply loop over it
@@ -1016,6 +1028,7 @@
 
         return self.copy().config(offset=offset, limit=limit)
 
+<<<<<<< TREE
     def __contains__(self, item):
         """Check if an item is contained within the result set."""
         columns, values = self._find_spec.get_columns_and_values_for_item(item)
@@ -1047,6 +1060,31 @@
         result = self._store._connection.execute(select)
         return (not result.get_one())
 
+=======
+    def __contains__(self, item):
+        """Check if an item is contained within the result set."""
+        columns, values = self._find_spec.get_columns_and_values_for_item(item)
+
+        if self._select is Undef and self._group_by is Undef:
+            # No predefined select: adjust the where clause.
+            dummy, default_tables = self._find_spec.get_columns_and_tables()
+            where = [Eq(*pair) for pair in zip(columns, values)]
+            if self._where is not Undef:
+                where.append(self._where)
+            select = Select(1, And(*where), self._tables,
+                            default_tables)
+        else:
+            # Rewrite the predefined query and use it as a subquery.
+            aliased_columns = [Alias(column, "_key%d" % index)
+                               for (index, column) in enumerate(columns)]
+            subquery = replace_columns(self._get_select(), aliased_columns)
+            where = [Eq(*pair) for pair in zip(aliased_columns, values)]
+            select = Select(1, And(*where), Alias(subquery, "_tmp"))
+
+        result = self._store._connection.execute(select)
+        return result.get_one() is not None
+
+>>>>>>> MERGE-SOURCE
     def any(self):
         """Return a single item from the result set.
 
@@ -1438,12 +1476,18 @@
     def __getitem__(self, index):
         return self.copy()
 
+<<<<<<< TREE
     def __contains__(self, item):
         return False
 
     def is_empty(self):
         return True
 
+=======
+    def __contains__(self, item):
+        return False
+
+>>>>>>> MERGE-SOURCE
     def any(self):
         return None
 
 
=== modified file 'storm/tracer.py'
--- storm/tracer.py	2009-02-04 01:53:02 +0000
+++ storm/tracer.py	2009-05-06 21:20:16 +0000
@@ -14,6 +14,7 @@
 
     def connection_raw_execute(self, connection, raw_cursor, statement, params):
         time = datetime.now().isoformat()[11:]
+<<<<<<< TREE
         raw_params = []
         for param in params:
             if isinstance(param, Variable):
@@ -23,6 +24,10 @@
         raw_params = tuple(raw_params)
         self._stream.write(
             "[%s] EXECUTE: %r, %r\n" % (time, statement, raw_params))
+=======
+        params = tuple(param.get() for param in params)
+        self._stream.write("[%s] EXECUTE: %r, %r\n" % (time, statement, params))
+>>>>>>> MERGE-SOURCE
         self._stream.flush()
 
     def connection_raw_execute_error(self, connection, raw_cursor,
 
=== modified file 'storm/variables.py'
--- storm/variables.py	2009-03-04 16:56:58 +0000
+++ storm/variables.py	2009-05-06 21:20:16 +0000
@@ -536,6 +536,7 @@
             raise ValueError("Invalid enum value: %s" % repr(value))
 
 
+<<<<<<< TREE
 class MutableValueVariable(Variable):
     """
     A variable which contains a reference to mutable content. For this kind
@@ -544,6 +545,10 @@
     flushing current objects, to check if the state has changed.
     """
     __slots__ = ("_event_system")
+=======
+class PickleVariable(Variable):
+    __slots__ = ()
+>>>>>>> MERGE-SOURCE
 
     def __init__(self, *args, **kwargs):
         self._event_system = None
@@ -603,9 +608,21 @@
         self._lazy_value = state[0]
         self._value = pickle.loads(state[1])
 
+<<<<<<< TREE
 
 class ListVariable(MutableValueVariable):
     __slots__ = ("_item_factory",)
+=======
+    def __hash__(self):
+        try:
+            return hash(self._value)
+        except TypeError:
+            return hash(pickle.dumps(self._value, -1))
+
+
+class ListVariable(Variable):
+    __slots__ = ("_item_factory",)
+>>>>>>> MERGE-SOURCE
 
     def __init__(self, item_factory, *args, **kwargs):
         self._item_factory = item_factory
 
=== modified file 'storm/zope/__init__.py'
--- storm/zope/__init__.py	2008-07-30 06:07:40 +0000
+++ storm/zope/__init__.py	2009-05-06 21:20:16 +0000
@@ -27,6 +27,7 @@
 
 
 classImplements(storm_sqlobject.SQLObjectResultSet, ISQLObjectResultSet)
+<<<<<<< TREE
 classImplements(ResultSet, IResultSet)
 classImplements(EmptyResultSet, IResultSet)
 
@@ -43,3 +44,7 @@
     # Store.
     _available_by_default.append("__storm_object_info__")
     BasicTypes[ObjectInfo] = NoProxy
+=======
+classImplements(ResultSet, IResultSet)
+classImplements(EmptyResultSet, IResultSet)
+>>>>>>> MERGE-SOURCE
 
=== modified file 'storm/zope/interfaces.py'
=== modified file 'storm/zope/zstorm.py'
=== modified file 'test'
=== modified file 'tests/__init__.py'
--- tests/__init__.py	2008-06-20 14:08:30 +0000
+++ tests/__init__.py	2009-05-06 21:20:16 +0000
@@ -0,0 +1,1 @@
+#import storm.psycer as p; p.enable()
 
=== modified file 'tests/databases/base.py'
=== modified file 'tests/databases/postgres.py'
=== modified file 'tests/expr.py'
--- tests/expr.py	2008-10-02 15:47:18 +0000
+++ tests/expr.py	2009-05-06 21:20:16 +0000
@@ -662,16 +662,30 @@
                                      'ORDER BY column1')
         self.assertEquals(state.parameters, [])
 
-    def test_select_having(self):
-        expr = Select(column1, tables=table1, order_by=u"column1",
-                      group_by=[u"column2"], having=u"1 = 2")
-        state = State()
-        statement = compile(expr, state)
-        self.assertEquals(statement, 'SELECT column1 FROM "table 1" '
-                                     'GROUP BY column2 HAVING 1 = 2 '
-                                     'ORDER BY column1')
-        self.assertEquals(state.parameters, [])
-
+<<<<<<< TREE
+    def test_select_having(self):
+        expr = Select(column1, tables=table1, order_by=u"column1",
+                      group_by=[u"column2"], having=u"1 = 2")
+        state = State()
+        statement = compile(expr, state)
+        self.assertEquals(statement, 'SELECT column1 FROM "table 1" '
+                                     'GROUP BY column2 HAVING 1 = 2 '
+                                     'ORDER BY column1')
+        self.assertEquals(state.parameters, [])
+
+=======
+    def test_select_having(self):
+        expr = Select(column1, tables=table1, order_by=u"column1",
+                      group_by=[u"column2"], having=u"1 = 2")
+        state = State()
+        statement = compile(expr, state)
+        self.assertEquals(statement, 'SELECT column1 FROM "table 1" '
+                                     'GROUP BY column2 HAVING 1 = 2 '
+                                     'ORDER BY column1')
+        self.assertEquals(state.parameters, [])
+    
+
+>>>>>>> MERGE-SOURCE
     def test_select_contexts(self):
         column, where, table, order_by, group_by = track_contexts(5)
         expr = Select(column, where, table,
@@ -932,8 +946,13 @@
         expr = Func1().is_in([])
         state = State()
         statement = compile(expr, state)
+<<<<<<< TREE
         self.assertEquals(statement, "?")
         self.assertVariablesEqual(state.parameters, [BoolVariable(False)])
+=======
+        self.assertEquals(statement, "?")
+        self.assertEquals(state.parameters, [BoolVariable(False)])
+>>>>>>> MERGE-SOURCE
 
     def test_is_in_expr(self):
         expr = Func1().is_in(Select(column1))
 
=== modified file 'tests/store/base.py'
--- tests/store/base.py	2009-02-19 16:44:33 +0000
+++ tests/store/base.py	2009-05-06 21:20:16 +0000
@@ -21,17 +21,26 @@
 #
 import decimal
 import gc
+<<<<<<< TREE
 import operator
 import weakref
+=======
+import operator
+>>>>>>> MERGE-SOURCE
 
 from storm.references import Reference, ReferenceSet, Proxy
 from storm.database import Result
 from storm.properties import Int, Float, RawStr, Unicode, Property, Pickle
 from storm.properties import PropertyPublisherMeta, Decimal
+<<<<<<< TREE
 from storm.variables import PickleVariable
 from storm.expr import (
     Asc, Desc, Select, Func, LeftJoin, SQL, Count, Sum, Avg, And, Or, Eq,
     Lower)
+=======
+from storm.expr import (
+    Asc, Desc, Select, Func, LeftJoin, SQL, Count, Sum, Avg, And, Or, Eq)
+>>>>>>> MERGE-SOURCE
 from storm.variables import Variable, UnicodeVariable, IntVariable
 from storm.info import get_obj_info, ClassAlias
 from storm.exceptions import *
@@ -1306,131 +1315,259 @@
         foo = self.store.find(Foo, Foo.id == 10).one()
         self.assertEqual(foo.title, "Title 30")
 
-    def test_find_group_by(self):
-        result = self.store.find((Count(FooValue.id), Sum(FooValue.value1)))
-        result.group_by(FooValue.value2)
-        result.order_by(Count(FooValue.id), Sum(FooValue.value1))
-        result = list(result)
-        self.assertEquals(result, [(2L, 2L), (2L, 2L), (2L, 3L), (3L, 6L)])
-
-    def test_find_group_by_table(self):
-        result = self.store.find(
-            (Sum(FooValue.value2), Foo), Foo.id == FooValue.foo_id)
-        result.group_by(Foo)
-        foo1 = self.store.get(Foo, 10)
-        foo2 = self.store.get(Foo, 20)
-        self.assertEquals(list(result), [(5, foo1), (16, foo2)])
-
-    def test_find_group_by_table_contains(self):
-        result = self.store.find(
-            (Sum(FooValue.value2), Foo), Foo.id == FooValue.foo_id)
-        result.group_by(Foo)
-        foo1 = self.store.get(Foo, 10)
-        self.assertEquals((5, foo1) in result, True)
-
-    def test_find_group_by_multiple_tables(self):
-        result = self.store.find(
-            Sum(FooValue.value2), Foo.id == FooValue.foo_id)
-        result.group_by(Foo.id)
-        result.order_by(Sum(FooValue.value2))
-        result = list(result)
-        self.assertEquals(result, [5, 16])
-
-        result = self.store.find(
-            (Sum(FooValue.value2), Foo), Foo.id == FooValue.foo_id)
-        result.group_by(Foo)
-        result.order_by(Sum(FooValue.value2))
-        result = list(result)
-        foo1 = self.store.get(Foo, 10)
-        foo2 = self.store.get(Foo, 20)
-        self.assertEquals(result, [(5, foo1), (16, foo2)])
-
-        result = self.store.find(
-            (Foo.id, Sum(FooValue.value2), Avg(FooValue.value1)),
-            Foo.id == FooValue.foo_id)
-        result.group_by(Foo.id)
-        result.order_by(Foo.id)
-        result = list(result)
-        self.assertEquals(result, [(10, 5, 2),
-                                   (20, 16, 1)])
-
-    def test_find_group_by_having(self):
-        result = self.store.find(
-            Sum(FooValue.value2), Foo.id == FooValue.foo_id)
-        result.group_by(Foo.id)
-        result.having(Sum(FooValue.value2) == 5)
-        self.assertEquals(list(result), [5])
-        result = self.store.find(
-            Sum(FooValue.value2), Foo.id == FooValue.foo_id)
-        result.group_by(Foo.id)
-        result.having(Count() == 5)
-        self.assertEquals(list(result), [16])
-
-    def test_find_having_without_group_by(self):
-        result = self.store.find(FooValue)
-        self.assertRaises(FeatureError, result.having, FooValue.value1 == 1)
-
-    def test_find_group_by_multiple_having(self):
-        result = self.store.find((Count(), FooValue.value2))
-        result.group_by(FooValue.value2)
-        result.having(Count() == 2, FooValue.value2 >= 3)
-        result.order_by(Count(), FooValue.value2)
-        list_result = list(result)
-        self.assertEquals(list_result, [(2, 3), (2, 4)])
-
-    def test_find_successive_group_by(self):
-        result = self.store.find(Count())
-        result.group_by(FooValue.value2)
-        result.order_by(Count())
-        list_result = list(result)
-        self.assertEquals(list_result, [2, 2, 2, 3])
-        result.group_by(FooValue.value1)
-        list_result = list(result)
-        self.assertEquals(list_result, [4, 5])
-
-    def test_find_multiple_group_by(self):
-        result = self.store.find(Count())
-        result.group_by(FooValue.value2, FooValue.value1)
-        result.order_by(Count())
-        list_result = list(result)
-        self.assertEquals(list_result, [1, 1, 2, 2, 3])
-
-    def test_find_multiple_group_by_with_having(self):
-        result = self.store.find((Count(), FooValue.value2))
-        result.group_by(FooValue.value2, FooValue.value1).having(Count() == 2)
-        result.order_by(Count(), FooValue.value2)
-        list_result = list(result)
-        self.assertEquals(list_result, [(2, 3), (2, 4)])
-
-    def test_find_group_by_avg(self):
-        result = self.store.find((Count(FooValue.id), Sum(FooValue.value1)))
-        result.group_by(FooValue.value2)
-        self.assertRaises(FeatureError, result.avg, FooValue.value2)
-
-    def test_find_group_by_values(self):
-        result = self.store.find(
-            (Sum(FooValue.value2), Foo), Foo.id == FooValue.foo_id)
-        result.group_by(Foo)
-        result.order_by(Foo.title)
-        result = list(result.values(Foo.title))
-        self.assertEquals(result, [u'Title 20', u'Title 30'])
-
-    def test_find_group_by_union(self):
-        result1 = self.store.find(Foo, id=30)
-        result2 = self.store.find(Foo, id=10)
-        result3 = result1.union(result2)
-        self.assertRaises(FeatureError, result3.group_by, Foo.title)
-
-    def test_find_group_by_remove(self):
-        result = self.store.find((Count(FooValue.id), Sum(FooValue.value1)))
-        result.group_by(FooValue.value2)
-        self.assertRaises(FeatureError, result.remove)
-
-    def test_find_group_by_set(self):
-        result = self.store.find((Count(FooValue.id), Sum(FooValue.value1)))
-        result.group_by(FooValue.value2)
-        self.assertRaises(FeatureError, result.set, FooValue.value1 == 1)
-
+<<<<<<< TREE
+    def test_find_group_by(self):
+        result = self.store.find((Count(FooValue.id), Sum(FooValue.value1)))
+        result.group_by(FooValue.value2)
+        result.order_by(Count(FooValue.id), Sum(FooValue.value1))
+        result = list(result)
+        self.assertEquals(result, [(2L, 2L), (2L, 2L), (2L, 3L), (3L, 6L)])
+
+    def test_find_group_by_table(self):
+        result = self.store.find(
+            (Sum(FooValue.value2), Foo), Foo.id == FooValue.foo_id)
+        result.group_by(Foo)
+        foo1 = self.store.get(Foo, 10)
+        foo2 = self.store.get(Foo, 20)
+        self.assertEquals(list(result), [(5, foo1), (16, foo2)])
+
+    def test_find_group_by_table_contains(self):
+        result = self.store.find(
+            (Sum(FooValue.value2), Foo), Foo.id == FooValue.foo_id)
+        result.group_by(Foo)
+        foo1 = self.store.get(Foo, 10)
+        self.assertEquals((5, foo1) in result, True)
+
+    def test_find_group_by_multiple_tables(self):
+        result = self.store.find(
+            Sum(FooValue.value2), Foo.id == FooValue.foo_id)
+        result.group_by(Foo.id)
+        result.order_by(Sum(FooValue.value2))
+        result = list(result)
+        self.assertEquals(result, [5, 16])
+
+        result = self.store.find(
+            (Sum(FooValue.value2), Foo), Foo.id == FooValue.foo_id)
+        result.group_by(Foo)
+        result.order_by(Sum(FooValue.value2))
+        result = list(result)
+        foo1 = self.store.get(Foo, 10)
+        foo2 = self.store.get(Foo, 20)
+        self.assertEquals(result, [(5, foo1), (16, foo2)])
+
+        result = self.store.find(
+            (Foo.id, Sum(FooValue.value2), Avg(FooValue.value1)),
+            Foo.id == FooValue.foo_id)
+        result.group_by(Foo.id)
+        result.order_by(Foo.id)
+        result = list(result)
+        self.assertEquals(result, [(10, 5, 2),
+                                   (20, 16, 1)])
+
+    def test_find_group_by_having(self):
+        result = self.store.find(
+            Sum(FooValue.value2), Foo.id == FooValue.foo_id)
+        result.group_by(Foo.id)
+        result.having(Sum(FooValue.value2) == 5)
+        self.assertEquals(list(result), [5])
+        result = self.store.find(
+            Sum(FooValue.value2), Foo.id == FooValue.foo_id)
+        result.group_by(Foo.id)
+        result.having(Count() == 5)
+        self.assertEquals(list(result), [16])
+
+    def test_find_having_without_group_by(self):
+        result = self.store.find(FooValue)
+        self.assertRaises(FeatureError, result.having, FooValue.value1 == 1)
+
+    def test_find_group_by_multiple_having(self):
+        result = self.store.find((Count(), FooValue.value2))
+        result.group_by(FooValue.value2)
+        result.having(Count() == 2, FooValue.value2 >= 3)
+        result.order_by(Count(), FooValue.value2)
+        list_result = list(result)
+        self.assertEquals(list_result, [(2, 3), (2, 4)])
+
+    def test_find_successive_group_by(self):
+        result = self.store.find(Count())
+        result.group_by(FooValue.value2)
+        result.order_by(Count())
+        list_result = list(result)
+        self.assertEquals(list_result, [2, 2, 2, 3])
+        result.group_by(FooValue.value1)
+        list_result = list(result)
+        self.assertEquals(list_result, [4, 5])
+
+    def test_find_multiple_group_by(self):
+        result = self.store.find(Count())
+        result.group_by(FooValue.value2, FooValue.value1)
+        result.order_by(Count())
+        list_result = list(result)
+        self.assertEquals(list_result, [1, 1, 2, 2, 3])
+
+    def test_find_multiple_group_by_with_having(self):
+        result = self.store.find((Count(), FooValue.value2))
+        result.group_by(FooValue.value2, FooValue.value1).having(Count() == 2)
+        result.order_by(Count(), FooValue.value2)
+        list_result = list(result)
+        self.assertEquals(list_result, [(2, 3), (2, 4)])
+
+    def test_find_group_by_avg(self):
+        result = self.store.find((Count(FooValue.id), Sum(FooValue.value1)))
+        result.group_by(FooValue.value2)
+        self.assertRaises(FeatureError, result.avg, FooValue.value2)
+
+    def test_find_group_by_values(self):
+        result = self.store.find(
+            (Sum(FooValue.value2), Foo), Foo.id == FooValue.foo_id)
+        result.group_by(Foo)
+        result.order_by(Foo.title)
+        result = list(result.values(Foo.title))
+        self.assertEquals(result, [u'Title 20', u'Title 30'])
+
+    def test_find_group_by_union(self):
+        result1 = self.store.find(Foo, id=30)
+        result2 = self.store.find(Foo, id=10)
+        result3 = result1.union(result2)
+        self.assertRaises(FeatureError, result3.group_by, Foo.title)
+
+    def test_find_group_by_remove(self):
+        result = self.store.find((Count(FooValue.id), Sum(FooValue.value1)))
+        result.group_by(FooValue.value2)
+        self.assertRaises(FeatureError, result.remove)
+
+    def test_find_group_by_set(self):
+        result = self.store.find((Count(FooValue.id), Sum(FooValue.value1)))
+        result.group_by(FooValue.value2)
+        self.assertRaises(FeatureError, result.set, FooValue.value1 == 1)
+
+=======
+    def test_find_group_by(self):
+        result = self.store.find((Count(FooValue.id), Sum(FooValue.value1)))
+        result.group_by(FooValue.value2)
+        result.order_by(Count(FooValue.id), Sum(FooValue.value1))
+        result = list(result)
+        self.assertEquals(result, [(2L, 2L), (2L, 2L), (2L, 3L), (3L, 6L)])
+
+    def test_find_group_by_table(self):
+        result = self.store.find(
+            (Sum(FooValue.value2), Foo), Foo.id == FooValue.foo_id)
+        result.group_by(Foo)
+        foo1 = self.store.get(Foo, 10)
+        foo2 = self.store.get(Foo, 20)
+        self.assertEquals(list(result), [(5, foo1), (16, foo2)])
+
+    def test_find_group_by_table_contains(self):
+        result = self.store.find(
+            (Sum(FooValue.value2), Foo), Foo.id == FooValue.foo_id)
+        result.group_by(Foo)
+        foo1 = self.store.get(Foo, 10)
+        self.assertEquals((5, foo1) in result, True)
+
+    def test_find_group_by_multiple_tables(self):
+        result = self.store.find(
+            Sum(FooValue.value2), Foo.id == FooValue.foo_id)
+        result.group_by(Foo.id)
+        result.order_by(Sum(FooValue.value2))
+        result = list(result)
+        self.assertEquals(result, [5, 16])
+
+        result = self.store.find(
+            (Sum(FooValue.value2), Foo), Foo.id == FooValue.foo_id)
+        result.group_by(Foo)
+        result.order_by(Sum(FooValue.value2))
+        result = list(result)
+        foo1 = self.store.get(Foo, 10)
+        foo2 = self.store.get(Foo, 20)
+        self.assertEquals(result, [(5, foo1), (16, foo2)])
+
+        result = self.store.find(
+            (Foo.id, Sum(FooValue.value2), Avg(FooValue.value1)),
+            Foo.id == FooValue.foo_id)
+        result.group_by(Foo.id)
+        result.order_by(Foo.id)
+        result = list(result)
+        self.assertEquals(result, [(10, 5, 2),
+                                   (20, 16, 1)])
+
+    def test_find_group_by_having(self):
+        result = self.store.find(
+            Sum(FooValue.value2), Foo.id == FooValue.foo_id)
+        result.group_by(Foo.id)
+        result.having(Sum(FooValue.value2) == 5)
+        self.assertEquals(list(result), [5])
+        result = self.store.find(
+            Sum(FooValue.value2), Foo.id == FooValue.foo_id)
+        result.group_by(Foo.id)
+        result.having(Count() == 5)
+        self.assertEquals(list(result), [16])
+
+    def test_find_having_without_group_by(self):
+        result = self.store.find(FooValue)
+        self.assertRaises(FeatureError, result.having, FooValue.value1 == 1)
+
+    def test_find_group_by_multiple_having(self):
+        result = self.store.find((Count(), FooValue.value2))
+        result.group_by(FooValue.value2)
+        result.having(Count() == 2, FooValue.value2 >= 3)
+        result.order_by(Count(), FooValue.value2)
+        list_result = list(result)
+        self.assertEquals(list_result, [(2, 3), (2, 4)])
+
+    def test_find_successive_group_by(self):
+        result = self.store.find(Count())
+        result.group_by(FooValue.value2)
+        result.order_by(Count())
+        list_result = list(result)
+        self.assertEquals(list_result, [2, 2, 2, 3])
+        result.group_by(FooValue.value1)
+        list_result = list(result)
+        self.assertEquals(list_result, [4, 5])
+
+    def test_find_multiple_group_by(self):
+        result = self.store.find(Count())
+        result.group_by(FooValue.value2, FooValue.value1)
+        result.order_by(Count())
+        list_result = list(result)
+        self.assertEquals(list_result, [1, 1, 2, 2, 3])
+
+    def test_find_multiple_group_by_with_having(self):
+        result = self.store.find((Count(), FooValue.value2))
+        result.group_by(FooValue.value2, FooValue.value1).having(Count() == 2)
+        result.order_by(Count(), FooValue.value2)
+        list_result = list(result)
+        self.assertEquals(list_result, [(2, 3), (2, 4)])
+
+    def test_find_group_by_avg(self):
+        result = self.store.find((Count(FooValue.id), Sum(FooValue.value1)))
+        result.group_by(FooValue.value2)
+        self.assertRaises(FeatureError, result.avg, FooValue.value2)
+
+    def test_find_group_by_values(self):
+        result = self.store.find(
+            (Sum(FooValue.value2), Foo), Foo.id == FooValue.foo_id)
+        result.group_by(Foo)
+        result.order_by(Foo.title)
+        result = list(result.values(Foo.title))
+        self.assertEquals(result, [u'Title 20', u'Title 30'])
+
+    def test_find_group_by_union(self):
+        result1 = self.store.find(Foo, id=30)
+        result2 = self.store.find(Foo, id=10)
+        result3 = result1.union(result2)
+        self.assertRaises(FeatureError, result3.group_by, Foo.title)
+
+    def test_find_group_by_remove(self):
+        result = self.store.find((Count(FooValue.id), Sum(FooValue.value1)))
+        result.group_by(FooValue.value2)
+        self.assertRaises(FeatureError, result.remove)
+    
+    def test_find_group_by_set(self):
+        result = self.store.find((Count(FooValue.id), Sum(FooValue.value1)))
+        result.group_by(FooValue.value2)
+        self.assertRaises(FeatureError, result.set, FooValue.value1 == 1)
+
+>>>>>>> MERGE-SOURCE
     def test_add_commit(self):
         foo = Foo()
         foo.id = 40
@@ -4316,6 +4453,10 @@
         self.assertEquals(foo.title, "Some default value")
 
     def test_pickle_variable(self):
+        # XXX 2008-06-19 jamesh bug=241267:
+        # Disabled, as Pickle() properties depend on the flush event.
+        return
+
         class PickleBlob(Blob):
             bin = Pickle()
 
@@ -4503,6 +4644,10 @@
         self.assertTrue(value is blob.pickle)
 
     def test_pickle_variable_with_deleted_object(self):
+        # XXX 2008-06-19 jamesh bug=241267:
+        # Disabled, as Pickle() properties depend on the flush event.
+        return
+
         class PickleBlob(Blob):
             bin = Pickle()
 
@@ -5387,6 +5532,7 @@
                     " (ensure your database was created with CREATE DATABASE"
                     " ... CHARACTER SET utf8)")
 
+<<<<<<< TREE
     def test_creation_order_is_preserved_when_possible(self):
         foos = [self.store.add(Foo()) for i in range(10)]
         self.store.flush()
@@ -5499,6 +5645,50 @@
         foo.title = u"New title"
         self.assertEqual(len(calls), 1)
         self.assertEqual(calls[0], self.store)
+=======
+    def test_creation_order_is_preserved_when_possible(self):
+        foos = [self.store.add(Foo()) for i in range(10)]
+        self.store.flush()
+        for i in range(len(foos)-1):
+            self.assertTrue(foos[i].id < foos[i+1].id)
+
+    def test_update_order_is_preserved_when_possible(self):
+        class MyFoo(Foo):
+            sequence = 0
+            def __storm_flushed__(self):
+                self.flush_order = MyFoo.sequence
+                MyFoo.sequence += 1
+
+        foos = [self.store.add(MyFoo()) for i in range(10)]
+        self.store.flush()
+
+        MyFoo.sequence = 0
+        for foo in foos:
+            foo.title = u"Changed Title"
+        self.store.flush()
+
+        for i, foo in enumerate(foos):
+            self.assertEquals(foo.flush_order, i)
+
+    def test_removal_order_is_preserved_when_possible(self):
+        class MyFoo(Foo):
+            sequence = 0
+            def __storm_flushed__(self):
+                self.flush_order = MyFoo.sequence
+                MyFoo.sequence += 1
+
+        foos = [self.store.add(MyFoo()) for i in range(10)]
+        self.store.flush()
+
+        MyFoo.sequence = 0
+        for foo in foos:
+            self.store.remove(foo)
+        self.store.flush()
+
+        for i, foo in enumerate(foos):
+            self.assertEquals(foo.flush_order, i)
+
+>>>>>>> MERGE-SOURCE
 
 class EmptyResultSetTest(object):
 
@@ -5560,6 +5750,7 @@
         self.assertEquals(list(self.result[:]), [])
         self.assertEquals(list(self.empty[:]), [])
 
+<<<<<<< TREE
     def test_contains(self):
         self.assertEquals(Foo() in self.empty, False)
 
@@ -5567,6 +5758,11 @@
         self.assertEquals(self.result.is_empty(), True)
         self.assertEquals(self.empty.is_empty(), True)
 
+=======
+    def test_contains(self):
+        self.assertEquals(Foo() in self.empty, False)
+
+>>>>>>> MERGE-SOURCE
     def test_any(self):
         self.assertEquals(self.result.any(), None)
         self.assertEquals(self.empty.any(), None)
 
=== modified file 'tests/store/mysql.py'
=== modified file 'tests/store/postgres.py'
--- tests/store/postgres.py	2009-03-04 16:56:58 +0000
+++ tests/store/postgres.py	2009-05-06 21:20:16 +0000
@@ -103,6 +103,9 @@
                 self.connection.rollback()
 
     def test_list_variable(self):
+        # XXX 2008-06-19 jamesh bug=241267:
+        # Disabled, as List() properties depend on the flush event.
+        return
 
         lst = Lst1()
         lst.id = 1
@@ -146,6 +149,9 @@
         self.assertEquals(result.get_one(), ([1,2,3],))
 
     def test_list_variable_nested(self):
+        # XXX 2008-06-19 jamesh bug=241267:
+        # Disabled, as List() properties depend on the flush event.
+        return
 
         lst = Lst2()
         lst.id = 1
 
=== modified file 'tests/store/sqlite.py'
=== modified file 'tests/tracer.py'
--- tests/tracer.py	2009-02-04 01:53:02 +0000
+++ tests/tracer.py	2009-05-06 21:20:16 +0000
@@ -74,6 +74,7 @@
         self.assertEquals(stash, ["m1", (1, 2), {"c": 3}, "m2", (), {}])
 
 
+<<<<<<< TREE
 
 class MockVariable(Variable):
 
@@ -84,6 +85,18 @@
         return self._value
 
 
+=======
+
+class MockVariable(object):
+
+    def __init__(self, value):
+        self._value = value
+
+    def get(self):
+        return self._value
+
+
+>>>>>>> MERGE-SOURCE
 class DebugTracerTest(TestHelper):
 
     def setUp(self):
@@ -116,6 +129,7 @@
         self.assertEqual(tracer._stream, marker)
 
     def test_connection_raw_execute(self):
+<<<<<<< TREE
         self.stream.write(
             "[04:05:06.000007] EXECUTE: 'STATEMENT', ('PARAM',)\n")
         self.stream.flush()
@@ -139,6 +153,17 @@
         raw_cursor = "RAW_CURSOR"
         statement = "STATEMENT"
         params = [self.variable, 1]
+=======
+        stderr = self.mocker.replace("sys.stderr")
+        stderr.write("[04:05:06.000007] EXECUTE: 'STATEMENT', ('PARAM',)\n")
+        stderr.flush()
+        self.mocker.replay()
+
+        connection = "CONNECTION"
+        raw_cursor = "RAW_CURSOR"
+        statement = "STATEMENT"
+        params = [self.variable]
+>>>>>>> MERGE-SOURCE
 
         self.tracer.connection_raw_execute(connection, raw_cursor,
                                            statement, params)
@@ -170,6 +195,25 @@
         self.tracer.connection_raw_execute_success(connection, raw_cursor,
                                                    statement, params)
 
+<<<<<<< TREE
+=======
+    def test_custom_stream(self):
+        self.tracer = DebugTracer(sys.stdout)
+
+        stdout = self.mocker.replace("sys.stdout")
+        stdout.write("[04:05:06.000007] EXECUTE: 'STATEMENT', ('PARAM',)\n")
+        stdout.flush()
+        self.mocker.replay()
+
+        connection = "CONNECTION"
+        raw_cursor = "RAW_CURSOR"
+        statement = "STATEMENT"
+        params = [self.variable]
+
+        self.tracer.connection_raw_execute(connection, raw_cursor,
+                                           statement, params)
+
+>>>>>>> MERGE-SOURCE
 
 class TimeoutTracerTestBase(TestHelper):
 
 
=== modified file 'tests/tutorial.txt'
=== modified file 'tests/zope/zstorm.py'
--- tests/zope/zstorm.py	2009-03-05 21:53:12 +0000
+++ tests/zope/zstorm.py	2009-05-06 21:20:16 +0000
@@ -21,7 +21,11 @@
 import thread, weakref, gc
 
 from tests.helper import TestHelper
+<<<<<<< TREE
 from tests.zope import has_transaction, has_zope_component
+=======
+from tests.zope import has_transaction, has_zope, has_zope_component
+>>>>>>> MERGE-SOURCE
 
 if has_transaction:
     import transaction
@@ -31,6 +35,9 @@
 if has_zope_component:
     from zope.component import provideUtility, getUtility
 
+if has_zope_component:
+    from zope.component import provideUtility, getUtility
+
 from storm.exceptions import OperationalError
 from storm.locals import Store
 
@@ -233,6 +240,7 @@
         store = self.zstorm.get("name", "sqlite:")
         store_ref = weakref.ref(store)
         transaction.abort()
+<<<<<<< TREE
         del store
         gc.collect()
         self.assertNotIdentical(store_ref(), None)
@@ -249,3 +257,24 @@
         provideUtility(ZStorm())
         self.assertTrue(isinstance(getUtility(IZStorm), ZStorm))
 
+=======
+        self.assertEquals(
+            len(transaction.manager._synchs.values()[0].data.values()), 1)
+        self.zstorm._reset()
+        self.assertEquals(
+            len(transaction.manager._synchs.values()[0].data.values()), 0)
+
+    def test_store_strong_reference(self):
+        """
+        The zstorm utility should be a strong reference to named stores so that
+        it doesn't recreate stores uselessly.
+        """
+        store = self.zstorm.get("name", "sqlite:")
+        store_ref = weakref.ref(store)
+        transaction.abort()
+        del store
+        gc.collect()
+        self.assertNotIdentical(store_ref(), None)
+        store = self.zstorm.get("name")
+        self.assertIdentical(store_ref(), store)
+>>>>>>> MERGE-SOURCE