/**
 * Example to invoke the serializer using the serialize() call on the query object.
 */
bool
serialization_example_2(Zorba* aZorba)
{
    try {
        XQuery_t lQuery = aZorba->compileQuery("for $i in (1 to 3) return <a> { $i } </a>");

        lQuery->execute(std::cout);
    } catch (ZorbaException& e) {
        std::cerr << e << std::endl;
        return false;
    }

    return true;
}
Exemple #2
0
 bool example1()
 {
   std::stringstream lStr;
   lStr << "(<anXMLExample/>, ";
   lStr << "<json type='object'><pair name='firstName' type='string'>";
   lStr << "John</pair></json>, ";
   lStr << "42)";
   XQuery_t lQuery = theZorba->compileQuery(lStr.str());
   try {
     lQuery->execute(std::cout, callback, this);
   } catch (ZorbaException& e) {
     std::cerr << e << std::endl;
     return false;
   }
   return true;
 }
/**
 * Example to serialize the result of a query with indentation.
 */
bool
serialization_example_4(Zorba* aZorba)
{
    try {
        XQuery_t lQuery = aZorba->compileQuery("for $i in (1 to 3) return <a> { $i } </a>");

        Zorba_SerializerOptions lSerOptions;
        lSerOptions.indent = ZORBA_INDENT_YES;

        lQuery->execute(std::cout, &lSerOptions);
    } catch (ZorbaException& e) {
        std::cerr << e << std::endl;
        return false;
    }

    return true;
}
/**
 * Example that shows HTML serialization of the results.
 */
bool
serialization_example_3(Zorba* aZorba)
{
    try {
        XQuery_t lQuery = aZorba->compileQuery("for $i in (1 to 3) return <a> { $i } </a>");

        Zorba_SerializerOptions lSerOptions;
        lSerOptions.ser_method = ZORBA_SERIALIZATION_METHOD_HTML;

        lQuery->execute(std::cout, &lSerOptions);
    } catch (ZorbaException& e) {
        std::cerr << e << std::endl;
        return false;
    }

    return true;
}
bool
serialization_example_6(Zorba* aZorba)
{
    try {
        XQuery_t lQuery = aZorba->compileQuery("for $i in (1 to 3) return <a> { $i } </a>");

        Zorba_SerializerOptions lSerOptions;
        lSerOptions.byte_order_mark = ZORBA_BYTE_ORDER_MARK_YES;

        lQuery->execute(std::cout, &lSerOptions);
    } catch (ZorbaException& e) {
        std::cerr << e << std::endl;
        return false;
    }

    return true;
}
bool
serialization_example_5(Zorba* aZorba)
{
    try {
        XQuery_t lQuery = aZorba->compileQuery("for $i in (1 to 3) return <a> { $i } </a>");

        Zorba_SerializerOptions lSerOptions;
        lSerOptions.omit_xml_declaration = ZORBA_OMIT_XML_DECLARATION_YES;

        lQuery->execute(std::cout, &lSerOptions);
    } catch (ZorbaException& e) {
        std::cerr << e << std::endl;
        return false;
    }

    return true;
}
Exemple #7
0
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;
}
Exemple #8
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;
}