C++ XQuery_t::getDynamicContext方法代码示例

bool
cxx_api_changes_test5(Zorba* aZorba)
{
  try
  {
    
    std::string lIn = "declare variable $a external; 1+1";
    
    XQuery_t lQuery = aZorba->compileQuery(lIn);

    std::vector<Item> lVars;
    Iterator_t varsIte;
    lQuery->getExternalVariables(varsIte);

    varsIte->open();
    Item temp;
    while(varsIte->next(temp))
      lVars.push_back(temp);
    varsIte->close();

    std::vector<Item>::const_iterator lIte = lVars.begin();
    std::vector<Item>::const_iterator lEnd = lVars.end();

    Item item = aZorba->getItemFactory()->createInt(4);
    

    bool isBound1;
    bool isBound2;

    for(; lIte != lEnd; ++lIte)
    {
      Item qname = *lIte;
      isBound1 = lQuery->getDynamicContext()->isBoundExternalVariable(qname.getNamespace(), qname.getLocalName());
      Item value = aZorba->getItemFactory()->createString("foo");
      lQuery->getDynamicContext()->setVariable(qname.getStringValue(), value);
      isBound2 = lQuery->getDynamicContext()->isBoundExternalVariable(qname.getNamespace(), qname.getLocalName());
    }

    if (!isBound1 && isBound2)
      return true;
     
  }
  catch (XQueryException& qe)
  {
    std::cerr << qe << std::endl;
    return false;
  }
  catch (ZorbaException& e)
  {
    std::cerr << e << std::endl;
    return false;
  }

  return true;
}

bool
external_function_test_2(Zorba* aZorba)
{
  try 
  {
    std::ifstream lIn("ext_main.xq");
    assert(lIn.good());
    std::ostringstream lOut;
    MyExternalModule lMod;

    StaticContext_t lSctx = aZorba->createStaticContext();
    lSctx->registerModule(&lMod);
    {
      XQuery_t lQuery = aZorba->compileQuery(lIn, lSctx);

      zorba::DynamicContext* lDynContext = lQuery->getDynamicContext();

      // must be released in MyExternalFunctionParameter::destroy
      MyExternalFunctionParameter* lParam1 = new MyExternalFunctionParameter();
      MyExternalFunctionParameter* lParam2 = new MyExternalFunctionParameter();

      lDynContext->addExternalFunctionParameter("myparam", lParam1);
      lDynContext->addExternalFunctionParameter("myparam", lParam2);

      // make sure that destroy is invoked if the first parameter is overwritten
      if (!lDestroyedParam)
      {
        return false;
      }
      else
      {
        lDestroyedParam = false;
      }

      lDynContext->setVariable("local:foo",
                               aZorba->getItemFactory()->createString("foo")); 

      std::cout << lQuery << std::endl;
    }

    // destroy is called if the XQuery object is destroyed
    return lGotParam && lDestroyedParam;

  } 
  catch (XQueryException& qe) 
  {
    std::cerr << qe << std::endl;
    return false;
  }
  catch (ZorbaException& e)
  {
    std::cerr << e << std::endl;
    return false;
  }
  return true;
}

bool
cxx_api_changes_test6(Zorba* aZorba)
{
  try
  {
    
    std::string lIn = "1+1";
    
    XQuery_t lQuery = aZorba->compileQuery(lIn);

    bool isBound1;
    bool isBound2;

    isBound1 = lQuery->getDynamicContext()->isBoundContextItem();

    Item lContextItem = aZorba->getItemFactory()->createString("foo");
    lQuery->getDynamicContext()->setContextItem(lContextItem);
    isBound2 = lQuery->getDynamicContext()->isBoundContextItem();

    if (!isBound1 && isBound2)
      return true;
     
  }
  catch (XQueryException& qe)
  {
    std::cerr << qe << std::endl;
    return false;
  }
  catch (ZorbaException& e)
  {
    std::cerr << e << std::endl;
    return false;
  }

  return true;
}

bool
example_2(Zorba* aZorba)
{
    XQuery_t lQuery = aZorba->createQuery();
    std::string path( "/home/adam/proj/marc2bibframe/xbin/zorba3-0.xqy");

    std::unique_ptr<std::istream> qfile;

    qfile.reset( new std::ifstream( path.c_str() ) );

    Zorba_CompilerHints lHints;

    // lQuery->setFileName("http://base/");
    lQuery->setFileName("/home/adam/proj/marc2bibframe/xbin/");

    lQuery->compile(*qfile, lHints);

    zorba::DynamicContext* lDynamicContext = lQuery->getDynamicContext();

    zorba::Item lItem = aZorba->getItemFactory()->createString("http://base/");
    lDynamicContext->setVariable("baseuri", lItem);

    lItem = aZorba->getItemFactory()->createString(
        "/home/adam/proj/yaz/test/marc6.xml");
    lDynamicContext->setVariable("marcxmluri", lItem);

    lItem = aZorba->getItemFactory()->createString("rdfxml");
    lDynamicContext->setVariable("serialization", lItem);

    std::cout << lQuery << std::endl;

    lItem = aZorba->getItemFactory()->createString(
        "/home/adam/proj/yaz/test/marc7.xml");
    lDynamicContext->setVariable("marcxmluri", lItem);

    std::stringstream ss;

    lQuery->execute(ss);

    std::string result = ss.str();

    std::cout << result << std::endl;

    return true;
}

void* query_stress_test_1(void *param)
{
  argv* var = (argv*)param;

  std::ostringstream os;
  os << var->index;

  XQuery_t aQuery = var->lZorba->compileQuery(".//chapter[@id=" + os.str() + "]");

  DynamicContext* lCtx = aQuery->getDynamicContext();

  lCtx->setContextItem(var->lItem);

  os.clear();
  os << aQuery << std::endl;

  var->lItem = NULL;
  aQuery->close();

  return (void*)0;
}

/**
 * Utility function: Given an item, bind that item to a simple query and
 * serialize the result, then ensure the result matches the expected string.
 */
bool
serialize(Zorba* aZorba, Item aItem, std::string aExpected)
{
  Zorba_SerializerOptions lSerialOpt;
  lSerialOpt.omit_xml_declaration = ZORBA_OMIT_XML_DECLARATION_YES;

  XQuery_t lQuery = aZorba->compileQuery("declare variable $i external; $i");

  lQuery->getDynamicContext()->setVariable("i", aItem);

  std::stringstream lStream;
  lQuery->execute(lStream, &lSerialOpt);

  std::string lResult = lStream.str();
  std::cout << lResult << std::endl;
  if (lResult.compare(aExpected) != 0) {
    std::cout << "Wrong value! Expected " << aExpected << std::endl;
    return false;
  }
  return true;
}