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::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 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();
}
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;
}
bool MultiDynamicFnCallIterator::nextImpl(
store::Item_t& result,
PlanState& planState) const
{
store::Item_t item;
store::Item_t targetItem;
FunctionItem* fnItem;
zstring key;
MultiDynamicFnCallIteratorState* state;
DEFAULT_STACK_INIT(MultiDynamicFnCallIteratorState, state, planState);
while (consumeNext(targetItem, theChild, planState))
{
if (targetItem->isFunction())
{
fnItem = static_cast<FunctionItem*>(targetItem.getp());
if (fnItem->getArity() != 0)
{
RAISE_ERROR(err::XPTY0004, loc,
ERROR_PARAMS("dynamic function invoked with incorrect number of arguments"));
}
state->thePlan = fnItem->getImplementation(planState.theCompilerCB);
// must be opened after vars and params are set
state->thePlan->open(planState, state->theUDFStateOffset);
state->theIsOpen = true;
while (consumeNext(result, state->thePlan, planState))
{
STACK_PUSH(true, state);
}
// Need to close here early in case the plan is completely consumed.
// Otherwise, the plan would still be opened if destroyed from the
// state's destructor.
state->thePlan->close(planState);
state->theIsOpen = false;
} // if (targetItem->isFunction())
else if (targetItem->isJSONItem())
{
if (targetItem->isObject())
{
if (!state->theKeysSet.get())
state->theKeysSet.reset(new HashSet<zstring, HashMapZStringCmp>(64, false));
state->theIterator = targetItem->getObjectKeys();
state->theIterator->open();
while (state->theIterator->next(result))
{
key = result->getStringValue();
if (!state->theKeysSet->exists(key))
{
state->theKeysSet->insert(key);
STACK_PUSH(true, state);
}
}
}
else
{
state->theIterator = targetItem->getArrayValues();
state->theIterator->open();
while (state->theIterator->next(result))
{
STACK_PUSH(true, state);
}
}
state->theIterator->close();
} // jsoniq item
#if 0
else if (theSctx->language_kind() == StaticContextConsts::language_kind_xquery)
{
xqtref_t type = theSctx->get_typemanager()->create_value_type(targetItem);
RAISE_ERROR(err::XPTY0004, loc,
ERROR_PARAMS(ZED(XPTY0004_NoTypePromote_23),
type->toSchemaString(),
GENV_TYPESYSTEM.ANY_FUNCTION_TYPE_ONE->toSchemaString()));
}
#endif
}
STACK_END(state);
};