Merge lp:~zorba-coders/zorba/bug1123016 into lp:zorba

[Juan Zacarias]

Implmentation of two new functions for xqxq module xqxq:query-plan and xqxq:load-from-query-plan

Implmentation of two new functions for xqxq module xqxq:query-plan and xqxq:load-from-query-plan

[Matthias Brantner (matthias-brantner)]

- nice job
- comments of the functions in xqxq.xq are missing
- std::stringstream* lExcPlan = new std::stringstream();
  will leak if saveExecutionPlan returns false or raises an error. You should use an auto_ptr or something similar
- Chris do you have ideas for better/nicer function names?

review: Needs Fixing

[Juan Zacarias (juan457)]

I added the comments and changed std::stringstream to an auto_ptr.

For names of the function something simple like xqxq:get-serialized-query and xqxq:load-serialized-query could work in my opnion

[Matthias Brantner (matthias-brantner)]

- in the documentation, I wouldn't use the word serialized because it's heavily overloaded
- xs:Base64Binary => xs:base64Binary
- why does the xqxq:query-plan function raise xqxq:UnboundVariable or xqxq:UndeclaredVariable?

[Matthias Brantner (matthias-brantner)]

review: Needs Fixing

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug1123016-2013-03-26T01-17-05.571Z/log.html

[Zorba Build Bot (zorba-buildbot)]

Validation queue job bug1123016-2013-03-26T01-17-05.571Z is finished. The final status was:

All tests succeeded!

[Zorba Build Bot (zorba-buildbot)]

Voting does not meet specified criteria. Required: Approve > 1, Disapprove < 1, Needs Fixing < 1, Pending < 1, Needs Information < 1, Resubmit < 1. Got: 1 Needs Fixing, 1 Pending.

[Juan Zacarias (juan457)]

> - in the documentation, I wouldn't use the word serialized because it's
> heavily overloaded
I removed the world serialized and just mentioned it was being returned as xs:base64binary.

> - xs:Base64Binary => xs:base64Binary
typo corrected.

> - why does the xqxq:query-plan function raise xqxq:UnboundVariable or
> xqxq:UndeclaredVariable?
Sorry this was an error, I copied the comments from another function to keep the comment and forgot to remove the extra errors. This was removed from the documentation.

[Matthias Brantner (matthias-brantner)]

review: Approve

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug1123016-2013-03-27T15-09-04.172Z/log.html

[Zorba Build Bot (zorba-buildbot)]

Validation queue job bug1123016-2013-03-27T15-09-04.172Z is finished. The final status was:

All tests succeeded!

[Zorba Build Bot (zorba-buildbot)]

Voting does not meet specified criteria. Required: Approve > 1, Disapprove < 1, Needs Fixing < 1, Pending < 1, Needs Information < 1, Resubmit < 1. Got: 1 Approve, 1 Pending.

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug1123016-2013-04-09T14-40-52.746Z/log.html

[Zorba Build Bot (zorba-buildbot)]

Validation queue job bug1123016-2013-04-09T14-40-52.746Z is finished. The final status was:

All tests succeeded!

[Zorba Build Bot (zorba-buildbot)]

Voting does not meet specified criteria. Required: Approve > 1, Disapprove < 1, Needs Fixing < 1, Pending < 1, Needs Information < 1, Resubmit < 1. Got: 1 Approve, 1 Pending.

[Chris Hillery (ceejatec)]

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.

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug1123016-2013-04-09T23-53-53.996Z/log.html

[Zorba Build Bot (zorba-buildbot)]

Validation queue job bug1123016-2013-04-09T23-53-53.996Z is finished. The final status was:

All tests succeeded!

=== modified file 'modules/xqxq/CMakeLists.txt'
--- modules/xqxq/CMakeLists.txt	2012-10-25 00:07:03 +0000
+++ modules/xqxq/CMakeLists.txt	2013-04-09 23:43:20 +0000
@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-DECLARE_ZORBA_MODULE (URI "http://www.zorba-xquery.com/modules/xqxq" VERSION 1.0 FILE "xqxq.xq")
 \ No newline at end of file
+DECLARE_ZORBA_MODULE (URI "http://www.zorba-xquery.com/modules/xqxq" VERSION 2.0 FILE "xqxq.xq")
 \ No newline at end of file
 
=== modified file 'modules/xqxq/xqxq.xq'
--- modules/xqxq/xqxq.xq	2013-03-15 18:25:44 +0000
+++ modules/xqxq/xqxq.xq	2013-04-09 23:43:20 +0000
@@ -30,7 +30,7 @@
 declare namespace op = "http://www.zorba-xquery.com/options/features";
 declare namespace f = "http://www.zorba-xquery.com/features";
 
-declare option ver:module-version "1.0";
+declare option ver:module-version "2.0";
 
 (:~
  : The function prepares a given XQuery program for execution.
@@ -386,6 +386,80 @@
 declare function xqxq:variable-value($query-key as xs:anyURI, $var-name as 
   xs:QName) as item()* external;
 
+(:~
+ : Returns the compiled query identified by the given query-key 
+ : as binary data.
+ :
+ : @param $query-key the identifier of a compiled query.
+ :
+ : @return the query as xs:base64Binary.
+ :
+ : @error xqxq:NoQueryMatch if no query with the given identifier
+ :   was prepared.
+ : @error xqxq:QueryPlanError if there is an error serializing the query.
+ :)
+declare function xqxq:query-plan($query-key as xs:anyURI) 
+  as xs:base64Binary external;
+  
+  
+(:~
+ : The function loads a given XQuery program for execution from a 
+ : xs:base64Binary query plan, obtained through the xqxq:query-plan function.
+ : If the program was successfully loaded, the function returns an
+ : identifier as xs:anyURI. This URI can be passed to other functions
+ : of this module (e.g. to actually evaluate the program). The URI
+ : is opaque and its lifetime is bound by the lifetime of the XQuery
+ : program that invoked this function. Further reference or uses
+ : of the identifier lead to unexpected results.
+ :
+ : Successfully prepared queries need to be deleted by passing the resulting
+ : identifier to the xqxq:delete-query function of this module.
+ :
+ : @param $main-module-text the XQuery program that should be prepared.
+ :   The program needs to be a XQuery main module.
+ :
+ : @return an identifier for the compiled program that can be passed
+ :   as arguments to other functions of this module.
+ :
+ : @error any (static or type) error that may be raised during the compilation
+ : of the query. For example, err:XPST0003 if the given XQuery program could
+ : not be parsed.
+ :)    
+declare function xqxq:load-from-query-plan($plan as xs:base64Binary)
+  as xs:anyURI external;
+
+(:~
+ : The function loads a given XQuery program for execution from a 
+ : xs:base64Binary query plan, obtained through the xqxq:query-plan function.
+ : If the program was successfully loaded, the function returns an
+ : identifier as xs:anyURI. This URI can be passed to other functions
+ : of this module (e.g. to actually evaluate the program). The URI
+ : is opaque and its lilfetime is bound by the lifetime of the XQuery
+ : program that invoked this function. Further reference or uses
+ : of the identifier lead to unexpected results.
+ : 
+ : For important notes regarding the second and third parameters of the 
+ : function, review the comments in xqxq:prepare-main-module#3.
+ :
+ : Successfully prepared queries need to be deleted by passing the resulting
+ : identifier to the xqxq:delete-query function of this module.
+ :
+ : @param $main-module-text the XQuery program that should be prepared.
+ :   The program needs to be a XQuery main module.
+ :
+ : @param $resolver the URL resolver function.
+ : 
+ : @param $mapper the URI mapper function.
+ :
+ : @return an identifier for the compiled program that can be passed
+ :   as arguments to other functions of this module.
+ :
+ : @error any (static or type) error that may be raised during the compilation
+ : of the query. For example, err:XPST0003 if the given XQuery program could
+ : not be parsed.
+ :)  
+declare function xqxq:load-from-query-plan($plan as xs:base64Binary,
+  $resolver as item()?, $mapper as item()?) as xs:anyURI external;
 
 (:~
  : Internal helper function. Only necessary because of incomplete HOF
 
=== modified file 'modules/xqxq/xqxq.xq.src/xqxq.cpp'
--- modules/xqxq/xqxq.xq.src/xqxq.cpp	2013-03-13 16:17:38 +0000
+++ modules/xqxq/xqxq.xq.src/xqxq.cpp	2013-04-09 23:43:20 +0000
@@ -85,6 +85,14 @@
     {
       lFunc = new VariableValueFunction(this);
     }
+    else if (localName == "query-plan")
+    {
+      lFunc = new QueryPlanFunction(this);
+    }
+    else if (localName == "load-from-query-plan")
+    {
+      lFunc = new LoadFromQueryPlanFunction(this);
+    }
   }
   
   return lFunc;
@@ -325,7 +333,7 @@
 /*******************************************************************************
 
 ********************************************************************************/
-void  PrepareMainModuleFunction::XQXQURIMapper::mapURI(
+void  XQXQURIMapper::mapURI(
     String aUri,
     EntityData const* aEntityData,
     std::vector<String>& oUris)
@@ -376,7 +384,7 @@
 /*******************************************************************************
 
 ********************************************************************************/
-Resource* PrepareMainModuleFunction::XQXQURLResolver::resolveURL(
+Resource* XQXQURLResolver::resolveURL(
     const String& aUrl,
     EntityData const* aEntityData)
 { 
@@ -964,7 +972,127 @@
   }
 }
 
+/*******************************************************************************
+
+********************************************************************************/
+zorba::ItemSequence_t QueryPlanFunction::evaluate(
+    const Arguments_t& aArgs,
+    const zorba::StaticContext* aSctx,
+    const zorba::DynamicContext* aDctx) const 
+{
+  String lQueryID = XQXQFunction::getOneStringArgument(aArgs,0);
+
+  QueryMap* lQueryMap;
+  if (!(lQueryMap= dynamic_cast<QueryMap*>(aDctx->getExternalFunctionParameter("xqxqQueryMap"))))
+  {
+    throwError("NoQueryMatch", "String identifying query does not exists.");
+  }
+
+  XQuery_t lQuery = getQuery(aDctx, lQueryID);
+
+  std::auto_ptr<std::stringstream> lExcPlan;
+  lExcPlan.reset(new std::stringstream());
+  if (!lQuery->saveExecutionPlan(*lExcPlan.get(), ZORBA_USE_BINARY_ARCHIVE))
+  {
+    throwError("QueryPlanError", "FAILED getting query execution plan.");
+  }
+  
+  return ItemSequence_t(new SingletonItemSequence(XQXQModule::getItemFactory()->createStreamableBase64Binary(*lExcPlan.release(), &streamReleaser)));
+}
  
+
+/*******************************************************************************
+
+********************************************************************************/
+zorba::ItemSequence_t LoadFromQueryPlanFunction::evaluate(
+    const Arguments_t& aArgs,
+    const zorba::StaticContext* aSctx,
+    const zorba::DynamicContext* aDctx) const 
+{
+  Item lQueryPlanItem = XQXQFunction::getItemArgument(aArgs,0);
+  std::istream& lQueryPlanStream = lQueryPlanItem.getStream();
+
+  DynamicContext* lDynCtx = const_cast<DynamicContext*>(aDctx);
+  StaticContext_t lSctxChild = aSctx->createChildContext();
+   
+  QueryMap* lQueryMap;
+  if (!(lQueryMap = dynamic_cast<QueryMap*>(lDynCtx->getExternalFunctionParameter("xqxqQueryMap"))))
+  {
+    lQueryMap = new QueryMap();
+    lDynCtx->addExternalFunctionParameter("xqxqQueryMap", lQueryMap);     
+  }
+
+  Zorba* lZorba = Zorba::getInstance(0);
+  XQuery_t lQuery;
+  
+  std::auto_ptr<XQXQURLResolver> lResolver;
+  std::auto_ptr<XQXQURIMapper> lMapper;
+  try
+  {
+    lQuery = lZorba->createQuery();
+    if ( aArgs.size() > 2)
+    {
+      QueryPlanSerializationCallback lPlanSer;
+
+      Item lMapperFunctionItem = getItemArgument(aArgs, 2);
+      if (!lMapperFunctionItem.isNull())
+      {
+        lMapper.reset(new XQXQURIMapper(lMapperFunctionItem, lSctxChild));
+        lPlanSer.add_URIMapper(lMapper.get());
+      }
+
+      Item lResolverFunctionItem = getItemArgument(aArgs, 1);
+      if (!lResolverFunctionItem.isNull())
+      {
+        lResolver.reset(new XQXQURLResolver(lResolverFunctionItem, lSctxChild));
+        lPlanSer.add_URLResolver(lResolver.get());
+      }
+
+      lQuery->loadExecutionPlan(lQueryPlanStream, &lPlanSer);
+    }
+    else
+    { 
+      lQuery->loadExecutionPlan(lQueryPlanStream);
+    }
+  }
+  catch (XQueryException& xe)
+  {
+    lQuery = NULL;
+    std::ostringstream err;
+    err << "The query loaded from the query plan raised an error at"
+      << " file" << xe.source_uri() << " line" << xe.source_line()
+      << " column" << xe.source_column() << ": " << xe.what();
+    Item errQName = XQXQModule::getItemFactory()->createQName(
+      xe.diagnostic().qname().ns(),
+      xe.diagnostic().qname().localname());
+    throw USER_EXCEPTION(errQName, err.str());
+  }
+  catch (ZorbaException& ze)
+  {
+    lQuery = NULL;
+    std::ostringstream err;
+    if (ze.diagnostic() == zerr::ZCSE0013_UNABLE_TO_LOAD_QUERY)
+      err << "The query loaded from the query plan raised an error: failed to load pre-compiled query: document, collection, or module resolver required but not given.";
+    else
+      err << "The query loaded from the query plan raised an error: "<< ze.what();
+    Item errQName = XQXQModule::getItemFactory()->createQName(
+      ze.diagnostic().qname().ns(),
+      ze.diagnostic().qname().localname());
+    throw USER_EXCEPTION(errQName, err.str());
+  }
+
+  uuid lUUID;
+  uuid::create(&lUUID);
+
+  std::stringstream lStream;
+  lStream << lUUID;
+
+  String lStrUUID = lStream.str();
+
+  lQueryMap->storeQuery(lStrUUID, lQuery, lMapper.release(), lResolver.release());
+  return ItemSequence_t(new SingletonItemSequence(XQXQModule::getItemFactory()->createAnyURI(lStrUUID)));
+}
+
 }/*namespace xqxq*/ }/*namespace zorba*/
 
 #ifdef WIN32
 
=== modified file 'modules/xqxq/xqxq.xq.src/xqxq.h'
--- modules/xqxq/xqxq.xq.src/xqxq.h	2013-02-15 06:11:20 +0000
+++ modules/xqxq/xqxq.xq.src/xqxq.h	2013-04-09 23:43:20 +0000
@@ -7,6 +7,7 @@
 #include <zorba/external_module.h>
 #include <zorba/function.h>
 #include <zorba/dynamic_context.h>
+#include <zorba/serialization_callback.h>
 
 #define XQXQ_MODULE_NAMESPACE "http://www.zorba-xquery.com/modules/xqxq"
 
@@ -51,6 +52,52 @@
 
 
 /*******************************************************************************
+
+********************************************************************************/
+class XQXQURLResolver : public URLResolver
+{
+protected:
+  Item             theFunction;
+  StaticContext_t  theCtx;
+
+public:
+  XQXQURLResolver(Item& aFunction, StaticContext_t& aSctx)
+    :
+    URLResolver(),
+    theFunction(aFunction),
+    theCtx(aSctx)
+  {
+  }
+        
+  virtual ~XQXQURLResolver() { }
+      
+  virtual Resource* resolveURL(const String& url, EntityData const* entityData);
+};
+  
+
+class XQXQURIMapper : public URIMapper
+{
+protected:
+  Item            theFunction;
+  StaticContext_t theCtx;
+    
+public:
+  XQXQURIMapper(Item& aFunction, StaticContext_t& aSctx)
+    :
+    URIMapper(),
+    theFunction(aFunction),
+    theCtx(aSctx)
+  {
+  }
+    
+  virtual ~XQXQURIMapper(){ }
+    
+  virtual void mapURI(
+    const zorba::String aUri,
+    EntityData const* aEntityData,
+    std::vector<zorba::String>& oUris);
+};
+/*******************************************************************************
   Bag class for objects associated with a prepared query
 ********************************************************************************/
 class QueryData : public SmartObject
@@ -144,52 +191,6 @@
   evaluate(const Arguments_t&,
            const zorba::StaticContext*,
            const zorba::DynamicContext*) const;
-  
-protected:
-  
-  class XQXQURLResolver : public URLResolver
-  {
-  protected:
-    Item             theFunction;
-    StaticContext_t  theCtx;
-
-  public:
-    XQXQURLResolver(Item& aFunction, StaticContext_t& aSctx)
-      :
-      URLResolver(),
-      theFunction(aFunction),
-      theCtx(aSctx)
-    {
-    }
-        
-    virtual ~XQXQURLResolver() { }
-      
-    virtual Resource* resolveURL(const String& url, EntityData const* entityData);
-  };
-  
-
-  class XQXQURIMapper : public URIMapper
-  {
-  protected:
-    Item            theFunction;
-    StaticContext_t theCtx;
-    
-  public:
-    XQXQURIMapper(Item& aFunction, StaticContext_t& aSctx)
-      :
-      URIMapper(),
-      theFunction(aFunction),
-      theCtx(aSctx)
-    {
-    }
-    
-    virtual ~XQXQURIMapper(){ }
-    
-    virtual void mapURI(
-      const zorba::String aUri,
-      EntityData const* aEntityData,
-      std::vector<zorba::String>& oUris);
-  };
 };
 
 
@@ -561,7 +562,87 @@
                  const zorba::DynamicContext*) const;
   };
 
-
+/*******************************************************************************
+
+********************************************************************************/
+class QueryPlanFunction : public XQXQFunction
+{
+public:
+  QueryPlanFunction(const XQXQModule* aModule) : XQXQFunction(aModule) {}
+
+  virtual ~QueryPlanFunction() {}
+
+  virtual zorba::String
+  getLocalName() const {return "query-plan"; }
+
+  virtual zorba::ItemSequence_t
+  evaluate(const Arguments_t&,
+           const zorba::StaticContext*,
+           const zorba::DynamicContext*) const;
+  
+  virtual String getURI() const {
+    return theModule->getURI();
+  }
+  
+protected:
+  const XQXQModule* theModule;
+};
+
+
+/*******************************************************************************
+
+********************************************************************************/
+class LoadFromQueryPlanFunction : public XQXQFunction
+{
+public:
+  LoadFromQueryPlanFunction(const XQXQModule* aModule) : XQXQFunction(aModule) {}
+
+  virtual ~LoadFromQueryPlanFunction() {}
+
+  virtual zorba::String
+  getLocalName() const {return "load-from-query-plan"; }
+
+  virtual zorba::ItemSequence_t
+  evaluate(const Arguments_t&,
+           const zorba::StaticContext*,
+           const zorba::DynamicContext*) const;
+  
+  virtual String getURI() const {
+    return theModule->getURI();
+  }
+  
+protected:
+  const XQXQModule* theModule;
+
+  class QueryPlanSerializationCallback : public zorba::SerializationCallback
+  {
+    std::vector<URIMapper*> theUriMappers;
+    std::vector<URLResolver*>theUrlResolvers;
+
+  public:
+    QueryPlanSerializationCallback()
+    {
+    }
+
+    virtual ~QueryPlanSerializationCallback() {}
+
+    void add_URIMapper(URIMapper* aMapper)
+    {
+      theUriMappers.push_back(aMapper);
+    }
+
+    void add_URLResolver(URLResolver* aResolver)
+    {
+      theUrlResolvers.push_back(aResolver);
+    }
+
+    virtual URIMapper*
+      getURIMapper(size_t  i ) const { return theUriMappers.size() < i? NULL : theUriMappers[i]; }
+
+    virtual URLResolver*
+    getURLResolver(size_t i) const { return theUrlResolvers.size() < i? NULL : theUrlResolvers[i]; }
+  };
+};
 }/*xqxq namespace*/}/*zorba namespace*/
 
 
 
=== modified file 'src/compiler/api/compilercb.cpp'
--- src/compiler/api/compilercb.cpp	2013-03-22 00:49:51 +0000
+++ src/compiler/api/compilercb.cpp	2013-04-09 23:43:20 +0000
@@ -199,6 +199,7 @@
   ar & theIsEval;
   ar & theIsLoadProlog;
   ar & theIsUpdating;
+  ar & theIsSequential;
   ar & theSctxMap;
   ar & theRootSctx;
 #ifdef ZORBA_WITH_DEBUGGER
 
=== modified file 'test/fots/CMakeLists.txt'
--- test/fots/CMakeLists.txt	2013-04-08 22:59:58 +0000
+++ test/fots/CMakeLists.txt	2013-04-09 23:43:20 +0000
@@ -17,7 +17,9 @@
   COMMAND "${CMAKE_COMMAND}" 
   -D "ZORBA=${ZORBA_EXE}"
   -D "BUILDDIR=${PROJECT_BINARY_DIR}"
-  -P "${CMAKE_CURRENT_SOURCE_DIR}/ImportFOTS.cmake")
+  -P "${CMAKE_CURRENT_SOURCE_DIR}/ImportFOTS.cmake"
+  COMMAND "${CMAKE_COMMAND}" "${PROJECT_SOURCE_DIR}"
+  WORKING_DIRECTORY "${PROJECT_BINARY_DIR}")
 
 # Create cached version of activate setting
 SET (ZORBA_FOTS_ACTIVATE inactive CACHE STRING "Which FOTS tests to activate")
 
=== modified file 'test/fots/ImportFOTS.cmake'
--- test/fots/ImportFOTS.cmake	2013-04-09 15:17:58 +0000
+++ test/fots/ImportFOTS.cmake	2013-04-09 23:43:20 +0000
@@ -82,6 +82,7 @@
     "-e mode:=run-test-set -e testSetName:=${_testset} "
     "-e expectedFailuresPath:=${BUILDDIR}/FOTSExpectedFailures.xml "
     "-e verbose:=true "
+    "-e usePlanSerializer:=true "
     "--disable-http-resolution --indent "
     "-z \"cdata-section-elements=${FOTS_CDATA_ELEMENTS}\")\n"
     "ZORBA_SET_TEST_PROPERTY (FOTS/${_testset} "
@@ -109,6 +110,7 @@
       "-e testSetName:=${_testset} -e testCaseName:=${_testcase} "
       "-e expectedFailuresPath:=${BUILDDIR}/FOTSExpectedFailures.xml "
       "-e verbose:=true "
+      "-e usePlanSerializer:=true "
       "--disable-http-resolution --indent "
       "-z \"cdata-section-elements=${FOTS_CDATA_ELEMENTS}\")\n"
       "ZORBA_SET_TEST_PROPERTY (FOTS/${_testset}/${_testcase} "
 
=== modified file 'test/fots/get-tests.xq'
--- test/fots/get-tests.xq	2012-12-05 09:12:38 +0000
+++ test/fots/get-tests.xq	2013-04-09 23:43:20 +0000
@@ -16,7 +16,6 @@
 
 declare namespace c = "http://www.w3.org/2010/09/qt-fots-catalog";
 
-declare variable $fotsPath as xs:string external := "";
 declare variable $testSet as xs:string external := "";
 
 let $catalog := fn:doc(fn:static-base-uri())/c:catalog
 
=== modified file 'test/fots_driver/README.TXT'
--- test/fots_driver/README.TXT	2013-02-22 10:41:13 +0000
+++ test/fots_driver/README.TXT	2013-04-09 23:43:20 +0000
@@ -27,6 +27,10 @@
 If you run Zorba from a checkout of the trunk and the build/bin folder,
 - /path/to/cli.xq can be set to ../../test/fots_driver/cli.xq
 
+'fotsPath' is set by default to the location where 'make fots-import' added the FOTS snapshot.
+Currently this location is ZORBA_BUILD_FOLDER/test/fots/2011/QT3-test-suite/catalog.xml.
+If you want to use other location please set 'fotsPath'.
+
 Always try to output the result back to an XML file with nice indentation:
 ./zorba -f -q ../../test/fots_driver/cli.xq -e SET_CLI_OPTIONS_HERE -o output.xml --indent
 
@@ -37,20 +41,21 @@
  is written down into a query_TESTCASENAME.xq file, where TESTCASENAME is
  the test case name.
 
-zorba -f -q /path/to/cli.xq -e fotsPath:=/path/to/QT3-test-suite/catalog.xml -e fotsZorbaManifestPath:=/path/to/Zorba_manifest.xml -e mode:=list-test-sets
+zorba -f -q /path/to/cli.xq -e fotsZorbaManifestPath:=/path/to/Zorba_manifest.xml -e mode:=list-test-sets
 zorba -f -q /path/to/cli.xq -e fotsPath:=/path/to/QT3-test-suite/catalog.xml -e mode:=list-test-sets
-zorba -f -q /path/to/cli.xq -e fotsPath:=/path/to/QT3-test-suite/catalog.xml -e mode:=list-test-sets -e testSetPrefixes:=prod,app
-zorba -f -q /path/to/cli.xq -e fotsPath:=/path/to/QT3-test-suite/catalog.xml -e mode:=list-test-cases -e testSetPrefixes:=prod-Literal
-zorba -f -q /path/to/cli.xq -e fotsPath:=/path/to/QT3-test-suite/catalog.xml -e mode:=list-test-cases -e dependency:=higherOrderFunctions
-zorba -f -q /path/to/cli.xq -e fotsPath:=/path/to/QT3-test-suite/catalog.xml -e mode:=list-test-cases -e dependency:=higherOrderFunctions -e assertions:=assert-count
-zorba -f -q /path/to/cli.xq -e fotsPath:=/path/to/QT3-test-suite/catalog.xml -e mode:=list-matching-test-cases -e pattern:=catch                                        
-zorba -f -q /path/to/cli.xq -e fotsPath:=/path/to/QT3-test-suite/catalog.xml -e mode:=run-test-sets -e testSetPrefixes:=prod -o result.xml --indent                     
-zorba -f -q /path/to/cli.xq -e fotsPath:=/path/to/QT3-test-suite/catalog.xml -e mode:=run-test-sets -e testSetPrefixes:=prod -e expectedFailuresPath:=ExpectedFailures.xml -o result.xml --indent                                                                                                                                               
-zorba -f -q /path/to/cli.xq -e fotsPath:=/path/to/QT3-test-suite/catalog.xml -e mode:=run-test-sets -e testSetPrefixes:=prod -e dependency:=higherOrderFunctions_false -o result.xml --indent
-zorba -f -q /path/to/cli.xq -e fotsPath:=/path/to/QT3-test-suite/catalog.xml -e mode:=run-test-sets -e testSetPrefixes:=prod -e assertions:=assert-count -o result.xml --indent
-zorba -f -q /path/to/cli.xq -e fotsPath:=/path/to/QT3-test-suite/catalog.xml -e mode:=run-test-sets -e testSetPrefixes:=prod-Literal -e verbose:=true -o result.xml --indent
-zorba -f -q /path/to/cli.xq -e fotsPath:=/path/to/QT3-test-suite/catalog.xml -e mode:=run-test-set  -e testSetName:=fn-matches -o result.xml --indent
-zorba -f -q /path/to/cli.xq -e fotsPath:=/path/to/QT3-test-suite/catalog.xml -e mode:=run-test-case -e testSetName:=prod-Literal -e testCaseName:=Literals001 -o result.xml --indent
-zorba -f -q /path/to/cli.xq -e fotsPath:=/path/to/QT3-test-suite/catalog.xml -e mode:=run-and-report -o results_Zorba_XQ30.xml --indent --disable-http-resolution
-zorba -f -q /path/to/cli.xq -e fotsPath:=/path/to/QT3-test-suite/catalog.xml -e mode:=report -e resultsFilePath:=results.xml -o results_Zorba_XQ30.xml --indent
+zorba -f -q /path/to/cli.xq -e mode:=list-test-sets -e testSetPrefixes:=prod,app
+zorba -f -q /path/to/cli.xq -e mode:=list-test-cases -e testSetPrefixes:=prod-Literal
+zorba -f -q /path/to/cli.xq -e mode:=list-test-cases -e dependency:=higherOrderFunctions
+zorba -f -q /path/to/cli.xq -e mode:=list-test-cases -e dependency:=higherOrderFunctions -e assertions:=assert-count
+zorba -f -q /path/to/cli.xq -e mode:=list-matching-test-cases -e pattern:=catch
+zorba -f -q /path/to/cli.xq -e mode:=run-test-sets -e testSetPrefixes:=prod -o result.xml --indent
+zorba -f -q /path/to/cli.xq -e mode:=run-test-sets -e testSetPrefixes:=prod -e expectedFailuresPath:=ExpectedFailures.xml -o result.xml --indent
+zorba -f -q /path/to/cli.xq -e mode:=run-test-sets -e testSetPrefixes:=prod -e dependency:=higherOrderFunctions_false -o result.xml --indent
+zorba -f -q /path/to/cli.xq -e mode:=run-test-sets -e testSetPrefixes:=prod -e assertions:=assert-count -o result.xml --indent
+zorba -f -q /path/to/cli.xq -e mode:=run-test-sets -e testSetPrefixes:=prod-Literal -e verbose:=true -o result.xml --indent
+zorba -f -q /path/to/cli.xq -e mode:=run-test-set  -e testSetName:=fn-matches -o result.xml --indent
+zorba -f -q /path/to/cli.xq -e mode:=run-test-set  -e testSetName:=fn-matches -e usePlanSerializer:=true -o result.xml --indent
+zorba -f -q /path/to/cli.xq -e mode:=run-test-case -e testSetName:=prod-Literal -e testCaseName:=Literals001 -o result.xml --indent
+zorba -f -q /path/to/cli.xq -e mode:=run-and-report -o results_Zorba_XQ30.xml --indent --disable-http-resolution
+zorba -f -q /path/to/cli.xq -e mode:=report -e resultsFilePath:=results.xml -o results_Zorba_XQ30.xml --indent
 zorba -f -q /path/to/cli.xq -e mode:=generate-expected-failures -e resultsFilePath:=failures.xml -o ExpectedFailures.xml --indent
 
=== modified file 'test/fots_driver/cli.xq'
--- test/fots_driver/cli.xq	2013-04-03 07:40:51 +0000
+++ test/fots_driver/cli.xq	2013-04-09 23:43:20 +0000
@@ -184,6 +184,13 @@
 declare variable $verbose as xs:string external := "false";
 
 
+(:~
+ : Enable or disable plan serializer usage. When this is set to true the query
+ : plan is saved then loaded and executed by XQXQ.
+ :)
+declare variable $usePlanSerializer as xs:string external := "false";
+
+
 declare function local:usage() as xs:string
 {
   string-join((
@@ -191,6 +198,10 @@
     "If you run Zorba from a checkout of the trunk and the build/bin folder,",
     "- /path/to/cli.xq can be set to ../../test/fots_driver/cli.xq",
     "",
+  	"'fotsPath' is set by default to the location where 'make fots-import' added the FOTS snapshot.",
+  	"Currently this location is ZORBA_BUILD_FOLDER/test/fots/2011/QT3-test-suite/catalog.xml.",
+  	"If you want to use other location please set 'fotsPath'.",
+    "",
     "Always try to output the result back to an XML file with nice indentation:",
     "./zorba -f -q ../../test/fots_driver/cli.xq -e SET_CLI_OPTIONS_HERE -o output.xml --indent",
     "",
@@ -201,22 +212,23 @@
   	" is written down into a query_TESTCASENAME.xq file, where TESTCASENAME is",
   	" the test case name.",
   	"",
-    "zorba -f -q /path/to/cli.xq -e fotsPath:=/path/to/QT3-test-suite/catalog.xml -e fotsZorbaManifestPath:=/path/to/Zorba_manifest.xml -e mode:=list-test-sets",
+    "zorba -f -q /path/to/cli.xq -e fotsZorbaManifestPath:=/path/to/Zorba_manifest.xml -e mode:=list-test-sets",
     "zorba -f -q /path/to/cli.xq -e fotsPath:=/path/to/QT3-test-suite/catalog.xml -e mode:=list-test-sets",
-    "zorba -f -q /path/to/cli.xq -e fotsPath:=/path/to/QT3-test-suite/catalog.xml -e mode:=list-test-sets -e testSetPrefixes:=prod,app",
-    "zorba -f -q /path/to/cli.xq -e fotsPath:=/path/to/QT3-test-suite/catalog.xml -e mode:=list-test-cases -e testSetPrefixes:=prod-Literal",
-    "zorba -f -q /path/to/cli.xq -e fotsPath:=/path/to/QT3-test-suite/catalog.xml -e mode:=list-test-cases -e dependency:=higherOrderFunctions",
-    "zorba -f -q /path/to/cli.xq -e fotsPath:=/path/to/QT3-test-suite/catalog.xml -e mode:=list-test-cases -e dependency:=higherOrderFunctions -e assertions:=assert-count",
-    "zorba -f -q /path/to/cli.xq -e fotsPath:=/path/to/QT3-test-suite/catalog.xml -e mode:=list-matching-test-cases -e pattern:=catch",
-    "zorba -f -q /path/to/cli.xq -e fotsPath:=/path/to/QT3-test-suite/catalog.xml -e mode:=run-test-sets -e testSetPrefixes:=prod -o result.xml --indent",
-    "zorba -f -q /path/to/cli.xq -e fotsPath:=/path/to/QT3-test-suite/catalog.xml -e mode:=run-test-sets -e testSetPrefixes:=prod -e expectedFailuresPath:=ExpectedFailures.xml -o result.xml --indent",
-    "zorba -f -q /path/to/cli.xq -e fotsPath:=/path/to/QT3-test-suite/catalog.xml -e mode:=run-test-sets -e testSetPrefixes:=prod -e dependency:=higherOrderFunctions_false -o result.xml --indent",
-    "zorba -f -q /path/to/cli.xq -e fotsPath:=/path/to/QT3-test-suite/catalog.xml -e mode:=run-test-sets -e testSetPrefixes:=prod -e assertions:=assert-count -o result.xml --indent",
-    "zorba -f -q /path/to/cli.xq -e fotsPath:=/path/to/QT3-test-suite/catalog.xml -e mode:=run-test-sets -e testSetPrefixes:=prod-Literal -e verbose:=true -o result.xml --indent",
-    "zorba -f -q /path/to/cli.xq -e fotsPath:=/path/to/QT3-test-suite/catalog.xml -e mode:=run-test-set  -e testSetName:=fn-matches -o result.xml --indent",
-    "zorba -f -q /path/to/cli.xq -e fotsPath:=/path/to/QT3-test-suite/catalog.xml -e mode:=run-test-case -e testSetName:=prod-Literal -e testCaseName:=Literals001 -o result.xml --indent",
-    "zorba -f -q /path/to/cli.xq -e fotsPath:=/path/to/QT3-test-suite/catalog.xml -e mode:=run-and-report -o results_Zorba_XQ30.xml --indent --disable-http-resolution",
-    "zorba -f -q /path/to/cli.xq -e fotsPath:=/path/to/QT3-test-suite/catalog.xml -e mode:=report -e resultsFilePath:=results.xml -o results_Zorba_XQ30.xml --indent",
+    "zorba -f -q /path/to/cli.xq -e mode:=list-test-sets -e testSetPrefixes:=prod,app",
+    "zorba -f -q /path/to/cli.xq -e mode:=list-test-cases -e testSetPrefixes:=prod-Literal",
+    "zorba -f -q /path/to/cli.xq -e mode:=list-test-cases -e dependency:=higherOrderFunctions",
+    "zorba -f -q /path/to/cli.xq -e mode:=list-test-cases -e dependency:=higherOrderFunctions -e assertions:=assert-count",
+    "zorba -f -q /path/to/cli.xq -e mode:=list-matching-test-cases -e pattern:=catch",
+    "zorba -f -q /path/to/cli.xq -e mode:=run-test-sets -e testSetPrefixes:=prod -o result.xml --indent",
+    "zorba -f -q /path/to/cli.xq -e mode:=run-test-sets -e testSetPrefixes:=prod -e expectedFailuresPath:=ExpectedFailures.xml -o result.xml --indent",
+    "zorba -f -q /path/to/cli.xq -e mode:=run-test-sets -e testSetPrefixes:=prod -e dependency:=higherOrderFunctions_false -o result.xml --indent",
+    "zorba -f -q /path/to/cli.xq -e mode:=run-test-sets -e testSetPrefixes:=prod -e assertions:=assert-count -o result.xml --indent",
+    "zorba -f -q /path/to/cli.xq -e mode:=run-test-sets -e testSetPrefixes:=prod-Literal -e verbose:=true -o result.xml --indent",
+    "zorba -f -q /path/to/cli.xq -e mode:=run-test-set  -e testSetName:=fn-matches -o result.xml --indent",
+    "zorba -f -q /path/to/cli.xq -e mode:=run-test-set  -e testSetName:=fn-matches -e usePlanSerializer:=true -o result.xml --indent",
+    "zorba -f -q /path/to/cli.xq -e mode:=run-test-case -e testSetName:=prod-Literal -e testCaseName:=Literals001 -o result.xml --indent",
+    "zorba -f -q /path/to/cli.xq -e mode:=run-and-report -o results_Zorba_XQ30.xml --indent --disable-http-resolution",
+    "zorba -f -q /path/to/cli.xq -e mode:=report -e resultsFilePath:=results.xml -o results_Zorba_XQ30.xml --indent",
     "zorba -f -q /path/to/cli.xq -e mode:=generate-expected-failures -e resultsFilePath:=failures.xml -o ExpectedFailures.xml --indent",
     ""
     ), "&#xA;")
@@ -307,7 +319,7 @@
   trace($dependency, "'dependency' set to:");
   trace($assertions, "'assertions' set to: ");
   trace($verbose, "'verbose' set to:");
-  trace($mode, "Cli command was set to:");
+  trace($mode, "Cli command set to:");
 
   d:run-fots($fotsPath,
              $fotsZorbaManifestPath,
@@ -319,7 +331,8 @@
              $assertions,
              xs:boolean($verbose),
              $expectedFailuresPath,
-             $mode)
+             $mode,
+             xs:boolean($usePlanSerializer))
 }
 
 case "run-test-set"
@@ -329,7 +342,7 @@
   trace($dependency, "'dependency' set to:");
   trace($assertions, "'assertions' set to: ");
   trace($verbose, "'verbose' set to:");
-  trace($mode, "Cli command was set to:");
+  trace($mode, "Cli command set to:");
 
   d:run-test-set($fotsPath,
                  $fotsZorbaManifestPath,
@@ -341,7 +354,8 @@
                  $assertions,
                  xs:boolean($verbose),
                  $expectedFailuresPath,
-                 $mode)
+                 $mode,
+                 xs:boolean($usePlanSerializer))
 }
 
 case "run-test-case"
@@ -350,7 +364,7 @@
   trace($testSetName, $testSetNameMsg);
   trace($testCaseName, $testCaseNameMsg);
   trace($verbose, "'verbose' set to:");
-  trace($mode, "Cli command was set to:");
+  trace($mode, "Cli command set to:");
 
   d:run-fots($fotsPath,
              $fotsZorbaManifestPath,
@@ -362,7 +376,8 @@
              (),
              xs:boolean($verbose),
              $expectedFailuresPath,
-             $mode)
+             $mode,
+             xs:boolean($usePlanSerializer))
 }
 
 case "run-and-report"
 
=== added file 'test/fots_driver/execute.xq'
--- test/fots_driver/execute.xq	1970-01-01 00:00:00 +0000
+++ test/fots_driver/execute.xq	2013-04-09 23:43:20 +0000
@@ -0,0 +1,95 @@
+(:
+ : Copyright 2006-2011 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.
+ :)
+
+(:~
+ : Zorba FOTS driver execute
+ : @author Sorin Nasoi
+ :)
+
+module namespace execute =
+  "http://www.zorba-xquery.com/fots-driver/execute";
+
+import module namespace xqxq =
+  "http://www.zorba-xquery.com/modules/xqxq#2.0";
+
+import module namespace eval =
+  "http://www.zorba-xquery.com/fots-driver/evaluate" at "evaluate.xq";
+
+declare namespace fots =
+  "http://www.w3.org/2010/09/qt-fots-catalog";
+
+declare namespace err =
+  "http://www.w3.org/2005/xqt-errors";
+
+declare namespace ann =
+  "http://www.zorba-xquery.com/annotations";
+
+
+declare namespace op = "http://www.zorba-xquery.com/options/features";
+declare namespace f = "http://www.zorba-xquery.com/features";
+declare option op:disable "f:trace";
+
+(:~
+ : XQXQ invoke.
+ : @param $xqxqQueryText the query that will be run.
+ : @param $case the test case.
+ : @param $verbose if set to TRUE it will also output the actual result.
+ : @param $testSetBaseURI the URI of the directory that contains the file of the
+          associated test set.
+ : @param $usePlanSerializer if true the plan serializer is used.
+ : @return the result of running the query with XQXQ.
+ :)
+declare %ann:sequential function execute:xqxq-invoke(
+  $xqxqQueryText      as xs:string,
+  $case               as element(fots:test-case),
+  $verbose            as xs:boolean?,
+  $testSetBaseURI     as xs:anyURI,
+  $usePlanSerializer  as xs:boolean
+)
+{
+  try
+  {
+    if($usePlanSerializer) then
+    {
+      variable $queryKey := xqxq:prepare-main-module($xqxqQueryText);
+      variable $queryPlan := xqxq:query-plan($queryKey);
+      variable $queryPlanKey := xqxq:load-from-query-plan($queryPlan);
+      variable $queryResult := xqxq:evaluate-sequential($queryPlanKey);
+
+      xqxq:delete-query($queryPlanKey);
+      xqxq:delete-query($queryKey);
+
+      eval:result($queryResult, $case/fots:result/*, $testSetBaseURI)
+    }
+    else
+    {
+      variable $queryKey := xqxq:prepare-main-module($xqxqQueryText);
+      variable $queryResult := xqxq:evaluate-sequential($queryKey);
+
+      xqxq:delete-query($queryKey);
+
+      eval:result($queryResult, $case/fots:result/*, $testSetBaseURI)
+    }
+  }
+  catch *
+  {
+    eval:error((),
+               $case/fots:result/*,
+               $err:code,
+               $err:description,
+               $testSetBaseURI)
+  }
+};
 
=== modified file 'test/fots_driver/feedback.xq'
--- test/fots_driver/feedback.xq	2013-03-29 06:15:19 +0000
+++ test/fots_driver/feedback.xq	2013-04-09 23:43:20 +0000
@@ -136,15 +136,13 @@
  : @return info about test case that passed.
  :)
 declare %private function feedback:pass(
-  $case             as element(fots:test-case),
-  $result           as item()*
+  $case     as element(fots:test-case),
+  $result   as item()*
 ) as element(fots:test-case)?
 {
-  let $status := if(exists($result/fots:errors))
-                 then 'wrongError'
-                 else 'pass'
-  return 
-  <fots:test-case name="{data($case/@name)}" result="{$status}"/>
+  if(exists($result/fots:errors))
+  then <fots:test-case name="{data($case/@name)}" result="wrongError" comment="{$result/fots:errors}"/>
+  else <fots:test-case name="{data($case/@name)}" result="pass"/>
 };
 
 
@@ -200,7 +198,7 @@
   then <fots:test-case name="{data($case/@name)}"
                        result="{$status}"
                        comment="{$info}"/>
- 
+
   else <fots:test-case name="{data($case/@name)}"
                        result="{$status}"/>
 };
 
=== modified file 'test/fots_driver/fots-driver.xq'
--- test/fots_driver/fots-driver.xq	2013-03-29 06:15:19 +0000
+++ test/fots_driver/fots-driver.xq	2013-04-09 23:43:20 +0000
@@ -25,9 +25,6 @@
 import module namespace functx =
   "http://www.functx.com/";
 
-import module namespace xqxq =
-  "http://www.zorba-xquery.com/modules/xqxq";
-
 import module namespace datetime  =
   "http://www.zorba-xquery.com/modules/datetime";
 
@@ -37,6 +34,9 @@
 import module namespace feedback =
   "http://www.zorba-xquery.com/fots-driver/feedback" at "feedback.xq";
 
+import module namespace execute =
+  "http://www.zorba-xquery.com/fots-driver/execute" at "execute.xq";
+
 import module namespace env =
   "http://www.zorba-xquery.com/fots-driver/environment" at "environment.xq";
 
@@ -320,6 +320,7 @@
  :        about each processed test-case.
  : @param $expectedFailures the root node of the ExpectedFailures.xml file.
  : @param $cliMode the cli command.
+ : @param $usePlanSerializer if true the plan serializer is used.
  : @return an XML tree containing info about all the processed tests-cases
  :)
 declare %ann:sequential function driver:run-fots(
@@ -333,12 +334,14 @@
   $assertions             as xs:string*,
   $verbose                as xs:boolean,
   $expectedFailuresPath   as xs:string,
-  $cliMode                as xs:string
+  $cliMode                as xs:string,
+  $usePlanSerializer      as xs:boolean
 ) as element(fots:test-cases)
 {
   trace($fotsPath, "Path to FOTS catalog.xml was set to: ");
   trace($zorbaManifestPath, "Path to FOTSZorbaManifest set to :");
   trace($expectedFailuresPath, "Path to ExpectedFailures.xml set to:");
+  trace($usePlanSerializer, "'usePlanSerializer' set to:");
 
   try
   {
@@ -347,6 +350,10 @@
     let $zorbaManifest := doc(resolve-uri($zorbaManifestPath))
 
     let $testSetNames :=
+    if(($cliMode = 'run-test-case') ||
+       ($cliMode = 'run-test-set'))
+    then $testSetPrefixes
+    else
     {
       if (empty($testSetPrefixes) and empty($exceptedTestSets)) then
       {
@@ -414,7 +421,8 @@
                            $exceptedTestCases,
                            $verbose,
                            $expectedFailures,
-                           $cliMode)
+                           $cliMode,
+                           $usePlanSerializer)
   }
   catch err:FODC0002
   {
@@ -475,6 +483,7 @@
  :        about each processed test-case.
  : @param $expectedFailures the root node of the ExpectedFailures.xml file.
  : @param $cliMode the cli command.
+ : @param $usePlanSerializer if true the plan serializer is used.
  : @return an XML tree containing info about all the processed tests-cases
  :)
 declare %ann:sequential function driver:run-test-set(
@@ -488,13 +497,15 @@
   $assertions             as xs:string*,
   $verbose                as xs:boolean,
   $expectedFailuresPath   as xs:string,
-  $cliMode                as xs:string
+  $cliMode                as xs:string,
+  $usePlanSerializer      as xs:boolean
 ) as element(fots:test-cases)
 {
   trace($fotsPath, "Path to FOTS catalog.xml was set to: ");
   trace($zorbaManifestPath, "Path to FOTSZorbaManifest set to :");
   trace($expectedFailuresPath, "Path to ExpectedFailures.xml set to:");
-
+  trace($usePlanSerializer, "'usePlanSerializer' set to:");
+  
   try
   {
     let $FOTSCatalog := doc(resolve-uri($fotsPath))
@@ -564,7 +575,8 @@
                            $exceptedTestCases,
                            $verbose,
                            $expectedFailures,
-                           $cliMode)
+                           $cliMode,
+                           $usePlanSerializer)
   }
   catch err:FODC0002
   {
@@ -615,6 +627,7 @@
  :        about each processed test-case.
  : @param $expectedFailures the root node of the ExpectedFailures.xml file.
  : @param $cliMode the cli command.
+ : @param $usePlanSerializer if true the plan serializer is used.
  : @return an XML tree containing info about all the processed tests-cases
  :)
 declare %private %ann:sequential function driver:run-fots(
@@ -626,7 +639,8 @@
   $exceptedTestCases  as xs:string*,
   $verbose            as xs:boolean,
   $expectedFailures   as document-node()?,
-  $cliMode            as xs:string
+  $cliMode            as xs:string,
+  $usePlanSerializer  as xs:boolean
 ) as element(fots:test-cases)
 {
   <fots:test-cases>
@@ -730,7 +744,8 @@
                           $verbose,
                           $expectedFailures//TestSet[@name eq $testSetName]/Test[@name eq $testCase/@name],
                           $cliMode,
-                          $mayNeedDTDValidation)
+                          $mayNeedDTDValidation,
+                          $usePlanSerializer)
             }
             else
             {
@@ -744,7 +759,8 @@
                           $verbose,
                           $expectedFailures//TestSet[@name eq $testSetName]/Test[@name eq $testCase/@name],
                           $cliMode,
-                          $mayNeedDTDValidation)
+                          $mayNeedDTDValidation,
+                          $usePlanSerializer)
             }
           }
         }
@@ -776,6 +792,7 @@
  : @param $cliMode the cli command.
  : @param $mayNeedDTDValidation true if the test case may need DTD validation
  :        for the document bound as context item.
+ : @param $usePlanSerializer if true the plan serializer is used.
  : @return an XML tree containing info about the result of running the test case.
  :)
 declare %ann:sequential function driver:test(
@@ -788,7 +805,8 @@
   $verbose              as xs:boolean,
   $expectedFailure      as element(Test)?,
   $cliMode              as xs:string,
-  $mayNeedDTDValidation as xs:boolean
+  $mayNeedDTDValidation as xs:boolean,
+  $usePlanSerializer    as xs:boolean
 ) as element(fots:test-case)?
 {
 (:TODO Cover the "(:%VARDECL%:)"when there are tests in FOTS that use it:)
@@ -853,10 +871,11 @@
 
     variable $startDateTime := datetime:current-dateTime();
 
-    variable $result := driver:xqxq-invoke($xqxqQuery,
+    variable $result := execute:xqxq-invoke($xqxqQuery,
                                            $case,
                                            $verbose,
-                                           $testSetBaseURI);
+                                           $testSetBaseURI,
+                                           $usePlanSerializer);
 
     variable $duration := (datetime:current-dateTime() - $startDateTime);
     
@@ -1020,42 +1039,3 @@
     "&#xA;"
     )
 };
-
-
-(:~
- : XQXQ invoke.
- : @param $xqxqQueryText the query that will be run.
- : @param $case the test case.
- : @param $verbose if set to TRUE it will also output the actual result.
- : @param $testSetBaseURI the URI of the directory that contains the file of the
-          associated test set.
- : @return the result of running the query with XQXQ.
- :)
-declare %private %ann:sequential function driver:xqxq-invoke(
-  $xqxqQueryText  as xs:string,
-  $case           as element(fots:test-case),
-  $verbose        as xs:boolean?,
-  $testSetBaseURI as xs:anyURI
-)
-{
-  try
-  {
-    {
-      variable $queryKey := xqxq:prepare-main-module($xqxqQueryText);
-
-      variable $queryResult := xqxq:evaluate-sequential($queryKey);
-
-      xqxq:delete-query($queryKey);
-
-      eval:result($queryResult, $case/fots:result/*, $testSetBaseURI)
-    }
-  }
-  catch *
-  {
-    eval:error((),
-               $case/fots:result/*,
-               $err:code,
-               $err:description,
-               $testSetBaseURI)
-  }
-};
 
=== modified file 'test/fots_driver/reporting.xq'
--- test/fots_driver/reporting.xq	2013-03-12 21:04:31 +0000
+++ test/fots_driver/reporting.xq	2013-04-09 23:43:20 +0000
@@ -89,7 +89,8 @@
                                            (),
                                            fn:false(),
                                            '',
-                                           'run-test-sets');
+                                           'run-test-sets',
+                                           fn:false());
 
       file:write("results.xml",
                  $results,
 
=== added file 'test/rbkt/ExpQueryResults/zorba/xqxq/query-plan.xml.res'
--- test/rbkt/ExpQueryResults/zorba/xqxq/query-plan.xml.res	1970-01-01 00:00:00 +0000
+++ test/rbkt/ExpQueryResults/zorba/xqxq/query-plan.xml.res	2013-04-09 23:43:20 +0000
@@ -0,0 +1,1 @@
+2
 \ No newline at end of file
 
=== added file 'test/rbkt/ExpQueryResults/zorba/xqxq/query-plan2.xml.res'
--- test/rbkt/ExpQueryResults/zorba/xqxq/query-plan2.xml.res	1970-01-01 00:00:00 +0000
+++ test/rbkt/ExpQueryResults/zorba/xqxq/query-plan2.xml.res	2013-04-09 23:43:20 +0000
@@ -0,0 +1,1 @@
+foo
 \ No newline at end of file
 
=== added file 'test/rbkt/ExpQueryResults/zorba/xqxq/query-plan3.xml.res'
--- test/rbkt/ExpQueryResults/zorba/xqxq/query-plan3.xml.res	1970-01-01 00:00:00 +0000
+++ test/rbkt/ExpQueryResults/zorba/xqxq/query-plan3.xml.res	2013-04-09 23:43:20 +0000
@@ -0,0 +1,1 @@
+foo
 \ No newline at end of file
 
=== added file 'test/rbkt/Queries/zorba/xqxq/query-plan.xq'
--- test/rbkt/Queries/zorba/xqxq/query-plan.xq	1970-01-01 00:00:00 +0000
+++ test/rbkt/Queries/zorba/xqxq/query-plan.xq	2013-04-09 23:43:20 +0000
@@ -0,0 +1,6 @@
+import module namespace xqxq = 'http://www.zorba-xquery.com/modules/xqxq';
+
+variable $queryID := xqxq:prepare-main-module("1+1");
+variable $query-plan := xqxq:query-plan($queryID); 
+variable $queryID2 := xqxq:load-from-query-plan($query-plan);
+xqxq:evaluate ($queryID2)
 
=== added file 'test/rbkt/Queries/zorba/xqxq/query-plan2.xq'
--- test/rbkt/Queries/zorba/xqxq/query-plan2.xq	1970-01-01 00:00:00 +0000
+++ test/rbkt/Queries/zorba/xqxq/query-plan2.xq	2013-04-09 23:43:20 +0000
@@ -0,0 +1,20 @@
+import module namespace xqxq = 'http://www.zorba-xquery.com/modules/xqxq';
+
+declare namespace resolver = 'http://www.zorba-xquery.com/modules/xqxq/url-resolver';
+declare namespace op = "http://www.zorba-xquery.com/options/features";
+declare namespace f = "http://www.zorba-xquery.com/features";
+
+declare function resolver:url-resolver($namespace as xs:string, $entity as xs:string) {
+  if($namespace = 'http://test.xq')
+  then "module namespace test = 'http://test'; declare function test:foo(){'foo'};"
+  else ()
+};
+
+variable $queryID := xqxq:prepare-main-module(
+  "import module namespace test = 'http://test'; test:foo()",
+  resolver:url-resolver#2, ());
+
+
+variable $query-plan := xqxq:query-plan($queryID); 
+variable $queryID2 := xqxq:load-from-query-plan($query-plan, resolver:url-resolver#2, ());
+xqxq:evaluate ($queryID2)
 
=== added file 'test/rbkt/Queries/zorba/xqxq/query-plan3.xq'
--- test/rbkt/Queries/zorba/xqxq/query-plan3.xq	1970-01-01 00:00:00 +0000
+++ test/rbkt/Queries/zorba/xqxq/query-plan3.xq	2013-04-09 23:43:20 +0000
@@ -0,0 +1,28 @@
+import module namespace xqxq = 'http://www.zorba-xquery.com/modules/xqxq';
+
+declare namespace resolver = 'http://www.zorba-xquery.com/modules/xqxq/url-resolver';
+declare namespace mapper = 'http://www.zorba-xquery.com/modules/xqxq/uri-mapper';
+declare namespace op = "http://www.zorba-xquery.com/options/features";
+declare namespace f = "http://www.zorba-xquery.com/features";
+
+declare function resolver:url-resolver($namespace as xs:string, $entity as xs:string) {
+  if($namespace = 'http://foo')
+  then "module namespace test = 'http://test'; declare function test:foo(){'foo'};"
+  else ()
+};
+
+declare function mapper:uri-mapper($namespace as xs:string, $entity as xs:string)
+{
+   if($namespace = 'http://test')
+   then 'http://foo'
+   else ()
+};
+
+variable $queryID := xqxq:prepare-main-module
+(
+  "import module namespace test = 'http://test'; test:foo()", 
+  resolver:url-resolver#2, mapper:uri-mapper#2
+);
+variable $query-plan := xqxq:query-plan($queryID); 
+variable $queryID2 := xqxq:load-from-query-plan($query-plan, resolver:url-resolver#2, mapper:uri-mapper#2);
+xqxq:evaluate ($queryID2)
 
=== added file 'test/rbkt/Queries/zorba/xqxq/query-plan4.spec'
--- test/rbkt/Queries/zorba/xqxq/query-plan4.spec	1970-01-01 00:00:00 +0000
+++ test/rbkt/Queries/zorba/xqxq/query-plan4.spec	2013-04-09 23:43:20 +0000
@@ -0,0 +1,1 @@
+Error: http://www.zorba-xquery.com/errors:ZCSE0013
 
=== added file 'test/rbkt/Queries/zorba/xqxq/query-plan4.xq'
--- test/rbkt/Queries/zorba/xqxq/query-plan4.xq	1970-01-01 00:00:00 +0000
+++ test/rbkt/Queries/zorba/xqxq/query-plan4.xq	2013-04-09 23:43:20 +0000
@@ -0,0 +1,28 @@
+import module namespace xqxq = 'http://www.zorba-xquery.com/modules/xqxq';
+
+declare namespace resolver = 'http://www.zorba-xquery.com/modules/xqxq/url-resolver';
+declare namespace mapper = 'http://www.zorba-xquery.com/modules/xqxq/uri-mapper';
+declare namespace op = "http://www.zorba-xquery.com/options/features";
+declare namespace f = "http://www.zorba-xquery.com/features";
+
+declare function resolver:url-resolver($namespace as xs:string, $entity as xs:string) {
+  if($namespace = 'http://foo')
+  then "module namespace test = 'http://test'; declare function test:foo(){'foo'};"
+  else ()
+};
+
+declare function mapper:uri-mapper($namespace as xs:string, $entity as xs:string)
+{
+   if($namespace = 'http://test')
+   then 'http://foo'
+   else ()
+};
+
+variable $queryID := xqxq:prepare-main-module
+(
+  "import module namespace test = 'http://test'; test:foo()", 
+  resolver:url-resolver#2, mapper:uri-mapper#2
+);
+variable $query-plan := xqxq:query-plan($queryID); 
+variable $queryID2 := xqxq:load-from-query-plan($query-plan);
+xqxq:evaluate ($queryID2)