Merge lp:~zorba-coders/zorba/no-batching into lp:zorba

[Markos Zaharioudakis]

Removed the Batcher class from the runtime (saves 10% off the size of the zorba library)

Removed the Batcher class from the runtime (saves 10% off the size of the zorba library)

[lp:~zorba-coders/zorba/no-batching]

11243. By Markos Zaharioudakis on 2013-05-28

merge from trunk

[Markos Zaharioudakis (markos-za)]

review: Approve

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/no-batching-2013-05-29T02-22-14.256Z/log.html

[Zorba Build Bot (zorba-buildbot)]

Validation queue job no-batching-2013-05-29T02-22-14.256Z is finished. The final status was:

All tests succeeded!

=== modified file 'include/zorba/config.h.cmake'
--- include/zorba/config.h.cmake	2013-02-07 17:24:36 +0000
+++ include/zorba/config.h.cmake	2013-05-28 18:24:26 +0000
@@ -194,8 +194,6 @@
 #cmakedefine ZORBA_DEBUG_STRING 
 
 // Zorba runtime configuration parameters
-#define ZORBA_BATCHING_TYPE         ${ZORBA_BATCHING_TYPE}
-#define ZORBA_BATCHING_BATCHSIZE    ${ZORBA_BATCHING_BATCHSIZE}
 #define ZORBA_FLOAT_POINT_PRECISION ${ZORBA_FLOAT_POINT_PRECISION}
 
 // Zorba threading mechanism

=== modified file 'src/runtime/api/plan_iterator_wrapper.cpp'
--- src/runtime/api/plan_iterator_wrapper.cpp	2013-05-25 14:36:27 +0000
+++ src/runtime/api/plan_iterator_wrapper.cpp	2013-05-28 18:24:26 +0000
@@ -81,13 +81,25 @@
 }
 
 
-void PlanStateIteratorWrapper::open(PlanState& planState, uint32_t& offset) 
+void PlanStateIteratorWrapper::openImpl(PlanState& planState, uint32_t& offset) 
 {
   theStoreIterator->open();
 }
 
 
-bool PlanStateIteratorWrapper::produceNext(
+void PlanStateIteratorWrapper::reset() const
+{
+  theStoreIterator->reset();
+}
+
+
+void PlanStateIteratorWrapper::resetImpl(PlanState& planState) const
+{
+  theStoreIterator->reset();
+}
+
+
+bool PlanStateIteratorWrapper::nextImpl(
     store::Item_t& result,
     PlanState& planState) const
 {
@@ -101,18 +113,6 @@
 }
 
 
-void PlanStateIteratorWrapper::reset() const
-{
-  theStoreIterator->reset();
-}
-
-
-void PlanStateIteratorWrapper::reset(PlanState& planState) const
-{
-  theStoreIterator->reset();
-}
-
-
 void PlanStateIteratorWrapper::accept(PlanIterVisitor& v) const
 {
 }

=== modified file 'src/runtime/api/plan_iterator_wrapper.h'
--- src/runtime/api/plan_iterator_wrapper.h	2013-05-25 14:36:27 +0000
+++ src/runtime/api/plan_iterator_wrapper.h	2013-05-28 18:24:26 +0000
@@ -84,22 +84,23 @@
 
   virtual void accept(PlanIterVisitor& v) const;
 
-  virtual void open(PlanState& planState, uint32_t& offset); 
-
-  virtual bool produceNext(store::Item_t& result, PlanState& planState) const;
-
+  virtual uint32_t getStateSize() const { return 0; }
+
+  virtual uint32_t getStateSizeOfSubtree() const { return 0; }
+
+  virtual void openImpl(PlanState& planState, uint32_t& offset); 
+
+  virtual void closeImpl(PlanState& planState) {}
+
+  virtual void resetImpl(PlanState& planState) const;
+
+  virtual bool nextImpl(store::Item_t& result, PlanState& planState) const;
+
+public:
   virtual bool next(store::Item_t&);
 
   virtual void reset() const;
 
-  virtual void reset(PlanState& planState) const;
-
-  virtual void close(PlanState& planState) {}
-
-  virtual uint32_t getStateSize() const { return 0; }
-
-  virtual uint32_t getStateSizeOfSubtree() const { return 0; }
-
 #ifndef NDEBUG
   virtual std::string toString() const;
 #endif

=== modified file 'src/runtime/base/binarybase.h'
--- src/runtime/base/binarybase.h	2013-02-07 17:24:36 +0000
+++ src/runtime/base/binarybase.h	2013-05-28 18:24:26 +0000
@@ -31,7 +31,7 @@
   data members.
 ********************************************************************************/
 template <class IterType, class StateType>
-class BinaryBaseIterator : public Batcher<IterType>
+class BinaryBaseIterator : public PlanIterator
 {
 protected:
   PlanIter_t theChild0;
@@ -39,10 +39,10 @@
 
 public:
   SERIALIZABLE_ABSTRACT_CLASS(BinaryBaseIterator)
-  SERIALIZABLE_CLASS_CONSTRUCTOR2(BinaryBaseIterator, Batcher<IterType>)
+  SERIALIZABLE_CLASS_CONSTRUCTOR2(BinaryBaseIterator, PlanIterator)
   void serialize(::zorba::serialization::Archiver& ar)
   {
-    serialize_baseclass(ar, (Batcher<IterType>*)this);
+    serialize_baseclass(ar, (PlanIterator*)this);
     ar & theChild0;
     ar & theChild1;
   }
@@ -54,7 +54,7 @@
         PlanIter_t& child0,
         PlanIter_t& child1)
     :
-    Batcher<IterType>(sctx, loc),
+    PlanIterator(sctx, loc),
     theChild0(child0),
     theChild1(child1)
   {

=== modified file 'src/runtime/base/narybase.h'
--- src/runtime/base/narybase.h	2013-02-07 17:24:36 +0000
+++ src/runtime/base/narybase.h	2013-05-28 18:24:26 +0000
@@ -34,17 +34,17 @@
   data members.
 ********************************************************************************/
 template <class IterType, class StateType>
-class NaryBaseIterator : public Batcher<IterType>
+class NaryBaseIterator : public PlanIterator
 {
 protected:
   std::vector<PlanIter_t> theChildren;
 
 public:
   SERIALIZABLE_ABSTRACT_CLASS(NaryBaseIterator)
-  SERIALIZABLE_CLASS_CONSTRUCTOR2(NaryBaseIterator, Batcher<IterType>)
+  SERIALIZABLE_CLASS_CONSTRUCTOR2(NaryBaseIterator, PlanIterator)
   void serialize(::zorba::serialization::Archiver& ar)
   {
-    serialize_baseclass(ar, (Batcher<IterType>*)this);
+    serialize_baseclass(ar, (PlanIterator*)this);
     ar & theChildren;
   }
 
@@ -80,18 +80,17 @@
 NaryBaseIterator<IterType, StateType>::NaryBaseIterator(
     static_context* sctx,
     const QueryLoc& loc,
-    std::vector<PlanIter_t>& aChildren)
+    std::vector<PlanIter_t>& children)
   :
-  Batcher<IterType>(sctx, loc),
-  theChildren(aChildren)
+  PlanIterator(sctx, loc),
+  theChildren(children)
 {
 #ifndef NDEBUG
-  std::vector<PlanIter_t>::const_iterator lEnd = aChildren.end();
-  for(std::vector<PlanIter_t>::const_iterator lIter = aChildren.begin();
-      lIter != lEnd;
-      ++lIter)
+  std::vector<PlanIter_t>::const_iterator end = children.end();
+  std::vector<PlanIter_t>::const_iterator ite = children.begin();
+  for(; ite != end; ++ite)
   {
-    assert(*lIter != 0);
+    assert(*ite != 0);
   }
 #endif
 }
@@ -114,11 +113,11 @@
 {
   uint32_t size = 0;
 
-  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
-  std::vector<PlanIter_t>::const_iterator lEnd = theChildren.end();
-  for (; lIter != lEnd; ++lIter )
+  std::vector<PlanIter_t>::const_iterator ite = theChildren.begin();
+  std::vector<PlanIter_t>::const_iterator end = theChildren.end();
+  for (; ite != end; ++ite)
   {
-    size += (*lIter)->getStateSizeOfSubtree();
+    size += (*ite)->getStateSizeOfSubtree();
   }
 
   return this->getStateSize() + size;
@@ -126,47 +125,44 @@
 
 
 template <class IterType, class StateType>
-void
-NaryBaseIterator<IterType, StateType>::openImpl(
+void NaryBaseIterator<IterType, StateType>::openImpl(
     PlanState& planState,
     uint32_t& offset)
 {
   StateTraitsImpl<StateType>::createState(planState, this->theStateOffset, offset);
   StateTraitsImpl<StateType>::initState(planState, this->theStateOffset);
 
-  std::vector<PlanIter_t>::iterator lIter = theChildren.begin();
-  std::vector<PlanIter_t>::iterator lEnd = theChildren.end();
-  for ( ; lIter != lEnd; ++lIter )
+  std::vector<PlanIter_t>::iterator ite = theChildren.begin();
+  std::vector<PlanIter_t>::iterator end = theChildren.end();
+  for (; ite != end; ++ite)
 	{
-    (*lIter)->open(planState, offset);
+    (*ite)->open(planState, offset);
   }
 }
 
 
 template <class IterType, class StateType>
-void
-NaryBaseIterator<IterType, StateType>::resetImpl(PlanState& planState) const
+void NaryBaseIterator<IterType, StateType>::resetImpl(PlanState& planState) const
 {
   StateTraitsImpl<StateType>::reset(planState, this->theStateOffset);
 
-  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
-  std::vector<PlanIter_t>::const_iterator lEnd = theChildren.end();
-  for ( ; lIter != lEnd; ++lIter )
+  std::vector<PlanIter_t>::const_iterator ite = theChildren.begin();
+  std::vector<PlanIter_t>::const_iterator end = theChildren.end();
+  for (; ite != end; ++ite)
 	{
-    (*lIter)->reset(planState);
+    (*ite)->reset(planState);
   }
 }
 
 
 template <class IterType, class StateType>
-void
-NaryBaseIterator<IterType, StateType>::closeImpl(PlanState& planState)
+void NaryBaseIterator<IterType, StateType>::closeImpl(PlanState& planState)
 {
-  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
-  std::vector<PlanIter_t>::const_iterator lEnd = theChildren.end();
-  for ( ; lIter != lEnd; ++lIter )
+  std::vector<PlanIter_t>::const_iterator ite = theChildren.begin();
+  std::vector<PlanIter_t>::const_iterator end = theChildren.end();
+  for (; ite != end; ++ite)
   {
-    (*lIter)->close(planState);
+    (*ite)->close(planState);
   }
 
   StateTraitsImpl<StateType>::destroyState(planState, this->theStateOffset);

=== modified file 'src/runtime/base/noarybase.h'
--- src/runtime/base/noarybase.h	2013-02-07 17:24:36 +0000
+++ src/runtime/base/noarybase.h	2013-05-28 18:24:26 +0000
@@ -31,22 +31,22 @@
   data members. 
 ********************************************************************************/
 template <class IterType, class StateType>
-class NoaryBaseIterator : public Batcher<IterType>
+class NoaryBaseIterator : public PlanIterator
 {
 public:
   SERIALIZABLE_TEMPLATE_ABSTRACT_CLASS(NoaryBaseIterator);
 
-  SERIALIZABLE_CLASS_CONSTRUCTOR2(NoaryBaseIterator, Batcher<IterType>);
+  SERIALIZABLE_CLASS_CONSTRUCTOR2(NoaryBaseIterator, PlanIterator);
 
   void serialize(::zorba::serialization::Archiver& ar)
   {
-    serialize_baseclass(ar, (Batcher<IterType>*)this);
+    serialize_baseclass(ar, (PlanIterator*)this);
   }
 
 public:
   NoaryBaseIterator(static_context* sctx, const QueryLoc& loc)
     :
-    Batcher<IterType>(sctx, loc)
+    PlanIterator(sctx, loc)
   {
   }
 

=== modified file 'src/runtime/base/plan_iterator.cpp'
--- src/runtime/base/plan_iterator.cpp	2013-05-24 22:52:47 +0000
+++ src/runtime/base/plan_iterator.cpp	2013-05-28 18:24:26 +0000
@@ -71,7 +71,6 @@
 }
 
 
-
 void PlanState::checkDepth(const QueryLoc& loc)
 {
   if (theStackDepth > 256)
@@ -181,10 +180,7 @@
 }
 
 
-#if ZORBA_BATCHING_TYPE == 0
-
 #ifndef NDEBUG
-
 bool PlanIterator::consumeNext(
     store::Item_t& result,
     const PlanIterator* iter,
@@ -210,7 +206,6 @@
 }
 #endif
 
-#endif
 
 } // namespace zorba
 /* vim:set et sw=2 ts=2: */

=== modified file 'src/runtime/base/plan_iterator.h'
--- src/runtime/base/plan_iterator.h	2013-05-24 22:52:47 +0000
+++ src/runtime/base/plan_iterator.h	2013-05-28 18:24:26 +0000
@@ -32,11 +32,6 @@
 #include "zorbaserialization/serialize_zorba_types.h"
 
 
-#if ZORBA_BATCHING_TYPE == 1
-#include "store/api/item.h"
-#endif
-
-
 // Info: Forcing inlining a function in g++:
 // store::Item_t next() __attribute__((always_inline)) {...}
 
@@ -168,27 +163,15 @@
 private:
   uint32_t        theDuffsLine;
 
-public:
-#if ZORBA_BATCHING_TYPE == 1
-public:
-  bool             theIsDone;
-  store::Item_t  * theEndItem;
-  store::Item_t  * theCurrItem;
-  store::Item_t    theBatch[ZORBA_BATCHING_BATCHSIZE];
-#endif
 #ifndef NDEBUG
-  bool             theIsOpened;
+public:
+  bool            theIsOpened;
 #endif
 
 public:
   PlanIteratorState()
     :
     theDuffsLine(DUFFS_ALLOCATE_RESOURCES)
-#if ZORBA_BATCHING_TYPE == 1
-    , theIsDone(false)
-    , theEndItem(NULL)
-    , theCurrItem(NULL)
-#endif
 #ifndef NDEBUG
     , theIsOpened(false)
 #endif
@@ -213,7 +196,10 @@
    * Each subclass implementation of this method must call the init() method of
    * their parent class explicitly in order to guarantee proper initialization.
    */
-  void init(PlanState& s) { reset(s); }
+  void init(PlanState&)
+  {
+    theDuffsLine = DUFFS_ALLOCATE_RESOURCES;
+  }
 
   /**
    * Reset the current state object.
@@ -230,11 +216,6 @@
   void reset(PlanState&)
   {
     theDuffsLine = DUFFS_ALLOCATE_RESOURCES;
-#if ZORBA_BATCHING_TYPE == 1
-    theIsDone = false;
-    theEndItem = NULL;
-    theCurrItem = NULL;
-#endif
   }
 };
 
@@ -297,9 +278,6 @@
   QueryLoc           loc;
   static_context   * theSctx;
 
-
-// Stable IDs for debugging purposes. An individual ID is assigned to each iterator
-// and this can be used to identify it in the debug information.
 #ifndef NDEBUG
   int                theId;
 
@@ -359,7 +337,19 @@
    * Begin the execution of the iterator. Initializes information required for
    * the plan state and constructs the state object.
    */
-  virtual void open(PlanState& planState, uint32_t& offset) = 0;
+  void open(PlanState& planState, uint32_t& offset)
+  {
+    openImpl(planState, offset);
+#ifndef NDEBUG
+    // do this after openImpl because the state is created there
+    PlanIteratorState* state =
+    StateTraitsImpl<PlanIteratorState>::getState(planState, theStateOffset);
+    ZORBA_ASSERT(!state->theIsOpened); // don't call open twice
+    state->theIsOpened = true;
+#endif
+  }
+
+  virtual void openImpl(PlanState& planState, uint32_t& offset) = 0;
 
   /**
    * Restarts the iterator so that the next 'produceNext' call will start
@@ -367,7 +357,17 @@
    *
    * @param planState
    */
-  virtual void reset(PlanState& planState) const = 0;
+  void reset(PlanState& planState) const
+  {
+#ifndef NDEBUG
+    PlanIteratorState* state =
+    StateTraitsImpl<PlanIteratorState>::getState(planState, theStateOffset);
+    ZORBA_ASSERT(state->theIsOpened);
+#endif
+    resetImpl(planState);
+  }
+
+  virtual void resetImpl(PlanState& planState) const = 0;
 
   /**
    * Finish the execution of the iterator. Releases all resources and destroys
@@ -376,7 +376,19 @@
    *
    * @param planState
    */
-  virtual void close(PlanState& planState) = 0;
+  void close(PlanState& planState)
+  {
+#ifndef NDEBUG
+    PlanIteratorState* state =
+    StateTraitsImpl<PlanIteratorState>::getState(planState, theStateOffset);
+    closeImpl(planState);
+    state->theIsOpened = false;
+#else
+    closeImpl(planState);
+#endif
+  }
+
+  virtual void closeImpl(PlanState& planState) = 0;
 
   /**
    * Return the number of items in the sequence that is computed by this
@@ -388,57 +400,6 @@
    */
   virtual bool count(store::Item_t& result, PlanState& planState) const;
 
-
-#if ZORBA_BATCHING_TYPE == 1
-
-  /**
-   * Produce the next batch of items and place them in the batch buffer.
-   * Implicitly, the first call  of producNext() initializes the iterator and
-   * allocates resources (main memory, file descriptors, etc.).
-   *
-   * @param stateBLock
-   */
-  virtual void produceNext(PlanState& planState) const = 0;
-
-  /**
-   * Static Method: Retreives the next item from the batch buffer of the given
-   * iterator and returns it to the caller. If all the items from the iterator's
-   * batch buffer have been consumed already, then it makes the iterator produce
-   * its next batch of results and retrieves the 1st item from this new batch.
-   */
-  static bool consumeNext(
-        store::Item_t& result,
-        const PlanIterator* iter,
-        PlanState& planState)
-  {
-    PlanIteratorState* state =
-    StateTraitsImpl<PlanIteratorState>::getState(planState, iter->getStateOffset());
-
-    if (state->theCurrItem == state->theEndItem)
-    {
-      // there are no more buffered items, so pruduce the next batch, if any
-
-      if (state->theIsDone)
-        return false;
-
-      iter->produceNext(planState);
-
-      if (state->theCurrItem == state->theEndItem)
-      {
-        // nothing was produced.
-        assert(state->theIsDone);
-        return false;
-      }
-    }
-
-    result.transfer(*state->theCurrItem);
-    ++state->theCurrItem;
-    return true;
-  }
-
-
-#else // ZORBA_BATCHING_TYPE
-
   /**
    * Produce the next item and return it to the caller. Implicitly, the first
    * call of 'producNext' initializes the iterator and allocates resources
@@ -446,7 +407,17 @@
    *
    * @param stateBLock
    */
-  virtual bool produceNext(store::Item_t& handle, PlanState& planState) const = 0;
+  bool produceNext(store::Item_t& result, PlanState& planState) const
+  {
+#ifndef NDEBUG
+    PlanIteratorState* state =
+    StateTraitsImpl<PlanIteratorState>::getState(planState, theStateOffset);
+    ZORBA_ASSERT(state->theIsOpened);
+#endif
+    return nextImpl(result, planState);
+  }
+
+  virtual bool nextImpl(store::Item_t& result, PlanState& planState) const = 0;
 
   /**
    * Static Method: Makes the given iterator produce its next result and returns
@@ -472,127 +443,6 @@
     return iter->produceNext(result, planState);
   }
 #endif
-
-#endif // ZORBA_BATCHING_TYPE
-};
-
-
-/*******************************************************************************
-  Class to implement batching
-********************************************************************************/
-template <class IterType>
-class Batcher: public PlanIterator
-{
-public:
-  SERIALIZABLE_TEMPLATE_ABSTRACT_CLASS(Batcher)
-  SERIALIZABLE_CLASS_CONSTRUCTOR2(Batcher, PlanIterator)
-  void serialize(::zorba::serialization::Archiver& ar)
-  {
-    serialize_baseclass(ar, (PlanIterator*)this);
-  }
-
-public:
-  Batcher(const Batcher<IterType>& b)  : PlanIterator(b) {}
-
-  Batcher(static_context* sctx, const QueryLoc& loc) : PlanIterator(sctx, loc) {}
-
-  ~Batcher() {}
-
-#if ZORBA_BATCHING_TYPE == 1
-
-  void produceNext(PlanState& planState) const
-  {
-    PlanIteratorState* state =
-    StateTraitsImpl<PlanIteratorState>::getState(planState, theStateOffset);
-    assert(state->theIsOpened);
-    state->theEndItem = &state->theBatch[ZORBA_BATCHING_BATCHSIZE];
-    state->theCurrItem = &state->theBatch[0];
-    do
-    {
-      // In general, to compute this iterator's next result, nextImpl() will
-      // call consumeNext() on one or more of this iterator's child iterators.
-      if (!static_cast<const IterType*>(this)->nextImpl(*state->theCurrItem, planState))
-      {
-        state->theEndItem = state->theCurrItem;
-        state->theCurrItem = &state->theBatch[0];
-        state->theIsDone = true;
-        return;
-      }
-
-      ++state->theCurrItem;
-    }
-    while (state->theCurrItem < state->theEndItem);
-
-    state->theCurrItem = &state->theBatch[0];
-  }
-
-#else // ZORBA_BATCHING_TYPE
-
-  bool produceNext(store::Item_t& result, PlanState& planState) const
-  {
-#ifndef NDEBUG
-    PlanIteratorState* state =
-    StateTraitsImpl<PlanIteratorState>::getState(planState, theStateOffset);
-    ZORBA_ASSERT(state->theIsOpened);
-#endif
-    return static_cast<const IterType*>(this)->nextImpl(result, planState);
-  }
-
-#endif // ZORBA_BATCHING_TYPE
-
-#ifndef NDEBUG
-  void open(PlanState& planState, uint32_t& offset)
-  {
-    static_cast<IterType*>(this)->openImpl(planState, offset);
-    // do this after openImpl because the state is created there
-    PlanIteratorState* state =
-    StateTraitsImpl<PlanIteratorState>::getState(planState, theStateOffset);
-    ZORBA_ASSERT(!state->theIsOpened); // don't call open twice
-    state->theIsOpened = true;
-  }
-
-  void reset(PlanState& planState) const
-  {
-    PlanIteratorState* state =
-    StateTraitsImpl<PlanIteratorState>::getState(planState, theStateOffset);
-    ZORBA_ASSERT(state->theIsOpened);
-    static_cast<const IterType*>(this)->resetImpl(planState);
-  }
-
-  void close(PlanState& planState)
-  {
-    PlanIteratorState* state =
-    StateTraitsImpl<PlanIteratorState>::getState(planState, theStateOffset);
-    static_cast<IterType*>(this)->closeImpl(planState);
-    state->theIsOpened = false;
-  }
-
-#else // NDEBUG
-
-  void open(PlanState& planState, uint32_t& offset)
-  {
-    static_cast<IterType*>(this)->openImpl(planState, offset);
-  }
-
-  void reset(PlanState& planState) const
-  {
-    static_cast<const IterType*>(this)->resetImpl(planState);
-  }
-
-  void close(PlanState& planState)
-  {
-    static_cast<IterType*>(this)->closeImpl(planState);
-  }
-
-#endif // NDEBUG
-
-  inline bool nextImpl(store::Item_t& result, PlanState& planState) const;
-
-  inline void openImpl(PlanState& planState, uint32_t& offset) const;
-
-  inline void resetImpl(PlanState& planState) const;
-
-  inline void closeImpl(PlanState& planState);
 };
 
 #ifndef NDEBUG

=== modified file 'src/runtime/base/unarybase.h'
--- src/runtime/base/unarybase.h	2013-02-07 17:24:36 +0000
+++ src/runtime/base/unarybase.h	2013-05-28 18:24:26 +0000
@@ -31,17 +31,17 @@
   data members.
 ********************************************************************************/
 template <class IterType, class StateType>
-class UnaryBaseIterator : public Batcher<IterType>
+class UnaryBaseIterator : public PlanIterator
 {
 protected:
   PlanIter_t theChild;
 
 public:
   SERIALIZABLE_ABSTRACT_CLASS(UnaryBaseIterator)
-  SERIALIZABLE_CLASS_CONSTRUCTOR2(UnaryBaseIterator, Batcher<IterType>)
+  SERIALIZABLE_CLASS_CONSTRUCTOR2(UnaryBaseIterator, PlanIterator)
   void serialize(::zorba::serialization::Archiver& ar)
   {
-    serialize_baseclass(ar, (Batcher<IterType>*)this);
+    serialize_baseclass(ar, (PlanIterator*)this);
     ar & theChild;
   }
 
@@ -51,7 +51,7 @@
       const QueryLoc& loc,
       const PlanIter_t& child)
     :
-    Batcher<IterType>(sctx, loc),
+    PlanIterator(sctx, loc),
     theChild(child)
   {
 #ifndef NDEBUG

=== modified file 'src/runtime/core/flwor_iterator.cpp'
--- src/runtime/core/flwor_iterator.cpp	2013-03-15 08:22:41 +0000
+++ src/runtime/core/flwor_iterator.cpp	2013-05-28 18:24:26 +0000
@@ -881,7 +881,7 @@
     MaterializeClause* materializeClause,
     PlanIter_t& aReturnClause)
   :
-  Batcher<FLWORIterator>(sctx, loc),
+  PlanIterator(sctx, loc),
   theForLetClauses(aForLetClauses),
   theNumBindings(aForLetClauses.size()),
   theWhereClause(aWhereClause),
@@ -934,7 +934,7 @@
 ********************************************************************************/
 void FLWORIterator::serialize(::zorba::serialization::Archiver& ar)
 {
-  serialize_baseclass(ar, (Batcher<FLWORIterator>*)this);
+  serialize_baseclass(ar, (PlanIterator*)this);
   ar & theForLetClauses;
   theNumBindings = theForLetClauses.size();
   ar & theWhereClause; //can be null

=== modified file 'src/runtime/core/flwor_iterator.h'
--- src/runtime/core/flwor_iterator.h	2013-03-04 21:00:58 +0000
+++ src/runtime/core/flwor_iterator.h	2013-05-28 18:24:26 +0000
@@ -437,7 +437,7 @@
   - Data Members:
 
 ********************************************************************************/
-class FLWORIterator : public Batcher<FLWORIterator>
+class FLWORIterator : public PlanIterator
 {
 private:
   std::vector<ForLetClause> theForLetClauses;
@@ -450,7 +450,7 @@
 
 public:
   SERIALIZABLE_CLASS(FLWORIterator);
-  SERIALIZABLE_CLASS_CONSTRUCTOR2(FLWORIterator, Batcher<FLWORIterator>);
+  SERIALIZABLE_CLASS_CONSTRUCTOR2(FLWORIterator, PlanIterator);
   void serialize(::zorba::serialization::Archiver& ar);
 
 public:

=== modified file 'src/runtime/core/gflwor/groupby_iterator.cpp'
--- src/runtime/core/gflwor/groupby_iterator.cpp	2013-02-07 17:24:36 +0000
+++ src/runtime/core/gflwor/groupby_iterator.cpp	2013-05-28 18:24:26 +0000
@@ -128,7 +128,7 @@
     std::vector<GroupingSpec> aGroupingSpecs,
     std::vector<NonGroupingSpec> aNonGroupingSpecs) 
   :
-  Batcher<GroupByIterator>(sctx, aLoc),
+  PlanIterator(sctx, aLoc),
   theTupleIter(aTupleIterator),
   theGroupingSpecs(aGroupingSpecs),
   theNonGroupingSpecs(aNonGroupingSpecs) 
@@ -149,7 +149,7 @@
 ********************************************************************************/
 void GroupByIterator::serialize(::zorba::serialization::Archiver& ar)
 {
-  serialize_baseclass(ar, (Batcher<GroupByIterator>*)this);
+  serialize_baseclass(ar, (PlanIterator*)this);
   ar & theTupleIter;
   ar & theGroupingSpecs;
   ar & theNonGroupingSpecs;

=== modified file 'src/runtime/core/gflwor/groupby_iterator.h'
--- src/runtime/core/gflwor/groupby_iterator.h	2013-02-07 17:24:36 +0000
+++ src/runtime/core/gflwor/groupby_iterator.h	2013-05-28 18:24:26 +0000
@@ -61,7 +61,7 @@
 /***************************************************************************//**
 
 ********************************************************************************/
-class GroupByIterator : public Batcher<GroupByIterator> 
+class GroupByIterator : public PlanIterator
 {
 private:
   PlanIter_t                    theTupleIter;
@@ -70,7 +70,7 @@
 
 public:
   SERIALIZABLE_CLASS(GroupByIterator)
-  SERIALIZABLE_CLASS_CONSTRUCTOR2(GroupByIterator, Batcher<GroupByIterator>)
+  SERIALIZABLE_CLASS_CONSTRUCTOR2(GroupByIterator, PlanIterator)
   void serialize(::zorba::serialization::Archiver& ar);
 
 public:

=== modified file 'src/runtime/core/gflwor/orderby_iterator.cpp'
--- src/runtime/core/gflwor/orderby_iterator.cpp	2013-02-26 04:12:43 +0000
+++ src/runtime/core/gflwor/orderby_iterator.cpp	2013-05-28 18:24:26 +0000
@@ -189,7 +189,7 @@
     std::vector<std::vector<PlanIter_t> >& outputForVarsRefs,
     std::vector<std::vector<PlanIter_t> >& outputLetVarsRefs) 
   :
-  Batcher<OrderByIterator>(sctx, aLoc),
+  PlanIterator(sctx, aLoc),
   theStable(stable),
   theOrderSpecs(orderSpecs),
   theTupleIter(tupleIterator),
@@ -208,7 +208,7 @@
 
 void OrderByIterator::serialize(::zorba::serialization::Archiver& ar)
 {
-  serialize_baseclass(ar, (Batcher<OrderByIterator>*)this);
+  serialize_baseclass(ar, (PlanIterator*)this);
   ar & theStable;
   ar & theOrderSpecs;
   ar & theTupleIter;

=== modified file 'src/runtime/core/gflwor/orderby_iterator.h'
--- src/runtime/core/gflwor/orderby_iterator.h	2013-02-26 04:12:43 +0000
+++ src/runtime/core/gflwor/orderby_iterator.h	2013-05-28 18:24:26 +0000
@@ -179,7 +179,7 @@
 /*******************************************************************************
 
 ********************************************************************************/    
-class OrderByIterator : public Batcher<OrderByIterator> 
+class OrderByIterator : public PlanIterator 
 {
 private:
   bool                                  theStable;
@@ -194,7 +194,7 @@
   
 public:
   SERIALIZABLE_CLASS(OrderByIterator)
-  SERIALIZABLE_CLASS_CONSTRUCTOR2(OrderByIterator, Batcher<OrderByIterator>)
+  SERIALIZABLE_CLASS_CONSTRUCTOR2(OrderByIterator, PlanIterator)
   void serialize(::zorba::serialization::Archiver& ar);
 
 public:

=== modified file 'src/runtime/core/gflwor/window_iterator.cpp'
--- src/runtime/core/gflwor/window_iterator.cpp	2013-04-24 18:01:51 +0000
+++ src/runtime/core/gflwor/window_iterator.cpp	2013-05-28 18:24:26 +0000
@@ -620,7 +620,7 @@
     bool lazyEval,
     ulong maxNeededHistory)
   :
-  Batcher<WindowIterator>(sctx, loc),
+  PlanIterator(sctx, loc),
   theWindowType(windowType),
   theTupleIter(tupleIter),
   theInputIter(domainIter),
@@ -651,7 +651,7 @@
 ********************************************************************************/
 void WindowIterator::serialize(::zorba::serialization::Archiver& ar)
 {
-  serialize_baseclass(ar, (Batcher<WindowIterator>*)this);
+  serialize_baseclass(ar, (PlanIterator*)this);
   SERIALIZE_ENUM(WindowType, theWindowType);
   ar & theTupleIter;
   ar & theInputIter;

=== modified file 'src/runtime/core/gflwor/window_iterator.h'
--- src/runtime/core/gflwor/window_iterator.h	2013-04-24 18:01:51 +0000
+++ src/runtime/core/gflwor/window_iterator.h	2013-05-28 18:24:26 +0000
@@ -312,7 +312,7 @@
                         buffer the domain sequence.
   theMaxNeededHistory : This is relevant only if a lazy temp sequence is used.
 ********************************************************************************/
-class WindowIterator : public Batcher<WindowIterator>
+class WindowIterator : public PlanIterator
 {
 public:
   static const ulong MAX_HISTORY;
@@ -344,7 +344,8 @@
 
   WindowIterator(::zorba::serialization::Archiver& ar) 
     :
-    Batcher<WindowIterator>(ar), theStartClause(ar) 
+    PlanIterator(ar),
+    theStartClause(ar) 
   {
   }
 

=== modified file 'src/runtime/core/item_iterator.cpp'
--- src/runtime/core/item_iterator.cpp	2013-03-05 00:45:43 +0000
+++ src/runtime/core/item_iterator.cpp	2013-05-28 18:24:26 +0000
@@ -85,7 +85,7 @@
     PlanIter_t& aElseIter,
     bool aIsBooleanIter)
   :
-  Batcher<IfThenElseIterator>(sctx, loc),
+  PlanIterator(sctx, loc),
   theCondIter(aCondIter),
   theThenIter(aThenIter),
   theElseIter(aElseIter),
@@ -96,7 +96,7 @@
 
 void IfThenElseIterator::serialize(::zorba::serialization::Archiver& ar)
 {
-  serialize_baseclass(ar, (Batcher<IfThenElseIterator>*)this);
+  serialize_baseclass(ar, (PlanIterator*)this);
   ar & theCondIter;
   ar & theThenIter;
   ar & theElseIter;
@@ -165,7 +165,7 @@
 }
 
 
-void IfThenElseIterator::closeImpl(PlanState& planState) const
+void IfThenElseIterator::closeImpl(PlanState& planState)
 {
   theCondIter->close(planState);
   theThenIter->close(planState);

=== modified file 'src/runtime/core/item_iterator.h'
--- src/runtime/core/item_iterator.h	2013-03-05 00:45:43 +0000
+++ src/runtime/core/item_iterator.h	2013-05-28 18:24:26 +0000
@@ -82,17 +82,17 @@
 };
 
 
-class IfThenElseIterator : public Batcher<IfThenElseIterator>
+class IfThenElseIterator : public PlanIterator
 {
 private:
   PlanIter_t theCondIter;
   PlanIter_t theThenIter;
   PlanIter_t theElseIter;
-  bool theIsBooleanIter;
+  bool       theIsBooleanIter;
     
 public:
   SERIALIZABLE_CLASS(IfThenElseIterator)
-  SERIALIZABLE_CLASS_CONSTRUCTOR2(IfThenElseIterator, Batcher<IfThenElseIterator>)
+  SERIALIZABLE_CLASS_CONSTRUCTOR2(IfThenElseIterator, PlanIterator)
   void serialize(::zorba::serialization::Archiver& ar);
 
 public:
@@ -127,7 +127,7 @@
 
   void resetImpl(PlanState& planState) const;
 
-  void closeImpl(PlanState& planState) const;
+  void closeImpl(PlanState& planState);
 };
 
 

=== modified file 'src/runtime/update/update.cpp'
--- src/runtime/update/update.cpp	2013-02-07 17:24:36 +0000
+++ src/runtime/update/update.cpp	2013-05-28 18:24:26 +0000
@@ -751,7 +751,7 @@
     PlanIter_t aApplyIter,
     PlanIter_t aReturnIter)
   :
-  Batcher<TransformIterator>(sctx, aLoc),
+  PlanIterator(sctx, aLoc),
   theCopyClauses(aCopyClauses),
   theModifyIter(aModifyIter),
   thePulHolderIter(aPulHolderIter),
@@ -768,7 +768,7 @@
 
 void TransformIterator::serialize(::zorba::serialization::Archiver& ar)
 {
-  serialize_baseclass(ar, (Batcher<TransformIterator>*)this);
+  serialize_baseclass(ar, (PlanIterator*)this);
   ar & theCopyClauses;
   ar & theModifyIter;
   ar & thePulHolderIter;
@@ -926,8 +926,7 @@
 }
 
 
-void 
-TransformIterator::resetImpl(PlanState& planState) const
+void TransformIterator::resetImpl(PlanState& planState) const
 {
   StateTraitsImpl<PlanIteratorState>::reset(planState, theStateOffset);
   
@@ -945,8 +944,7 @@
 }
 
 
-void 
-TransformIterator::closeImpl(PlanState& planState) const
+void TransformIterator::closeImpl(PlanState& planState)
 {
   CopyClause::const_iter_t lIter = theCopyClauses.begin();
   CopyClause::const_iter_t lEnd = theCopyClauses.end();

=== modified file 'src/runtime/update/update.h'
--- src/runtime/update/update.h	2013-02-07 17:24:36 +0000
+++ src/runtime/update/update.h	2013-05-28 18:24:26 +0000
@@ -175,7 +175,7 @@
 };
 
 
-class TransformIterator : public Batcher<TransformIterator>
+class TransformIterator : public PlanIterator
 {
 private:
   std::vector<CopyClause> theCopyClauses;
@@ -186,7 +186,7 @@
 
 public:
   SERIALIZABLE_CLASS(TransformIterator)
-  SERIALIZABLE_CLASS_CONSTRUCTOR2(TransformIterator, Batcher<TransformIterator>)
+  SERIALIZABLE_CLASS_CONSTRUCTOR2(TransformIterator, PlanIterator)
   void serialize(::zorba::serialization::Archiver& ar);
 
 public:
@@ -213,7 +213,7 @@
 
   void resetImpl(PlanState& planState) const;
 
-  void closeImpl(PlanState& planState) const;
+  void closeImpl(PlanState& planState);
 };