def test_merge(self):
self.assertJson(query.merge({"x": 24}, {
"y": 25}), '{"merge":{"object":{"x":24}},"with":{"object":{"y":25}}}')
self.assertJson(query.merge({"points": 900}, {
"name": "Trevor"}), '{"merge":{"object":{"points":900}},"with":{"object":{"name":"Trevor"}}}')
self.assertJson(query.merge({}, {
"id": 9}), '{"merge":{"object":{}},"with":{"object":{"id":9}}}')
self.assertJson(query.merge({"x": 24}, {
"y": 25}, lambda key, left, right: right),
'{"lambda":{"expr":{"var":"right"},"lambda":["key","left","right"]},"merge":{"object":{"x":24}},"with":{"object":{"y":25}}}')
def test_merge(self):
q1 = query.merge({"x": 1, "y": 2}, {"z": 3})
q2 = query.merge({}, {"a": 1})
q3 = query.merge({"a": 1}, [{"b": 2}, {"c": 3}, {"a": 5}])
q4 = query.merge({"a": 1, "b": 2, "c": 3}, {
"a": 'a', "b": 'b', "c": 'c'}, lambda key, left, right: right)
self.assertEqual(self._q(q1), {"x": 1, "y": 2, "z": 3})
self.assertEqual(self._q(q2), {"a": 1})
self.assertEqual(self._q(q3), {"a": 5, "b": 2, "c": 3})
self.assertEqual(self._q(q4), {"a": 'a', "b": 'b', "c": 'c'})
def find_order(secret, order_ref):
client = FaunaClient(secret=secret)
return client.query(
q.let(
{
"order": q.get(q.ref(q.collection("orders"), order_ref)),
"status_history": q.call("get_order_status_history", q.select(["ref"], q.var("order")))
},
{
"ref": q.select(["ref"], q.var("order")),
"data": q.merge(q.select(["data"], q.var("order")), {"status_history": q.var("status_history")})
}
)
)
def test_typecheckfns(self):
coll = query.collection("typecheck_coll")
db = query.database("typecheck_db")
fn = query.function("typecheck_fn")
index = query.index("typecheck_index")
self.admin_client.query(query.create_collection({"name": "typecheck_coll"}))
self.admin_client.query(query.create_index(
{"name": "typecheck_index", "source": coll, "active": True}))
doc = self.admin_client.query(query.create(
coll, {"data": {}, "credentials": {"password": "******"}}))
self.admin_client.query(query.create_database({"name": "typecheck_db"}))
function = self._q(query.create_function(
{"name": "typecheck_fn", "body": query.query(query.lambda_("x", query.now()))}))
key = self.admin_client.query(
query.create_key({"database": db, "role": "admin"}))
token = self._q(query.login(doc["ref"], {"password": "******"}))
credentials = self._q(query.select(['data', 0], query.paginate(query.credentials())))
role = self.admin_client.query(query.create_role(
{"name": "typecheck_role", "membership": [], "privileges": []}))
values = [
None,
bytearray([12,3,4,5]),
credentials,
90,
3.14,
True,
query.to_date(query.now()),
query.date("1970-01-01"),
query.now(),
query.epoch(1, "second"),
query.time("1970-01-01T00:00:00Z"),
{"x": 10},
query.get(doc["ref"]),
query.paginate(query.collections()),
[1, 2, 3],
"a string",
coll,
query.collections(),
query.match(index),
query.union(query.match(index)),
doc["ref"],
query.get(doc["ref"]),
index,
db,
coll,
token["ref"],
role["ref"],
key["ref"],
function["ref"],
query.get(function["ref"]),
query.query(query.lambda_("x", query.var("x"))),
]
pairs = [
["array", query.is_array],
["object", query.is_object],
["string", query.is_string],
["null", query.is_null],
["number", query.is_number],
["bytes", query.is_bytes],
["date", query.is_date],
["timestamp", query.is_timestamp],
["set", query.is_set],
["ref", query.is_ref],
["boolean", query.is_boolean],
["double", query.is_double],
["integer", query.is_integer],
["database", query.is_database],
["index", query.is_index],
["collection", query.is_collection],
["token", query.is_token],
["function", query.is_function],
["collection", query.is_collection],
["role", query.is_role],
["credentials", query.is_credentials],
["key", query.is_key],
]
expected = {
"array": 1,
"boolean": 1,
"bytes": 1,
"collection": 3,
"credentials": 1,
"database": 1,
"date": 2,
"double": 1,
"function": 2,
"integer": 1,
"index": 1,
"key": 1,
"null": 1,
"number": 2,
"object": 5,
"ref": 11,
"role": 1,
"set": 3,
"string": 1,
"timestamp": 3,
"token": 1,
}
q = []
for p in pairs:
d = dict()
d[p[0]] = query.count(query.filter_(query.lambda_("v", p[1](query.var("v"))), query.var("vals")))
q.append(d)
actual = self._q(query.let({"vals": values}, query.merge({}, q)))
self.assertEqual(actual, expected)
def translate_select(sql_query: sql.SQLQuery) -> QueryExpression:
"""Translate a SELECT SQL query into an equivalent FQL query.
Params:
-------
sql_query: An SQLQuery instance.
Returns:
--------
An FQL query expression based on the SQL query.
"""
document_pages = _define_document_pages(sql_query)
selected_table = next(table for table in sql_query.tables
if table.has_columns)
get_field_value = lambda function_value, raw_value: q.if_(
q.equals(function_value, common.NULL),
q.if_(q.equals(raw_value, common.NULL), None, raw_value),
q.select([common.DATA, 0], function_value),
)
calculate_function_value = lambda document_set, function_name: q.if_(
q.is_null(function_name),
common.NULL,
q.if_(
q.equals(function_name, sql.Function.COUNT.value),
q.count(document_set),
common.NULL,
),
)
# With aggregation functions, standard behaviour is to include the first value
# if any column selections are part of the query, at least until we add support
# for GROUP BY
get_first_document = lambda documents: q.if_(q.is_empty(documents), [{}],
q.take(1, documents))
translate_document_fields = lambda maybe_documents: q.let(
{
# We map over selected_fields to build document object
# to maintain the order of fields as queried. Otherwise,
# SQLAlchemy gets confused and assigns values to the incorrect keys.
"selected_column_info":
[[col.table_name, col.name, col.function_name]
for col in sql_query.columns],
"has_functions":
any(col.function_name for col in sql_query.columns),
"maybe_document_set":
q.if_(
q.var("has_functions"),
get_first_document(maybe_documents),
maybe_documents,
),
"field_alias_map":
sql_query.alias_map,
},
q.map_(
q.lambda_(
"maybe_document",
q.let(
{
"document":
q.if_(
q.is_ref(q.var("maybe_document")),
{
# We use the selected table name here instead of deriving
# the collection name from the document ref in order to
# save a 'get' call from inside of a map, which could get
# expensive.
selected_table.name:
q.merge(
q.select(
common.DATA,
q.get(q.var("maybe_document")),
),
{"ref": q.var("maybe_document")},
),
},
q.var("maybe_document"),
),
},
q.to_object(
q.map_(
q.lambda_(
[
"collection_name", "field_name",
"function_name"
],
q.let(
{
"function_value":
calculate_function_value(
maybe_documents,
q.var("function_name")),
"raw_value":
q.select(
[
q.var("collection_name"),
q.var("field_name"),
],
q.var("document"),
default=common.NULL,
),
},
[
q.select(
[
q.var("collection_name"),
q.var("field_name"),
],
q.var("field_alias_map"),
),
get_field_value(
q.var("function_value"),
q.var("raw_value")),
],
),
),
q.var("selected_column_info"),
)),
),
),
q.var("maybe_document_set"),
),
)
return q.let(
{
"maybe_documents":
document_pages,
"translated_documents":
translate_document_fields(q.var("maybe_documents")),
"result":
q.distinct(q.var("translated_documents"))
if sql_query.distinct else q.var("translated_documents"),
},
# Paginated sets hold an array of results in a 'data' field, so we try to flatten it
# in case we're dealing with pages instead of an array of results which doesn't
# have such nesting
{common.DATA: q.select(common.DATA, q.var("result"), q.var("result"))},
)