uint32_t deHashAttributes(
const QueryLoc& loc,
static_context* sctx,
const store::Iterator_t& it,
XQPCollator* collator,
int timezone)
{
uint32_t lHash = FNV_32_INIT;
std::vector<uint32_t> lInnerHashes;
store::Item_t attr;
it->open();
while (it->next(attr))
{
lInnerHashes.push_back(deHash(loc, sctx, attr, collator, timezone));
}
std::sort(lInnerHashes.begin(), lInnerHashes.end());
for(std::vector<uint32_t>::iterator it = lInnerHashes.begin(); it != lInnerHashes.end(); ++it)
{
lHash = hashfun::h32(&(*it), sizeof(*it), lHash);
}
return lHash;
}
uint32_t deHashChildren(
const QueryLoc& loc,
static_context* sctx,
const store::Iterator_t& it,
XQPCollator* collator,
int timezone)
{
uint32_t lHash = FNV_32_INIT;
uint32_t lInnerHash;
store::Item_t child;
it->open();
while (it->next(child))
{
if (child->getNodeKind() == store::StoreConsts::piNode
||
child->getNodeKind() == store::StoreConsts::commentNode)
continue;
lInnerHash = deHash(loc, sctx, child, collator, timezone);
lHash = hashfun::h32(&lInnerHash, sizeof(lInnerHash), lHash);
}
return lHash;
}
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 deepEqualChildren(
const QueryLoc& loc,
static_context* sctx,
const store::Iterator_t& it1,
const store::Iterator_t& it2,
XQPCollator* collator,
int timezone,
bool raiseError)
{
store::Item_t child1, child2;
bool c1Valid, c2Valid;
it1->open();
it2->open();
while (1)
{
while ((c1Valid = it1->next(child1)) &&
(child1->getNodeKind() == store::StoreConsts::piNode ||
child1->getNodeKind() == store::StoreConsts::commentNode))
;
while ((c2Valid = it2->next(child2)) &&
(child2->getNodeKind() == store::StoreConsts::piNode ||
child2->getNodeKind() == store::StoreConsts::commentNode))
;
if (!c1Valid && !c2Valid)
return true;
else if (!c1Valid || !c2Valid)
return false;
else if (!deepEqual(loc, sctx, child1, child2, collator, timezone, raiseError))
return false;
}
return true;
}
void SchemaValidatorImpl::validateAttributes(
EventSchemaValidator& schemaValidator,
store::Iterator_t attributes)
{
store::Item_t attribute;
while ( attributes->next(attribute) )
{
ZORBA_ASSERT(attribute->isNode());
ZORBA_ASSERT(attribute->getNodeKind() == store::StoreConsts::attributeNode);
//cout << " vup - attr: " << attribute->getNodeName()->getLocalName()->
// c_str() << "\n"; cout.flush();
store::Item_t attName = attribute->getNodeName();
schemaValidator.attr(attName, attribute->getStringValue());
}
}
bool deepEqualAttributes(
const QueryLoc& loc,
static_context* sctx,
const store::Iterator_t& it1,
const store::Iterator_t& it2,
XQPCollator* collator,
int timezone,
bool raiseError)
{
store::Item_t child1, child2;
int c1count = 0, c2count = 0;
it1->open();
it2->open();
while (it1->next(child1))
{
c1count++;
it2->reset();
bool found = false;
while (it2->next(child2))
{
if (deepEqual(loc, sctx, child1, child2, collator, timezone, raiseError))
{
found = true;
break;
}
}
if (!found)
return false;
}
it2->reset();
while (it2->next(child2))
c2count++;
if (c1count != c2count)
return false;
return true;
}
int SchemaValidatorImpl::processChildren(
store::PUL* pul,
namespace_context& nsCtx,
TypeManager* typeManager,
EventSchemaValidator& schemaValidator,
store::Iterator_t children,
std::vector<store::Item_t>& typedValues,
const QueryLoc& loc)
{
store::Item_t child;
store::Item_t typeName;
int noOfChildren = 0;
while ( children->next(child) )
{
noOfChildren++;
if ( child->isNode() )
{
//cout << " vup - processChildren: " << child->getType()->getLocalName()
// ->c_str() << "\n"; cout.flush();
switch ( child->getNodeKind() )
{
case store::StoreConsts::elementNode:
processElement(pul, typeManager, schemaValidator, child, loc);
break;
case store::StoreConsts::attributeNode:
ZORBA_ASSERT(false);
break;
case store::StoreConsts::documentNode:
ZORBA_ASSERT(false);
break;
case store::StoreConsts::textNode:
{
//cout << " vup - pC text: '" << child->getStringValue()->
// normalizeSpace()->str() << "'\n"; cout.flush();
zstring childStringValue;
child->getStringValue2(childStringValue);
schemaValidator.text(childStringValue);
store::Item_t typeQName = schemaValidator.getTypeQName();
processTextValue(pul,
typeManager,
nsCtx,
typeQName,
childStringValue,
child,
typedValues,
loc);
}
break;
case store::StoreConsts::piNode:
//cout << " vup - pi: " << child->getStringValue() << "\n"; cout.flush();
// do nothing
break;
case store::StoreConsts::commentNode:
//cout << " vup - comment: " << child->getStringValue() << "\n"; cout.flush();
// do nothing
break;
case store::StoreConsts::anyNode:
//cout << " vup - any: " << child->getStringValue() << "\n"; cout.flush();
ZORBA_ASSERT(false);
break;
default:
ZORBA_ASSERT(false);
}
}
}
return noOfChildren;
}
