void xml_to_json( store::Item_t const &xml_item, store::Item_t *json_item ) { ZORBA_ASSERT( json_item ); switch ( xml_item->getNodeKind() ) { case store::StoreConsts::elementNode: x2j_element( xml_item, json_item ); break; default: throw XQUERY_EXCEPTION( zerr::ZJSE0001_NOT_ELEMENT_NODE ); } }
void SchemaValidatorImpl::processElement( store::PUL* pul, TypeManager* typeManager, EventSchemaValidator& schemaValidator, store::Item_t element, const QueryLoc& loc) { ZORBA_ASSERT(element->isNode()); ZORBA_ASSERT(element->getNodeKind() == store::StoreConsts::elementNode); store::Item_t nodeName = element->getNodeName(); zstring baseUri; element->getBaseURI(baseUri); //cout << " vup - processElement: " << nodeName->getLocalName()->c_str() // << " @ " << nodeName->getNamespace()->c_str() << "\n"; cout.flush(); schemaValidator.startElem(nodeName); // namespace declarations must go first processNamespaces( schemaValidator, element); // since the type of an element is determined only after the validator // receives all of it's attributes, and an attribute node needs it's // parent when created we need to go through the attributes twice: once // for validation and once for creation validateAttributes(schemaValidator, element->getAttributes()); store::Item_t typeQName = schemaValidator.getTypeQName(); store::Item_t substitutedElemQName = schemaValidator.getSubstitutedElemQName(); //cout << " vup - elemType old: " // << element->getType()->getLocalName()->c_str() << " @ " // << element->getType()->getNamespace()->c_str() << "\n"; cout.flush(); //cout << " vup - elemType new: " << typeQName->getLocalName()->c_str() // << " @ " << typeQName->getNamespace()->c_str() << "\n"; cout.flush(); bool isInSubstitutionElement = false; if (substitutedElemQName) { isInSubstitutionElement = true; // cout << " vup - substitutes: " << substitutedElemQName->g // etLocalName()->c_str() << " @ " << substitutedElemQName->getNamespace()-> // c_str() << "\n"; cout.flush(); } bool isNewType = false; xqtref_t newType; store::Item_t elm; if ( !typeQName->equals(element->getType()) ) { isNewType = true; newType = typeManager->create_named_type(typeQName, SequenceType::QUANT_ONE, loc); elm = element; } store::NsBindings bindings; element->getNamespaceBindings(bindings); namespace_context nsCtx = namespace_context(theSctx, bindings); processAttributes(pul, nsCtx, typeManager, schemaValidator, element, element->getAttributes(), loc); std::vector<store::Item_t> typedValues; int noOfChildren = processChildren(pul, nsCtx, typeManager, schemaValidator, element->getChildren(), typedValues, loc); if ( isNewType ) { bool tHasValue = Validator::typeHasValue(newType); bool tHasTypedValue = Validator::typeHasTypedValue(typeManager, newType, loc); bool tHasEmptyValue = Validator::typeHasEmptyValue(newType); if ( noOfChildren==0 ) { // workaround for elem of type xsd:string with no text child if ( newType->is_builtin() && newType->getQName()->equals(GENV_TYPESYSTEM.STRING_TYPE_ONE->getQName()) ) { /*store::Item_t result; zstring emptyStr = ""; GENV_ITEMFACTORY->createString( result, emptyStr); typedValues.push_back(result);*/ tHasEmptyValue = true; tHasTypedValue = false; tHasValue = false; } else if ( newType->type_kind()==XQType::USER_DEFINED_KIND ) { const UserDefinedXQType udXQType = static_cast<const UserDefinedXQType&>(*newType); if ( udXQType.isSubTypeOf(typeManager, *GENV_TYPESYSTEM.STRING_TYPE_ONE) ) { tHasEmptyValue = true; tHasTypedValue = false; tHasValue = false; } } } //cout << " vup - addSetElementType: " << elm->getNodeName()-> // getLocalName()->str() << " " << newType->get_qname()->getLocalName() // << " @ " << newType->get_qname()->getNamespace() << "\n"; cout.flush(); //cout << " vup - " << ( tHasTypedValue ? "hasTypedValue" : "" ) // << " values.size: " << typedValues.size() << (typedValues.size()>0 ? // " [0]=" + typedValues[0]->getStringValue()->str() : "" ) << ( tHasValue ? // " hasValue" : "" ) << ( tHasEmptyValue ? " hasEmptyValue" : "" ) << "\n"; // cout.flush(); if ( typedValues.size()==1 ) pul->addSetElementType(&loc, elm, typeQName, typedValues[0], tHasValue, tHasEmptyValue, tHasTypedValue, isInSubstitutionElement); else pul->addSetElementType(&loc, elm, typeQName, (std::vector<store::Item_t>&)typedValues, tHasValue, tHasEmptyValue, tHasTypedValue, isInSubstitutionElement); } schemaValidator.endElem(nodeName); }
bool FnZorbaParseXmlFragmentIterator::nextImpl( store::Item_t& result, PlanState& planState) const { store::Store& lStore = GENV.getStore(); zstring docString; store::Item_t tempItem; bool validated = true; FnZorbaParseXmlFragmentIteratorState* state; DEFAULT_STACK_INIT(FnZorbaParseXmlFragmentIteratorState, state, planState); if (consumeNext(result, theChildren[0].getp(), planState)) { if (result->isStreamable()) { state->theFragmentStream.theStream = &result->getStream(); state->theFragmentStream.setStreamReleaser(result->getStreamReleaser()); result->setStreamReleaser(nullptr); } else { result->getStringValue2(docString); state->theFragmentStream.theIss = new std::istringstream(docString.c_str()); state->theFragmentStream.theStream = state->theFragmentStream.theIss; } // read options consumeNext(tempItem, theChildren[1].getp(), planState); state->theProperties.setBaseUri(theSctx->get_base_uri()); state->theProperties.setStoreDocument(false); state->theProperties.setUseCachedDocument(false); processOptions(tempItem, state->theProperties, theSctx, loc); state->theProperties.setCreateDocParentLink(false); // baseURI serves both as the base URI used by the XML parser // to resolve relative entity references within the document, // and as the base URI of the document node that is returned. state->baseUri = state->theProperties.getBaseUri(); state->docUri = state->theProperties.getBaseUri(); //////////////////////////////////////////////////////////////////////// // External parsed entity processing //////////////////////////////////////////////////////////////////////// if (state->theProperties.getParseExternalParsedEntity()) { state->theFragmentStream.root_elements_to_skip = state->theProperties.getSkipRootNodes(); while ( ! state->theFragmentStream.stream_is_consumed()) { try { result = lStore.loadDocument(state->baseUri, state->docUri, state->theFragmentStream, state->theProperties); } catch ( ZorbaException const &e ) { if ( !state->theProperties.getNoError() ) { XQueryException xe( XQUERY_EXCEPTION( err::FODC0006, ERROR_PARAMS( "parse-xml:parse()", e.what() ), ERROR_LOC( loc ) ) ); set_data( xe, e ); throw xe; } result = nullptr; } if (result == NULL) continue; // Return the children of document node state->theFragmentStream.children = result->getChildren(); while (state->theFragmentStream.children->next(result) && result != NULL) { if (state->theProperties.getSkipTopLevelTextNodes() && result->getNodeKind() == store::StoreConsts::textNode) continue; STACK_PUSH(true, state); } } } //////////////////////////////////////////////////////////////////////// // XML document processing //////////////////////////////////////////////////////////////////////// else // if (!state->theProperties.getEnableExtParsedEntity()) { try { result = lStore.loadDocument(state->baseUri, state->docUri, *state->theFragmentStream.theStream, state->theProperties); } catch ( ZorbaException const &e ) { if ( !state->theProperties.getNoError() ) { XQueryException xe( XQUERY_EXCEPTION( err::FODC0006, ERROR_PARAMS( "parse-xml:parse()", e.what() ), ERROR_LOC( loc ) ) ); set_data( xe, e ); throw xe; } result = nullptr; } if (result != NULL) { #ifndef ZORBA_NO_XMLSCHEMA if (state->theProperties.getSchemaLaxValidate() || state->theProperties.getSchemaStrictValidate()) { try { tempItem = NULL; // used as the effectiveValidationValue()'s typeName validated = Validator::effectiveValidationValue( result, result, tempItem, theSctx->get_typemanager(), state->theProperties.getSchemaLaxValidate() ? ParseConstants::val_lax : ParseConstants::val_strict, theSctx, this->loc); } catch (ZorbaException& /*e*/) { if ( ! state->theProperties.getNoError()) throw; else { result = NULL; validated = false; } } } #endif // Ignore the schema validation options if Zorba is built without schema support STACK_PUSH(validated, state); } // if (result != NULL) } // if (state->theProperties.getEnableExtParsedEntity()) } // if (consumeNext(result, theChildren[0].getp(), planState)) STACK_END(state); }