/******************************************************************************* 14.9.2 fn:parse-xml-fragment ********************************************************************************/ bool FnParseXmlFragmentIterator::nextImpl( store::Item_t& result, PlanState& planState) const { zstring docString; FnParseXmlFragmentIteratorState* state; DEFAULT_STACK_INIT(FnParseXmlFragmentIteratorState, state, planState); if (consumeNext(result, theChildren[0].getp(), planState)) { if (result->isStreamable()) { state->theFragmentStream.theStream = &result->getStream(); } else { result->getStringValue2(docString); state->theFragmentStream.theIss = new std::istringstream(docString.c_str()); state->theFragmentStream.theStream = state->theFragmentStream.theIss; } state->theProperties.setBaseUri(theSctx->get_base_uri()); state->theProperties.setParseExternalParsedEntity(true); state->theProperties.setStoreDocument(false); state->baseUri = state->theProperties.getBaseUri(); // create only one document node holding all fragment nodes state->theFragmentStream.only_one_doc_node = 1; try { result = GENV.getStore().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( "fn:parse-xml-fragment()", e.what() ), ERROR_LOC( loc ))); set_data( xe, e ); throw xe; } result = nullptr; } if (result != NULL) STACK_PUSH(true, state); } // if STACK_END(state); }
void IndexDelta::addGeneralPair(store::Item_t& node, store::Item_t& key) { assert(node->isNode() && key->isAtomic()); theGeneralDelta.resize(theGeneralDelta.size() + 1); theGeneralDelta.back().first.transfer(node); theGeneralDelta.back().second.transfer(key); }
static void get_options( store::Item_t const &options_object, options_type *options ) { ZORBA_ASSERT( options_object->getKind() == store::Item::OBJECT ); store::Iterator_t i( options_object->getObjectKeys() ); i->open(); store::Item_t opt_key; while ( i->next( opt_key ) ) { zstring const opt_name( opt_key->getStringValue() ); store::Item_t const opt_value( options_object->getObjectValue( opt_key ) ); (*options)[ opt_name ] = opt_value->getStringValue(); } i->close(); }
void dynamic_context::get_variable( ulong varid, const store::Item_t& varname, const QueryLoc& loc, store::Item_t& itemValue, store::TempSeq_t& seqValue) const { itemValue = NULL; seqValue = NULL; if (varid >= theVarValues.size() || theVarValues[varid].theState == VarValue::undeclared) { zstring varName = static_context::var_name(varname.getp()); if (varid >= theVarValues.size() || theVarValues[varid].theIsExternalOrLocal || (varid > 0 && varid < MAX_IDVARS_RESERVED)) { RAISE_ERROR(err::XPDY0002, loc, ERROR_PARAMS(ZED(XPDY0002_VariableUndeclared_2), varName)); } else { RAISE_ERROR(err::XQDY0054, loc, ERROR_PARAMS(varName)); } } const VarValue& var = theVarValues[varid]; if (var.theState == VarValue::declared) { zstring varName = static_context::var_name(varname.getp()); if (var.theIsExternalOrLocal) { RAISE_ERROR(err::XPDY0002, loc, ERROR_PARAMS(ZED(XPDY0002_VariableHasNoValue_2), varName)); } else { RAISE_ERROR(err::XQDY0054, loc, ERROR_PARAMS(varName)); } } if (var.theState == VarValue::item) itemValue = var.theValue.item; else seqValue = var.theValue.temp_seq; }
bool ZorbaValidateInPlaceIterator::nextImpl(store::Item_t& result, PlanState& planState) const { store::Item_t node; PlanIteratorState* state; store::PUL_t pul; DEFAULT_STACK_INIT(PlanIteratorState, state, planState); if (consumeNext(node, theChild.getp(), planState)) { // verify that if the element being revalidated is an element it is the root if (node->getNodeKind()==store::StoreConsts::elementNode && node->getParent() && node->getParent()->getNodeKind()!=store::StoreConsts::documentNode) throw XQUERY_EXCEPTION( zerr::ZAPI0090_CANNOT_VALIDATE_NON_ROOT, ERROR_LOC( loc ) ); pul = GENV_ITEMFACTORY->createPendingUpdateList(); pul->addRevalidate(&loc,node); result.transfer(pul); STACK_PUSH(true, state); } STACK_END(state); }
static void x2j_children( store::Item_t const &parent, vector<store::Item_t> *children ) { ZORBA_ASSERT( children ); store::Iterator_t i( parent->getChildren() ); i->open(); store::Item_t child_item, temp_item; while ( i->next( child_item ) ) { if ( !x2j_map_atomic( child_item, &temp_item ) ) { if ( !child_item->isNode() ) throw XQUERY_EXCEPTION( zerr::ZJ2X0001_JSONML_ARRAY_BAD_JSON, ERROR_PARAMS( ZED( ZJ2X0001_BadElement ), child_item->getKind() ) ); switch ( child_item->getNodeKind() ) { case store::StoreConsts::elementNode: x2j_element( child_item, &temp_item ); break; case store::StoreConsts::textNode: { zstring s( child_item->getStringValue() ); GENV_ITEMFACTORY->createString( temp_item, s ); break; } default: continue; } // switch } // if children->push_back( temp_item ); } // while i->close(); }
bool PlanIterator::consumeNext( store::Item_t& result, const PlanIterator* iter, PlanState& planState) { if (planState.theHasToQuit) { // std::cout << "Plan interupted" << std::endl; throw FlowCtlException(FlowCtlException::INTERRUPT); } bool status = iter->produceNext(result, planState); if (planState.theCompilerCB->theConfig.print_item_flow) { if (Properties::instance().getStableIteratorIDs()) std::cout << "next (" << iter->getId(); else std::cout << "next (" << iter; std::cout << " = " << iter->getNameAsString() // typeid (*iter).name() << ") -> " << "status: " << status << " -> " << ((status && result != NULL) ? result->show().c_str() : "null") << std::endl; } return status; }
bool NumArithIterator<Operation>::compute( store::Item_t& result, dynamic_context* dctx, const TypeManager* tm, const QueryLoc& aLoc, store::Item_t& n0, store::Item_t& n1) { assert(n0->isAtomic()); assert(n1->isAtomic()); store::SchemaTypeCode type0 = n0->getTypeCode(); store::SchemaTypeCode type1 = n1->getTypeCode(); return computeAtomic(result, dctx, tm, aLoc, n0, type0, n1, type1); }
store::Item_t get_json_value( store::Item_t const &object, char const *key ) { zstring key_str( key ); store::Item_t key_item; GENV_ITEMFACTORY->createString( key_item, key_str ); return object->getObjectValue( key_item ); }
store::Item_t getFirstAttribute(store::Item_t node) { store::Item_t attr; store::Iterator_t attributes = node->getAttributes(); attributes->open(); attributes->next(attr); attributes->close(); return attr; }
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 ); } }
bool x2j_map_atomic( store::Item_t const &xml_item, store::Item_t *json_item ) { if ( xml_item->isAtomic() ) { switch ( xml_item->getTypeCode() ) { case store::JS_NULL: case store::XS_BOOLEAN: case store::XS_BYTE: case store::XS_DECIMAL: case store::XS_DOUBLE: case store::XS_ENTITY: case store::XS_FLOAT: case store::XS_ID: case store::XS_IDREF: case store::XS_INT: case store::XS_INTEGER: case store::XS_LONG: case store::XS_NAME: case store::XS_NCNAME: case store::XS_NEGATIVE_INTEGER: case store::XS_NMTOKEN: case store::XS_NON_NEGATIVE_INTEGER: case store::XS_NON_POSITIVE_INTEGER: case store::XS_NORMALIZED_STRING: case store::XS_POSITIVE_INTEGER: case store::XS_SHORT: case store::XS_STRING: case store::XS_TOKEN: case store::XS_UNSIGNED_BYTE: case store::XS_UNSIGNED_INT: case store::XS_UNSIGNED_LONG: case store::XS_UNSIGNED_SHORT: *json_item = xml_item; break; default: zstring s( xml_item->getStringValue() ); GENV_ITEMFACTORY->createString( *json_item, s ); break; } // switch return true; } // if return false; }
void dynamic_context::set_variable( ulong varid, const store::Item_t& varname, const QueryLoc& loc, store::Item_t& valueItem) { if (varid >= theVarValues.size() || theVarValues[varid].theState == VarValue::undeclared) { RAISE_ERROR(err::XPDY0002, loc, ERROR_PARAMS(ZED(XPDY0002_VariableUndeclared_2), varname->getStringValue())); } VarValue& var = theVarValues[varid]; // variables can be set multiple times, so we need to make sure to remove // previously set temp sequences if (var.theState == VarValue::item) { assert(var.theValue.item != NULL); var.theValue.item->removeReference(); } else if (var.theState == VarValue::temp_seq) { assert(var.theValue.temp_seq != NULL); RCHelper::removeReference(var.theValue.temp_seq); } else if (var.theState == VarValue::declared) { assert(var.theValue.item == NULL); } else { ZORBA_ASSERT(false); } var.theState = VarValue::item; var.theValue.item = valueItem.release(); }
static void j2x_object( store::Item_t const &object_item, store::Item_t *parent_xml_item ) { ZORBA_ASSERT( parent_xml_item ); store::Item_t junk_item, key_item, type_name; store::Iterator_t k( object_item->getObjectKeys() ); k->open(); while ( k->next( key_item ) ) { store::Item_t att_name; GENV_ITEMFACTORY->createQName( att_name, "", "", key_item->getStringValue() ); store::Item_t value_item( object_item->getObjectValue( key_item ) ); zstring value_str( value_item->getStringValue() ); GENV_ITEMFACTORY->createString( value_item, value_str ); type_name = GENV_TYPESYSTEM.XS_UNTYPED_QNAME; GENV_ITEMFACTORY->createAttributeNode( junk_item, *parent_xml_item, att_name, type_name, value_item ); } k->close(); }
void GeneralIndexCondition::pushRange( store::Item_t& lower, store::Item_t& upper, bool haveLower, bool haveUpper, bool lowerIncl, bool upperIncl) { assert(theKind == BOX_VALUE); assert(!theIsSet); assert(!haveLower || (lower && lower->isAtomic())); assert(!haveUpper || (upper && upper->isAtomic())); theRangeFlags.theHaveLowerBound = haveLower; theRangeFlags.theHaveUpperBound = haveUpper; theRangeFlags.theLowerBoundIncl = lowerIncl; theRangeFlags.theUpperBoundIncl = upperIncl; if (haveLower) { theLowerBound.transfer(lower); store::Item* baseItem = theLowerBound->getBaseItem(); if (baseItem != NULL) theLowerBound = baseItem; } if (haveUpper) { theUpperBound.transfer(upper); store::Item* baseItem = theUpperBound->getBaseItem(); if (baseItem != NULL) theUpperBound = baseItem; } theIsSet = true; }
void GeneralIndexCondition::pushItem(store::Item_t& item) { assert(theKind == POINT_VALUE || theKind == POINT_GENERAL); assert(!theIsSet); assert(item && item->isAtomic()); theKey.transfer(item); store::Item* baseItem = theKey->getBaseItem(); if (baseItem != NULL) theKey = baseItem; theIsSet = true; }
void dynamic_context::set_variable( ulong varid, const store::Item_t& varname, const QueryLoc& loc, store::Iterator_t& valueIter) { if (varid >= theVarValues.size() || theVarValues[varid].theState == VarValue::undeclared) { RAISE_ERROR(err::XPDY0002, loc, ERROR_PARAMS(ZED(XPDY0002_VariableUndeclared_2), varname->getStringValue())); } valueIter->open(); // For now, use eager eval because the assignment expression may reference // the variable itself, and the current value of the variable is overwriten // here by this temp sequence. TODO: use lazy eval if we know the the // assignment expression does not reference the variable itself. store::TempSeq_t seq = GENV_STORE.createTempSeq(valueIter, false); // no lazy eval valueIter->close(); VarValue& var = theVarValues[varid]; // variables can be set multiple times, so we need to make sure to remove // previously set temp sequences if (var.theState == VarValue::item) { assert(var.theValue.item != NULL); var.theValue.item->removeReference(); } else if (var.theState == VarValue::temp_seq) { assert(var.theValue.temp_seq != NULL); RCHelper::removeReference(var.theValue.temp_seq); } else if (var.theState == VarValue::declared) { assert(var.theValue.item == NULL); } else { ZORBA_ASSERT(false); } var.theState = VarValue::temp_seq; var.theValue.temp_seq = seq.release(); }
bool EitherNodesOrAtomicsIterator::nextImpl( store::Item_t& result, PlanState& planState) const { EitherNodesOrAtomicsIteratorState* state; DEFAULT_STACK_INIT(EitherNodesOrAtomicsIteratorState, state, planState); if (CONSUME(result, 0)) { state->atomics = !result->isNode(); STACK_PUSH(true, state); while (CONSUME(result, 0)) { if (state->atomics == result->isNode()) throw XQUERY_EXCEPTION(err::XPTY0018, ERROR_LOC(loc)); STACK_PUSH(true, state); } } STACK_END(state); }
void json_to_xml( store::Item_t const &json_item, store::Item_t *xml_item ) { ZORBA_ASSERT( xml_item ); switch ( json_item->getKind() ) { case store::Item::ARRAY: *xml_item = j2x_array( json_item, nullptr ); break; case store::Item::OBJECT: throw XQUERY_EXCEPTION( zerr::ZJ2X0001_JSONML_ARRAY_BAD_JSON, ERROR_PARAMS( ZED( ZJ2X0001_ArrayRequired ) ) ); default: ZORBA_ASSERT( false ); } }
bool get_attribute_value( store::Item_t const &element, char const *att_name, zstring *att_value ) { store::Iterator_t i( element->getAttributes() ); bool found = false; i->open(); store::Item_t att_item; while ( i->next( att_item ) ) { if ( name_of( att_item ) == att_name ) { att_item->getStringValue2( *att_value ); found = true; break; } } i->close(); return found; }
/******************************************************************************* declare updating function remove($uri as xs:string) as empty-sequence() ********************************************************************************/ bool RemoveDocumentIterator::nextImpl( store::Item_t& result, PlanState& aPlanState) const { zstring lRetrievedUriString; zstring lResolvedUriString; store::Item_t lUri; store::Item_t lResolvedUriItem; store::PUL_t lPul; PlanIteratorState* state; DEFAULT_STACK_INIT(PlanIteratorState, state, aPlanState); consumeNext(lUri, theChildren[0].getp(), aPlanState); // absolutize retrieved uri try { lUri->getStringValue2(lRetrievedUriString); lResolvedUriString = theSctx->resolve_relative_uri(lRetrievedUriString, true); } catch (ZorbaException const&) { RAISE_ERROR(err::FODC0004, loc, ERROR_PARAMS(lResolvedUriString, ZED(NoResolveRelativeURI))); } // check if document exists in the store if (GENV_STORE.getDocument(lResolvedUriString) == NULL) { RAISE_ERROR(zerr::ZXQD0002_DOCUMENT_NOT_VALID, loc, ERROR_PARAMS(lResolvedUriString, ZED(NoURIInStore))); } // create the pul and add the primitive GENV_ITEMFACTORY->createAnyURI(lResolvedUriItem, lResolvedUriString); lPul = GENV_ITEMFACTORY->createPendingUpdateList(); lPul->addDeleteDocument(&loc, lResolvedUriItem); result.transfer(lPul); STACK_PUSH(result != NULL, state); STACK_END(state); }
static void x2j_attributes( store::Item_t const &element, store::Item_t *json_item ) { ZORBA_ASSERT( json_item ); store::Item_t att_item; vector<store::Item_t> keys, values; store::Iterator_t i( element->getAttributes() ); i->open(); while ( i->next( att_item ) ) { zstring const att_name( name_of( att_item ) ); if ( att_name != "xmlns" ) { push_back( &keys, att_name ); push_back( &values, att_item->getStringValue() ); } } // while i->close(); if ( !keys.empty() ) GENV_ITEMFACTORY->createJSONObject( *json_item, keys, values ); }
store::Item_t SchemaValidatorImpl::findAttributeItem(const store::Item *parent, store::Item_t &attQName) { store::Iterator_t attributes = parent->getAttributes(); store::Item_t attribute; while ( attributes->next(attribute) ) { ZORBA_ASSERT(attribute->isNode()); ZORBA_ASSERT(attribute->getNodeKind() == store::StoreConsts::attributeNode); store::Item_t currentAttName = attribute->getNodeName(); if (attQName->equals(currentAttName)) { return attribute.getp(); } } //ZORBA_ASSERT(false); return NULL; }
bool TreatIterator::count( store::Item_t &result, PlanState &planState) const { bool const ret_val = theChild->count( result, planState ); xs_integer const count( result->getIntegerValue() ); switch ( theQuantifier ) { case SequenceType::QUANT_QUESTION: if ( count <= numeric_consts<xs_integer>::one() ) break; // no break; case SequenceType::QUANT_ONE: if ( count > numeric_consts<xs_integer>::one() ) raiseError("sequence of more than one item"); // no break; case SequenceType::QUANT_PLUS: if ( count == numeric_consts<xs_integer>::zero() ) raiseError("empty-sequence()"); break; default: // do nothing break; } return ret_val; }
void dynamic_context::unset_variable( ulong varid, const store::Item_t& varname, const QueryLoc& loc) { if (varid >= theVarValues.size() || theVarValues[varid].theState == VarValue::undeclared) { RAISE_ERROR(err::XPDY0002, loc, ERROR_PARAMS(ZED(XPDY0002_VariableUndeclared_2), varname->getStringValue())); } VarValue& var = theVarValues[varid]; if (var.theState == VarValue::item) { assert(var.theValue.item != NULL); var.theValue.item->removeReference(); } else if (var.theState == VarValue::temp_seq) { assert(var.theValue.temp_seq != NULL); RCHelper::removeReference(var.theValue.temp_seq); } else if (var.theState == VarValue::declared) { assert(var.theValue.item == NULL); } else { ZORBA_ASSERT(false); } var.theState = VarValue::declared; var.theValue.item = NULL; }
void processOptions(store::Item_t item, store::LoadProperties& props, static_context* theSctx, const QueryLoc& loc) { URI lValidatedBaseUri; store::Item_t child, tempItem; if (item.getp() == NULL) return; #ifndef ZORBA_NO_XMLSCHEMA if (item->isValidated()) { if (item->getNodeName() == NULL || item->getNodeName()->getNamespace() != static_context::ZORBA_XML_FN_OPTIONS_NS) { throw XQUERY_EXCEPTION(zerr::ZXQD0003_INCONSISTENT_PARSE_FRAGMENT_OPTIONS, ERROR_PARAMS(ZED(ParseFragmentInvalidOptions)), ERROR_LOC( loc )); } } else { tempItem = NULL; // used as the effectiveValidationValue()'s typeName Validator::effectiveValidationValue( item, item, tempItem, theSctx->get_typemanager(), ParseConstants::val_strict, theSctx, loc); } #endif store::Iterator_t children = item->getChildren(); children->open(); while (children->next(child)) { if (child->getNodeKind() != store::StoreConsts::elementNode) continue; if (child->getNodeName()->getLocalName() == "base-uri") { store::Item_t attr = getFirstAttribute(child); try { lValidatedBaseUri = URI(attr->getStringValue()); } catch (ZorbaException const& /* e */) { throw XQUERY_EXCEPTION( err::FODC0007, ERROR_PARAMS( attr->getStringValue() ), ERROR_LOC( loc ) ); } if (!lValidatedBaseUri.is_absolute()) { throw XQUERY_EXCEPTION( err::FODC0007, ERROR_PARAMS( lValidatedBaseUri.toString() ), ERROR_LOC( loc ) ); } props.setBaseUri(attr->getStringValue()); } else if (child->getNodeName()->getLocalName() == "no-error") props.setNoError(true); else if (child->getNodeName()->getLocalName() == "strip-boundary-space") props.setStripWhitespace(true); else if (child->getNodeName()->getLocalName() == "schema-validate") { store::Item_t attr = getFirstAttribute(child); if (attr->getStringValue() == "strict") props.setSchemaStrictValidate(true); else props.setSchemaLaxValidate(true); } else if (child->getNodeName()->getLocalName() == "DTD-validate") props.setDTDValidate(true); else if (child->getNodeName()->getLocalName() == "DTD-load") props.setDTDLoad(true); else if (child->getNodeName()->getLocalName() == "default-DTD-attributes") props.setDefaultDTDAttributes(true); else if (child->getNodeName()->getLocalName() == "parse-external-parsed-entity") { props.setParseExternalParsedEntity(true); store::Item_t attr; store::Iterator_t attribs = child->getAttributes(); attribs->open(); while (attribs->next(attr)) { if (attr->getNodeName()->getLocalName() == "skip-root-nodes") props.setSkipRootNodes(ztd::aton<xs_int>(attr->getStringValue().c_str())); else if (attr->getNodeName()->getLocalName() == "skip-top-level-text-nodes") props.setSkipTopLevelTextNodes(true); else if (attr->getNodeName()->getLocalName() == "error-on-doctype") props.setErrorOnDoctype(true); } attribs->close(); } else if (child->getNodeName()->getLocalName() == "substitute-entities") props.setSubstituteEntities(true); else if (child->getNodeName()->getLocalName() == "xinclude-substitutions") props.setXincludeSubstitutions(true); else if (child->getNodeName()->getLocalName() == "remove-redundant-ns") props.setRemoveRedundantNS(true); else if (child->getNodeName()->getLocalName() == "no-CDATA") props.setNoCDATA(true); else if (child->getNodeName()->getLocalName() == "no-xinclude-nodes") props.setNoXIncludeNodes(true); else if (child->getNodeName()->getLocalName() == "no-network-access") props.setNoNetworkAccess(true); } children->close(); if (props.getSchemaLaxValidate() + props.getSchemaStrictValidate() + props.getDTDValidate() + props.getParseExternalParsedEntity() > 1) { throw XQUERY_EXCEPTION(zerr::ZXQD0003_INCONSISTENT_PARSE_FRAGMENT_OPTIONS, ERROR_PARAMS(ZED(ParseFragmentOptionCombinationNotAllowed)), ERROR_LOC( loc )); } }
bool TreatIterator::nextImpl(store::Item_t& result, PlanState& planState) const { store::Item_t temp; bool res; const TypeManager* tm = theSctx->get_typemanager(); PlanIteratorState* state; DEFAULT_STACK_INIT(PlanIteratorState, state, planState); if (!consumeNext(result, theChild.getp(), planState)) { if (theQuantifier == SequenceType::QUANT_PLUS || theQuantifier == SequenceType::QUANT_ONE) { raiseError("empty-sequence()"); } } else if (theQuantifier == SequenceType::QUANT_QUESTION || theQuantifier == SequenceType::QUANT_ONE) { if (consumeNext(temp, theChild.getp(), planState)) { raiseError("sequence of more than one item"); } if (theCheckPrime) { if (theTreatType->type_kind() == XQType::ATOMIC_TYPE_KIND && result->isAtomic()) { store::SchemaTypeCode targetType = static_cast<const AtomicXQType*>(theTreatType.getp())->get_type_code(); store::SchemaTypeCode itemType = result->getTypeCode(); res = TypeOps::is_subtype(itemType, targetType); } else { res = TypeOps::is_subtype(tm, result, *theTreatType, loc); } if (!res) { zstring valueType = tm->create_value_type(result)->toSchemaString(); raiseError(valueType); } } STACK_PUSH(true, state); } else { do { if (theCheckPrime) { if (theTreatType->type_kind() == XQType::ATOMIC_TYPE_KIND && result->isAtomic()) { store::SchemaTypeCode targetType = static_cast<const AtomicXQType*>(theTreatType.getp())->get_type_code(); store::SchemaTypeCode itemType = result->getTypeCode(); res = TypeOps::is_subtype(itemType, targetType); } else { res = TypeOps::is_subtype(tm, result, *theTreatType, loc); } if (!res) { zstring valueType = tm->create_value_type(result)->toSchemaString(); raiseError(valueType); } } STACK_PUSH(true, state); } while (consumeNext(result, theChild.getp(), planState)); } STACK_END(state); }
bool GenericArithIterator<Operation>::compute( store::Item_t& result, dynamic_context* dctx, const TypeManager* tm, const QueryLoc& aLoc, store::Item_t& n0, store::Item_t& n1) { RootTypeManager& rtm = GENV_TYPESYSTEM; assert(n0->isAtomic()); assert(n1->isAtomic()); store::SchemaTypeCode type0 = n0->getTypeCode(); store::SchemaTypeCode type1 = n1->getTypeCode(); if (TypeOps::is_numeric(type0) && (TypeOps::is_subtype(type1, store::XS_YM_DURATION) || TypeOps::is_subtype(type1, store::XS_DT_DURATION))) { GenericCast::castToAtomic(n0, n0, &*rtm.DOUBLE_TYPE_ONE, tm, NULL, aLoc); if (TypeOps::is_subtype(type1, store::XS_YM_DURATION)) { return Operation::template compute<store::XS_DOUBLE, store::XS_YM_DURATION> (result, dctx, tm, &aLoc, n0, n1); } else { return Operation::template compute<store::XS_DOUBLE,store::XS_DT_DURATION> (result, dctx, tm, &aLoc, n0, n1); } } else if (TypeOps::is_subtype(type0, store::XS_DT_DURATION) && TypeOps::is_subtype(type1, store::XS_TIME)) { return Operation::template compute<store::XS_DURATION,store::XS_TIME> (result, dctx, tm, &aLoc, n0, n1); } else if (TypeOps::is_subtype(type0, store::XS_YM_DURATION)) { if (TypeOps::is_numeric(type1)) { GenericCast::castToAtomic(n1, n1, &*rtm.DOUBLE_TYPE_ONE, tm, NULL, aLoc); return Operation::template compute<store::XS_YM_DURATION,store::XS_DOUBLE> (result, dctx, tm, &aLoc, n0, n1); } else if (TypeOps::is_subtype(type1, store::XS_DATETIME)) { return Operation::template compute<store::XS_DURATION,store::XS_DATETIME> (result, dctx, tm, &aLoc, n0, n1); } else if (TypeOps::is_subtype(type1, store::XS_DATE)) { return Operation::template compute<store::XS_DURATION,store::XS_DATE> (result, dctx, tm, &aLoc, n0, n1); } else if (type0 == type1) { return Operation::template computeSingleType<store::XS_YM_DURATION> (result, dctx, tm, &aLoc, n0, n1); } } else if (TypeOps::is_subtype(type0, store::XS_DT_DURATION)) { if (TypeOps::is_numeric(type1)) { GenericCast::castToAtomic(n1, n1, &*rtm.DOUBLE_TYPE_ONE, tm, NULL, aLoc); return Operation::template compute<store::XS_DT_DURATION,store::XS_DOUBLE> (result, dctx, tm, &aLoc, n0, n1); } else if (TypeOps::is_subtype(type1, store::XS_DATETIME)) { return Operation::template compute<store::XS_DURATION,store::XS_DATETIME> (result, dctx, tm, &aLoc, n0, n1); } else if (TypeOps::is_subtype(type1, store::XS_DATE)) { return Operation::template compute<store::XS_DURATION,store::XS_DATE> (result, dctx, tm, &aLoc, n0, n1); } else if (type0 == type1) { return Operation::template computeSingleType<store::XS_DT_DURATION> (result, dctx, tm, &aLoc, n0, n1); } } else if (TypeOps::is_subtype(type0, store::XS_DATETIME)) { if (TypeOps::is_subtype(type1, store::XS_DATETIME)) { return Operation::template compute<store::XS_DATETIME,store::XS_DATETIME> (result, dctx, tm, &aLoc, n0, n1); } else if (TypeOps::is_subtype(type1, store::XS_YM_DURATION)) { return Operation::template compute<store::XS_DATETIME,store::XS_DURATION> (result, dctx, tm, &aLoc, n0, n1); } else if (TypeOps::is_subtype(type1, store::XS_DT_DURATION)) { return Operation::template compute<store::XS_DATETIME,store::XS_DURATION> (result, dctx, tm, &aLoc, n0, n1); } } else if (TypeOps::is_subtype(type0, store::XS_DATE)) { if (TypeOps::is_subtype(type1, store::XS_DATE)) { return Operation::template compute<store::XS_DATE,store::XS_DATE> (result, dctx, tm, &aLoc, n0, n1); } else if (TypeOps::is_subtype(type1, store::XS_YM_DURATION)) { return Operation::template compute<store::XS_DATE,store::XS_DURATION> (result, dctx, tm, &aLoc, n0, n1); } else if (TypeOps::is_subtype(type1, store::XS_DT_DURATION)) { return Operation::template compute<store::XS_DATE,store::XS_DURATION> (result, dctx, tm, &aLoc, n0, n1); } } else if (TypeOps::is_subtype(type0, store::XS_TIME)) { if (TypeOps::is_subtype(type1, store::XS_TIME)) { return Operation::template compute<store::XS_TIME,store::XS_TIME> (result, dctx, tm, &aLoc, n0, n1); } else if (TypeOps::is_subtype(type1, store::XS_DT_DURATION)) { return Operation::template compute<store::XS_TIME,store::XS_DURATION> (result, dctx, tm, &aLoc, n0, n1); } } else if ((TypeOps::is_numeric(type0) || type0 == store::XS_UNTYPED_ATOMIC) && (TypeOps::is_numeric(type1) || type1 == store::XS_UNTYPED_ATOMIC)) { return NumArithIterator<Operation>:: computeAtomic(result, dctx, tm, aLoc, n0, type0, n1, type1); } { xqtref_t type0 = tm->create_value_type(n0); xqtref_t type1 = tm->create_value_type(n1); RAISE_ERROR(err::XPTY0004, aLoc, ERROR_PARAMS(ZED(ArithOpNotDefinedBetween_23), *type0, *type1)); } return false; // suppresses wanring }
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); }
static store::Item_t j2x_array( store::Item_t const &array_item, store::Item *parent_xml_item ) { zstring base_uri; store::NsBindings ns_bindings; store::Item_t array_elt_item, element_name, junk_item, type_name, xml_item; store::Iterator_t i( array_item->getArrayValues() ); i->open(); if ( !i->next( array_elt_item ) ) throw XQUERY_EXCEPTION( zerr::ZJ2X0001_JSONML_ARRAY_BAD_JSON, ERROR_PARAMS( ZED( ZJ2X0001_EmptyArray ) ) ); if ( !array_elt_item->isAtomic() || !TypeOps::is_subtype( array_elt_item->getTypeCode(), store::XS_STRING ) ) throw XQUERY_EXCEPTION( zerr::ZJ2X0001_JSONML_ARRAY_BAD_JSON, ERROR_PARAMS( ZED( ZJ2X0001_Bad1stElement ) ) ); GENV_ITEMFACTORY->createQName( element_name, "", "", array_elt_item->getStringValue() ); type_name = GENV_TYPESYSTEM.XS_UNTYPED_QNAME; GENV_ITEMFACTORY->createElementNode( xml_item, parent_xml_item, element_name, type_name, false, false, ns_bindings, base_uri ); bool did_attributes = false; while ( i->next( array_elt_item ) ) { switch ( array_elt_item->getKind() ) { case store::Item::ARRAY: j2x_array( array_elt_item, xml_item.getp() ); break; case store::Item::ATOMIC: { zstring value_str( array_elt_item->getStringValue() ); GENV_ITEMFACTORY->createTextNode( junk_item, xml_item, value_str ); break; } case store::Item::OBJECT: if ( did_attributes ) throw XQUERY_EXCEPTION( zerr::ZJ2X0001_JSONML_ARRAY_BAD_JSON, ERROR_PARAMS( ZED( ZJ2X0001_UnexpectedObject ) ) ); j2x_object( array_elt_item, &xml_item ); did_attributes = true; break; default: throw XQUERY_EXCEPTION( zerr::ZJ2X0001_JSONML_ARRAY_BAD_JSON, ERROR_PARAMS( ZED( ZJ2X0001_BadElement ), array_elt_item->getKind() ) ); } // switch } // while i->close(); return xml_item; }