Merge lp:~zorba-coders/zorba/markos-scratch into lp:zorba

[Markos Zaharioudakis]

Optimized implementation of function caching and removed the restriction on the return type.

Optimized implementation of function caching and removed the restriction on the return type.

[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/markos-scratch-2013-06-15T23-03-13.979Z/log.html

[Zorba Build Bot (zorba-buildbot)]

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

CMake Error at /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake:281 (message):
  Validation queue job markos-scratch-2013-06-15T23-03-13.979Z is finished.
  The final status was:

  No tests were run - build or configure step must have failed.

  Not commiting changes.

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

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/markos-scratch-2013-06-15T23-34-46.252Z/log.html

[Zorba Build Bot (zorba-buildbot)]

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

CMake Error at /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake:281 (message):
  Validation queue job markos-scratch-2013-06-15T23-34-46.252Z is finished.
  The final status was:

  No tests were run - build or configure step must have failed.

  Not commiting changes.

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

[lp:~zorba-coders/zorba/markos-scratch]

11149. By Markos Zaharioudakis on 2013-06-16

added missing file

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/markos-scratch-2013-06-16T06-55-56.112Z/log.html

[Zorba Build Bot (zorba-buildbot)]

Validation queue job markos-scratch-2013-06-16T06-55-56.112Z is finished. The final status was:

All tests succeeded!

=== modified file 'ChangeLog'
--- ChangeLog	2013-06-14 05:20:13 +0000
+++ ChangeLog	2013-06-16 06:47:28 +0000
@@ -16,6 +16,8 @@
     if the FOR clause is followed by an orderby or groupby clause.
   * Replaced use of create_value_type() in runtime with getTypeCode().
   * Optimized switch expression
+  * Optimized implementation of function caching and removed the restriction
+    on the return type.
 
 Bug Fixes/Other Changes:
   * Fixed bug #1117952 (Improve XML error output format)

=== modified file 'src/functions/udf.cpp'
--- src/functions/udf.cpp	2013-05-08 20:14:47 +0000
+++ src/functions/udf.cpp	2013-06-16 06:47:28 +0000
@@ -651,14 +651,14 @@
   }
 
   // was the %ann:cache annotation given explicitly by the user
-  bool lExplicitCacheRequest =
+  bool explicitCacheRequest =
     (theAnnotationList ?
      theAnnotationList->contains(AnnotationInternal::zann_cache) :
      false);
 
   if (isVariadic())
   {
-    if (lExplicitCacheRequest)
+    if (explicitCacheRequest)
     {
       diag->add_warning(
       NEW_XQUERY_WARNING(zwarn::ZWST0005_CACHING_NOT_POSSIBLE,
@@ -668,27 +668,9 @@
     return;
   }
 
-  // parameter and return types are subtype of xs:anyAtomicType?
-  const xqtref_t& lRes = theSignature.returnType();
   TypeManager* tm = theBodyExpr->get_sctx()->get_typemanager();
 
-  if (!TypeOps::is_subtype(tm,
-                           *lRes,
-                           *GENV_TYPESYSTEM.ANY_ATOMIC_TYPE_ONE,
-                           theLoc))
-  {
-    if (lExplicitCacheRequest)
-    {
-      diag->add_warning(
-      NEW_XQUERY_WARNING(zwarn::ZWST0005_CACHING_NOT_POSSIBLE,
-      WARN_PARAMS(getName()->getStringValue(),
-                  ZED(ZWST0005_RETURN_TYPE),
-                  lRes->toString()),
-      WARN_LOC(theLoc)));
-    }
-    return;
-  }
-
+  // parameter and return types are subtype of xs:anyAtomicType
   csize lArity = theSignature.paramCount();
   for (csize i = 0; i < lArity; ++i)
   {
@@ -698,7 +680,7 @@
                              *GENV_TYPESYSTEM.ANY_ATOMIC_TYPE_ONE,
                              theLoc))
     {
-      if (lExplicitCacheRequest)
+      if (explicitCacheRequest)
       {
         diag->add_warning(
         NEW_XQUERY_WARNING(zwarn::ZWST0005_CACHING_NOT_POSSIBLE,
@@ -715,7 +697,7 @@
   // function updating?
   if (isUpdating())
   {
-    if (lExplicitCacheRequest)
+    if (explicitCacheRequest)
     {
       diag->add_warning(
       NEW_XQUERY_WARNING(zwarn::ZWST0005_CACHING_NOT_POSSIBLE,
@@ -727,7 +709,7 @@
 
   if (isSequential() || !isDeterministic())
   {
-    if (lExplicitCacheRequest)
+    if (explicitCacheRequest)
     {
       diag->add_warning(
       NEW_XQUERY_WARNING(zwarn::ZWST0006_CACHING_MIGHT_NOT_BE_INTENDED,
@@ -740,9 +722,8 @@
     return;
   }
 
-
   // optimization is prerequisite before invoking isRecursive
-  if (!lExplicitCacheRequest && isOptimized() && !isRecursive())
+  if (!explicitCacheRequest && isOptimized() && !isRecursive())
   {
     return;
   }

=== modified file 'src/runtime/core/fncall_iterator.cpp'
--- src/runtime/core/fncall_iterator.cpp	2013-04-24 01:35:58 +0000
+++ src/runtime/core/fncall_iterator.cpp	2013-06-16 06:47:28 +0000
@@ -55,6 +55,7 @@
 
 
 #ifdef ZORBA_WITH_DEBUGGER
+
 #include "debugger/debugger_commons.h"
 
 #define DEBUGGER_COMMONS state->thePlanState->theDebuggerCommons
@@ -78,6 +79,12 @@
   if (DEBUGGER_COMMONS) {                                     \
     DEBUGGER_COMMONS->popStackFrame();                        \
   }
+
+#else
+
+#define DEBUGGER_PUSH_FRAME
+#define DEBUGGER_POP_FRAME
+
 #endif
 
 namespace zorba {
@@ -179,8 +186,6 @@
   {
     thePlan->reset(*thePlanState);
   }
-
-  theArgValues.clear();
 }
 
 
@@ -244,34 +249,45 @@
     PlanState& planState,
     UDFunctionCallIteratorState* state)
 {
-  store::Index_t lIndex = theUDF->getCache();
-
-  if (!lIndex && theUDF->cacheResults())
+  if (theUDF->cacheResults())
   {
-    const signature& sig = theUDF->getSignature();
+    store::Index_t index = theUDF->getCache();
 
     csize numArgs = theChildren.size();
 
-    store::IndexSpecification lSpec;
-    lSpec.theNumKeyColumns = numArgs;
-    lSpec.theKeyTypes.resize(numArgs);
-    lSpec.theCollations.resize(numArgs);
-    lSpec.theIsTemp = true;
-    lSpec.theIsUnique = true;
+    if (!index)
+    {
+      const signature& sig = theUDF->getSignature();
+
+      store::IndexSpecification lSpec;
+      lSpec.theNumKeyColumns = numArgs;
+      lSpec.theKeyTypes.resize(numArgs);
+      lSpec.theCollations.resize(numArgs);
+      lSpec.theIsTemp = true;
+      lSpec.theIsUnique = false;
+
+      for (csize i = 0; i < numArgs; ++i)
+      {
+        lSpec.theKeyTypes[i] = sig[i]->getBaseBuiltinType()->getQName().getp();
+      }
+
+      index = GENV_STORE.createIndex(theUDF->getName(), lSpec, 0);
+
+      theUDF->setCache(index.getp()); // cache the cache in the function itself
+
+      state->theArgValues.reserve(numArgs);
+    }
+
+    state->theCache = index.getp();
+    state->theCacheCond = index->createCondition(store::IndexCondition::POINT_VALUE);
+    state->theCacheProbeIte = GENV_ITERATOR_FACTORY->createIndexProbeIterator(index);
+    state->theArgValues.resize(numArgs);
 
     for (csize i = 0; i < numArgs; ++i)
     {
-      lSpec.theKeyTypes[i] = sig[i]->getBaseBuiltinType()->getQName().getp();
+      state->theArgValues[i] = new SingleItemIterator();
     }
-
-    lIndex = GENV_STORE.createIndex(theUDF->getName(), lSpec, 0);
-
-    theUDF->setCache(lIndex.getp()); // cache the cache in the function itself
-
-    state->theArgValues.reserve(numArgs);
   }
-
-  state->theCache = lIndex.getp();
 }
 
 
@@ -284,11 +300,9 @@
     store::Item_t& result,
     std::vector<store::Item_t>& argValues) const
 {
-  if (!state->theCache)
-    return false;
+  assert(state->theCache);
 
-  store::IndexCondition_t cond =
-  state->theCache->createCondition(store::IndexCondition::POINT_VALUE);
+  state->theCacheCond->clear();
 
   std::vector<store::Iterator_t>::iterator ite = state->theArgWrappers.begin();
 
@@ -296,21 +310,21 @@
   {
     store::Iterator_t& argWrapper = (*ite);
     store::Item_t argValue;
+
     if (argWrapper) // might be 0 if argument is not used
     {
       argWrapper->next(argValue); // guaranteed to have exactly one result
     }
+
     argValues.push_back(argValue);
-    cond->pushItem(argValue);
+
+    state->theCacheCond->pushItem(argValue);
   }
 
-  store::IndexProbeIterator_t probeIte = 
-  GENV_STORE.getIteratorFactory()->createIndexProbeIterator(state->theCache);
-
-  probeIte->init(cond);
-  probeIte->open();
-
-  return probeIte->next(result);
+  state->theCacheProbeIte->init(state->theCacheCond);
+  state->theCacheProbeIte->open();
+
+  return state->theCacheProbeIte->next(result);
 }
 
 
@@ -320,18 +334,22 @@
 void UDFunctionCallIterator::insertCacheEntry(
   UDFunctionCallIteratorState* state,
   std::vector<store::Item_t>& argValues,
-  store::Item_t& udfValue) const
+  const store::Item_t& udfResult) const
 {
-  if (state->theCache)
-  {
-    std::auto_ptr<store::IndexKey> k(new store::IndexKey());
-    store::IndexKey* k2 = k.get();
-    k->theItems = argValues;
-    store::Item_t lTmp = udfValue; // insert will eventually transfer the Item_t
-    if (!state->theCache->insert(k2, lTmp))
-    {
-      k.release();
-    }
+  assert(state->theCache);
+
+  state->theCacheKey = new store::IndexKey();
+  state->theCacheKey->theItems.swap(argValues);
+  store::Item_t tmp = udfResult;
+
+  try
+  {
+    ZORBA_ASSERT(!state->theCache->insert(state->theCacheKey, tmp));
+  }
+  catch (...)
+  {
+    delete state->theCacheKey;
+    throw;
   }
 }
 
@@ -449,8 +467,9 @@
 {
   try
   {
-    std::vector<store::Item_t> lKey;
-    bool lCacheHit;
+    std::vector<store::Item_t> argValues;
+    bool cacheHit;
+    store::Item_t tmp;
 
     UDFunctionCallIteratorState* state;
     DEFAULT_STACK_INIT(UDFunctionCallIteratorState, state, planState);
@@ -465,82 +484,133 @@
       state->thePlanOpen = true;
     }
 
-    // check if there is a cache and the result is already in the cache
-    lCacheHit = probeCache(planState, state, result, lKey);
-
-    // if not in the cache, we bind the arguments to the function
-    if (!lCacheHit)
-    {
-      const std::vector<ArgVarRefs>& argsRefs = theUDF->getArgVarsRefs();
-      const std::vector<store::Iterator_t>& argWraps = state->theArgWrappers;
-
-      for (size_t i = 0; i < argsRefs.size(); ++i)
-      {
-        if (argWraps[i] != NULL)
-        {
-          const ArgVarRefs& argVarRefs = argsRefs[i];
-          store::Iterator_t argWrapper;
-          if (state->theCache)
-          {
-            std::vector<store::Item_t> lParam(1, lKey[i]);
-            state->theArgValues.push_back(GENV_STORE.createTempSeq(lParam));
-            argWrapper = state->theArgValues.back()->getIterator();
-            argWrapper->open();
-          }
-          else
-          {
+    if (state->theCache)
+    {
+      // check if the result is already in the cache
+      cacheHit = probeCache(planState, state, result, argValues);
+
+      // if not in the cache, we bind the arguments to the function
+      if (!cacheHit)
+      {
+        const std::vector<ArgVarRefs>& argsRefs = theUDF->getArgVarsRefs();
+        const std::vector<store::Iterator_t>& argWraps = state->theArgWrappers;
+
+        for (csize i = 0; i < argsRefs.size(); ++i)
+        {
+          if (argWraps[i] != NULL)
+          {
+            const ArgVarRefs& argVarRefs = argsRefs[i];
+            store::Iterator_t argWrapper;
+            
+            store::Item_t argValue = argValues[i];
+            state->theArgValues[i]->init(argValue);
+            argWrapper = state->theArgValues[i];
+
+            ArgVarRefs::const_iterator argVarRefsIte = argVarRefs.begin();
+            ArgVarRefs::const_iterator argVarRefsEnd = argVarRefs.end();
+
+            for (; argVarRefsIte != argVarRefsEnd; ++argVarRefsIte)
+            {
+              const LetVarIter_t& argRef = (*argVarRefsIte);
+              assert(argRef != NULL);
+              
+              if (argRef != NULL)
+              {
+                argRef->bind(argWrapper, *state->thePlanState);
+              }
+            }
+          }
+        }
+      }
+
+      if (!cacheHit)
+      {
+        DEBUGGER_PUSH_FRAME;
+
+        if (consumeNext(result, state->thePlan, *state->thePlanState))
+        {
+          insertCacheEntry(state, argValues, result);
+
+          DEBUGGER_POP_FRAME;
+          STACK_PUSH(true, state);
+          DEBUGGER_PUSH_FRAME;
+
+          while (consumeNext(result, state->thePlan, *state->thePlanState))
+          {
+            tmp = result;
+            ZORBA_ASSERT(state->theCache->insert(state->theCacheKey, tmp));
+
+            DEBUGGER_POP_FRAME;
+            STACK_PUSH(true, state);
+            DEBUGGER_PUSH_FRAME;
+          }
+        }
+        else
+        {
+          insertCacheEntry(state, argValues, NULL);
+        }
+
+        DEBUGGER_POP_FRAME;
+      }
+      else // cache hit
+      {
+        if (result != NULL)
+        {
+          STACK_PUSH(true, state);
+
+          while (state->theCacheProbeIte->next(result))
+          {
+            STACK_PUSH(true, state);
+          }
+        }
+      }
+    }
+    else // no cache
+    {
+      {
+        const std::vector<ArgVarRefs>& argsRefs = theUDF->getArgVarsRefs();
+        const std::vector<store::Iterator_t>& argWraps = state->theArgWrappers;
+
+        for (csize i = 0; i < argsRefs.size(); ++i)
+        {
+          if (argWraps[i] != NULL)
+          {
+            const ArgVarRefs& argVarRefs = argsRefs[i];
+            store::Iterator_t argWrapper;
+
             if (i < argWraps.size())
               argWrapper = argWraps[i];
-          }
-
-          ArgVarRefs::const_iterator argVarRefsIte = argVarRefs.begin();
-          ArgVarRefs::const_iterator argVarRefsEnd = argVarRefs.end();
-
-          for (; argVarRefsIte != argVarRefsEnd; ++argVarRefsIte)
-          {
-            const LetVarIter_t& argRef = (*argVarRefsIte);
-            assert(argRef != NULL);
-            
-            if (argRef != NULL)
+
+            ArgVarRefs::const_iterator argVarRefsIte = argVarRefs.begin();
+            ArgVarRefs::const_iterator argVarRefsEnd = argVarRefs.end();
+
+            for (; argVarRefsIte != argVarRefsEnd; ++argVarRefsIte)
             {
-              argRef->bind(argWrapper, *state->thePlanState);
+              const LetVarIter_t& argRef = (*argVarRefsIte);
+              assert(argRef != NULL);
+              
+              if (argRef != NULL)
+              {
+                argRef->bind(argWrapper, *state->thePlanState);
+              }
             }
           }
         }
       }
-    }
 
-    if (lCacheHit)
-    {
-      STACK_PUSH(true, state);
-    }
-    else
-    {
-#ifdef ZORBA_WITH_DEBUGGER
       DEBUGGER_PUSH_FRAME;
-#endif
+
       while (consumeNext(result, state->thePlan, *state->thePlanState))
       {
-#ifdef ZORBA_WITH_DEBUGGER
         DEBUGGER_POP_FRAME;
-#endif
-
-        insertCacheEntry(state, lKey, result);
         STACK_PUSH(true, state);
-
-#ifdef ZORBA_WITH_DEBUGGER
         DEBUGGER_PUSH_FRAME;
-#endif
       }
 
-#ifdef ZORBA_WITH_DEBUGGER
       DEBUGGER_POP_FRAME;
-#endif
-
     }
 
     STACK_END(state);
-
   }
   catch (ZorbaException& err)
   {

=== modified file 'src/runtime/core/fncall_iterator.h'
--- src/runtime/core/fncall_iterator.h	2013-05-25 14:36:27 +0000
+++ src/runtime/core/fncall_iterator.h	2013-06-16 06:47:28 +0000
@@ -23,6 +23,7 @@
 #include "common/shared_types.h"
 
 #include "runtime/hof/function_item.h"
+#include "runtime/util/single_item_iterator.h"
 
 #include "context/static_context.h"
 
@@ -93,15 +94,21 @@
 class UDFunctionCallIteratorState : public PlanIteratorState 
 {
 public:
-  dynamic_context                * theLocalDCtx;
-  bool                             theIsLocalDCtxOwner;
-  PlanIter_t                       thePlan;
-  PlanState                      * thePlanState;
-  bool                             thePlanOpen;
-  uint32_t                         thePlanStateSize;
-  std::vector<store::Iterator_t>   theArgWrappers;
-  store::Index                   * theCache;
-  std::vector<store::TempSeq_t>    theArgValues;
+  dynamic_context                  * theLocalDCtx;
+  bool                               theIsLocalDCtxOwner;
+
+  PlanIter_t                         thePlan;
+  PlanState                        * thePlanState;
+  bool                               thePlanOpen;
+  uint32_t                           thePlanStateSize;
+
+  std::vector<store::Iterator_t>     theArgWrappers;
+
+  store::Index                     * theCache;
+  store::IndexKey                  * theCacheKey;
+  store::IndexCondition_t            theCacheCond;
+  store::IndexProbeIterator_t        theCacheProbeIte;
+  std::vector<SingleItemIterator_t>  theArgValues;
 
   UDFunctionCallIteratorState();
 
@@ -194,7 +201,7 @@
   void insertCacheEntry(
     UDFunctionCallIteratorState* state,
     std::vector<store::Item_t>& argValues,
-    store::Item_t& udfValue) const;
+    const store::Item_t& udfResult) const;
 };
 
 

=== modified file 'src/runtime/util/item_iterator.cpp'
--- src/runtime/util/item_iterator.cpp	2013-03-04 21:00:58 +0000
+++ src/runtime/util/item_iterator.cpp	2013-06-16 06:47:28 +0000
@@ -20,7 +20,7 @@
 
 namespace zorba { 
 
-ItemIterator::ItemIterator(std::vector<store::Item_t> const &aItems) 
+ItemIterator::ItemIterator(const std::vector<store::Item_t>& aItems) 
   :
   theItems(aItems)
 {

=== modified file 'src/runtime/util/item_iterator.h'
--- src/runtime/util/item_iterator.h	2013-03-05 00:45:43 +0000
+++ src/runtime/util/item_iterator.h	2013-06-16 06:47:28 +0000
@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#ifndef ZORBA_RUNTIME_ITEM_ITERATOR_H2
-#define ZORBA_RUNTIME_ITEM_ITERATOR_H2
+#ifndef ZORBA_RUNTIME_UTIL_ITEM_ITERATOR
+#define ZORBA_RUNTIME_UTIL_ITEM_ITERATOR
 
 #include <vector>
 #include "store/api/iterator.h"
@@ -25,12 +25,14 @@
 class ItemIterator : public store::Iterator
 {
 private:
-  std::vector<store::Item_t> theItems;
+  std::vector<store::Item_t>           theItems;
   std::vector<store::Item_t>::iterator theIterator;
 
 public:
-  ItemIterator(std::vector<store::Item_t> const &aItems);
+  ItemIterator(const std::vector<store::Item_t>& aItems);
+
   ItemIterator(store::Item_t aItem);
+
   ItemIterator(); // construct the empty sequence
 
   virtual ~ItemIterator(){}

=== added file 'src/runtime/util/single_item_iterator.h'
--- src/runtime/util/single_item_iterator.h	1970-01-01 00:00:00 +0000
+++ src/runtime/util/single_item_iterator.h	2013-06-16 06:47:28 +0000
@@ -0,0 +1,80 @@
+/*
+ * 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.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef ZORBA_RUNTIME_UTIL_SINGLE_ITEM_ITERATOR
+#define ZORBA_RUNTIME_UTIL_SINGLE_ITEM_ITERATOR
+
+#include <vector>
+
+#include "store/api/iterator.h"
+
+#include "common/shared_types.h"
+
+namespace zorba
+{ 
+
+class SingleItemIterator : public store::Iterator
+{
+private:
+  store::Item_t theItem;
+  bool          theIsDone;
+
+public:
+  SingleItemIterator() : theIsDone(true) {}
+
+  SingleItemIterator(store::Item_t& item)
+  {
+    theIsDone = false;
+    theItem.transfer(item);
+  } 
+
+  virtual ~SingleItemIterator() {}
+
+  void init(store::Item_t& item)
+  {
+    theIsDone = false;
+    theItem.transfer(item);
+  }
+
+  void open() {}
+
+  bool next(store::Item_t& res) 
+  {
+    if (theIsDone)
+      return false;
+
+    res = theItem;
+    theIsDone = true;
+    return true;
+  }
+
+  void reset() { theIsDone = (theItem == NULL); }
+
+  void close() { theItem = NULL; theIsDone = true; }
+
+#ifndef NDEBUG
+  // toString() debugging method.
+  virtual std::string toString() const { return ""; };
+#endif      
+};
+
+
+typedef rchandle<SingleItemIterator> SingleItemIterator_t;
+
+
+} // namespace zorba
+
+#endif
+/* vim:set et sw=2 ts=2: */

=== added file 'test/rbkt/ExpQueryResults/zorba/udf/cache01.xml.res'
--- test/rbkt/ExpQueryResults/zorba/udf/cache01.xml.res	1970-01-01 00:00:00 +0000
+++ test/rbkt/ExpQueryResults/zorba/udf/cache01.xml.res	2013-06-16 06:47:28 +0000
@@ -0,0 +1,6 @@
+4 
+ 
+ 4 
+ 
+ 22  ==  484 
+ 22  ==  484 

=== added file 'test/rbkt/ExpQueryResults/zorba/udf/cache_01.xml.res'
--- test/rbkt/ExpQueryResults/zorba/udf/cache_01.xml.res	1970-01-01 00:00:00 +0000
+++ test/rbkt/ExpQueryResults/zorba/udf/cache_01.xml.res	2013-06-16 06:47:28 +0000
@@ -0,0 +1,6 @@
+4 
+ 
+ 4 
+ 
+ 22  ==  484 
+ 22  ==  484 

=== added file 'test/rbkt/Queries/zorba/udf/cache_01.xq'
--- test/rbkt/Queries/zorba/udf/cache_01.xq	1970-01-01 00:00:00 +0000
+++ test/rbkt/Queries/zorba/udf/cache_01.xq	2013-06-16 06:47:28 +0000
@@ -0,0 +1,37 @@
+
+declare namespace ann = "http://www.zorba-xquery.com/annotations";
+
+declare function local:dummy()
+{
+  ()
+};
+
+
+declare %ann:cache function local:foo($x as xs:integer)
+{
+  if ($x < 10)
+  then $x * $x
+  else if ($x < 20)
+  then local:dummy()
+  else ($x, " == ", $x * $x)
+};
+
+
+local:foo(2),
+"
+",
+local:foo(12),
+"
+",
+local:foo(2),
+"
+",
+local:foo(12),
+"
+",
+local:foo(22),
+"
+",
+local:foo(22),
+"
+"