def evaluate(self, static, dynamic, local):
left = utils.get_single(self.left.evaluate(static, dynamic, local))
right = utils.get_single(self.right.evaluate(static, dynamic, local))
if left.jpath_type != right.jpath_type:
raise e.TypeException("Left and right values to the ++ operator "
"have to be of the same type, but the left value was of "
"type " + str(type(left)) + " and the right value was of "
"type " + str(type(right)))
if isinstance(left, d.String): # String concatenation
return utils.singleton(d.StandardString(left.get_value() + right.get_value()))
if isinstance(left, d.List): # List concatenation
return utils.singleton(d.StandardList(left.to_python_list() + right.to_python_list()))
if isinstance(left, d.Object): # Object union; take the object on the
# left side, create a new copy of it, then update it with the
# pairs of the object on the right side. The right side should
# override the left side in the case of a key conflict.
dictionary = {}
for k, v in left:
dictionary[k] = v
for k, v in right:
dictionary[k] = v
return utils.singleton(d.StandardObject([d.StandardPair(k, v) for k, v in dictionary.iteritems()]))
raise e.TypeException("Values of type " + str(type(left)) + " can't "
"be concatenated using the ++ operator. Only values of type "
"string, list, or object can be given to ++. To convert "
"values to strings, you can use the string() function.")
def run_query(self, query, update, vars={}):
interpreter = self.interpreter_constructor()
module = interpreter.get_binder("jpath").create_query(query)
wrapped_vars = utils.singleton(translate.json_to_jpath(vars))
result = module.call_with_values(self.make_context(), [wrapped_vars])
result = self.process_result(result, update)
return result
def run_module(self, module, update, vars={}):
interpreter = self.interpreter_constructor()
module = interpreter.bind_module("jpath", module)
wrapped_vars = utils.singleton(translate.json_to_jpath(vars))
result = module.call_with_values(self.make_context(), [wrapped_vars])
result = self.process_result(result, update)
return result
def evaluate(self, static, dynamic, local):
value = utils.get_single(self.value.evaluate(static, dynamic, local))
reference = utils.get_single(self.reference.evaluate(static, dynamic, local))
if isinstance(self.position, Production):
position = self.position.evaluate(static, dynamic, local)
position = utils.get_single_instance(position, d.Number).get_as_int()
else:
position = self.position
return utils.singleton(d.StandardInsert(value, reference, position))
def root(dynamic):
function = dynamic.userland.get("db.get_root", None)
if function is None:
raise e.OtherException("Query is not running in the context of a "
"database, so the root function cannot be called. "
"Specifically, the dynamic context userland does not have an "
"entry named db.get_root; this should be a function that "
"returns the root database object.")
root = function()
if not isinstance(root, d.Item):
raise e.OtherException("Dynamic context userland db.get_root "
"function returned a value that was not an instance of Item; "
"specifically, it was an instance of " + str(type(root)))
return utils.singleton(root)
def input(dynamic):
return utils.singleton(d.StandardString(raw_input()))
def get_for_pair_indexer(self, value):
result = self.get_pair(utils.get_single(value))
if result is None:
return EmptySequence()
return utils.singleton(result)
def get_for_pair_pattern(self, pattern):
value = self.get_pair(StandardString(pattern))
if value is None:
return EmptySequence()
return utils.singleton(value)
def evaluate(self, static, dynamic, local):
source = self.source.evaluate(static, dynamic, local)
target = self.target.evaluate(static, dynamic, local)
return utils.singleton(d.StandardMerge(source, target))
def evaluate(self, static, dynamic, local):
target = self.target.evaluate(static, dynamic, local)
replacement = self.replacement.evaluate(static, dynamic, local)
return utils.singleton(d.StandardReplace(target, replacement))
def evaluate(self, static, dynamic, local):
value = self.expr.evaluate(static, dynamic, local)
return utils.singleton(d.StandardDelete(value))
