void SimpleLazyTempSeqIter::init(
const store::TempSeq_t& seq,
xs_integer startPos,
xs_integer endPos)
{
assert(seq->isLazy());
theTempSeq = static_cast<SimpleLazyTempSeq*>(seq.getp());
try
{
theStartPos = to_xs_long(startPos);
}
catch ( std::range_error const& )
{
throw ZORBA_EXCEPTION(
zerr::ZSTR0060_RANGE_EXCEPTION,
ERROR_PARAMS( startPos, ZED( ZSTR0060_ForSequence ) )
);
}
try
{
theEndPos = to_xs_long(endPos);
}
catch ( std::range_error const& )
{
throw ZORBA_EXCEPTION(
zerr::ZSTR0060_RANGE_EXCEPTION,
ERROR_PARAMS( endPos, ZED( ZSTR0060_ForSequence ) )
);
}
theCurPos = theStartPos - 1;
}
SimpleLazyTempSeqIter::SimpleLazyTempSeqIter(
const SimpleLazyTempSeq* tempSeq,
xs_integer startPos,
xs_integer endPos)
:
theTempSeq(const_cast<SimpleLazyTempSeq*>(tempSeq))
{
try
{
theStartPos = to_xs_long(startPos);
}
catch ( std::range_error const& )
{
throw ZORBA_EXCEPTION(
zerr::ZSTR0060_RANGE_EXCEPTION,
ERROR_PARAMS( startPos, ZED( ZSTR0060_ForSequence ) )
);
}
try
{
theEndPos = to_xs_long(endPos);
}
catch ( std::range_error const& )
{
throw ZORBA_EXCEPTION(
zerr::ZSTR0060_RANGE_EXCEPTION,
ERROR_PARAMS( endPos, ZED( ZSTR0060_ForSequence ) )
);
}
theCurPos = theStartPos - 1;
}
void areNodeModifiersViolated(
const static_context* aSctx,
const store::Item* aTarget,
const QueryLoc& aLoc)
{
const store::Collection* lColl = aTarget->getCollection();
if (lColl != 0 && !lColl->isDynamic())
{
const StaticallyKnownCollection* lDeclColl =
aSctx->lookup_collection(lColl->getName());
if (lDeclColl == NULL)
{
throw XQUERY_EXCEPTION(zerr::ZDDY0001_COLLECTION_NOT_DECLARED,
ERROR_PARAMS(lColl->getName()->getStringValue()),
ERROR_LOC(aLoc));
}
switch(lDeclColl->getNodeModifier())
{
case StaticContextConsts::read_only:
throw XQUERY_EXCEPTION(zerr::ZDDY0010_COLLECTION_CONST_NODE_UPDATE,
ERROR_PARAMS( lColl->getName()->getStringValue() ),
ERROR_LOC(aLoc));
case StaticContextConsts::mutable_node:
// good to go
break;
}
}
}
AnnotationList::RuleBitSet AnnotationList::checkDuplicateDeclarations(
DeclarationKind declKind,
const QueryLoc& loc) const
{
RuleBitSet lCurrAnn;
// mark and detect duplicates
for (Annotations::const_iterator ite = theAnnotationList.begin();
ite != theAnnotationList.end();
++ite)
{
const store::Item* qname = (*ite)->getQName();
AnnotationId id = (*ite)->getId();
// detect duplicate annotations (if we "know" them)
if (id != AnnotationInternal::zann_end && lCurrAnn.test(id))
{
if (declKind == var_decl)
{
RAISE_ERROR(err::XQST0116, loc,
ERROR_PARAMS(ZED(XQST0116_Duplicate), qname->getStringValue()));
}
else
{
RAISE_ERROR(err::XQST0106, loc,
ERROR_PARAMS(ZED(XQST0106_Duplicate), qname->getStringValue()));
}
}
lCurrAnn.set(id);
}
return lCurrAnn;
}
store::IndexCondition_t IndexImpl::createCondition(store::IndexCondition::Kind k)
{
if (!isSorted() &&
(k == store::IndexCondition::BOX_VALUE ||
k == store::IndexCondition::BOX_GENERAL))
{
RAISE_ERROR_NO_LOC(zerr::ZSTR0007_INDEX_UNSUPPORTED_PROBE_CONDITION,
ERROR_PARAMS(IndexConditionImpl::getKindString(k), getName()->getStringValue()));
}
if (isGeneral())
{
return new GeneralIndexCondition(this, k);
}
else if (k == store::IndexCondition::POINT_VALUE)
{
return new IndexPointCondition(this, k);
}
else if (k == store::IndexCondition::BOX_VALUE)
{
return new IndexBoxValueCondition(this, k);
}
else
{
RAISE_ERROR_NO_LOC(zerr::ZSTR0007_INDEX_UNSUPPORTED_PROBE_CONDITION,
ERROR_PARAMS(IndexConditionImpl::getKindString(k), getName()->getStringValue()));
ZORBA_ASSERT(false);
}
}
bool
IndexKeysIterator::nextImpl(
store::Item_t& result,
PlanState& aPlanState) const
{
store::Item_t lQName;
IndexDecl_t indexDecl;
store::IndexKey lKey;
store::Item_t lKeyNodeName;
GENV_ITEMFACTORY->createQName(lKeyNodeName,
static_context::ZORBA_STORE_UNORDERED_MAPS_FN_NS,
"", "key");
IndexKeysIteratorState* state;
DEFAULT_STACK_INIT(IndexKeysIteratorState, state, aPlanState);
consumeNext(lQName, theChildren[0].getp(), aPlanState);
if ((indexDecl = theSctx->lookup_index(lQName)) == NULL)
{
throw XQUERY_EXCEPTION(
zerr::ZDDY0021_INDEX_NOT_DECLARED,
ERROR_PARAMS( lQName->getStringValue() ),
ERROR_LOC( loc )
);
}
state->theIndex = GENV_STORE.getIndex(lQName);
if (!state->theIndex)
{
throw XQUERY_EXCEPTION(
zerr::ZDDY0023_INDEX_DOES_NOT_EXIST,
ERROR_PARAMS( lQName->getStringValue() ),
ERROR_LOC( loc )
);
}
state->theIter = state->theIndex->keys();
state->theIter->open();
// generate result elements of the form
// <key>
// <attribute value="key1_value"/>
// <attribute value="key2_value"/>
// <attribute value="key3_value"/>
// </key>
while (state->theIter->next(lKey))
{
IndexUtil::createIndexKeyElement(
state->theIndex->getSpecification().theIsGeneral,
result, lKey, static_context::ZORBA_STORE_STATIC_INDEXES_DML_FN_NS
);
STACK_PUSH(true, state);
}
STACK_END(state);
}
Item ItemFactoryImpl::createQName(
const String& aNamespace,
const String& aPrefix,
const String& aLocalname)
{
zstring const &lNamespace = Unmarshaller::getInternalString( aNamespace );
zstring const &lPrefix = Unmarshaller::getInternalString( aPrefix );
zstring const &lLocalname = Unmarshaller::getInternalString( aLocalname );
if (!GenericCast::instance()->castableToNCName(lLocalname.c_str()))
{
RAISE_ERROR_NO_LOC(err::FORG0001,
ERROR_PARAMS(ZED(FORG0001_LocalNotNCName_2), lLocalname));
}
if (lPrefix.size() && !GenericCast::instance()->castableToNCName(lPrefix.c_str()))
{
RAISE_ERROR_NO_LOC(err::FORG0001,
ERROR_PARAMS(ZED(FORG0001_PrefixNotNCName_2), lPrefix));
}
store::Item_t lItem;
theItemFactory->createQName(lItem, lNamespace, lPrefix, lLocalname);
return &*lItem;
}
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;
}
/*******************************************************************************
declare updating function
put($uri as xs:string, $doc as xs:document-node()) as empty-sequence()
********************************************************************************/
bool PutDocumentIterator::nextImpl(
store::Item_t& result,
PlanState& aPlanState) const
{
zstring lRetrievedUriString;
zstring lResolvedUriString;
store::Item_t lUri;
store::Item_t lDoc;
store::Item_t lResolvedUriItem;
std::unique_ptr<store::PUL> 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 already exists in the store
if (GENV_STORE.getDocument(lResolvedUriString) != NULL)
{
RAISE_ERROR(zerr::ZAPI0020_DOCUMENT_ALREADY_EXISTS, loc,
ERROR_PARAMS(lResolvedUriString));
}
// create the pul and add the primitive
GENV_ITEMFACTORY->createAnyURI(lResolvedUriItem, lResolvedUriString);
lPul.reset(GENV_ITEMFACTORY->createPendingUpdateList());
consumeNext(lDoc, theChildren[1].getp(), aPlanState);
lPul->addCreateDocument(&loc, lResolvedUriItem, lDoc);
result = lPul.release();
STACK_PUSH(result != NULL, state);
STACK_END(state);
}
void dynamic_context::set_implicit_timezone(long tzone_seconds)
{
if (tzone_seconds > 14*3600 || tzone_seconds < -14*3600)
throw XQUERY_EXCEPTION(err::FODT0003, ERROR_PARAMS(tzone_seconds));
theTimezone = tzone_seconds;
}
/*******************************************************************************
declare function
is-available-document($uri as xs:string) as xs:boolean
********************************************************************************/
bool IsAvailableDocumentIterator::nextImpl(
store::Item_t& result,
PlanState& aPlanState) const
{
zstring lRetrievedUriString;
zstring lResolvedUriString;
store::Item_t lUri;
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
GENV_ITEMFACTORY->
createBoolean(result, GENV_STORE.getDocument(lResolvedUriString) != NULL);
STACK_PUSH(true, state);
STACK_END(state);
}
void relpath_expr::compute_scripting_kind()
{
theScriptingKind = UNKNOWN_SCRIPTING_KIND;
for (unsigned i = 0; i < size(); ++i)
{
expr* step = theSteps[i];
if (step->is_updating())
{
throw XQUERY_EXCEPTION(err::XUST0001,
ERROR_PARAMS(ZED(XUST0001_Generic)),
ERROR_LOC(get_loc()));
}
theScriptingKind |= step->get_scripting_detail();
}
theScriptingKind &= ~VACUOUS_EXPR;
if (is_sequential(theScriptingKind))
theScriptingKind &= ~SIMPLE_EXPR;
checkScriptingKind();
}
Resource*
FileURLResolver::resolveURL
(zstring const& aUrl, EntityData const* aEntityData)
{
switch ( aEntityData->getKind() ) {
case EntityData::COLLECTION:
#ifndef ZORBA_NO_FULL_TEXT
case EntityData::THESAURUS:
#endif /* ZORBA_NO_FULL_TEXT */
return nullptr;
default:
break;
}
uri::scheme lScheme = uri::get_scheme(aUrl);
if (lScheme != uri::file) {
return NULL;
}
try {
std::string lPath( fs::normalize_path(aUrl) );
if (fs::get_type(lPath) == fs::file) {
std::ifstream* lStream = new std::ifstream(lPath.c_str());
return new StreamResource(
lStream, &fileStreamReleaser, "", true /* seekable */);
}
return NULL;
}
catch ( std::invalid_argument const &e ) {
throw XQUERY_EXCEPTION( err::XPTY0004, ERROR_PARAMS( e.what() ) );
}
}
void AnnotationList::checkLiterals(DeclarationKind k, const QueryLoc& loc) const
{
for (Annotations::const_iterator ite = theAnnotationList.begin();
ite != theAnnotationList.end();
++ite)
{
AnnotationInternal* lAnn = *ite;
switch (lAnn->getId())
{
case AnnotationInternal::zann_exclude_from_cache_key:
case AnnotationInternal::zann_compare_with_deep_equal:
//One or more integers
if (!lAnn->getNumLiterals())
{
RAISE_ERROR(zerr::ZXQP0062_INVALID_ANNOTATION_LITERALS_NUMBER, loc,
ERROR_PARAMS(
AnnotationInternal::lookup(lAnn->getId())->getStringValue(),
ZED(ZXQP0062_ONE_OR_MORE_LITERALS)));
}
for (csize i=0; i<lAnn->getNumLiterals(); ++i)
checkLiteralType(lAnn, lAnn->getLiteral(i), store::XS_INTEGER, loc);
break;
default:
break;
}
}
}
void SimpleLazyTempSeq::getItem(xs_integer position, store::Item_t& result)
{
xs_long pos;
try
{
pos = to_xs_long(position);
}
catch (std::range_error const&)
{
RAISE_ERROR_NO_LOC(zerr::ZSTR0060_RANGE_EXCEPTION,
ERROR_PARAMS(position,ZED(ZSTR0060_ForSequence)));
}
ZORBA_ASSERT(pos > thePurgedUpTo);
std::vector<store::Item*>::size_type numItemsToBuffer = pos - thePurgedUpTo;
while (!theMatFinished && theItems.size() < numItemsToBuffer)
{
matNextItem();
}
if (theItems.size() >= numItemsToBuffer)
{
std::vector<store::Item*>::size_type sPos = static_cast<std::vector<store::Item*>::size_type>(pos - thePurgedUpTo - 1);
result = theItems[sPos];
}
else
{
result = NULL;
}
}
ModuleInfo* XQueryCompiler::parseInfo(
std::istream& aXQuery,
const zstring& aFileName)
{
parsenode_t lParseNode = parse(aXQuery, aFileName);
if (typeid (*lParseNode) == typeid (ParseErrorNode))
{
ParseErrorNode* pen = static_cast<ParseErrorNode *>(lParseNode.getp());
throw XQUERY_EXCEPTION_VAR(pen->err,
ERROR_PARAMS(pen->msg), ERROR_LOC(pen->get_location()));
}
LibraryModule* lLibModule = dynamic_cast<LibraryModule*>(lParseNode.getp());
zstring lTargetNamespace;
if (lLibModule)
{
ModuleDecl* lDecl = lLibModule->get_decl().getp();
lTargetNamespace = lDecl->get_target_namespace();
}
return new ModuleInfoImpl(lTargetNamespace);
}
void SimpleLazyTempSeq::purgeUpTo(xs_integer position)
{
xs_long pos;
try
{
pos = to_xs_long(position);
}
catch (std::range_error const&)
{
throw ZORBA_EXCEPTION(zerr::ZSTR0060_RANGE_EXCEPTION,
ERROR_PARAMS(position,ZED(ZSTR0060_ForSequence)));
}
ZORBA_ASSERT(pos >= thePurgedUpTo);
ZORBA_ASSERT(static_cast<std::vector<store::Item*>::size_type>(pos - thePurgedUpTo) <= theItems.size());
std::vector<store::Item*>::iterator ite = theItems.begin();
std::vector<store::Item*>::iterator end = theItems.begin() + static_cast<std::vector<store::Item*>::size_type>(pos - thePurgedUpTo);
for (; ite != end; ++ite)
{
(*ite)->removeReference();
}
theItems.erase(theItems.begin(), end);
thePurgedUpTo = pos;
}
bool OpNumericUnaryIterator::nextImpl(store::Item_t& result, PlanState& planState) const
{
store::Item_t item;
store::SchemaTypeCode type;
const TypeManager* tm = theSctx->get_typemanager();
PlanIteratorState* state;
DEFAULT_STACK_INIT(PlanIteratorState, state, planState);
if (consumeNext(item, theChild.getp(), planState ))
{
assert(item->isAtomic());
type = item->getTypeCode();
if (type == store::XS_UNTYPED_ATOMIC)
{
GenericCast::castToBuiltinAtomic(item, item, store::XS_DOUBLE, NULL, loc);
type = store::XS_DOUBLE;
}
// TODO Optimizations (e.g. if item has already the correct type and value,
// it does not have to be created newly)
if (TypeOps::is_subtype(type, store::XS_DOUBLE))
{
GENV_ITEMFACTORY->
createDouble(result,
(thePlus ? item->getDoubleValue() : -item->getDoubleValue()));
}
else if (TypeOps::is_subtype(type, store::XS_FLOAT))
{
GENV_ITEMFACTORY->
createFloat(result,
(thePlus ? item->getFloatValue() : -item->getFloatValue()));
}
else if (TypeOps::is_subtype(type, store::XS_INTEGER))
{
GENV_ITEMFACTORY->
createInteger(result,
(thePlus ? item->getIntegerValue() : -item->getIntegerValue()));
}
else if (TypeOps::is_subtype(type, store::XS_DECIMAL))
{
GENV_ITEMFACTORY->
createDecimal(result,
(thePlus ? item->getDecimalValue() : -item->getDecimalValue()));
}
else
{
xqtref_t type = tm->create_value_type(item);
RAISE_ERROR(err::XPTY0004, loc,
ERROR_PARAMS(ZED(BadTypeFor_23), type->toSchemaString(), ZED(UnaryArithOp)));
}
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();
}
/*******************************************************************************
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 AnnotationList::checkRequiredDeclarations(
RuleBitSet declaredAnn,
DeclarationKind declKind,
const QueryLoc& loc) const
{
// check rules
std::vector<AnnotationRequirement>::const_iterator ite = AnnotationInternal::theRequiredRuleSet.begin();
std::vector<AnnotationRequirement>::const_iterator end = AnnotationInternal::theRequiredRuleSet.end();
for (; ite != end; ++ite)
{
const AnnotationId& lCurrAnn = ite->first;
const RuleBitSet& lCurrSet = ite->second;
if (declaredAnn.test(lCurrAnn) && (declaredAnn & lCurrSet).count() == 0)
{
// build error string to return set of required annotations
std::ostringstream lProblems;
for (csize i = 0, j = 0; i < AnnotationInternal::zann_end; ++i)
{
if (lCurrSet.test(i))
{
AnnotationId id = static_cast<AnnotationId>(i);
lProblems << AnnotationInternal::lookup(id)->getStringValue()
<< ((j == lCurrSet.count() - 1) ? "" : ", ");
++j;
}
}
if (declKind == var_decl)
{
RAISE_ERROR(err::XQST0116, loc,
ERROR_PARAMS(ZED(XQST0116_Requirement),
AnnotationInternal::lookup(lCurrAnn)->getStringValue(),
lProblems.str()));
}
else
{
RAISE_ERROR(err::XQST0106, loc,
ERROR_PARAMS(ZED(XQST0106_Requirement),
AnnotationInternal::lookup(lCurrAnn)->getStringValue(),
lProblems.str()));
}
}
}
}
/*******************************************************************************
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);
}
void AnnotationList::checkConflictingDeclarations(
RuleBitSet currAnn,
DeclarationKind declKind,
const QueryLoc& loc) const
{
// check rules
std::vector<RuleBitSet>::const_iterator ite = AnnotationInternal::theConflictRuleSet.begin();
std::vector<RuleBitSet>::const_iterator end = AnnotationInternal::theConflictRuleSet.end();
for (; ite != end; ++ite)
{
const RuleBitSet& lCurrSet = *ite;
if ((currAnn & lCurrSet).count() > 1)
{
// build error string to return set of conflicting annotations
std::ostringstream lProblems;
for (csize i = 0, j = 0; i < AnnotationInternal::zann_end; ++i)
{
if (lCurrSet.test(i))
{
AnnotationId id = static_cast<AnnotationId>(i);
lProblems << AnnotationInternal::lookup(id)->getStringValue()
<< ((j == (currAnn & lCurrSet).count() - 1) ? "" : ", ");
++j;
}
}
if (declKind == var_decl)
{
RAISE_ERROR(err::XQST0116, loc,
ERROR_PARAMS(ZED(XQST0116_Conflicting), lProblems.str()));
}
else
{
RAISE_ERROR(err::XQST0106, loc,
ERROR_PARAMS(ZED(XQST0106_Conflicting), lProblems.str()));
}
}
}
}
void ArithOperationsCommons::createError(
const TypeManager* tm,
const char* aOp,
const QueryLoc* aLoc,
store::SchemaTypeCode aType0,
store::SchemaTypeCode aType1)
{
xqtref_t t0 = tm->create_builtin_atomic_type(aType0,SequenceType::QUANT_ONE);
xqtref_t t1 = tm->create_builtin_atomic_type(aType1,SequenceType::QUANT_ONE);
RAISE_ERROR(err::XPTY0004, aLoc,
ERROR_PARAMS(ZED(OperationNotPossibleWithTypes_234), aOp, *t0, *t1 ));
}
/******************************************************************************
Create a dummy main module to wrap a library module.
******************************************************************************/
parsenode_t XQueryCompiler::createMainModule(
parsenode_t aLibraryModule,
std::istream& aXQuery,
const zstring& aFileName)
{
//get the namespace from the LibraryModule
LibraryModule* mod_ast = dynamic_cast<LibraryModule *>(&*aLibraryModule);
if (!mod_ast)
throw ZORBA_EXCEPTION(zerr::ZAPI0002_XQUERY_COMPILATION_FAILED,
ERROR_PARAMS(ZED(BadLibraryModule)));
const zstring& lib_namespace = mod_ast->get_decl()->get_target_namespace();
URI lURI(lib_namespace);
if(!lURI.is_absolute())
{
throw XQUERY_EXCEPTION(err::XQST0046,
ERROR_PARAMS(lURI.toString(), ZED(MustBeAbsoluteURI)),
ERROR_LOC(mod_ast->get_decl()->get_location()));
}
// Set up the original query stream as the result of resolving the
// library module's URI
aXQuery.clear();
aXQuery.seekg(0);
FakeLibraryModuleURLResolver* aFakeResolver =
new FakeLibraryModuleURLResolver(aFileName, aXQuery);
theCompilerCB->theRootSctx->add_url_resolver(aFakeResolver);
// create a dummy main module and parse it
std::stringstream lDocStream;
zstring tmp;
zorba::xml::escape(lib_namespace, &tmp);
lDocStream << "import module namespace m = '" << tmp << "'; 1";
return parse(lDocStream, aFileName);
}
Item ItemFactoryImpl::createNCName(const String& aValue)
{
zstring lString = Unmarshaller::getInternalString(aValue);
if (!GenericCast::instance()->castableToNCName(lString.c_str()))
{
RAISE_ERROR_NO_LOC(err::FORG0001,
ERROR_PARAMS(ZED(FORG0001_NameNotNCName_2), lString));
}
store::Item_t lItem;
theItemFactory->createNCName(lItem, lString);
return &*lItem;
}
/*******************************************************************************
declare function
document($uri as xs:string) as document-node()
********************************************************************************/
bool RetrieveDocumentIterator::nextImpl(
store::Item_t& result,
PlanState& aPlanState) const
{
zstring lRetrievedUriString;
zstring lResolvedUriString;
store::Item_t lUri;
store::Item_t lResolvedUriItem;
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 ((result = GENV_STORE.getDocument(lResolvedUriString)) == NULL)
{
RAISE_ERROR(zerr::ZXQD0002_DOCUMENT_NOT_VALID, loc,
ERROR_PARAMS(lResolvedUriString, ZED( NoURIInStore)));
}
STACK_PUSH(true, state);
STACK_END(state);
}
bool IntegerDivideOperation::compute<store::XS_DOUBLE,store::XS_DOUBLE>(
store::Item_t& result,
dynamic_context* /* dctx */,
const TypeManager* /* tm */,
const QueryLoc* loc,
const store::Item* i0,
const store::Item* i1 )
{
xs_double d0 = i0->getDoubleValue();
xs_double d1 = i1->getDoubleValue();
if ( d1 == numeric_consts<xs_double>::zero() )
{
throw XQUERY_EXCEPTION( err::FOAR0001, ERROR_LOC( loc ) );
}
if (i0->isNaN() || i1->isNaN())
{
throw XQUERY_EXCEPTION(
err::FOAR0002, ERROR_PARAMS( ZED( DivisionNoNaN ) ), ERROR_LOC( loc )
);
}
if (i0->isPosOrNegInf())
{
throw XQUERY_EXCEPTION(
err::FOAR0002, ERROR_PARAMS( ZED( DivisionNoINF ) ), ERROR_LOC( loc )
);
}
if (i0->isPosOrNegInf()) {
// idiv with +-INF divisor has 0 as result
return GENV_ITEMFACTORY->createInteger(result, numeric_consts<xs_integer>::zero());
}
xs_integer const lInteger( d0 / d1 );
return GENV_ITEMFACTORY->createInteger (result, lInteger );
}
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();
}
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 );
}
}
