Merge lp:~zorba-coders/zorba/collection-counting into lp:zorba

[Markos Zaharioudakis]

Optimization for count(collection("foo")) expression

[Matthias Brantner (matthias-brantner)]

Why do all the generate files show up as changed?

review: Needs Information

[Chris Hillery (ceejatec)]

> Why do all the generate files show up as changed?

That's showing up as a problem on one of Rodolfo's branches also. I assume it's line-ending problems but I can't imagine how it's happening.

[Markos Zaharioudakis (markos-za)]

Carlos, let's try to finis this today and commit to the main trunk. So, please add a test for w3c collections, and also update the ChangeLog file with a one-line description of the change.

[Matthias Brantner (matthias-brantner)]

One question: Why is the iterator not generated using the runtime code generation?

[Markos Zaharioudakis (markos-za)]

review: Approve

[Zorba Build Bot (zorba-buildbot)]

There are additional revisions which have not been approved in review. Please seek review and approval of these new revisions.

[Matthias Brantner (matthias-brantner)]

review: Approve

[Zorba Build Bot (zorba-buildbot)]

Attempt to merge into lp:zorba failed due to conflicts:

text conflict in ChangeLog

[Zorba Build Bot (zorba-buildbot)]

There are additional revisions which have not been approved in review. Please seek review and approval of these new revisions.

[Markos Zaharioudakis (markos-za)]

review: Approve

[Markos Zaharioudakis (markos-za)]

review: Approve

[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/collection-counting-2011-10-20T23-16-14.372Z/log.html

[Zorba Build Bot (zorba-buildbot)]

The attempt to merge lp:~zorba-coders/zorba/collection-counting into lp:zorba failed. Below is the output from the failed tests.

CMake Error at /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake:272 (message):
  Validation queue job collection-counting-2011-10-20T23-16-14.372Z is
  finished. The final status was:

  3 tests did not succeed - changes not commited.

Error in read script: /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake

[lp:~zorba-coders/zorba/collection-counting]

10496. By Markos Zaharioudakis on 2011-10-21

fixed failing iter tests

[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/collection-counting-2011-10-21T00-49-13.645Z/log.html

[Zorba Build Bot (zorba-buildbot)]

Validation queue job collection-counting-2011-10-21T00-49-13.645Z is finished. The final status was:

All tests succeeded!

=== modified file 'ChangeLog'
--- ChangeLog	2011-10-17 21:30:33 +0000
+++ ChangeLog	2011-10-21 00:32:19 +0000
@@ -50,6 +50,7 @@
 	different nodes cannot have the same identifier.
   * Fixed bug #872697  (segmentation fault with validation of NMTOKENS)
   * Added undo for node revalidation
+  * Optimization for count(collection()) expressions
   * Fixed bug #872796  (validate-in-place can interfere with other update primitives)
   * Fixed bug #872799 (validate-in-place can set incorrect types)
   * Fixed bug #855715 (Invalid escaped characters in regex not caught)

=== modified file 'src/context/default_url_resolvers.cpp'
--- src/context/default_url_resolvers.cpp	2011-08-20 01:30:48 +0000
+++ src/context/default_url_resolvers.cpp	2011-10-21 00:32:19 +0000
@@ -41,6 +41,9 @@
 HTTPURLResolver::resolveURL
 (zstring const& aUrl, EntityData const* aEntityData)
 {
+  if (aEntityData->getKind() == impl::EntityData::COLLECTION)
+    return NULL;
+
   uri::scheme lScheme = uri::get_scheme(aUrl);
   switch (lScheme) {
     case uri::http:
@@ -79,6 +82,9 @@
 FileURLResolver::resolveURL
 (zstring const& aUrl, EntityData const* aEntityData)
 {
+  if (aEntityData->getKind() == impl::EntityData::COLLECTION)
+    return NULL;
+
   uri::scheme lScheme = uri::get_scheme(aUrl);
   if (lScheme != uri::file) {
     return NULL;

=== modified file 'src/functions/func_sequences_impl.cpp'
--- src/functions/func_sequences_impl.cpp	2011-06-14 17:26:33 +0000
+++ src/functions/func_sequences_impl.cpp	2011-10-21 00:32:19 +0000
@@ -15,6 +15,8 @@
  */
  #include "stdafx.h"
 
+#include <typeinfo>
+
 #include "functions/func_sequences.h"
 #include "functions/func_sequences_impl.h"
 
@@ -22,6 +24,9 @@
 #include "runtime/sequences/SequencesImpl.h"
 #include "runtime/core/var_iterators.h"
 
+#include "runtime/collections/collections_impl.h"
+#include "runtime/collections/collections.h"
+
 #include "system/globalenv.h"
 
 #include "compiler/expression/expr.h"
@@ -30,7 +35,7 @@
 
 #include "types/typeops.h"
 
-namespace zorba 
+namespace zorba
 {
 
 
@@ -39,7 +44,7 @@
 ********************************************************************************/
 xqtref_t op_concatenate::getReturnType(
     const TypeManager* tm,
-    const std::vector<xqtref_t>& arg_types) const 
+    const std::vector<xqtref_t>& arg_types) const
 {
   ulong sz = (ulong)arg_types.size();
 
@@ -47,11 +52,11 @@
   {
     return GENV_TYPESYSTEM.EMPTY_TYPE;
   }
-  else 
+  else
   {
     xqtref_t t = arg_types[0];
     TypeConstants::quantifier_t q = TypeConstants::QUANT_STAR;
-    for (ulong i = 1; i < sz; i++) 
+    for (ulong i = 1; i < sz; i++)
     {
       t = TypeOps::union_type(*t, *arg_types[i], tm);
       TypeConstants::quantifier_t pq = TypeOps::quantifier(*t);
@@ -65,14 +70,14 @@
   }
 }
 
-  
-BoolAnnotationValue op_concatenate::ignoresSortedNodes(expr* fo, ulong input) const 
+
+BoolAnnotationValue op_concatenate::ignoresSortedNodes(expr* fo, ulong input) const
 {
   return fo->getIgnoresSortedNodes();
 }
 
 
-BoolAnnotationValue op_concatenate::ignoresDuplicateNodes(expr* fo, ulong input) const 
+BoolAnnotationValue op_concatenate::ignoresDuplicateNodes(expr* fo, ulong input) const
 {
   return fo->getIgnoresDuplicateNodes();
 }
@@ -81,13 +86,13 @@
 /*******************************************************************************
 
 ********************************************************************************/
-BoolAnnotationValue fn_empty::ignoresSortedNodes(expr* fo, ulong input) const 
+BoolAnnotationValue fn_empty::ignoresSortedNodes(expr* fo, ulong input) const
 {
   return ANNOTATION_TRUE;
 }
 
 
-BoolAnnotationValue fn_empty::ignoresDuplicateNodes(expr* fo, ulong input) const 
+BoolAnnotationValue fn_empty::ignoresDuplicateNodes(expr* fo, ulong input) const
 {
   return ANNOTATION_TRUE;
 }
@@ -96,13 +101,13 @@
 /*******************************************************************************
 
 ********************************************************************************/
-BoolAnnotationValue fn_exists::ignoresSortedNodes(expr* fo, ulong input) const 
+BoolAnnotationValue fn_exists::ignoresSortedNodes(expr* fo, ulong input) const
 {
   return ANNOTATION_TRUE;
 }
 
 
-BoolAnnotationValue fn_exists::ignoresDuplicateNodes(expr* fo, ulong input) const 
+BoolAnnotationValue fn_exists::ignoresDuplicateNodes(expr* fo, ulong input) const
 {
   return ANNOTATION_TRUE;
 }
@@ -120,8 +125,8 @@
 
 
 BoolAnnotationValue fn_distinct_values::ignoresSortedNodes(
-    expr* fo, 
-    ulong input) const 
+    expr* fo,
+    ulong input) const
 {
   if (input == 0)
     return fo->getIgnoresSortedNodes();
@@ -132,7 +137,7 @@
 
 BoolAnnotationValue fn_distinct_values::ignoresDuplicateNodes(
     expr* fo,
-    ulong input) const 
+    ulong input) const
 {
   if (input == 0)
     return ANNOTATION_TRUE;
@@ -146,7 +151,7 @@
 ********************************************************************************/
 BoolAnnotationValue fn_insert_before::ignoresSortedNodes(
     expr* fo,
-    ulong input) const 
+    ulong input) const
 {
   if (input == 0 || input == 2)
     return fo->getIgnoresSortedNodes();
@@ -157,7 +162,7 @@
 
 BoolAnnotationValue fn_insert_before::ignoresDuplicateNodes(
     expr* fo,
-    ulong input) const 
+    ulong input) const
 {
   if (input == 0 || input == 2)
     return fo->getIgnoresSortedNodes();
@@ -179,7 +184,7 @@
 
 BoolAnnotationValue fn_remove::ignoresSortedNodes(
     expr* fo,
-    ulong input) const 
+    ulong input) const
 {
   if (input == 0)
     return ANNOTATION_FALSE;
@@ -190,7 +195,7 @@
 
 BoolAnnotationValue fn_remove::ignoresDuplicateNodes(
     expr* fo,
-    ulong input) const 
+    ulong input) const
 {
   return ANNOTATION_FALSE;
 }
@@ -209,7 +214,7 @@
 
 BoolAnnotationValue fn_reverse::ignoresSortedNodes(
     expr* fo,
-    ulong input) const 
+    ulong input) const
 {
   return fo->getIgnoresSortedNodes();
 }
@@ -217,7 +222,7 @@
 
 BoolAnnotationValue fn_reverse::ignoresDuplicateNodes(
     expr* fo,
-    ulong input) const 
+    ulong input) const
 {
   return fo->getIgnoresSortedNodes();
 }
@@ -250,7 +255,7 @@
   const expr* lenExpr = (subseqExpr.num_args() > 2 ? subseqExpr.get_arg(2) : NULL);
 
   if (inputExpr->get_expr_kind() == relpath_expr_kind &&
-      posExpr->get_expr_kind() == const_expr_kind && 
+      posExpr->get_expr_kind() == const_expr_kind &&
       lenExpr != NULL &&
       lenExpr->get_expr_kind() == const_expr_kind)
   {
@@ -281,6 +286,55 @@
 
 
 /******************************************************************************
+fn:count
+*******************************************************************************/
+PlanIter_t fn_count::codegen(
+  CompilerCB*,
+  static_context* sctx,
+  const QueryLoc& loc,
+  std::vector<PlanIter_t>& argv,
+  AnnotationHolder& ann) const
+{
+  const std::type_info& counted_type = typeid(*argv[0]);
+
+  if (typeid(ZorbaCollectionIterator) == counted_type)
+  {
+    ZorbaCollectionIterator& collection =
+    static_cast<ZorbaCollectionIterator&>(*argv[0]);
+
+    if (collection.isDynamic())
+    {
+      return new CountCollectionIterator(sctx,
+                                         loc,
+                                         collection.getChildren(),
+                                         CountCollectionIterator::ZORBADYNAMIC);
+    }
+    else
+    {
+      return new CountCollectionIterator(sctx,
+                                         loc,
+                                         collection.getChildren(),
+                                         CountCollectionIterator::ZORBASTATIC);
+    }
+  }
+  else if (typeid(FnCollectionIterator) == counted_type)
+  {
+    FnCollectionIterator& collection =
+    static_cast<FnCollectionIterator&>(*argv[0]);
+
+    return new CountCollectionIterator(sctx, 
+                                       loc,
+                                       collection.getChildren(),
+                                       CountCollectionIterator::W3C);
+  }
+  else
+  {
+    return new FnCountIterator(sctx, loc, argv);
+  }
+}
+
+
+/******************************************************************************
 
 *******************************************************************************/
 xqtref_t op_zorba_subsequence_int::getReturnType(
@@ -310,7 +364,7 @@
   CtxVarIterator* ctxVarIter;
 
   if (inputExpr->get_expr_kind() == relpath_expr_kind &&
-      posExpr->get_expr_kind() == const_expr_kind && 
+      posExpr->get_expr_kind() == const_expr_kind &&
       lenExpr != NULL &&
       lenExpr->get_expr_kind() == const_expr_kind)
   {
@@ -402,14 +456,14 @@
     if (inputExpr->get_expr_kind() == relpath_expr_kind)
     {
       const relpath_expr* pathExpr = static_cast<const relpath_expr*>(inputExpr);
-      
+
       ulong numSteps = pathExpr->numSteps();
 
       if (pos > 0 && numSteps == 2)
       {
         AxisIteratorHelper* input = dynamic_cast<AxisIteratorHelper*>(aArgs[0].getp());
         assert(input != NULL);
-        
+
         if (input->setTargetPos(pos-1))
           return aArgs[0];
       }
@@ -436,7 +490,7 @@
   else if ((inputVarIter = dynamic_cast<LetVarIterator*>(aArgs[0].getp())) != NULL)
   {
     const var_expr* inputVar = inputExpr->get_var();
-      
+
     if (inputVar != NULL &&
         (inputVar->get_kind() == var_expr::let_var ||
          inputVar->get_kind() == var_expr::win_var ||
@@ -496,7 +550,7 @@
 }
 
 
-BoolAnnotationValue fn_zero_or_one::ignoresSortedNodes(expr* fo, ulong input) const 
+BoolAnnotationValue fn_zero_or_one::ignoresSortedNodes(expr* fo, ulong input) const
 {
   return ANNOTATION_TRUE;
 }
@@ -528,13 +582,13 @@
 }
 
 
-BoolAnnotationValue fn_one_or_more::ignoresSortedNodes(expr* fo, ulong input) const 
+BoolAnnotationValue fn_one_or_more::ignoresSortedNodes(expr* fo, ulong input) const
 {
   return fo->getIgnoresSortedNodes();
 }
 
 
-BoolAnnotationValue fn_one_or_more::ignoresDuplicateNodes(expr* fo, ulong input) const 
+BoolAnnotationValue fn_one_or_more::ignoresDuplicateNodes(expr* fo, ulong input) const
 {
   return fo->getIgnoresDuplicateNodes();
 }
@@ -589,7 +643,7 @@
 PlanIter_t fn_intersect::codegen(
     CompilerCB* /*cb*/,
     static_context* sctx,
-    const QueryLoc& loc, 
+    const QueryLoc& loc,
     std::vector<PlanIter_t>& argv,
     AnnotationHolder& ann) const
 {
@@ -626,7 +680,7 @@
 /*******************************************************************************
 
 ********************************************************************************/
-BoolAnnotationValue fn_count::ignoresSortedNodes(expr* fo, ulong input) const 
+BoolAnnotationValue fn_count::ignoresSortedNodes(expr* fo, ulong input) const
 {
   return ANNOTATION_TRUE;
 }
@@ -635,7 +689,7 @@
 /*******************************************************************************
 
 ********************************************************************************/
-BoolAnnotationValue fn_avg::ignoresSortedNodes(expr* fo, ulong input) const 
+BoolAnnotationValue fn_avg::ignoresSortedNodes(expr* fo, ulong input) const
 {
   return ANNOTATION_TRUE;
 }
@@ -672,7 +726,7 @@
 /*******************************************************************************
 
 ********************************************************************************/
-BoolAnnotationValue fn_sum::ignoresSortedNodes(expr* fo, ulong input) const 
+BoolAnnotationValue fn_sum::ignoresSortedNodes(expr* fo, ulong input) const
 {
   return ANNOTATION_TRUE;
 }
@@ -766,13 +820,13 @@
 /*******************************************************************************
 
 ********************************************************************************/
-BoolAnnotationValue fn_id::ignoresSortedNodes(expr* fo, ulong input) const 
+BoolAnnotationValue fn_id::ignoresSortedNodes(expr* fo, ulong input) const
 {
   return ANNOTATION_TRUE;
 }
 
 
-BoolAnnotationValue fn_id::ignoresDuplicateNodes(expr* fo, ulong input) const 
+BoolAnnotationValue fn_id::ignoresDuplicateNodes(expr* fo, ulong input) const
 {
   if (input == 0)
     return ANNOTATION_TRUE;
@@ -786,7 +840,7 @@
 ********************************************************************************/
 BoolAnnotationValue fn_element_with_id::ignoresSortedNodes(
     expr* fo,
-    ulong input) const 
+    ulong input) const
 {
   return ANNOTATION_TRUE;
 }
@@ -794,7 +848,7 @@
 
 BoolAnnotationValue fn_element_with_id::ignoresDuplicateNodes(
     expr* fo,
-    ulong input) const 
+    ulong input) const
 {
   if (input == 0)
     return ANNOTATION_TRUE;
@@ -806,13 +860,13 @@
 /*******************************************************************************
 
 ********************************************************************************/
-BoolAnnotationValue fn_idref::ignoresSortedNodes(expr* fo, ulong input) const 
+BoolAnnotationValue fn_idref::ignoresSortedNodes(expr* fo, ulong input) const
 {
   return ANNOTATION_TRUE;
 }
 
 
-BoolAnnotationValue fn_idref::ignoresDuplicateNodes(expr* fo, ulong input) const 
+BoolAnnotationValue fn_idref::ignoresDuplicateNodes(expr* fo, ulong input) const
 {
   if (input == 0)
     return ANNOTATION_TRUE;
@@ -867,7 +921,7 @@
 
   DECL(sctx, fn_exactly_one,
        (createQName(fn_ns, "", "exactly-one"),
-        GENV_TYPESYSTEM.ITEM_TYPE_STAR, 
+        GENV_TYPESYSTEM.ITEM_TYPE_STAR,
         GENV_TYPESYSTEM.ITEM_TYPE_ONE));
 
   DECL(sctx, fn_exactly_one_noraise,
@@ -895,9 +949,9 @@
 
   DECL(sctx, fn_max,
        (createQName(fn_ns,"","max"),
-        GENV_TYPESYSTEM.ANY_ATOMIC_TYPE_STAR, 
+        GENV_TYPESYSTEM.ANY_ATOMIC_TYPE_STAR,
         GENV_TYPESYSTEM.ANY_ATOMIC_TYPE_QUESTION));
-  
+
   DECL(sctx, fn_max,
        (createQName(fn_ns,"","max"),
         GENV_TYPESYSTEM.ANY_ATOMIC_TYPE_STAR,
@@ -906,23 +960,23 @@
 
   DECL(sctx, fn_min,
        (createQName(fn_ns,"","min"),
-        GENV_TYPESYSTEM.ANY_ATOMIC_TYPE_STAR, 
+        GENV_TYPESYSTEM.ANY_ATOMIC_TYPE_STAR,
         GENV_TYPESYSTEM.ANY_ATOMIC_TYPE_QUESTION));
 
   DECL(sctx, fn_min,
        (createQName(fn_ns,"","min"),
-        GENV_TYPESYSTEM.ANY_ATOMIC_TYPE_STAR, 
-        GENV_TYPESYSTEM.STRING_TYPE_ONE, 
+        GENV_TYPESYSTEM.ANY_ATOMIC_TYPE_STAR,
+        GENV_TYPESYSTEM.STRING_TYPE_ONE,
         GENV_TYPESYSTEM.ANY_ATOMIC_TYPE_QUESTION));
 
   DECL(sctx, fn_head,
        (createQName(fn_ns,"","head"),
-        GENV_TYPESYSTEM.ANY_ATOMIC_TYPE_STAR, 
+        GENV_TYPESYSTEM.ANY_ATOMIC_TYPE_STAR,
         GENV_TYPESYSTEM.ANY_ATOMIC_TYPE_QUESTION));
 
   DECL(sctx, fn_tail,
        (createQName(fn_ns,"","tail"),
-        GENV_TYPESYSTEM.ANY_ATOMIC_TYPE_STAR, 
+        GENV_TYPESYSTEM.ANY_ATOMIC_TYPE_STAR,
         GENV_TYPESYSTEM.ANY_ATOMIC_TYPE_STAR));
 
 }

=== modified file 'src/functions/function_impl.h'
--- src/functions/function_impl.h	2011-06-14 17:26:33 +0000
+++ src/functions/function_impl.h	2011-10-21 00:32:19 +0000
@@ -1,12 +1,12 @@
 /*
  * Copyright 2006-2008 The FLWOR Foundation.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -125,7 +125,7 @@
 
 
 
-namespace zorba 
+namespace zorba
 {
 
 static inline store::Item_t createQName(

=== modified file 'src/functions/pregenerated/func_sequences.cpp'
--- src/functions/pregenerated/func_sequences.cpp	2011-06-17 14:40:56 +0000
+++ src/functions/pregenerated/func_sequences.cpp	2011-10-21 00:32:19 +0000
@@ -138,15 +138,6 @@
   return new FnDeepEqualIterator(sctx, loc, argv);
 }
 
-PlanIter_t fn_count::codegen(
-  CompilerCB*,
-  static_context* sctx,
-  const QueryLoc& loc,
-  std::vector<PlanIter_t>& argv,
-  AnnotationHolder& ann) const
-{
-  return new FnCountIterator(sctx, loc, argv);
-}
 
 PlanIter_t fn_avg::codegen(
   CompilerCB*,

=== modified file 'src/runtime/base/binarybase.h'
--- src/runtime/base/binarybase.h	2011-06-14 17:26:33 +0000
+++ src/runtime/base/binarybase.h	2011-10-21 00:32:19 +0000
@@ -1,12 +1,12 @@
 /*
  * Copyright 2006-2008 The FLWOR Foundation.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -29,7 +29,7 @@
 
 /*******************************************************************************
   Superclass for all iterators which have 2 child iterators and no additional
-  data members. 
+  data members.
 ********************************************************************************/
 template <class IterType, class StateType>
 class BinaryBaseIterator : public Batcher<IterType>
@@ -52,7 +52,7 @@
   BinaryBaseIterator(
         static_context* sctx,
         const QueryLoc& loc,
-        PlanIter_t& child0, 
+        PlanIter_t& child0,
         PlanIter_t& child1)
     :
     Batcher<IterType>(sctx, loc),
@@ -63,9 +63,19 @@
 
   virtual ~BinaryBaseIterator() {}
 
-  virtual uint32_t getStateSize() const 
-  {
-    return StateTraitsImpl<StateType>::getStateSize(); 
+  PlanIter_t& getChild0()
+  {
+    return theChild0;
+  }
+
+  PlanIter_t& getChild1()
+  {
+    return theChild1;
+  }
+
+  virtual uint32_t getStateSize() const
+  {
+    return StateTraitsImpl<StateType>::getStateSize();
   }
 
   virtual uint32_t getStateSizeOfSubtree() const
@@ -179,7 +189,7 @@
 ********************************************************************************/
 
 #define BINARY_ITER(name) \
-BINARY_ITER_STATE(name, PlanIteratorState) 
+BINARY_ITER_STATE(name, PlanIteratorState)
 
 
 

=== modified file 'src/runtime/base/narybase.h'
--- src/runtime/base/narybase.h	2011-06-14 17:26:33 +0000
+++ src/runtime/base/narybase.h	2011-10-21 00:32:19 +0000
@@ -1,12 +1,12 @@
 /*
  * Copyright 2006-2008 The FLWOR Foundation.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -34,7 +34,7 @@
 
 /*******************************************************************************
   Superclass for all iterators which have N child iterators and no additional
-  data members. 
+  data members.
 ********************************************************************************/
 template <class IterType, class StateType>
 class NaryBaseIterator : public Batcher<IterType>
@@ -59,11 +59,16 @@
 
   virtual ~NaryBaseIterator(){}
 
+  std::vector<PlanIter_t>& getChildren()
+  {
+    return theChildren;
+  }
+
   virtual uint32_t getStateSize() const
   {
     return StateTraitsImpl<StateType>::getStateSize();
   }
- 
+
   virtual uint32_t getStateSizeOfSubtree() const;
 
   void openImpl(PlanState& planState, uint32_t& offset);
@@ -101,7 +106,7 @@
 {
   uint32_t size = 0;
 
-  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin(); 
+  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
   std::vector<PlanIter_t>::const_iterator lEnd = theChildren.end();
   for (; lIter != lEnd; ++lIter )
   {
@@ -116,12 +121,12 @@
 void
 NaryBaseIterator<IterType, StateType>::openImpl(
     PlanState& planState,
-    uint32_t& offset) 
+    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 lIter = theChildren.begin();
   std::vector<PlanIter_t>::iterator lEnd = theChildren.end();
   for ( ; lIter != lEnd; ++lIter )
 	{
@@ -136,7 +141,7 @@
 {
   StateTraitsImpl<StateType>::reset(planState, this->theStateOffset);
 
-  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin(); 
+  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
   std::vector<PlanIter_t>::const_iterator lEnd = theChildren.end();
   for ( ; lIter != lEnd; ++lIter )
 	{
@@ -149,7 +154,7 @@
 void
 NaryBaseIterator<IterType, StateType>::closeImpl(PlanState& planState)
 {
-  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin(); 
+  std::vector<PlanIter_t>::const_iterator lIter = theChildren.begin();
   std::vector<PlanIter_t>::const_iterator lEnd = theChildren.end();
   for ( ; lIter != lEnd; ++lIter )
   {
@@ -214,7 +219,7 @@
 ********************************************************************************/
 
 #define NARY_ITER(name) \
-NARY_ITER_STATE(name, PlanIteratorState) 
+NARY_ITER_STATE(name, PlanIteratorState)
 
 
 } /* namespace zorba */

=== modified file 'src/runtime/base/plan_iterator.h'
--- src/runtime/base/plan_iterator.h	2011-07-12 20:15:01 +0000
+++ src/runtime/base/plan_iterator.h	2011-10-21 00:32:19 +0000
@@ -1,12 +1,12 @@
 /*
  * Copyright 2006-2008 The FLWOR Foundation.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -40,7 +40,7 @@
 
 /*******************************************************************************
 
-  Macros to automate Duff's Device and separation of code and state. 
+  Macros to automate Duff's Device and separation of code and state.
 
   These macros are used in the nextImpl() method of each iterator. In general,
   the nextImpl() method will be called multiple times, and during each invocation,
@@ -48,18 +48,18 @@
   info about what the previous invocation(s) did). The Duff's device is a
   techique by which the point where each invocation exited from is remembered,
   and during the next invocation, execution of the method resumes at that point.
-  In general, this simplifies the implementation of the method. 
+  In general, this simplifies the implementation of the method.
 
   DEFUALT_STACK_INIT : Gets a pointer to the iterator's state in the state block
                        and "starts" the duff's device.
   STACK_PUSH         : Causes the nextImpl() method to return with the given
-                       status and saves the current line in the source file 
+                       status and saves the current line in the source file
                        into the duffs line so that when the nextImpl method
                        is called again, execution will start right after the
                        STACK_PUSH macro.
   STACK_END          : Causes the nextImpl() method to return with false,
                        indicating that there are no more results to produce.
-                       It also saves the current line in the source file into 
+                       It also saves the current line in the source file into
                        the duffs line so that if the nextImpl method is called
                        again, an exception will be raised.
 ********************************************************************************/
@@ -104,7 +104,7 @@
 
 
 /*******************************************************************************
-  Class to represent state that is shared by all plan iterators. 
+  Class to represent state that is shared by all plan iterators.
 
   theBlock        : Pointer to the memory block that stores the local state of
                     each individual plan iterator.
@@ -125,11 +125,11 @@
   uint32_t                  theStackDepth;
 
   uint32_t                  theMaxStackDepth;
-  
+
   // TODO this guy should become const because nothing can change anymore during
   // runtime. We need to make all accessor in the control block and static context
   // (see also shortcut below) const before doing that
-  CompilerCB              * theCompilerCB; 
+  CompilerCB              * theCompilerCB;
 
   XQueryImpl              * theQuery;
 
@@ -179,7 +179,7 @@
 #endif
 
 public:
-  PlanIteratorState() 
+  PlanIteratorState()
     :
     theDuffsLine(DUFFS_ALLOCATE_RESOURCES)
 #if ZORBA_BATCHING_TYPE == 1
@@ -196,8 +196,8 @@
 
   uint32_t getDuffsLine() const { return theDuffsLine; }
 
-  /** 
-   * Initialize the current state object. 
+  /**
+   * Initialize the current state object.
    *
    * This method is invoked be the openImpl() method of the associated iterator
    * to initialize the state info needed by the iterator. All initialization of
@@ -208,15 +208,15 @@
    * 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&) 
-  { 
+  void init(PlanState&)
+  {
     theDuffsLine = DUFFS_ALLOCATE_RESOURCES;
 #if ZORBA_BATCHING_TYPE == 1
     theCurrItem = ZORBA_BATCHING_BATCHSIZE;
 #endif
   }
 
-  /** 
+  /**
    * Reset the current state object.
    *
    * This method is invoked by the resetImpl() method of the associated iterator.
@@ -225,17 +225,17 @@
    * the first time.
    *
    * Classes that inherit from PlanIteratorState must reimplement this method.
-   * Each subclass implementation of this method must call the reset() method 
+   * Each subclass implementation of this method must call the reset() method
    * of their parent class explicitly in order to guarantee proper reset.
    */
-  void reset(PlanState&) 
-  { 
-    theDuffsLine = DUFFS_ALLOCATE_RESOURCES; 
+  void reset(PlanState&)
+  {
+    theDuffsLine = DUFFS_ALLOCATE_RESOURCES;
 #if ZORBA_BATCHING_TYPE == 1
     theCurrItem = ZORBA_BATCHING_BATCHSIZE;
     // seeting the first item to NULL only is sufficient so
     // that produceNext knows that it's not finished yet
-    theBatch[0] = NULL; 
+    theBatch[0] = NULL;
 #endif
   }
 };
@@ -251,9 +251,9 @@
   StateTraitsImpl() {} // prevent instantiation
 
 public:
-  static uint32_t getStateSize() 
-  { 
-    return sizeof(T); 
+  static uint32_t getStateSize()
+  {
+    return sizeof(T);
   }
 
   static T* getState(PlanState& planState, uint32_t stateOffset)
@@ -270,7 +270,7 @@
 
   static void initState(PlanState& planState, uint32_t& stateOffset)
   {
-    getState(planState, stateOffset)->init(planState); 
+    getState(planState, stateOffset)->init(planState);
   }
 
   static void reset(PlanState& planState, uint32_t stateOffset)
@@ -278,9 +278,9 @@
     (reinterpret_cast<T*>(planState.theBlock+ stateOffset))->reset(planState);
   }
 
-  static void destroyState(PlanState& planState, uint32_t stateOffset) 
-  { 
-    (reinterpret_cast<T*>(planState.theBlock + stateOffset))->~T(); 
+  static void destroyState(PlanState& planState, uint32_t stateOffset)
+  {
+    (reinterpret_cast<T*>(planState.theBlock + stateOffset))->~T();
   }
 };
 
@@ -318,17 +318,17 @@
   void serialize(::zorba::serialization::Archiver& ar);
 
 public:
-  PlanIterator(static_context* aContext, const QueryLoc& aLoc) 
+  PlanIterator(static_context* aContext, const QueryLoc& aLoc)
     :
     theStateOffset(0),
     loc(aLoc),
     theSctx(aContext)
   {
   }
-  
-  PlanIterator(const PlanIterator& it) 
-    : 
-    SimpleRCObject(it), 
+
+  PlanIterator(const PlanIterator& it)
+    :
+    SimpleRCObject(it),
     theStateOffset(0),
     loc(it.loc),
     theSctx(it.theSctx)
@@ -346,17 +346,17 @@
 
   /**
    * Accept method for the PlanIterator-Tree-Visitor
-   * 
+   *
    * @param PlanIterVisitor
    */
   virtual void accept(PlanIterVisitor&) const = 0;
 
-  /** 
+  /**
    * Returns the size of the state which must be saved for the current iterator
    * on the state block
    */
   virtual uint32_t getStateSize() const = 0;
-  
+
   /**
    * Returns the size of the state for this iterator and all its sub-iterators.
    */
@@ -368,15 +368,15 @@
    */
   virtual void open(PlanState& planState, uint32_t& offset) = 0;
 
-  /** 
-   * Restarts the iterator so that the next 'produceNext' call will start 
-   * again from the beginning (should not release any resources).  
+  /**
+   * Restarts the iterator so that the next 'produceNext' call will start
+   * again from the beginning (should not release any resources).
    *
    * @param planState
    */
   virtual void reset(PlanState& planState) const = 0;
 
-  /** 
+  /**
    * Finish the execution of the iterator. Releases all resources and destroys
    * the according plan state* objects. Make sure that no exception is throw
    * when destroying the states. Otherwise we will have a lot of memory leaks.
@@ -384,14 +384,14 @@
    * @param planState
    */
   virtual void close(PlanState& planState) = 0;
-  
+
 
 #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.). 
+   * allocates resources (main memory, file descriptors, etc.).
    *
    * @param stateBLock
    */
@@ -401,7 +401,7 @@
    * 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.  
+   * its next batch of results and retrieves the 1st item from this new batch.
    */
   static store::Item_t consumeNext(
         store::Item_t& result,
@@ -411,7 +411,7 @@
     try
     {
       // use the given iterator's planstate to access it's batch
-      PlanIteratorState* lState = 
+      PlanIteratorState* lState =
       StateTraitsImpl<PlanIteratorState>::getState(planState, iter->getStateOffset());
 
       if ( lState->theCurrItem == ZORBA_BATCHING_BATCHSIZE )
@@ -435,10 +435,10 @@
 
 #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 
-   * (main memory, file descriptors, etc.). 
+   * call of 'producNext' initializes the iterator and allocates resources
+   * (main memory, file descriptors, etc.).
    *
    * @param stateBLock
    */
@@ -446,20 +446,20 @@
 
   /**
    * Static Method: Makes the given iterator produce its next result and returns
-   * that result to the caller.  
+   * that result to the caller.
    */
 #ifndef NDEBUG
   static bool consumeNext(
-        store::Item_t& result, 
+        store::Item_t& result,
         const PlanIterator* iter,
         PlanState& planState);
 #else
   static bool consumeNext(
-        store::Item_t& result, 
+        store::Item_t& result,
         const PlanIterator* iter,
         PlanState& planState)
   {
-    if (planState.theHasToQuit) 
+    if (planState.theHasToQuit)
     {
       // Quit the execution
       throw FlowCtlException(FlowCtlException::INTERRUPT);
@@ -499,14 +499,14 @@
   ~Batcher() {}
 
 
-#if ZORBA_BATCHING_TYPE == 1  
+#if ZORBA_BATCHING_TYPE == 1
 
-  void produceNext(PlanState& planState) const 
+  void produceNext(PlanState& planState) const
   {
     PlanIteratorState* lState =
     StateTraitsImpl<PlanIteratorState>::getState(planState, stateOffset);
 #ifndef NDEBUG
-    ZORBA_ASSERT(lState->theIsOpened); 
+    ZORBA_ASSERT(lState->theIsOpened);
 #endif
     bool more;
     uint32_t i = 0;
@@ -516,7 +516,7 @@
       // call consumeNext() on one or more of this iterator's child iterators.
       more = static_cast<const IterType*>(this)->nextImpl(lState->theBatch[i], planState);
     }
-    while ( more && ++i < ZORBA_BATCHING_BATCHSIZE ); 
+    while ( more && ++i < ZORBA_BATCHING_BATCHSIZE );
   }
 
 #else
@@ -526,7 +526,7 @@
 #ifndef NDEBUG
     PlanIteratorState* lState =
     StateTraitsImpl<PlanIteratorState>::getState(planState, theStateOffset);
-    ZORBA_ASSERT(lState->theIsOpened); 
+    ZORBA_ASSERT(lState->theIsOpened);
 #endif
     return static_cast<const IterType*>(this)->nextImpl(result, planState);
   }
@@ -548,9 +548,9 @@
   void reset(PlanState& planState) const
   {
 #ifndef NDEBUG
-    PlanIteratorState* lState = 
+    PlanIteratorState* lState =
     StateTraitsImpl<PlanIteratorState>::getState(planState, theStateOffset);
-    ZORBA_ASSERT( lState->theIsOpened ); 
+    ZORBA_ASSERT( lState->theIsOpened );
 #endif
     static_cast<const IterType*>(this)->resetImpl(planState);
   }
@@ -558,7 +558,7 @@
   void close(PlanState& planState)
   {
 #ifndef NDEBUG
-    PlanIteratorState* lState = 
+    PlanIteratorState* lState =
     StateTraitsImpl<PlanIteratorState>::getState(planState, theStateOffset);
     static_cast<IterType*>(this)->closeImpl(planState);
     lState->theIsOpened = false;

=== modified file 'src/runtime/base/unarybase.h'
--- src/runtime/base/unarybase.h	2011-06-14 17:26:33 +0000
+++ src/runtime/base/unarybase.h	2011-10-21 00:32:19 +0000
@@ -1,12 +1,12 @@
 /*
  * Copyright 2006-2008 The FLWOR Foundation.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -51,7 +51,7 @@
 public:
   UnaryBaseIterator(
       static_context* sctx,
-      const QueryLoc& loc, 
+      const QueryLoc& loc,
       const PlanIter_t& child)
     :
     Batcher<IterType>(sctx, loc),
@@ -64,9 +64,14 @@
 
   virtual ~UnaryBaseIterator() {}
 
-  virtual uint32_t getStateSize() const 
-  {
-    return StateTraitsImpl<StateType>::getStateSize(); 
+  const PlanIter_t& getChild()
+  {
+    return theChild;
+  }
+
+  virtual uint32_t getStateSize() const
+  {
+    return StateTraitsImpl<StateType>::getStateSize();
   }
 
   virtual uint32_t getStateSizeOfSubtree() const
@@ -100,8 +105,8 @@
 UnaryBaseIterator<IterType, StateType>::resetImpl(PlanState& planState) const
 {
   StateTraitsImpl<StateType>::reset(planState, this->theStateOffset);
-    
-  theChild->reset(planState); 
+
+  theChild->reset(planState);
 }
 
 
@@ -159,7 +164,7 @@
 ********************************************************************************/
 
 #define UNARY_ITER(name) \
-UNARY_ITER_STATE(name, PlanIteratorState) 
+UNARY_ITER_STATE(name, PlanIteratorState)
 
 
 }; /* namespace zorba*/

=== modified file 'src/runtime/collections/collections_base.h'
--- src/runtime/collections/collections_base.h	2011-06-28 23:34:08 +0000
+++ src/runtime/collections/collections_base.h	2011-10-21 00:32:19 +0000
@@ -5,7 +5,7 @@
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- * http://www.apache.org/licenses/LICENSE-2.0
+ * http://www.apache.org/licenses/LICENSE2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -32,12 +32,12 @@
 
 
 /*******************************************************************************
-  Check that the type of a node to be inserted into a collection matches with 
+  Check that the type of a node to be inserted into a collection matches with
   the statically declared type of the collection nodes. If not, raise an error.
 ********************************************************************************/
 void checkNodeType(
     const static_context* sctx,
-    const store::Item_t& node, 
+    const store::Item_t& node,
     const StaticallyKnownCollection* collectionDecl,
     const QueryLoc& loc,
     bool dyn_coll);
@@ -52,7 +52,7 @@
  ******************************************************************************/
 template <class Iter, class State>
 class ZorbaCollectionIteratorHelper : public NaryBaseIterator<Iter, State>
-{ 
+{
 protected:
   //whether it's the function of the dynamic or the static collection module
   bool theDynamicCollection;
@@ -66,7 +66,7 @@
       store::Collection_t& coll) const
   {
     const StaticallyKnownCollection* collectionDecl = aSctx->lookup_collection(aName);
-    if (collectionDecl == 0  && !aDynamicCollection) 
+    if (collectionDecl == 0  && !aDynamicCollection)
     {
       throw XQUERY_EXCEPTION(
         zerr::ZDDY0001_COLLECTION_NOT_DECLARED,
@@ -74,10 +74,10 @@
         ERROR_LOC( aLoc )
       );
     }
-  
+
     coll = GENV_STORE.getCollection(aName, aDynamicCollection);
-  
-    if (coll == NULL) 
+
+    if (coll == NULL)
     {
       throw XQUERY_EXCEPTION(
         zerr::ZDDY0003_COLLECTION_DOES_NOT_EXIST,
@@ -85,7 +85,7 @@
         ERROR_LOC( aLoc )
       );
     }
-  
+
     return collectionDecl;
   }
 
@@ -102,21 +102,21 @@
     store::Item_t                    node;
     store::Item_t                    copyNode;
     xs_integer                       targetPos;
-  
+
     store::CopyMode lCopyMode;
-  
+
     this->consumeNext(collName, this->theChildren[0].getp(), planState);
-  
+
     collectionDecl = getCollection(
         this->theSctx, collName, this->loc, theDynamicCollection, collection);
 
     if (beforeOrAfter) {
-      if(!this->consumeNext(targetNode, this->theChildren[this->theChildren.size()-2].getp(), planState)) 
+      if(!this->consumeNext(targetNode, this->theChildren[this->theChildren.size()-2].getp(), planState))
       {
         ZORBA_ASSERT(false);
       }
 
-      if (!collection->findNode(targetNode.getp(), targetPos)) 
+      if (!collection->findNode(targetNode.getp(), targetPos))
       {
         throw XQUERY_EXCEPTION(
           zerr::ZDDY0011_COLLECTION_NODE_NOT_FOUND,
@@ -125,9 +125,9 @@
         );
       }
     }
-  
+
     getCopyMode(lCopyMode, this->theSctx);
-  
+
     while (this->consumeNext(node, this->theChildren[this->theChildren.size()-1].getp(), planState))
     {
       checkNodeType(this->theSctx, node, collectionDecl, this->loc, theDynamicCollection);

=== modified file 'src/runtime/collections/collections_impl.cpp'
--- src/runtime/collections/collections_impl.cpp	2011-10-03 19:38:22 +0000
+++ src/runtime/collections/collections_impl.cpp	2011-10-21 00:32:19 +0000
@@ -1,12 +1,12 @@
 /*
  * Copyright 2006-2008 The FLWOR Foundation.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  * http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -33,7 +33,10 @@
 #include "compiler/xqddf/value_ic.h"
 
 #include "runtime/collections/collections.h"
+#include "runtime/collections/collections_impl.h"
 #include "runtime/core/apply_updates.h"
+#include "runtime/base/plan_iterator.h"
+#include "runtime/visitors/planiter_visitor.h"
 
 #include "store/api/pul.h"
 #include "store/api/item.h"
@@ -56,7 +59,7 @@
 
 void checkNodeType(
     const static_context* aSctx,
-    const store::Item_t& aNode, 
+    const store::Item_t& aNode,
     const StaticallyKnownCollection* aColl,
     const QueryLoc& aLoc,
     bool  dyn_coll);
@@ -68,11 +71,11 @@
 ********************************************************************************/
 FnCollectionIteratorState::~FnCollectionIteratorState()
 {
-  if ( theIterator != NULL ) 
+  if ( theIterator != NULL )
   {
     // closing the iterator is necessary here if an exception occurs
     // in the producer or if the iterator is not fully consumed
-    if (theIteratorOpened) 
+    if (theIteratorOpened)
     {
       theIterator->close();
       theIteratorOpened = false;
@@ -93,11 +96,11 @@
 {
   PlanIteratorState::reset(planState);
 
-  if ( theIterator != NULL ) 
+  if ( theIterator != NULL )
   {
     // closing the iterator is necessary here if an exception occurs
     // in the producer or if the iterator is not fully consumed
-    if (theIteratorOpened) 
+    if (theIteratorOpened)
     {
       theIterator->close();
       theIteratorOpened = false;
@@ -120,13 +123,13 @@
   DEFAULT_STACK_INIT(FnCollectionIteratorState, state, planState);
 
   if (theChildren.size() == 1 &&
-      consumeNext(lURI, theChildren[0].getp(), planState)) 
+      consumeNext(lURI, theChildren[0].getp(), planState))
   {
-    try 
+    try
     {
       resolvedURIString = theSctx->resolve_relative_uri(lURI->getStringValue());
     }
-    catch (ZorbaException const&) 
+    catch (ZorbaException const&)
     {
       throw XQUERY_EXCEPTION(
         err::FODC0004,
@@ -135,21 +138,26 @@
       );
     }
   }
-  else 
+  else
   {
     resolvedURIItem = planState.theGlobalDynCtx->get_default_collection();
+
+    if (NULL == resolvedURIItem)
+      throw XQUERY_EXCEPTION(
+        err::FODC0002,
+        ERROR_PARAMS( ZED( DefaultCollation ), ZED( NotDefInDynamicCtx ) ),
+        ERROR_LOC( loc )
+      );
+
     resolvedURIString = theSctx->resolve_relative_uri(resolvedURIItem->getStringValue());
-
-    if( NULL == resolvedURIItem)
-      throw XQUERY_EXCEPTION(
-        err::FODC0002,
-        ERROR_PARAMS( ZED( DefaultCollation ), ZED( NotDefInDynamicCtx ) ),
-        ERROR_LOC( loc )
-      );
   }
 
-  lResource = theSctx->resolve_uri( resolvedURIString, impl::EntityData::COLLECTION, lErrorMessage );
+  lResource = theSctx->resolve_uri(resolvedURIString,
+                                   impl::EntityData::COLLECTION,
+                                   lErrorMessage);
+
   lCollResource = dynamic_cast<impl::CollectionResource*>(lResource.get());
+
   if ( lCollResource == 0 || !(coll = lCollResource->getCollection()) )
   {
     throw XQUERY_EXCEPTION(
@@ -177,14 +185,162 @@
 
 
 /*******************************************************************************
+  Iterator for optimizing fn:count when applied to collections
+********************************************************************************/
+CountCollectionIterator::CountCollectionIterator(
+    static_context* sctx,
+    const QueryLoc& loc,
+    std::vector<PlanIter_t>& children,
+    CollectionType collectionType)
+  :
+  NaryBaseIterator<CountCollectionIterator, PlanIteratorState>(sctx, loc, children),
+  theCollectionType(collectionType)
+{
+}
+
+
+CountCollectionIterator::~CountCollectionIterator() 
+{
+}
+
+
+void CountCollectionIterator::serialize(::zorba::serialization::Archiver& ar)
+{
+  serialize_baseclass(ar,
+  (NaryBaseIterator<CountCollectionIterator, PlanIteratorState>*)this);
+
+  SERIALIZE_ENUM(enum CollectionType, theCollectionType);
+}
+
+
+bool CountCollectionIterator::nextImpl(store::Item_t& result, PlanState& planState) const
+{
+  store::Collection_t coll;
+  store::Item_t qName;
+
+  PlanIteratorState* state;
+  DEFAULT_STACK_INIT(PlanIteratorState, state, planState);
+
+  if (this->isZorbaCollection())
+    coll = getZorbaCollection(planState);
+  else
+    coll = getW3CCollection(planState);
+
+  STACK_PUSH(GENV_ITEMFACTORY->createInteger(result, coll->size()), state);
+
+  STACK_END(state);
+}
+
+
+store::Collection_t CountCollectionIterator::getW3CCollection(PlanState& planState) const
+{
+  store::Item_t lURI;
+  store::Collection_t coll;
+  std::auto_ptr<impl::Resource> lResource;
+  impl::CollectionResource* lCollResource;
+  zstring resolvedURIString;
+  zstring lErrorMessage;
+
+  if (!theChildren.empty()) //if a URI was given
+  {
+    ZORBA_ASSERT(consumeNext(lURI, theChildren[0].getp(), planState));
+
+    try
+    {
+      resolvedURIString = theSctx->resolve_relative_uri(lURI->getStringValue());
+    }
+    catch (ZorbaException const&)
+    {
+      throw XQUERY_EXCEPTION(
+        err::FODC0004,
+        ERROR_PARAMS(lURI->getStringValue(), ZED(BadAnyURI)),
+        ERROR_LOC( loc )
+      );
+    }
+  }
+  else
+  {
+    lURI = planState.theGlobalDynCtx->get_default_collection();
+
+    if( NULL == lURI)
+      throw XQUERY_EXCEPTION(
+        err::FODC0002,
+        ERROR_PARAMS( ZED( DefaultCollation ), ZED( NotDefInDynamicCtx ) ),
+        ERROR_LOC( loc )
+      );
+
+    resolvedURIString = theSctx->resolve_relative_uri(lURI->getStringValue());
+  }
+
+
+  lResource = theSctx->resolve_uri(resolvedURIString, 
+                                   impl::EntityData::COLLECTION,
+                                   lErrorMessage);
+
+  lCollResource = dynamic_cast<impl::CollectionResource*>(lResource.get());
+
+  if ( lCollResource == 0 || !(coll = lCollResource->getCollection()) )
+  {
+    throw XQUERY_EXCEPTION(
+      err::FODC0004,
+      ERROR_PARAMS(resolvedURIString, lErrorMessage),
+      ERROR_LOC( loc )
+    );
+  }
+
+  return coll;
+}
+
+
+store::Collection_t CountCollectionIterator::getZorbaCollection(
+    PlanState& planState) const
+{
+  store::Item_t qName;
+  store::Collection_t coll;
+
+  ZORBA_ASSERT(consumeNext(qName, theChildren[0].getp(), planState));
+
+  if (theSctx->lookup_collection(qName) == 0  && ! this->isDynamicCollection())
+  {
+    throw XQUERY_EXCEPTION(
+      zerr::ZDDY0001_COLLECTION_NOT_DECLARED,
+      ERROR_PARAMS( qName->getStringValue() ),
+      ERROR_LOC( loc )
+    );
+  }
+
+  coll = GENV_STORE.getCollection(qName, isDynamicCollection());
+
+  if (coll == NULL)
+  {
+    throw XQUERY_EXCEPTION(
+      zerr::ZDDY0003_COLLECTION_DOES_NOT_EXIST,
+      ERROR_PARAMS( qName->getStringValue() ),
+      ERROR_LOC( loc )
+    );
+  }
+
+  return coll;
+}
+
+
+SERIALIZABLE_CLASS_VERSIONS(CountCollectionIterator)
+END_SERIALIZABLE_CLASS_VERSIONS(CountCollectionIterator)
+
+
+NARY_ACCEPT(CountCollectionIterator);
+
+
+/*******************************************************************************
+
 ********************************************************************************/
 ZorbaCollectionIteratorState::~ZorbaCollectionIteratorState()
 {
-  if ( theIterator != NULL ) 
+  if ( theIterator != NULL )
   {
     // closing the iterator is necessary here if an exception occurs
     // in the producer or if the iterator is not fully consumed
-    if (theIteratorOpened) 
+    if (theIteratorOpened)
     {
       theIterator->close();
       theIteratorOpened = false;
@@ -205,11 +361,11 @@
 {
   PlanIteratorState::reset(planState);
 
-  if (theIterator != NULL) 
+  if (theIterator != NULL)
   {
     // closing the iterator is necessary here if an exception occurs
     // in the producer or if the iterator is not fully consumed
-    if (theIteratorOpened) 
+    if (theIteratorOpened)
     {
       theIterator->close();
       theIteratorOpened = false;
@@ -258,7 +414,7 @@
     store::Collection_t& coll) const
 {
   const StaticallyKnownCollection* collectionDecl = aSctx->lookup_collection(aName);
-  if (collectionDecl == 0  && !aDynamicCollection) 
+  if (collectionDecl == 0  && !aDynamicCollection)
   {
     throw XQUERY_EXCEPTION(
       zerr::ZDDY0001_COLLECTION_NOT_DECLARED,
@@ -269,7 +425,7 @@
 
   coll = GENV_STORE.getCollection(aName, aDynamicCollection);
 
-  if (coll == NULL) 
+  if (coll == NULL)
   {
     throw XQUERY_EXCEPTION(
       zerr::ZDDY0003_COLLECTION_DOES_NOT_EXIST,
@@ -287,7 +443,7 @@
                             $target as node()) as xs:integer
 
   The function will return the index of the $target node within the collection
-  identified by $name. Note: the function uses index numbers starting at 1. 
+  identified by $name. Note: the function uses index numbers starting at 1.
 ********************************************************************************/
 bool ZorbaIndexOfIterator::nextImpl(
     store::Item_t& result,
@@ -326,7 +482,7 @@
     store::Collection_t& coll) const
 {
   const StaticallyKnownCollection* collectionDecl = aSctx->lookup_collection(aName);
-  if (collectionDecl == 0  && !aDynamicCollection) 
+  if (collectionDecl == 0  && !aDynamicCollection)
   {
     throw XQUERY_EXCEPTION(
       zerr::ZDDY0001_COLLECTION_NOT_DECLARED,
@@ -337,7 +493,7 @@
 
   coll = GENV_STORE.getCollection(aName, aDynamicCollection);
 
-  if (coll == NULL) 
+  if (coll == NULL)
   {
     throw XQUERY_EXCEPTION(
       zerr::ZDDY0003_COLLECTION_DOES_NOT_EXIST,
@@ -446,7 +602,7 @@
   }
 
   // also add some optional nodes to the collection
-  if (theChildren.size() == 2) 
+  if (theChildren.size() == 2)
   {
     store::CopyMode copymode;
     getCopyMode(copymode, theSctx);
@@ -481,7 +637,7 @@
     store::Collection_t& coll) const
 {
   const StaticallyKnownCollection* collectionDecl = aSctx->lookup_collection(aName);
-  if (collectionDecl == 0  && !aDynamicCollection) 
+  if (collectionDecl == 0  && !aDynamicCollection)
   {
     throw XQUERY_EXCEPTION(
       zerr::ZDDY0001_COLLECTION_NOT_DECLARED,
@@ -534,7 +690,7 @@
     store::Collection_t& coll) const
 {
   const StaticallyKnownCollection* collectionDecl = aSctx->lookup_collection(aName);
-  if (collectionDecl == 0  && !aDynamicCollection) 
+  if (collectionDecl == 0  && !aDynamicCollection)
   {
     throw XQUERY_EXCEPTION(
       zerr::ZDDY0001_COLLECTION_NOT_DECLARED,
@@ -543,7 +699,7 @@
     );
   }
   coll = GENV_STORE.getCollection(aName, aDynamicCollection);
-  if (coll == NULL) 
+  if (coll == NULL)
   {
     throw XQUERY_EXCEPTION(
       zerr::ZDDY0003_COLLECTION_DOES_NOT_EXIST,
@@ -605,21 +761,21 @@
         throw XQUERY_EXCEPTION(
           zerr::ZDDY0004_COLLECTION_CONST_UPDATE,
           ERROR_PARAMS( aName->getStringValue() ),
-          ERROR_LOC( loc ) 
+          ERROR_LOC( loc )
         );
 
       case StaticContextConsts::decl_append_only:
         throw XQUERY_EXCEPTION(
           zerr::ZDDY0005_COLLECTION_APPEND_BAD_INSERT,
           ERROR_PARAMS( aName->getStringValue() ),
-          ERROR_LOC( loc ) 
+          ERROR_LOC( loc )
         );
 
       case StaticContextConsts::decl_queue:
         throw XQUERY_EXCEPTION(
           zerr::ZDDY0006_COLLECTION_QUEUE_BAD_INSERT,
           ERROR_PARAMS( aName->getStringValue() ),
-          ERROR_LOC( loc ) 
+          ERROR_LOC( loc )
         );
 
       case StaticContextConsts::decl_mutable:
@@ -689,21 +845,21 @@
         throw XQUERY_EXCEPTION(
           zerr::ZDDY0004_COLLECTION_CONST_UPDATE,
           ERROR_PARAMS( aName->getStringValue() ),
-          ERROR_LOC( loc ) 
+          ERROR_LOC( loc )
         );
 
       case StaticContextConsts::decl_append_only:
         throw XQUERY_EXCEPTION(
           zerr::ZDDY0005_COLLECTION_APPEND_BAD_INSERT,
           ERROR_PARAMS( aName->getStringValue() ),
-          ERROR_LOC( loc ) 
+          ERROR_LOC( loc )
         );
 
       case StaticContextConsts::decl_queue:
         throw XQUERY_EXCEPTION(
           zerr::ZDDY0006_COLLECTION_QUEUE_BAD_INSERT,
           ERROR_PARAMS( aName->getStringValue() ),
-          ERROR_LOC( loc ) 
+          ERROR_LOC( loc )
         );
 
       case StaticContextConsts::decl_mutable:
@@ -730,7 +886,7 @@
   insert-nodes-last($name as xs:QName, $newnode as node()*) as none
 
   The function will insert the given node(s) as the last node(s) of the given
-  collection. If multiple nodes are inserted, the nodes remain adjacent and 
+  collection. If multiple nodes are inserted, the nodes remain adjacent and
   their order preserves the node ordering of the source expression.
 
   Error conditions:
@@ -739,7 +895,7 @@
   - If the specified collection does not exist, an error is raised
     (ZAPI0006_COLLECTION_NOT_FOUND - collection does not exist).
   - If the node is already in the collection, an error is raised
-    (ZAPI0031_NODE_ALREADY_IN_COLLECTION) 
+    (ZAPI0031_NODE_ALREADY_IN_COLLECTION)
 ********************************************************************************/
 bool ZorbaInsertNodesLastIterator::nextImpl(
     store::Item_t& result,
@@ -781,13 +937,13 @@
         aSctx, aName, aLoc, aDynamicCollection, coll);
 
   if (!aDynamicCollection) {
-    switch(collectionDecl->getUpdateProperty()) 
+    switch(collectionDecl->getUpdateProperty())
     {
       case StaticContextConsts::decl_const:
         throw XQUERY_EXCEPTION(
           zerr::ZDDY0004_COLLECTION_CONST_UPDATE,
           ERROR_PARAMS( aName->getStringValue() ),
-          ERROR_LOC( loc ) 
+          ERROR_LOC( loc )
         );
 
       case StaticContextConsts::decl_append_only:
@@ -866,27 +1022,27 @@
         aSctx, aName, aLoc, aDynamicCollection, coll);
 
   if (!aDynamicCollection) {
-    switch(collectionDecl->getUpdateProperty()) 
+    switch(collectionDecl->getUpdateProperty())
     {
       case StaticContextConsts::decl_const:
         throw XQUERY_EXCEPTION(
           zerr::ZDDY0004_COLLECTION_CONST_UPDATE,
           ERROR_PARAMS( aName->getStringValue() ),
-          ERROR_LOC( loc ) 
+          ERROR_LOC( loc )
         );
 
       case StaticContextConsts::decl_append_only:
         throw XQUERY_EXCEPTION(
           zerr::ZDDY0005_COLLECTION_APPEND_BAD_INSERT,
           ERROR_PARAMS( aName->getStringValue() ),
-          ERROR_LOC( loc ) 
+          ERROR_LOC( loc )
         );
 
       case StaticContextConsts::decl_queue:
         throw XQUERY_EXCEPTION(
           zerr::ZDDY0006_COLLECTION_QUEUE_BAD_INSERT,
           ERROR_PARAMS( aName->getStringValue() ),
-          ERROR_LOC( loc ) 
+          ERROR_LOC( loc )
         );
 
       case StaticContextConsts::decl_mutable:
@@ -910,12 +1066,12 @@
 }
 
 /*******************************************************************************
-  declare updating function 
+  declare updating function
   insert-nodes-after($name as xs:QName,
                      $target as node(),
                      $newnode as node()*)
 
-  The inserted nodes become the following nodes of the $target. The $target 
+  The inserted nodes become the following nodes of the $target. The $target
   should be a non-updating expression (e.g. an XPath expression) identifying a
   node that is part of the given collection at the top-level. If multiple nodes
   are inserted by a single insert expression, the nodes remain adjacent and
@@ -972,21 +1128,21 @@
         throw XQUERY_EXCEPTION(
           zerr::ZDDY0004_COLLECTION_CONST_UPDATE,
           ERROR_PARAMS( aName->getStringValue() ),
-          ERROR_LOC( loc ) 
+          ERROR_LOC( loc )
         );
 
       case StaticContextConsts::decl_append_only:
         throw XQUERY_EXCEPTION(
           zerr::ZDDY0005_COLLECTION_APPEND_BAD_INSERT,
           ERROR_PARAMS( aName->getStringValue() ),
-          ERROR_LOC( loc ) 
+          ERROR_LOC( loc )
         );
 
       case StaticContextConsts::decl_queue:
         throw XQUERY_EXCEPTION(
           zerr::ZDDY0006_COLLECTION_QUEUE_BAD_INSERT,
           ERROR_PARAMS( aName->getStringValue() ),
-          ERROR_LOC( loc ) 
+          ERROR_LOC( loc )
         );
 
       case StaticContextConsts::decl_mutable:
@@ -1069,7 +1225,7 @@
     ++(state->iterator);
     STACK_PUSH(true, state);
   }
-  
+
   STACK_PUSH(false, state);
 
 
@@ -1135,7 +1291,7 @@
     ++(state->iterator);
     STACK_PUSH(true, state);
   }
-  
+
   STACK_PUSH(false, state);
 
   STACK_END(state);
@@ -1200,7 +1356,7 @@
     ++(state->iterator);
     STACK_PUSH(true, state);
   }
-  
+
   STACK_PUSH(false, state);
 
   STACK_END(state);
@@ -1267,7 +1423,7 @@
     ++(state->iterator);
     STACK_PUSH(true, state);
   }
-  
+
   STACK_PUSH(false, state);
 
 
@@ -1334,7 +1490,7 @@
     ++(state->iterator);
     STACK_PUSH(true, state);
   }
-  
+
   STACK_PUSH(false, state);
 
 
@@ -1342,7 +1498,7 @@
 }
 
 /*******************************************************************************
-  declare updating function 
+  declare updating function
   delete-nodes($name as xs:QName, $target as node()*)
 
   The function will remove the node(s) identified by the $target expression
@@ -1363,7 +1519,7 @@
   PlanIteratorState* state;
   DEFAULT_STACK_INIT(PlanIteratorState, state, planState);
 
-  while (consumeNext(node, theChildren[theChildren.size()-1].getp(), planState)) 
+  while (consumeNext(node, theChildren[theChildren.size()-1].getp(), planState))
   {
     if (! node->getCollection()) {
       throw XQUERY_EXCEPTION( zerr::ZDDY0017_NODE_IS_ORPHAN, ERROR_LOC( loc ) );
@@ -1412,7 +1568,7 @@
     store::Collection_t& coll) const
 {
   const StaticallyKnownCollection* collectionDecl = aSctx->lookup_collection(aName);
-  if (collectionDecl == 0 && !aDynamicCollection) 
+  if (collectionDecl == 0 && !aDynamicCollection)
   {
     throw XQUERY_EXCEPTION(
       zerr::ZDDY0001_COLLECTION_NOT_DECLARED,
@@ -1422,27 +1578,27 @@
   }
 
   if (!aDynamicCollection) {
-    switch(collectionDecl->getUpdateProperty()) 
+    switch(collectionDecl->getUpdateProperty())
     {
       case StaticContextConsts::decl_const:
         throw XQUERY_EXCEPTION(
           zerr::ZDDY0004_COLLECTION_CONST_UPDATE,
           ERROR_PARAMS( aName->getStringValue() ),
-          ERROR_LOC( loc ) 
+          ERROR_LOC( loc )
         );
 
       case StaticContextConsts::decl_append_only:
         throw XQUERY_EXCEPTION(
           zerr::ZDDY0007_COLLECTION_APPEND_BAD_DELETE,
           ERROR_PARAMS( aName->getStringValue() ),
-          ERROR_LOC( loc ) 
+          ERROR_LOC( loc )
         );
 
       case StaticContextConsts::decl_queue:
         throw XQUERY_EXCEPTION(
           zerr::ZDDY0009_COLLECTION_QUEUE_BAD_DELETE,
           ERROR_PARAMS( aName->getStringValue() ),
-          ERROR_LOC( loc ) 
+          ERROR_LOC( loc )
         );
 
       case StaticContextConsts::decl_mutable:
@@ -1454,7 +1610,7 @@
     }
   }
   coll = GENV_STORE.getCollection(aName, aDynamicCollection);
-  if (coll == NULL) 
+  if (coll == NULL)
   {
     throw XQUERY_EXCEPTION(
       zerr::ZDDY0003_COLLECTION_DOES_NOT_EXIST,
@@ -1530,7 +1686,7 @@
     store::Collection_t& coll) const
 {
   const StaticallyKnownCollection* collectionDecl = aSctx->lookup_collection(aName);
-  if (collectionDecl == 0 && !aDynamicCollection) 
+  if (collectionDecl == 0 && !aDynamicCollection)
   {
     throw XQUERY_EXCEPTION(
       zerr::ZDDY0001_COLLECTION_NOT_DECLARED,
@@ -1540,20 +1696,20 @@
   }
 
   if (!aDynamicCollection) {
-    switch(collectionDecl->getUpdateProperty()) 
+    switch(collectionDecl->getUpdateProperty())
     {
       case StaticContextConsts::decl_const:
         throw XQUERY_EXCEPTION(
           zerr::ZDDY0004_COLLECTION_CONST_UPDATE,
           ERROR_PARAMS( aName->getStringValue() ),
-          ERROR_LOC( loc ) 
+          ERROR_LOC( loc )
         );
 
       case StaticContextConsts::decl_append_only:
         throw XQUERY_EXCEPTION(
           zerr::ZDDY0007_COLLECTION_APPEND_BAD_DELETE,
           ERROR_PARAMS( aName->getStringValue() ),
-          ERROR_LOC( loc ) 
+          ERROR_LOC( loc )
         );
 
       case StaticContextConsts::decl_queue:
@@ -1566,7 +1722,7 @@
     }
   }
   coll = GENV_STORE.getCollection(aName, aDynamicCollection);
-  if (coll == NULL) 
+  if (coll == NULL)
   {
     throw XQUERY_EXCEPTION(
       zerr::ZDDY0003_COLLECTION_DOES_NOT_EXIST,
@@ -1574,7 +1730,7 @@
       ERROR_LOC( aLoc )
     );
   }
-  if (collectionDecl && 
+  if (collectionDecl &&
       collectionDecl->getOrderProperty() == StaticContextConsts::decl_unordered)
   {
     throw XQUERY_EXCEPTION(
@@ -1617,7 +1773,7 @@
     numNodes = numNodesItem->getIntegerValue();
   }
 
-  if (collection->size() < numNodes) 
+  if (collection->size() < numNodes)
   {
     throw XQUERY_EXCEPTION(
       zerr::ZDDY0011_COLLECTION_NODE_NOT_FOUND,
@@ -1681,7 +1837,7 @@
     store::Collection_t& coll) const
 {
   const StaticallyKnownCollection* collectionDecl = aSctx->lookup_collection(aName);
-  if (collectionDecl == 0 && !aDynamicCollection) 
+  if (collectionDecl == 0 && !aDynamicCollection)
   {
     throw XQUERY_EXCEPTION(
       zerr::ZDDY0001_COLLECTION_NOT_DECLARED,
@@ -1691,27 +1847,27 @@
   }
 
   if (!aDynamicCollection) {
-    switch(collectionDecl->getUpdateProperty()) 
+    switch(collectionDecl->getUpdateProperty())
     {
       case StaticContextConsts::decl_const:
         throw XQUERY_EXCEPTION(
           zerr::ZDDY0004_COLLECTION_CONST_UPDATE,
           ERROR_PARAMS( aName->getStringValue() ),
-          ERROR_LOC( loc ) 
+          ERROR_LOC( loc )
         );
 
       case StaticContextConsts::decl_append_only:
         throw XQUERY_EXCEPTION(
           zerr::ZDDY0007_COLLECTION_APPEND_BAD_DELETE,
           ERROR_PARAMS( aName->getStringValue() ),
-          ERROR_LOC( loc ) 
+          ERROR_LOC( loc )
         );
 
       case StaticContextConsts::decl_queue:
         throw XQUERY_EXCEPTION(
           zerr::ZDDY0008_COLLECTION_QUEUE_BAD_DELETE,
           ERROR_PARAMS( aName->getStringValue() ),
-          ERROR_LOC( loc ) 
+          ERROR_LOC( loc )
         );
 
       case StaticContextConsts::decl_mutable:
@@ -1723,7 +1879,7 @@
     }
   }
   coll = GENV_STORE.getCollection(aName, aDynamicCollection);
-  if (coll == NULL) 
+  if (coll == NULL)
   {
     throw XQUERY_EXCEPTION(
       zerr::ZDDY0003_COLLECTION_DOES_NOT_EXIST,
@@ -1760,7 +1916,7 @@
 
   consumeNext(lName, theChildren[0].getp(), planState);
 
-  try 
+  try
   {
     (void)getCollection(theSctx, lName, loc, theDynamicCollection, lCollection);
   }
@@ -1791,7 +1947,7 @@
     store::Collection_t& coll) const
 {
   const StaticallyKnownCollection* collectionDecl = aSctx->lookup_collection(aName);
-  if (collectionDecl == 0 && !aDynamicCollection) 
+  if (collectionDecl == 0 && !aDynamicCollection)
   {
     throw XQUERY_EXCEPTION(
       zerr::ZDDY0001_COLLECTION_NOT_DECLARED,
@@ -1800,7 +1956,7 @@
     );
   }
   coll = GENV_STORE.getCollection(aName, aDynamicCollection);
-  if (coll == NULL) 
+  if (coll == NULL)
   {
     throw XQUERY_EXCEPTION(
       zerr::ZDDY0003_COLLECTION_DOES_NOT_EXIST,
@@ -1816,7 +1972,7 @@
 ********************************************************************************/
 AvailableCollectionsIteratorState::~AvailableCollectionsIteratorState()
 {
-  if ( nameItState != NULL ) 
+  if ( nameItState != NULL )
   {
     nameItState->close();
     nameItState = NULL;
@@ -1852,7 +2008,7 @@
   if (theDynamicCollection)
   {
     for ((state->nameItState = GENV_STORE.listCollectionNames(theDynamicCollection))->open ();
-         state->nameItState->next(nameItem);) 
+         state->nameItState->next(nameItem);)
     {
       result = nameItem;
       STACK_PUSH( true, state);
@@ -1862,7 +2018,7 @@
   {
     // static collections have to exist and need to be declared
     for ((state->nameItState = theSctx->collection_names())->open ();
-         state->nameItState->next(nameItem);) 
+         state->nameItState->next(nameItem);)
     {
       if (!GENV_STORE.getCollection(nameItem.getp()))
       {
@@ -1946,7 +2102,7 @@
   DEFAULT_STACK_INIT(AvailableIndexesIteratorState, state, planState);
 
   for ((state->nameItState = GENV_STORE.listIndexNames())->open ();
-       state->nameItState->next(nameItem); ) 
+       state->nameItState->next(nameItem); )
   {
     result = nameItem;
     STACK_PUSH( true, state);
@@ -1959,7 +2115,7 @@
 
 /*******************************************************************************
 *******************************************************************************/
-bool IsActivatedICIterator::nextImpl(store::Item_t& result, 
+bool IsActivatedICIterator::nextImpl(store::Item_t& result,
                                      PlanState& planState) const
 {
   PlanIteratorState  *state;
@@ -2009,7 +2165,7 @@
 }
 
 bool
-ActivatedICsIterator::nextImpl(store::Item_t& result, 
+ActivatedICsIterator::nextImpl(store::Item_t& result,
                                PlanState& planState) const
 {
   store::Item_t              nameItem;
@@ -2018,7 +2174,7 @@
   DEFAULT_STACK_INIT(ActivatedICsIteratorState, state, planState);
 
   for ((state->nameItState = GENV_STORE.listActiveICNames())->open ();
-       state->nameItState->next(nameItem); ) 
+       state->nameItState->next(nameItem); )
   {
     result = nameItem;
     STACK_PUSH( true, state);

=== added file 'src/runtime/collections/collections_impl.h'
--- src/runtime/collections/collections_impl.h	1970-01-01 00:00:00 +0000
+++ src/runtime/collections/collections_impl.h	2011-10-21 00:32:19 +0000
@@ -0,0 +1,78 @@
+/*
+ * Copyright 2006-2008 The FLWOR Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+#ifndef ZORBA_RUNTIME_COLLECTIONS_COLLECTIONS_IMPL_H
+#define ZORBA_RUNTIME_COLLECTIONS_COLLECTIONS_IMPL_H
+
+#include "common/shared_types.h"
+
+#include "runtime/base/unarybase.h"
+#include "runtime/collections/collections_base.h"
+
+namespace zorba{
+
+/*******************************************************************************
+  Iterator to optimize a fn:count(collection) expression
+
+  theCollectionType:
+  ------------------
+  Whether the Collection is a W3C or Zorba Collection and if it's dynamic or 
+  static collection module.
+********************************************************************************/
+class CountCollectionIterator : public NaryBaseIterator<CountCollectionIterator, 
+                                                        PlanIteratorState>
+{
+public:
+  enum CollectionType { W3C = 0, ZORBASTATIC = 1, ZORBADYNAMIC = 2 };
+
+protected:
+  CollectionType theCollectionType;
+
+public:
+  SERIALIZABLE_CLASS(CountCollectionIterator);
+
+  SERIALIZABLE_CLASS_CONSTRUCTOR2T(CountCollectionIterator,
+  NaryBaseIterator<CountCollectionIterator, PlanIteratorState>);
+
+  void serialize(::zorba::serialization::Archiver& ar);
+
+public:
+  CountCollectionIterator(
+      static_context* sctx,
+      const QueryLoc& loc,
+      std::vector<PlanIter_t>& children,
+      CollectionType collectionType);
+
+  ~CountCollectionIterator();
+
+  bool isZorbaCollection() const { return W3C != theCollectionType; }
+
+  bool isDynamicCollection() const { return ZORBADYNAMIC == theCollectionType; }
+
+  void accept(PlanIterVisitor& v) const;
+
+  bool nextImpl(store::Item_t& result, PlanState& aPlanState) const;
+
+protected:
+  store::Collection_t getZorbaCollection(PlanState& planState) const;
+
+  store::Collection_t getW3CCollection(PlanState& planState) const;
+};
+
+} //namespace zorba
+#endif /* ZORBA_RUNTIME_COLLECTIONS_COLLECTIONS_IMPL_H */
+/* vim:set et sw=2 ts=2: */
+

=== modified file 'src/runtime/collections/pregenerated/collections.h'
--- src/runtime/collections/pregenerated/collections.h	2011-08-12 16:07:57 +0000
+++ src/runtime/collections/pregenerated/collections.h	2011-10-21 00:32:19 +0000
@@ -134,6 +134,8 @@
 
   virtual ~ZorbaCollectionIterator();
 
+  bool isDynamic() const { return theDynamicCollection; }
+
 public:
   const StaticallyKnownCollection* getCollection(const static_context* sctx, const store::Item_t& name, const QueryLoc& loc, bool dyn_coll, store::Collection_t& coll) const;
   void accept(PlanIterVisitor& v) const;

=== modified file 'src/runtime/sequences/pregenerated/sequences.h'
--- src/runtime/sequences/pregenerated/sequences.h	2011-05-05 15:10:24 +0000
+++ src/runtime/sequences/pregenerated/sequences.h	2011-10-21 00:32:19 +0000
@@ -92,22 +92,22 @@
 
 /**
  * 
- *  Summary: Returns a sequence of positive integers giving the positions 
- *  within the sequence $seqParam of items that are equal to $srchParam. 
- *      
- *  The collation used by the invocation of this function is determined 
- *  according to the rules in 7.3.1 Collations. The collation is used when 
- *  string comparison is required. 
- *      
- *  The items in the sequence $seqParam are compared with $srchParam under 
- *  the rules for the 'eq' operator. Values that cannot be compared, i.e. 
- *  the 'eq' operator is not defined for their types, are considered to be 
- *  distinct. If an item compares equal, then the position of that item in 
- *  the sequence $seqParam is included in the result. 
- *      
- *  If the value of $seqParam is the empty sequence, or if no item in 
- *  $seqParam matches $srchParam, then the empty sequence is returned. 
- *      
+ *  Summary: Returns a sequence of positive integers giving the positions
+ *  within the sequence $seqParam of items that are equal to $srchParam.
+ *
+ *  The collation used by the invocation of this function is determined
+ *  according to the rules in 7.3.1 Collations. The collation is used when
+ *  string comparison is required.
+ *
+ *  The items in the sequence $seqParam are compared with $srchParam under
+ *  the rules for the 'eq' operator. Values that cannot be compared, i.e.
+ *  the 'eq' operator is not defined for their types, are considered to be
+ *  distinct. If an item compares equal, then the position of that item in
+ *  the sequence $seqParam is included in the result.
+ *
+ *  If the value of $seqParam is the empty sequence, or if no item in
+ *  $seqParam matches $srchParam, then the empty sequence is returned.
+ *
  *  The first item in a sequence is at position 1, not position 0.
  *  The result sequence is in ascending numeric order.
  *  
@@ -197,7 +197,7 @@
 
 /**
  * 
- *  If the value of $arg is not the empty sequence, the function returns true; 
+ *  If the value of $arg is not the empty sequence, the function returns true;
  *  otherwise, the function returns false.
  *  
  * Author: Zorba Team
@@ -234,7 +234,7 @@
 
 /**
  * 
- *  Returns the sequence that results from removing from arg all but one of a 
+ *  Returns the sequence that results from removing from arg all but one of a
  *  set of values that are eq to one other. Values of type xs:untypedAtomic are
  *  compared as if they were of type xs:string. Values that cannot be compared,
  *  i.e. the eq operator is not defined for their types, are considered to be
@@ -763,8 +763,8 @@
 /**
  * 
  *  Hashing semi/anti join iterator.
- *      
- *  First producer goes in the result if a match in the second producer is 
+ *
+ *  First producer goes in the result if a match in the second producer is
  *  found/not found. The order of the first producer is retained. No duplicate
  *  elimination is performed.
  *  
@@ -826,7 +826,7 @@
  *  First producer goes in the result if a match in the second producer is found.
  *  Precondition: both inputs must be sorted.
  *  Postcondition: the order of the first producer is retained.
- *      
+ *
  *  If either of the inputs is guaranteed to contain no duplicates, then the
  *  output will be duplicate-free. Otherwise the output may contain duplicates.
  *  
@@ -934,7 +934,7 @@
 
 /**
  * 
- *  Returns a value obtained by adding together the values in $arg. If $zero is 
+ *  Returns a value obtained by adding together the values in $arg. If $zero is
  *  not specified, then the value returned for an empty sequence is the xs:integer
  *  value 0. If $zero is specified, then the value returned for an empty sequence
  *  is $zero.
@@ -1167,7 +1167,7 @@
 /**
  * 
  *  Returns the sequence of element nodes that are in the target document and have
- *  an ID value matching the value of one or more of the IDREF values supplied in 
+ *  an ID value matching the value of one or more of the IDREF values supplied in
  *  $arg. The target document is the document containing $node, or the document
  *  containing the context item (.) if the second argument is omitted.
  *  

=== modified file 'src/runtime/spec/collections/collections.xml'
--- src/runtime/spec/collections/collections.xml	2011-08-12 16:07:57 +0000
+++ src/runtime/spec/collections/collections.xml	2011-10-21 00:32:19 +0000
@@ -10,7 +10,7 @@
   xmlns:zorba="http://www.zorba-xquery.com"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://www.zorba-xquery.com ../runtime.xsd">
-    
+
 <zorba:source>
     <zorba:include  form="Quoted">store/api/iterator.h</zorba:include>
 </zorba:source>
@@ -54,7 +54,7 @@
       <zorba:member type="bool" name="theIteratorOpened" defaultValue="false"
                     brief="flag indicating whether theIterator was opened"/>
     </zorba:state>
-  
+
 </zorba:iterator>
 
 <!--
@@ -81,7 +81,7 @@
 
       <zorba:methods>
         <zorba:accessesDynCtx returnValue="true"/>
-        <zorba:isSource returnValue="true"/>        
+        <zorba:isSource returnValue="true"/>
         <zorba:producesDistinctNodes returnValue="YES"/>
         <zorba:producesSortedNodes returnValue="YES"/>
       </zorba:methods>
@@ -102,6 +102,7 @@
     </zorba:method>
 
     <zorba:member type="bool" name="theDynamicCollection"
+      getterName="isDynamic"
       brief="whether it's the function of the dynamic or the static collection module"/>
 
     <zorba:state generateInit="false" generateReset="false" generateDestructor="false">
@@ -110,7 +111,7 @@
       <zorba:member type="bool" name="theIteratorOpened" defaultValue="false"
                     brief="flag indicating whether theIterator was opened"/>
     </zorba:state>
-  
+
 </zorba:iterator>
 
 <!--
@@ -296,7 +297,7 @@
 
       <zorba:methods>
         <zorba:getScriptingKind returnValue="UPDATING_EXPR"/>
-        <zorba:accessesDynCtx returnValue="true"/>        
+        <zorba:accessesDynCtx returnValue="true"/>
       </zorba:methods>
 
     </zorba:function>
@@ -735,7 +736,7 @@
     </zorba:state>
 
 </zorba:iterator>
- 
+
 
 <!--
 /*******************************************************************************
@@ -1110,8 +1111,8 @@
       </zorba:methods>
     </zorba:function>
 
-    <zorba:state  generateInit="false" 
-                  generateReset="false" 
+    <zorba:state  generateInit="false"
+                  generateReset="false"
                   generateDestructor="false">
       <zorba:member type="store::Iterator_t" name="nameItState"
                     brief="the current iterator"/>

=== modified file 'src/runtime/spec/sequences/sequences.xml'
--- src/runtime/spec/sequences/sequences.xml	2011-06-17 14:40:56 +0000
+++ src/runtime/spec/sequences/sequences.xml	2011-10-21 00:32:19 +0000
@@ -22,7 +22,7 @@
 <zorba:source>
     <zorba:include form="Quoted">runtime/util/handle_hashset_item_value.h</zorba:include>
 </zorba:source>
-  
+
 <zorba:codegen>
   <zorba:cpp>
     <zorba:include form="Quoted">system/globalenv.h</zorba:include>
@@ -72,35 +72,35 @@
 /*******************************************************************************
   15.1.3 fn:index-of($seqParam as xs:anyAtomicType*,
                      $srchParam as xs:anyAtomicType) as xs:integer*
-       
+
          fn:index-of($seqParam as xs:anyAtomicType*,
                      $srchParam as xs:anyAtomicType,
                      $collation as xs:string) as xs:integer*
 ********************************************************************************/
 -->
 <zorba:iterator name="FnIndexOfIterator">
-    
+
   <zorba:description author="Zorba Team">
-  Summary: Returns a sequence of positive integers giving the positions 
-  within the sequence $seqParam of items that are equal to $srchParam. 
-      
-  The collation used by the invocation of this function is determined 
-  according to the rules in 7.3.1 Collations. The collation is used when 
-  string comparison is required. 
-      
-  The items in the sequence $seqParam are compared with $srchParam under 
-  the rules for the 'eq' operator. Values that cannot be compared, i.e. 
-  the 'eq' operator is not defined for their types, are considered to be 
-  distinct. If an item compares equal, then the position of that item in 
-  the sequence $seqParam is included in the result. 
-      
-  If the value of $seqParam is the empty sequence, or if no item in 
-  $seqParam matches $srchParam, then the empty sequence is returned. 
-      
+  Summary: Returns a sequence of positive integers giving the positions
+  within the sequence $seqParam of items that are equal to $srchParam.
+
+  The collation used by the invocation of this function is determined
+  according to the rules in 7.3.1 Collations. The collation is used when
+  string comparison is required.
+
+  The items in the sequence $seqParam are compared with $srchParam under
+  the rules for the 'eq' operator. Values that cannot be compared, i.e.
+  the 'eq' operator is not defined for their types, are considered to be
+  distinct. If an item compares equal, then the position of that item in
+  the sequence $seqParam is included in the result.
+
+  If the value of $seqParam is the empty sequence, or if no item in
+  $seqParam matches $srchParam, then the empty sequence is returned.
+
   The first item in a sequence is at position 1, not position 0.
   The result sequence is in ascending numeric order.
   </zorba:description>
-    
+
   <zorba:function >
 
     <zorba:signature localname="index-of" prefix="fn">
@@ -137,12 +137,12 @@
 ********************************************************************************/
 -->
 <zorba:iterator name="FnEmptyIterator">
-    
+
   <zorba:description author="Zorba Team">
   If the value of $arg is the empty sequence, the function returns true;
   otherwise, the function returns false.
   </zorba:description>
-  
+
   <zorba:function>
 
     <zorba:signature localname="empty" prefix="fn">
@@ -151,13 +151,13 @@
     </zorba:signature>
 
     <zorba:methods>
-      <zorba:ignoresSortedNodes/> 
-      <zorba:ignoresDuplicateNodes/> 
+      <zorba:ignoresSortedNodes/>
+      <zorba:ignoresDuplicateNodes/>
     </zorba:methods>
 
   </zorba:function>
 
-</zorba:iterator> 
+</zorba:iterator>
 
 <!--
 /*******************************************************************************
@@ -165,12 +165,12 @@
 ********************************************************************************/
 -->
 <zorba:iterator name="FnExistsIterator">
-    
+
   <zorba:description author="Zorba Team">
-  If the value of $arg is not the empty sequence, the function returns true; 
+  If the value of $arg is not the empty sequence, the function returns true;
   otherwise, the function returns false.
   </zorba:description>
-  
+
   <zorba:function >
     <zorba:signature localname="exists" prefix="fn">
       <zorba:param>item()*</zorba:param>
@@ -178,8 +178,8 @@
     </zorba:signature>
 
     <zorba:methods>
-      <zorba:ignoresSortedNodes/> 
-      <zorba:ignoresDuplicateNodes/> 
+      <zorba:ignoresSortedNodes/>
+      <zorba:ignoresDuplicateNodes/>
     </zorba:methods>
   </zorba:function>
 
@@ -194,9 +194,9 @@
 ********************************************************************************/
 -->
 <zorba:iterator name="FnDistinctValuesIterator">
-    
+
   <zorba:description author="Zorba Team">
-  Returns the sequence that results from removing from arg all but one of a 
+  Returns the sequence that results from removing from arg all but one of a
   set of values that are eq to one other. Values of type xs:untypedAtomic are
   compared as if they were of type xs:string. Values that cannot be compared,
   i.e. the eq operator is not defined for their types, are considered to be
@@ -206,7 +206,7 @@
   </zorba:description>
 
   <zorba:function>
- 
+
    <zorba:signature localname="distinct-values" prefix="fn">
       <zorba:param>xs:anyAtomicType*</zorba:param>
       <zorba:param>xs:string</zorba:param>
@@ -221,7 +221,7 @@
     <zorba:methods>
       <zorba:getReturnType/>
       <zorba:ignoresSortedNodes/>
-      <zorba:ignoresDuplicateNodes/> 
+      <zorba:ignoresDuplicateNodes/>
     </zorba:methods>
 
   </zorba:function>
@@ -244,16 +244,16 @@
   15.1.7 fn:insert-before($target as item()*,
                           $position as xs:integer,
                           $inserts as item()*) as item()*
-********************************************************************************/ 
+********************************************************************************/
 -->
 <zorba:iterator name="FnInsertBeforeIterator">
-    
+
   <zorba:description author="Zorba Team">
   Returns a new sequence constructed from the value of the first parameter with
   the value of third parameter inserted at the position specified by the value
   of the second parameter.
   </zorba:description>
-    
+
   <zorba:function>
 
     <zorba:signature localname="insert-before" prefix="fn">
@@ -265,7 +265,7 @@
 
     <zorba:methods>
       <zorba:ignoresSortedNodes/>
-      <zorba:ignoresDuplicateNodes/> 
+      <zorba:ignoresDuplicateNodes/>
     </zorba:methods>
 
   </zorba:function>
@@ -289,12 +289,12 @@
 ********************************************************************************/
 -->
 <zorba:iterator name="FnRemoveIterator">
-    
+
   <zorba:description author="Zorba Team">
   Returns a new sequence constructed from the value of aTarget with the item at
   the position specified by the value of aPosition removed.
   </zorba:description>
-  
+
   <zorba:function>
 
     <zorba:signature localname="remove" prefix="fn">
@@ -309,7 +309,7 @@
       <zorba:propagatesDistinctNodes producer="0"/>
       <zorba:propagatesSortedNodes producer="0"/>
       <zorba:ignoresSortedNodes/>
-      <zorba:ignoresDuplicateNodes/>    
+      <zorba:ignoresDuplicateNodes/>
     </zorba:methods>
 
   </zorba:function>
@@ -317,10 +317,10 @@
   <zorba:state>
     <zorba:member type="xs_integer" name="theCurrentPos"
                   defaultValue="xs_integer::zero()" brief="the current position in the sequence"/>
-  
+
     <zorba:member type="xs_integer" name="thePosition"
                   defaultValue="xs_integer::zero()" brief="the position to delete"/>
-  
+
     <zorba:member type="XQPCollator*" name="theCollator"
                   defaultValue="0" brief="the collator"/>
   </zorba:state>
@@ -333,23 +333,23 @@
 ********************************************************************************/
 -->
 <zorba:iterator name="FnReverseIterator">
-    
+
   <zorba:description author="Zorba Team">
   fn:reverse
   </zorba:description>
-  
+
   <zorba:function>
 
-    <zorba:signature localname="reverse" prefix="fn"> 
+    <zorba:signature localname="reverse" prefix="fn">
       <zorba:param>item()*</zorba:param>
-      <zorba:output>item()*</zorba:output>      
+      <zorba:output>item()*</zorba:output>
     </zorba:signature>
 
     <zorba:methods>
       <zorba:getReturnType/>
       <zorba:propagatesDistinctNodes producer="0"/>
       <zorba:ignoresSortedNodes/>
-      <zorba:ignoresDuplicateNodes/> 
+      <zorba:ignoresDuplicateNodes/>
     </zorba:methods>
 
   </zorba:function>
@@ -371,13 +371,13 @@
                          $length as xs:double) as item()*
 ********************************************************************************/
 -->
-<zorba:iterator name="FnSubsequenceIterator" 
+<zorba:iterator name="FnSubsequenceIterator"
                 generateResetImpl="true">
-    
+
   <zorba:description author="Zorba Team">
   fn:subsequence
   </zorba:description>
-  
+
   <zorba:function generateCodegen="false">
 
     <zorba:signature localname="subsequence" prefix="fn">
@@ -409,7 +409,7 @@
     <zorba:member type="bool" name="theIsChildReset" defaultValue="false"/>
 
   </zorba:state>
-  
+
 </zorba:iterator>
 
 
@@ -418,13 +418,13 @@
   zorbaop:subsequence-int
 ********************************************************************************/
 -->
-<zorba:iterator name="SubsequenceIntIterator" 
+<zorba:iterator name="SubsequenceIntIterator"
                 generateResetImpl="true">
-    
+
   <zorba:description author="Zorba Team">
     zorbaop:subsequence-int
   </zorba:description>
-  
+
   <zorba:function generateCodegen="false">
 
     <zorba:signature localname="subsequence-int" prefix="op-zorba">
@@ -455,7 +455,7 @@
     <zorba:member type="bool" name="theIsChildReset" defaultValue="false"/>
 
   </zorba:state>
-  
+
 </zorba:iterator>
 
 
@@ -467,11 +467,11 @@
 -->
 <zorba:iterator name="SequencePointAccessIterator"
                 generateResetImpl="true">
-    
+
   <zorba:description author="Zorba Team">
     zorbaop:sequence-point-access
   </zorba:description>
-  
+
   <zorba:function generateCodegen="false">
 
     <zorba:signature localname="sequence-point-access" prefix="op-zorba">
@@ -483,7 +483,7 @@
     <zorba:methods>
       <zorba:getReturnType/>
       <zorba:propagatesDistinctNodes producer="0"/>
-      <zorba:propagatesSortedNodes producer="0"/>      
+      <zorba:propagatesSortedNodes producer="0"/>
     </zorba:methods>
 
   </zorba:function>
@@ -491,7 +491,7 @@
   <zorba:state>
     <zorba:member type="bool" name="theIsChildReset" defaultValue="false"/>
   </zorba:state>
-  
+
 </zorba:iterator>
 
 
@@ -510,11 +510,11 @@
 ********************************************************************************/
 -->
 <zorba:iterator name="FnZeroOrOneIterator">
-    
+
   <zorba:description author="Zorba Team">
   Returns $arg if it contains zero or one items. Otherwise, raises err:FORG0003.
   </zorba:description>
-    
+
     <zorba:function generateCodegen="false">
       <zorba:signature localname="zero-or-one" prefix="fn">
         <zorba:param>item()*</zorba:param>
@@ -531,9 +531,9 @@
     <zorba:constructor>
         <zorba:parameter type="bool" name="doDistinct" defaultValue="false"/>
     </zorba:constructor>
-    
+
     <zorba:member type="bool" name="theDoDistinct" brief=""/>
-  
+
 </zorba:iterator>
 
 <!--
@@ -542,25 +542,25 @@
 ********************************************************************************/
 -->
 <zorba:iterator name="FnOneOrMoreIterator">
-    
+
   <zorba:description author="Zorba Team">
   Returns $arg if it contains one or more items. Otherwise, raises err:FORG0004.
   </zorba:description>
-  
+
   <zorba:function>
 
     <zorba:signature localname="one-or-more" prefix="fn">
       <zorba:param>item()*</zorba:param>
-      <zorba:output>item()+</zorba:output>  
+      <zorba:output>item()+</zorba:output>
     </zorba:signature>
 
     <zorba:methods>
       <zorba:getReturnType/>
       <zorba:isMap producer="0"/>
       <zorba:propagatesDistinctNodes producer="0"/>
-      <zorba:propagatesSortedNodes producer="0"/>  
+      <zorba:propagatesSortedNodes producer="0"/>
       <zorba:ignoresSortedNodes/>
-      <zorba:ignoresDuplicateNodes/> 
+      <zorba:ignoresDuplicateNodes/>
     </zorba:methods>
 
   </zorba:function>
@@ -573,19 +573,19 @@
 ********************************************************************************/
 -->
 <zorba:iterator name="FnExactlyOneIterator" generateCodegen="false">
-    
+
   <zorba:description author="Zorba Team">
   Returns $arg if it contains exactly one item. Otherwise, raises err:FORG0005.
   </zorba:description>
-    
+
   <zorba:constructor>
       <zorba:parameter type="bool" name="raiseError" defaultValue="true"/>
       <zorba:parameter type="bool" name="doDistinct" defaultValue="false"/>
   </zorba:constructor>
-    
+
   <zorba:member type="bool" name="theRaiseError" brief=""/>
   <zorba:member type="bool" name="theDoDistinct" brief=""/>
-  
+
 </zorba:iterator>
 
 <!--
@@ -599,14 +599,14 @@
 ********************************************************************************/
 -->
 <zorba:iterator name="FnDeepEqualIterator">
-    
+
   <zorba:description author="Zorba Team">
   This function assesses whether two sequences are deep-equal to each other. To
   be deep-equal, they must contain items that are pairwise deep-equal; and for
   two items to be deep-equal, they must either be atomic values that compare equal,
   or nodes of the same kind, with the same name, whose children are deep-equal.
   </zorba:description>
-  
+
   <zorba:function>
 
     <zorba:signature localname="deep-equal" prefix="fn">
@@ -654,13 +654,13 @@
 ********************************************************************************/
 -->
 
-<zorba:iterator name="HashSemiJoinIterator" 
+<zorba:iterator name="HashSemiJoinIterator"
                 generateCodegen="false">
-    
+
   <zorba:description author="Zorba Team">
   Hashing semi/anti join iterator.
-      
-  First producer goes in the result if a match in the second producer is 
+
+  First producer goes in the result if a match in the second producer is
   found/not found. The order of the first producer is retained. No duplicate
   elimination is performed.
   </zorba:description>
@@ -673,37 +673,37 @@
   <zorba:constructor>
     <zorba:parameter type="bool" name="antijoin" defaultValue="false"/>
   </zorba:constructor>
-    
+
   <zorba:member type="bool" name="theAntijoin" brief=""/>
-    
-</zorba:iterator>    
-
-
-<zorba:iterator name="SortSemiJoinIterator" 
+
+</zorba:iterator>
+
+
+<zorba:iterator name="SortSemiJoinIterator"
                 generateCodegen="false">
-    
+
   <zorba:description author="Zorba Team">
   Sortmerge based semijoin iterator.
 
   First producer goes in the result if a match in the second producer is found.
   Precondition: both inputs must be sorted.
   Postcondition: the order of the first producer is retained.
-      
+
   If either of the inputs is guaranteed to contain no duplicates, then the
   output will be duplicate-free. Otherwise the output may contain duplicates.
   </zorba:description>
 </zorba:iterator>
-    
+
 <!--
 /*******************************************************************************
   15.4.1 fn:count($arg as item()*) as xs:integer
 ********************************************************************************/
 -->
 <zorba:iterator name="FnCountIterator">
-    
+
     <zorba:description author="Zorba Team">fn:count</zorba:description>
-  
-  <zorba:function>
+
+  <zorba:function generateCodegen="false">
     <zorba:signature localname="count" prefix="fn">
       <zorba:param>item()*</zorba:param>
       <zorba:output>xs:integer</zorba:output>
@@ -716,18 +716,18 @@
   </zorba:function>
 
 </zorba:iterator>
-    
+
 <!--
 /*******************************************************************************
   15.4.2 fn:avg($arg as xs:anyAtomicType*) as xs:anyAtomicType?
 ********************************************************************************/
 -->
 <zorba:iterator name="FnAvgIterator">
-    
+
     <zorba:description author="Zorba Team">
       fn:avg
     </zorba:description>
-  
+
   <zorba:function >
     <zorba:signature localname="avg" prefix="fn">
       <zorba:param>xs:anyAtomicType*</zorba:param>
@@ -746,7 +746,7 @@
 /*******************************************************************************
   15.4.3 fn:max($arg as xs:anyAtomicType*) as xs:anyAtomicType?
 
-         fn:max($arg as xs:anyAtomicType*, 
+         fn:max($arg as xs:anyAtomicType*,
                 $collation as string) as xs:anyAtomicType?
 ********************************************************************************/
 -->
@@ -756,7 +756,7 @@
 /*******************************************************************************
   15.4.4 fn:min($arg as xs:anyAtomicType*) as xs:anyAtomicType?
 
-         fn:min($arg as xs:anyAtomicType*, 
+         fn:min($arg as xs:anyAtomicType*,
                 $collation as string) as xs:anyAtomicType?
 ********************************************************************************/
 -->
@@ -771,14 +771,14 @@
 ********************************************************************************/
 -->
 <zorba:iterator name="FnSumIterator">
-  
+
   <zorba:description author="Zorba Team">
-  Returns a value obtained by adding together the values in $arg. If $zero is 
+  Returns a value obtained by adding together the values in $arg. If $zero is
   not specified, then the value returned for an empty sequence is the xs:integer
   value 0. If $zero is specified, then the value returned for an empty sequence
   is $zero.
   </zorba:description>
-  
+
   <zorba:function specializable="true">
 
     <zorba:signature localname="sum" prefix="fn">
@@ -802,11 +802,11 @@
 
 
 <zorba:iterator name="FnSumDoubleIterator">
-    
+
     <zorba:description author="Zorba Team">
       fn:sum with arguments xs:double
     </zorba:description>
-  
+
   <zorba:function>
 
     <zorba:signature localname="sum_double" prefix="op">
@@ -830,11 +830,11 @@
 
 
 <zorba:iterator name="FnSumFloatIterator">
-    
+
     <zorba:description author="Zorba Team">
       fn:sum with arguments xs:float
     </zorba:description>
-  
+
   <zorba:function >
 
     <zorba:signature localname="sum_float" prefix="op">
@@ -858,11 +858,11 @@
 
 
 <zorba:iterator name="FnSumDecimalIterator">
-    
+
     <zorba:description author="Zorba Team">
       fn:sum with arguments xs:decimal
     </zorba:description>
-  
+
   <zorba:function >
 
     <zorba:signature localname="sum_decimal" prefix="op">
@@ -886,11 +886,11 @@
 
 
 <zorba:iterator name="FnSumIntegerIterator">
-    
+
     <zorba:description author="Zorba Team">
       fn:sum with arguments xs:integer
     </zorba:description>
-  
+
   <zorba:function >
 
     <zorba:signature localname="sum_integer" prefix="op">
@@ -955,7 +955,7 @@
 
   <zorba:description author="Zorba Team">
   Returns the sequence of element nodes that are in the target document and have
-  an ID value matching the value of one or more of the IDREF values supplied in 
+  an ID value matching the value of one or more of the IDREF values supplied in
   $arg. The target document is the document containing $node, or the document
   containing the context item (.) if the second argument is omitted.
   </zorba:description>
@@ -1089,9 +1089,9 @@
 ********************************************************************************/
 -->
 <zorba:iterator name="FnDocIterator">
-    
+
     <zorba:description author="Zorba Team">fn:doc</zorba:description>
-  
+
   <zorba:function>
 
     <zorba:signature localname="doc" prefix="fn">
@@ -1115,9 +1115,9 @@
 ********************************************************************************/
 -->
 <zorba:iterator name="FnDocAvailableIterator">
-    
+
   <zorba:description author="Zorba Team">fn:doc-available</zorba:description>
-  
+
   <zorba:function>
     <zorba:signature localname="doc-available" prefix="fn">
       <zorba:param>xs:string?</zorba:param>

=== modified file 'src/runtime/visitors/planiter_visitor_impl_code.h'
--- src/runtime/visitors/planiter_visitor_impl_code.h	2011-06-14 17:26:33 +0000
+++ src/runtime/visitors/planiter_visitor_impl_code.h	2011-10-21 00:32:19 +0000
@@ -355,4 +355,6 @@
 PLAN_ITER_VISITOR(ExitIterator);
 PLAN_ITER_VISITOR(ExitCatcherIterator);
 PLAN_ITER_VISITOR(FlowCtlIterator);
+
+PLAN_ITER_VISITOR(CountCollectionIterator);
 /* vim:set et sw=2 ts=2: */

=== modified file 'src/runtime/visitors/planiter_visitor_impl_include.h'
--- src/runtime/visitors/planiter_visitor_impl_include.h	2011-06-14 17:26:33 +0000
+++ src/runtime/visitors/planiter_visitor_impl_include.h	2011-10-21 00:32:19 +0000
@@ -177,6 +177,8 @@
 class LoopIterator;
 class FlowCtlIterator;
 
+class CountCollectionIterator;
+
 #define PLAN_ITER_VISITOR(class)                \
 virtual void beginVisit ( const class& ) = 0;  \
 virtual void endVisit ( const class& ) = 0

=== modified file 'src/runtime/visitors/printer_visitor_impl.cpp'
--- src/runtime/visitors/printer_visitor_impl.cpp	2011-07-29 06:13:28 +0000
+++ src/runtime/visitors/printer_visitor_impl.cpp	2011-10-21 00:32:19 +0000
@@ -56,6 +56,7 @@
 #include "runtime/eval/eval.h"
 #include "runtime/misc/materialize.h"
 #include "runtime/scripting/scripting.h"
+#include "runtime/collections/collections_impl.h"
 
 #ifdef ZORBA_WITH_DEBUGGER
 #include "debugger/debugger_commons.h"
@@ -186,7 +187,7 @@
   thePrinter.endEndVisit();
 }
 
-void PrinterVisitor::beginVisit ( const TreatIterator& a ) 
+void PrinterVisitor::beginVisit ( const TreatIterator& a )
 {
   thePrinter.startBeginVisit("TreatIterator", ++theId);
   if (a.theCheckPrime)
@@ -197,13 +198,13 @@
   thePrinter.endBeginVisit(theId);
 }
 
-void PrinterVisitor::endVisit ( const TreatIterator& ) 
+void PrinterVisitor::endVisit ( const TreatIterator& )
 {
   thePrinter.startEndVisit();
   thePrinter.endEndVisit();
 }
 
-void PrinterVisitor::beginVisit ( const NumArithIterator<AddOperation>& a ) 
+void PrinterVisitor::beginVisit ( const NumArithIterator<AddOperation>& a )
 {
   thePrinter.startBeginVisit("NumArithIterator_AddOperation", ++theId);
   printCommons( &a, theId );
@@ -1116,7 +1117,7 @@
 }
 
 
-void PrinterVisitor::beginVisit(const CastIterator& a) 
+void PrinterVisitor::beginVisit(const CastIterator& a)
 {
   thePrinter.startBeginVisit("CastIterator", ++theId);
   std::ostringstream lStream;
@@ -1154,26 +1155,26 @@
   thePrinter.endBeginVisit(theId);
 }
 
-void PrinterVisitor::endVisit(const CastableIterator&) 
+void PrinterVisitor::endVisit(const CastableIterator&)
 {
   thePrinter.startEndVisit();
   thePrinter.endEndVisit();
 }
 
-void PrinterVisitor::beginVisit(const FTContainsIterator& a) 
+void PrinterVisitor::beginVisit(const FTContainsIterator& a)
 {
   thePrinter.startBeginVisit("FTContainsIterator", ++theId);
   // TODO
   thePrinter.endBeginVisit(theId);
 }
 
-void PrinterVisitor::endVisit(const FTContainsIterator&) 
+void PrinterVisitor::endVisit(const FTContainsIterator&)
 {
   thePrinter.startEndVisit();
   thePrinter.endEndVisit();
 }
 
-void PrinterVisitor::beginVisit(const flwor::OuterForIterator& a) 
+void PrinterVisitor::beginVisit(const flwor::OuterForIterator& a)
 {
   thePrinter.startBeginVisit("flwor::OuterForIterator", ++theId);
   thePrinter.addAttribute("varname", a.getVarName()->getStringValue().str());
@@ -1181,7 +1182,7 @@
   thePrinter.endBeginVisit(theId);
 }
 
-void PrinterVisitor::endVisit(const flwor::OuterForIterator&) 
+void PrinterVisitor::endVisit(const flwor::OuterForIterator&)
 {
   thePrinter.startEndVisit();
   thePrinter.endEndVisit();
@@ -1389,5 +1390,7 @@
   PRINTER_VISITOR_DEFINITION(ExitCatcherIterator);
   PRINTER_VISITOR_DEFINITION(LoopIterator);
   PRINTER_VISITOR_DEFINITION(FlowCtlIterator);
+
+  PRINTER_VISITOR_DEFINITION(CountCollectionIterator);
 }
 /* vim:set et sw=2 ts=2: */

=== modified file 'src/runtime/visitors/printer_visitor_impl.h'
--- src/runtime/visitors/printer_visitor_impl.h	2011-06-14 17:26:33 +0000
+++ src/runtime/visitors/printer_visitor_impl.h	2011-10-21 00:32:19 +0000
@@ -307,4 +307,6 @@
   DECLARE_VISITOR(ExitCatcherIterator);
   DECLARE_VISITOR(LoopIterator);
   DECLARE_VISITOR(FlowCtlIterator);
+
+  DECLARE_VISITOR(CountCollectionIterator);
 /* vim:set et sw=2 ts=2: */

=== added directory 'test/rbkt/ExpCompilerResults/IterPlan/zorba/collections'
=== added file 'test/rbkt/ExpCompilerResults/IterPlan/zorba/collections/count_dynamic_zorba_collection.iter'
--- test/rbkt/ExpCompilerResults/IterPlan/zorba/collections/count_dynamic_zorba_collection.iter	1970-01-01 00:00:00 +0000
+++ test/rbkt/ExpCompilerResults/IterPlan/zorba/collections/count_dynamic_zorba_collection.iter	2011-10-21 00:32:19 +0000
@@ -0,0 +1,25 @@
+Iterator tree for main query:
+<SequentialIterator>
+  <CtxVarDeclareIterator varid="2" varname="coll">
+    <SingletonIterator value="xs:QName(,,collection)"/>
+  </CtxVarDeclareIterator>
+  <SequentialIterator>
+    <ApplyIterator>
+      <ZorbaCreateCollectionIterator>
+        <PromoteIterator type="xs:QName">
+          <FnDataIterator>
+            <CtxVarIterator varid="2" varname="coll" varkind="global"/>
+          </FnDataIterator>
+        </PromoteIterator>
+      </ZorbaCreateCollectionIterator>
+    </ApplyIterator>
+    <CountCollectionIterator>
+      <PromoteIterator type="xs:QName">
+        <FnDataIterator>
+          <CtxVarIterator varid="2" varname="coll" varkind="global"/>
+        </FnDataIterator>
+      </PromoteIterator>
+    </CountCollectionIterator>
+  </SequentialIterator>
+</SequentialIterator>
+

=== added file 'test/rbkt/ExpCompilerResults/IterPlan/zorba/collections/count_static_zorba_collection.iter'
--- test/rbkt/ExpCompilerResults/IterPlan/zorba/collections/count_static_zorba_collection.iter	1970-01-01 00:00:00 +0000
+++ test/rbkt/ExpCompilerResults/IterPlan/zorba/collections/count_static_zorba_collection.iter	2011-10-21 00:32:19 +0000
@@ -0,0 +1,61 @@
+Iterator tree for main query:
+<SequentialIterator>
+  <CtxVarDeclareIterator varid="2" varname="ns:collection_1">
+    <SingletonIterator value="xs:QName(http://example.org/datamodule/,ns,collection_1)"/>
+  </CtxVarDeclareIterator>
+  <TreatIterator type="xs:QName" quant="">
+    <CtxVarIterator varid="2" varname="ns:collection_1" varkind="global"/>
+  </TreatIterator>
+  <CtxVarDeclareIterator varid="3" varname="ns:collection_2">
+    <SingletonIterator value="xs:QName(http://example.org/datamodule/,ns,collection_2)"/>
+  </CtxVarDeclareIterator>
+  <TreatIterator type="xs:QName" quant="">
+    <CtxVarIterator varid="3" varname="ns:collection_2" varkind="global"/>
+  </TreatIterator>
+  <CtxVarDeclareIterator varid="4" varname="ns:http">
+    <SingletonIterator value="xs:QName(http://example.org/datamodule/,ns,http)"/>
+  </CtxVarDeclareIterator>
+  <TreatIterator type="xs:QName" quant="">
+    <CtxVarIterator varid="4" varname="ns:http" varkind="global"/>
+  </TreatIterator>
+  <CtxVarDeclareIterator varid="5" varname="ns:test1">
+    <SingletonIterator value="xs:QName(http://example.org/datamodule/,ns,test1)"/>
+  </CtxVarDeclareIterator>
+  <TreatIterator type="xs:QName" quant="">
+    <CtxVarIterator varid="5" varname="ns:test1" varkind="global"/>
+  </TreatIterator>
+  <CtxVarDeclareIterator varid="6" varname="ns:test2">
+    <SingletonIterator value="xs:QName(http://example.org/datamodule/,ns,test2)"/>
+  </CtxVarDeclareIterator>
+  <TreatIterator type="xs:QName" quant="">
+    <CtxVarIterator varid="6" varname="ns:test2" varkind="global"/>
+  </TreatIterator>
+  <CtxVarDeclareIterator varid="7" varname="ns:test3">
+    <SingletonIterator value="xs:QName(http://example.org/datamodule/,ns,test3)"/>
+  </CtxVarDeclareIterator>
+  <TreatIterator type="xs:QName" quant="">
+    <CtxVarIterator varid="7" varname="ns:test3" varkind="global"/>
+  </TreatIterator>
+  <CtxVarDeclareIterator varid="8" varname="coll">
+    <SingletonIterator value="xs:QName(http://example.org/datamodule/,ns,test1)"/>
+  </CtxVarDeclareIterator>
+  <SequentialIterator>
+    <ApplyIterator>
+      <ZorbaCreateCollectionIterator>
+        <PromoteIterator type="xs:QName">
+          <FnDataIterator>
+            <CtxVarIterator varid="8" varname="coll" varkind="global"/>
+          </FnDataIterator>
+        </PromoteIterator>
+      </ZorbaCreateCollectionIterator>
+    </ApplyIterator>
+    <CountCollectionIterator>
+      <PromoteIterator type="xs:QName">
+        <FnDataIterator>
+          <CtxVarIterator varid="8" varname="coll" varkind="global"/>
+        </FnDataIterator>
+      </PromoteIterator>
+    </CountCollectionIterator>
+  </SequentialIterator>
+</SequentialIterator>
+

=== added file 'test/rbkt/ExpCompilerResults/IterPlan/zorba/collections/count_w3c_collection.iter'
--- test/rbkt/ExpCompilerResults/IterPlan/zorba/collections/count_w3c_collection.iter	1970-01-01 00:00:00 +0000
+++ test/rbkt/ExpCompilerResults/IterPlan/zorba/collections/count_w3c_collection.iter	2011-10-21 00:32:19 +0000
@@ -0,0 +1,35 @@
+Iterator tree for main query:
+<SequentialIterator>
+  <CtxVarDeclareIterator varid="2" varname="coll">
+    <SingletonIterator value="xs:string(http://www.zorba-xquery.com/collection)"/>
+  </CtxVarDeclareIterator>
+  <SequentialIterator>
+    <ApplyIterator>
+      <UDFunctionCallIterator>
+        <PromoteIterator type="xs:string">
+          <FnDataIterator>
+            <CtxVarIterator varid="2" varname="coll" varkind="global"/>
+          </FnDataIterator>
+        </PromoteIterator>
+      </UDFunctionCallIterator>
+    </ApplyIterator>
+    <CountCollectionIterator>
+      <PromoteIterator type="xs:string">
+        <FnDataIterator>
+          <CtxVarIterator varid="2" varname="coll" varkind="global"/>
+        </FnDataIterator>
+      </PromoteIterator>
+    </CountCollectionIterator>
+  </SequentialIterator>
+</SequentialIterator>
+
+Iterator tree for ddl:create:
+<ZorbaCreateCollectionIterator>
+  <FunctionTraceIterator>
+    <QNameIterator>
+      <LetVarIterator varname="coll-name"/>
+      <SingletonIterator value="xs:string(zorba-internal-name-for-w3c-collections)"/>
+    </QNameIterator>
+  </FunctionTraceIterator>
+</ZorbaCreateCollectionIterator>
+

=== added file 'test/rbkt/ExpQueryResults/zorba/collections/count_dynamic_zorba_collection.xml.res'
--- test/rbkt/ExpQueryResults/zorba/collections/count_dynamic_zorba_collection.xml.res	1970-01-01 00:00:00 +0000
+++ test/rbkt/ExpQueryResults/zorba/collections/count_dynamic_zorba_collection.xml.res	2011-10-21 00:32:19 +0000
@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+0
\ No newline at end of file

=== added file 'test/rbkt/ExpQueryResults/zorba/collections/count_static_zorba_collection.xml.res'
--- test/rbkt/ExpQueryResults/zorba/collections/count_static_zorba_collection.xml.res	1970-01-01 00:00:00 +0000
+++ test/rbkt/ExpQueryResults/zorba/collections/count_static_zorba_collection.xml.res	2011-10-21 00:32:19 +0000
@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+0
\ No newline at end of file

=== added file 'test/rbkt/ExpQueryResults/zorba/collections/count_w3c_collection.xml.res'
--- test/rbkt/ExpQueryResults/zorba/collections/count_w3c_collection.xml.res	1970-01-01 00:00:00 +0000
+++ test/rbkt/ExpQueryResults/zorba/collections/count_w3c_collection.xml.res	2011-10-21 00:32:19 +0000
@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+0
\ No newline at end of file

=== added file 'test/rbkt/Queries/zorba/collections/count_dynamic_zorba_collection.xq'
--- test/rbkt/Queries/zorba/collections/count_dynamic_zorba_collection.xq	1970-01-01 00:00:00 +0000
+++ test/rbkt/Queries/zorba/collections/count_dynamic_zorba_collection.xq	2011-10-21 00:32:19 +0000
@@ -0,0 +1,10 @@
+import module namespace ddl =
+    "http://www.zorba-xquery.com/modules/store/dynamic/collections/ddl";
+import module namespace dml =
+    "http://www.zorba-xquery.com/modules/store/dynamic/collections/dml";
+
+declare variable $coll := xs:QName("collection");
+
+ddl:create($coll);
+
+fn:count(dml:collection($coll))

=== added file 'test/rbkt/Queries/zorba/collections/count_static_zorba_collection.xq'
--- test/rbkt/Queries/zorba/collections/count_static_zorba_collection.xq	1970-01-01 00:00:00 +0000
+++ test/rbkt/Queries/zorba/collections/count_static_zorba_collection.xq	2011-10-21 00:32:19 +0000
@@ -0,0 +1,14 @@
+import module namespace ddl =
+    "http://www.zorba-xquery.com/modules/store/static/collections/ddl";
+
+import module namespace dml =
+    "http://www.zorba-xquery.com/modules/store/static/collections/dml";
+
+import module namespace ns = "http://example.org/datamodule/" 
+    at "collections.xqdata";
+
+declare variable $coll := xs:QName("ns:test1");
+
+ddl:create($coll);
+
+fn:count(dml:collection($coll))

=== added file 'test/rbkt/Queries/zorba/collections/count_w3c_collection.xq'
--- test/rbkt/Queries/zorba/collections/count_w3c_collection.xq	1970-01-01 00:00:00 +0000
+++ test/rbkt/Queries/zorba/collections/count_w3c_collection.xq	2011-10-21 00:32:19 +0000
@@ -0,0 +1,8 @@
+import module namespace ddl =
+    "http://www.zorba-xquery.com/modules/store/dynamic/collections/w3c/ddl";
+
+declare variable $coll := "http://www.zorba-xquery.com/collection";
+
+ddl:create($coll);
+
+fn:count(fn:collection($coll))