def get_multiple(index, data=None):
"""
Get multiple records by ID
"""
try:
serverClient = FaunaClient(
secret=os.environ.get("FAUNA_SERVER_SECRET"))
res_arr = []
if data is None:
res = serverClient.query(
q.map_(q.lambda_("data", q.get(q.var("data"))),
q.paginate(q.match(q.index(index)))))
res_arr.extend(res["data"])
elif isinstance(data, list):
for x in data:
res = serverClient.query(
q.map_(q.lambda_("data", q.get(q.var("data"))),
q.paginate(q.match(q.index(index), q.casefold(x)))))
res_arr.extend(res["data"])
else:
res = serverClient.query(
q.map_(q.lambda_("data", q.get(q.var("data"))),
q.paginate(q.match(q.index(index), q.casefold(data)))))
res_arr.extend(res["data"])
arr = []
for x in res_arr:
x["data"]["ref_id"] = x["ref"].id()
arr.append(x["data"])
return arr
except Exception as ex:
raise ex
def test_lambda_expr(self):
self.assertJson(query.lambda_("a", query.var("a")),
'{"expr":{"var":"a"},"lambda":"a"}')
self.assertJson(
query.lambda_(["a", "b"], query.add(query.var("a"),
query.var("b"))),
'{"expr":{"add":[{"var":"a"},{"var":"b"}]},"lambda":["a","b"]}')
def processHeroInformation(match_data):
radiant_win = match_data['result']['radiant_win']
players = match_data['result']['players']
win_heros = []
heros_in_game = []
for player in players:
win_flag = getWinFlag(player, radiant_win)
heros_in_game.append(player['hero_id'])
if win_flag:
win_heros.append(player['hero_id'])
hero_list=client.query(
q.map_(
q.lambda_(
'hero',
q.get(q.ref(q.collection('heroes'), q.var('hero')))
),
heros_in_game
)
)
update_hero_list = []
for hero_info in hero_list:
ref = hero_info['ref']
data = hero_info['data']
if data['id'] in win_heros:
data['wins'] += 1
data['games'] += 1
else:
data['games'] += 1
for player in players:
if player['hero_id'] == data['id']:
getItemsData(player, data)
update_info = {}
update_info['ref'] = ref
update_info['data'] = data
update_hero_list.append(update_info)
client.query(
q.map_(
q.lambda_(
'hero',
q.update(
q.select(['ref'], q.var('hero')),
{ 'data': q.select(['data'], q.var('hero')) }
)
),
update_hero_list
)
)
def updatePairInformationForTeam(hero_ids, team_win):
key_list=[]
for k in range(0, len(hero_ids)):
for j in range(k + 1, len(hero_ids)):
if hero_ids[k] < hero_ids[j]:
key = format(hero_ids[k], '03d') + format(hero_ids[j], '03d')
else:
key = format(hero_ids[j], '03d') + format(hero_ids[k], '03d')
key_list.append(key)
try:
hero_data_list=client.query(
q.map_(
q.lambda_(
'hero_pair',
q.get(q.ref(q.collection('hero_pairs'), q.var('hero_pair')))
),
key_list
)
)
except Exception as e:
logging.info(e)
logging.info(key_list)
hero_team_list=[]
for hero_data in hero_data_list :
hero_team_dictionary = {}
hero_pair_ref=hero_data['ref']
hero_pair_data = hero_data['data']
hero_pair_data['games']+=1
if team_win:
hero_pair_data['wins'] += 1
hero_team_dictionary['ref']=hero_pair_ref
hero_team_dictionary['data']=hero_pair_data
hero_team_list.append(hero_team_dictionary)
client.query(
q.map_(
q.lambda_(
'hero_pair',
q.update(
q.select(['ref'],q.var('hero_pair')),
{'data': q.select(['data'], q.var('hero_pair'))}
)
),
hero_team_list
)
)
def processTemporalHeroInformation(match_data):
radiant_win = match_data['result']['radiant_win']
players = match_data['result']['players']
temporal_hero_list = []
for player in players:
win_flag = False
if player['player_slot'] <= 4 and radiant_win:
win_flag = True
elif player['player_slot'] > 4 and not radiant_win:
win_flag = True
temporal_hero = {}
temporal_hero['id'] = player['hero_id']
temporal_hero['win'] = win_flag
temporal_hero['match_start_time'] = pytz.utc.localize(datetime.utcfromtimestamp(match_data['result']['start_time']))
temporal_hero_list.append(temporal_hero)
client.query(
q.map_(
q.lambda_(
'temporal_hero',
q.create(q.collection('heroes_temporal'), { "data": q.var('temporal_hero') })
),
temporal_hero_list
)
)
def unsubscribe(update: Update, context: CallbackContext):
user = User(update.effective_chat.id)
try:
animes_watched = client.query(
q.let({'bot_user': q.ref(q.collection(users), user.chat_id)},
q.if_(
q.exists(q.var('bot_user')),
q.map_(
q.lambda_('doc_ref', q.get(q.var('doc_ref'))),
q.select(['data', 'animes_watching'],
q.get(q.var('bot_user')))), [])))
for anime in animes_watched:
markup = [[
InlineKeyboardButton('Unsubscribe',
callback_data='unsubscribe=' +
anime['ref'].id())
]]
context.bot.send_message(chat_id=user.chat_id,
text=anime['data']['title'],
reply_markup=InlineKeyboardMarkup(markup))
# update last command
user.last_command = ''
if not animes_watched:
context.bot.send_message(
chat_id=user.chat_id,
text='You are currently not subscribed to any anime')
except Exception as err:
log_error(err)
def _create_documents(let_params, records, build_document):
results = []
idx = 0
while True:
if idx > len(records):
break
end_idx = idx + BATCH_LIMIT
batch = _execute_with_retries(
q.let(
let_params,
q.map_(
q.lambda_(
"document",
q.create(
q.var("collection"),
{"data": build_document(q.var("document"))},
),
),
records[idx:end_idx],
),
)
)
results.extend(batch)
idx = end_idx
return results
def test_count_mean_sum(self):
data = [1, 2, 3, 4, 5, 6, 7, 8, 9]
self._q(query.create_collection({"name": "countmeansum_test"}))
self._q(
query.create_index({
"name": "countmeansum_idx",
"source": query.collection("countmeansum_test"),
"active": True,
"values": [{
"field": ["data", "value"]
}]
}))
self._q(
query.foreach(
query.lambda_(
"x",
query.create(
query.collection("countmeansum_test"),
{"data": {
"value": query.add(query.var("x"), 2)
}})), data))
m = query.match(query.index("countmeansum_idx"))
expected = [9, 5.0, 45, 9, 7.0, 63]
self.assertEqual(
self._q([
query.count(data),
query.mean(data),
query.sum(data),
query.count(m),
query.mean(m),
query.sum(m)
]), expected)
def _load_matches(data):
matches = data["matches"]
records = list(matches.values())
build_document = lambda match: q.to_object(
q.map_(
q.lambda_(
["key", "value"],
[
q.var("key"),
q.if_(
q.equals(q.var("key"), "winner_id"),
_assign_ref(q.var("teams"), q.var("team_map"), q.var("value")),
q.var("value"),
),
],
),
q.to_array(match),
)
)
let_params = {
"collection": q.collection("matches"),
"teams": q.collection("teams"),
"team_map": data["teams"],
}
documents = _create_documents(let_params, records, build_document)
for record, document in zip(records, documents):
record["id"] = document["ref"].id()
def test_documents(self):
aCollection = "col_test_documents"
anIndex = "idx_test_documents"
self._q(query.create_collection({"name": aCollection}))
self._q(
query.create_index({
"name": anIndex,
"source": query.collection(aCollection),
"active": True
}))
count = 56
data = [{} for x in range(count)]
self._q(
query.foreach(
query.lambda_(
"x",
query.create(query.collection(aCollection),
{"data": query.var("x")})), data))
self.assertEqual(
self._q(
query.select([0],
query.count(
query.paginate(
query.documents(
query.collection(aCollection)))))),
count)
self.assertEqual(
self._q(query.count(query.documents(
query.collection(aCollection)))), count)
def _sort_document_set(document_set: QueryExpression,
order_by: typing.Optional[sql.OrderBy]):
if order_by is None:
return q.paginate(document_set, size=common.MAX_PAGE_SIZE)
if len(order_by.columns) > 1:
raise exceptions.NotSupportedError(
"Ordering by multiple columns is not yet supported.")
ordered_column = order_by.columns[0]
assert ordered_column.table_name is not None
ordered_document_set = q.join(
document_set,
q.index(
common.index_name(
ordered_column.table_name,
column_name=ordered_column.name,
index_type=common.IndexType.SORT,
)),
)
if order_by.direction == sql.OrderDirection.DESC:
ordered_document_set = q.reverse(ordered_document_set)
return q.map_(
q.lambda_(["_", "ref"], q.var("ref")),
q.paginate(ordered_document_set, size=common.MAX_PAGE_SIZE),
)
def _delete_data():
resources = [q.functions(), q.indexes(), q.collections()]
delete = lambda res: q.foreach(
q.lambda_("res", q.delete(q.var("res"))), q.paginate(res)
)
delete_queries = [delete(res) for res in resources]
_execute_with_retries(q.do(*delete_queries))
def get_all_students(self):
result = self.clientf.query(
query.map_(
query.lambda_("x", query.get(query.var('x'))),
query.paginate(query.match(query.index('all_students')),
size=1000)))
students = result['data']
students = [student['data'] for student in students]
return students
def test_create_accprov_with_roles(self):
providerName = "provider_with_roles"
issuerName = "issuer_%s" % (self._randStr())
fullUri = "https: //$%s.auth0.com" % (self._randStr(4))
roleOneName = "role_one_%s" % (self._randStr(4))
roleTwoName = "role_two_%s" % (self._randStr(4))
self.admin_client.query(
query.create_role({
"name":
roleOneName,
"privileges": [
{
"resource": query.databases(),
"actions": {
"read": True
},
},
],
}))
self.admin_client.query(
query.create_role({
"name":
roleTwoName,
"privileges": [
{
"resource": query.databases(),
"actions": {
"read": True
},
},
],
}))
provider = self.admin_client.query(
query.create_access_provider({
"name":
providerName,
"issuer":
issuerName,
"jwks_uri":
fullUri,
"roles": [
query.role(roleOneName),
{
"role": query.role(roleTwoName),
"predicate": query.query(query.lambda_("x", True)),
},
],
}))
self.assertEqual(provider["name"], providerName)
self.assertEqual(provider["issuer"], issuerName)
self.assertEqual(provider["jwks_uri"], fullUri)
self.assertTrue(isinstance(provider["roles"], list))
def get_subscribed_users_for_anime(anime_doc_id):
"""
This function gets all the user subscribed to a particular anime
"""
subscribed_users = client.query(
q.map_(
q.lambda_('doc_ref', q.get(q.var('doc_ref'))),
q.paginate(q.match(q.index(all_users_by_anime),
q.ref(q.collection(animes), str(anime_doc_id))),
size=100000)))
subscribed_users = subscribed_users['data']
return subscribed_users
def _assign_ids_to_teams(teams):
result = _execute_with_retries(
q.map_(
q.lambda_("team", q.get(q.var("team"))),
q.paginate(q.match(q.index("teams_all"))),
)
)
team_documents = result["data"]
for team in teams.values():
team_document = next(
doc for doc in team_documents if doc["data"]["name"] == team["name"]
)
team["id"] = team_document["ref"].id()
def unsubscribe_from_anime(self, anime_doc_id: str):
try:
anime = client.query(
q.get(q.ref(q.collection(animes), anime_doc_id)))
client.query(
q.let(
{
'anime_ref':
q.ref(q.collection(animes), anime_doc_id),
'bot_user':
q.ref(q.collection(users), self.chat_id),
'followers':
q.select(['data', 'followers'],
q.get(q.var('anime_ref'))),
},
q.do(
q.update(
q.var('anime_ref'), {
'data': {
'followers': q.subtract(
q.var('followers'), 1)
}
}),
q.update(
q.var('bot_user'), {
'data': {
'animes_watching':
q.filter_(
q.lambda_(
'watched_anime_ref',
q.not_(
q.equals(
q.var('watched_anime_ref'),
q.var('anime_ref')))),
q.select(['data', 'animes_watching'],
q.get(q.var('bot_user'))))
}
}),
q.if_(q.equals(q.var('followers'), 1),
q.delete(q.var('anime_ref')), 'successful!'))))
updater.bot.send_message(chat_id=self.chat_id,
text='You have stopped following ' +
anime['data']['title'])
except errors.NotFound:
logger.info(
'Somehow, a user {0} almost unsubscribed from an anime that did not exist'
.format(self.chat_id))
except Exception as err:
log_error(err)
def getTopHeroPairs(hero_id, n):
logging.info(f'Query: Fetching top {n} partners for hero: {hero_id}')
key_list = []
id_list = []
for k in range(1, hero_id):
key = format(k, '03d') + format(hero_id, '03d')
key_list.append(key)
id_list.append(k)
for k in range(hero_id + 1, 130):
key = format(hero_id, '03d') + format(k, '03d')
key_list.append(key)
id_list.append(k)
try:
hero_data_list = client.query(
q.map_(
q.lambda_(
'hero_pair',
q.get(q.ref(q.collection('hero_pairs'),
q.var('hero_pair')))), key_list))
logging.debug(
'Finished querying the hero_pair collection successfully')
hero_team_list = []
for i in range(0, len(hero_data_list)):
hero_team_dictionary = {'partner_id': id_list[i]}
if hero_data_list[i]['data']['games'] > 0:
hero_team_dictionary['win_rate'] = format(
hero_data_list[i]['data']['wins'] /
hero_data_list[i]['data']['games'], '.4f')
else:
hero_team_dictionary['win_rate'] = '0.0000'
hero_team_list.append(hero_team_dictionary)
hero_team_list = sorted(hero_team_list,
key=lambda i: i['win_rate'],
reverse=True)
logging.info('Returning from the function getTopHeroPairs')
return hero_team_list[0:n]
except Exception as e:
logging.error(e)
logging.error('Could not fetch from hero_pairs collection')
def convert_to_ref_set(collection_name: str,
index_match: QueryExpression) -> QueryExpression:
"""Convert value-based match set to set of refs.
Params:
-------
collection_name: Name of the source collection for the index.
index_match: Match set of the index. Index must have values attribute of the form
[{"field": ["data", <field>]}, {"field": ["ref"}]}]
"""
return q.join(
index_match,
q.lambda_(
["value", "ref"],
q.match(
q.index(index_name(collection_name, index_type=IndexType.REF)),
q.var("ref"),
),
),
)
def get_converted_documents(self) -> Iterator[Document]:
results = self.client.query(
q.filter_(
q.lambda_(
['original_name', 'converted', 'ref'],
q.var('converted')
),
q.paginate(q.match(q.index('documents')))
)
)
documents = []
for data in results['data']:
documents.append(
Document(
original_name=data[0],
converted=data[1],
ref=data[2]
)
)
return documents
def translate_delete(sql_query: sql.SQLQuery) -> typing.List[QueryExpression]:
"""Translate a DELETE SQL query into an equivalent FQL query.
Params:
-------
sql_query: An SQLQuery instance.
Returns:
--------
An FQL query expression.
"""
tables = sql_query.tables
if len(tables) > 1:
document_set = common.join_collections(sql_query)
else:
document_set = common.build_document_set_union(tables[0],
sql_query.filter_groups)
return q.map_(q.lambda_("ref", q.delete(q.var("ref"))),
q.paginate(document_set))
def things():
userSecret = request.headers.get('fauna-user-secret')
client = FaunaClient(secret=userSecret)
try:
result = client.query(
q.map_(q.lambda_("ref", q.get(q.var("ref"))),
q.paginate(q.documents(q.collection("Things")))))
things = map(
lambda doc: {
"id": doc["ref"].id(),
"name": doc["data"]["name"],
"color": doc["data"]["color"]
}, result["data"])
return {"things": list(things)}
except faunadb.errors.Unauthorized as exception:
error = exception.errors[0]
return {"code": error.code, "description": error.description}, 401
def _translate_drop_default(table_name: str,
column_name: str) -> QueryExpression:
drop_default = q.map_(
q.lambda_(
"column_info_ref",
q.update(q.var("column_info_ref"), {"data": {
"default_": None
}}),
),
q.paginate(_fetch_column_info_refs(table_name, column_name)),
)
return q.let(
{
"altered_docs": drop_default,
# Should only be one document that matches the unique combination
# of collection and field name, so we just select the first.
"altered_ref": q.select([0, "ref"], q.var("altered_docs")),
},
{"data": [{
"id": q.var("altered_ref")
}]},
)
def extractMatchesFeatureMatrix(prediction_ref_ids):
try:
logging.info(f'[START] Extracting Matches Feature Matrix')
predictionData = client.query(
q.map_(
q.lambda_(
'pred_ref_id',
q.get(
q.ref(q.collection('match_prediction'),
q.var('pred_ref_id')))), prediction_ref_ids))
featuresLists = []
for pred in predictionData:
featuresLists.append(pred['data']['vector'])
dataFrame = pd.DataFrame(featuresLists)
dataFrame = dataFrame.iloc[:, :-2]
logging.info(f'[FINISHED] Extracting Matches Feature Matrix')
trainModel(dataFrame)
except Exception as e:
logging.error(f'Error occurred {str(e)}')
def testPrediction():
matchPreds = client.query(
q.paginate(q.match(q.index('all_match_prediction')), size=100))
matchPredsData = matchPreds['data']
pred_ids = []
for pred in matchPredsData:
pred_id = pred.value['id']
pred_ids.append(pred_id)
predictionData = client.query(
q.map_(
q.lambda_(
'matchPred',
q.get(
q.ref(q.collection('match_prediction'),
q.var('matchPred')))), pred_ids))
featuresLists = []
for pred in predictionData:
featuresLists.append(pred['data']['vector'])
dataFrame = pd.DataFrame(featuresLists)
dataFrame = dataFrame.iloc[:, :-2]
X_test = dataFrame.iloc[:, :-1]
y_test = dataFrame.iloc[:, -1]
clf = pickle.load(open('../data/model_file.p', 'rb'))
print("Trained Model parameters:")
print("Kernel: ", clf.kernel)
print("Win Labels:", clf.classes_)
print("Gamma:", clf.gamma)
y_pred = clf.predict(X_test)
acc = clf.score(X_test, y_test)
print("Model Accuracy = ", acc * 100, "%")
def recommend(update: Update, context: CallbackContext):
chat_id = update.effective_chat.id
results = client.query(
q.map_(q.lambda_(['followers', 'doc_ref'], q.get(q.var('doc_ref'))),
q.paginate(q.match(q.index(sort_anime_by_followers)), size=5)))
context.bot.send_message(
chat_id=chat_id,
text='Here are the top animes people using Anime Alarm are watching')
for anime in results['data']:
if anime['data']['link'].startswith('https://tinyurl.com/') or anime[
'data']['link'].startswith('https://bit.ly/'):
link = anime['data']['link']
else:
link = shorten(anime['data']['link'])
markup = [[
InlineKeyboardButton('Subscribe',
callback_data='subscribe=' + link)
]]
context.bot.send_message(chat_id=chat_id,
reply_markup=InlineKeyboardMarkup(markup),
text=str(results['data'].index(anime) + 1) +
'. ' + anime['data']['title'])
def translate_drop(
statement: token_groups.Statement) -> typing.List[QueryExpression]:
"""Translate a DROP SQL query into an equivalent FQL query.
Params:
-------
statement: An SQL statement returned by sqlparse.
Returns:
--------
An FQL query expression.
"""
idx, _ = statement.token_next_by(m=(token_types.Keyword, "TABLE"))
_, table_identifier = statement.token_next_by(i=token_groups.Identifier,
idx=idx)
table_name = table_identifier.value
deleted_collection = q.select("ref", q.delete(q.collection(table_name)))
return [
q.do(
q.map_(
q.lambda_("ref", q.delete(q.var("ref"))),
q.paginate(
q.union(
q.match(
q.index(
fql.index_name(
"information_schema_tables_",
column_name="name_",
index_type=fql.IndexType.TERM,
)),
table_name,
),
fql.convert_to_ref_set(
"information_schema_columns_",
q.range(
q.match(
q.index(
fql.index_name(
"information_schema_columns_",
column_name="table_name_",
index_type=fql.IndexType.VALUE,
))),
[table_name],
[table_name],
),
),
fql.convert_to_ref_set(
"information_schema_indexes_",
q.range(
q.match(
q.index(
fql.index_name(
"information_schema_indexes_",
column_name="table_name_",
index_type=fql.IndexType.VALUE,
))),
[table_name],
[table_name],
),
),
), ),
),
q.let(
{"collection": deleted_collection},
{"data": [{
"id": q.var("collection")
}]},
),
)
]
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"))},
)
def _define_match_set(query_filter: sql.Filter) -> QueryExpression:
field_name = query_filter.column.name
comparison_value = query_filter.value
index_name_for_collection = functools.partial(index_name,
query_filter.table_name)
convert_to_collection_ref_set = functools.partial(convert_to_ref_set,
query_filter.table_name)
get_info_indexes_with_references = lambda collection_name, field_name: q.map_(
q.lambda_("info_index_ref", q.get(q.var("info_index_ref"))),
q.paginate(
q.match(
q.index(
index_name(
"information_schema_indexes_",
column_name="name_",
index_type=IndexType.TERM,
)),
index_name(
collection_name,
column_name=field_name,
index_type=IndexType.REF,
),
), ),
)
index_name_for_field = functools.partial(index_name_for_collection,
field_name)
equality_range = q.range(
q.match(q.index(index_name_for_field(IndexType.VALUE))),
[comparison_value],
[comparison_value],
)
if query_filter.checks_whether_equal:
if field_name == "ref":
assert isinstance(comparison_value, str)
return q.singleton(
q.ref(q.collection(query_filter.table_name), comparison_value))
return q.let(
{
"ref_index":
q.index(index_name_for_field(IndexType.REF)),
"term_index":
q.index(index_name_for_field(IndexType.TERM)),
"info_indexes":
get_info_indexes_with_references(query_filter.table_name,
field_name),
"comparison_value":
comparison_value,
},
q.if_(
q.exists(q.var("ref_index")),
q.match(
q.var("ref_index"),
get_foreign_key_ref(
q.var("comparison_value"),
# Assumes that there is only one reference per foreign key
# and that it refers to the associated collection's ID field
# (e.g. {'associated_table': 'id'}).
# This is enforced via NotSupported errors when creating collections.
q.select([0, DATA, "referred_table_"],
q.var("info_indexes")),
),
),
q.if_(
q.exists(q.var("term_index")),
q.match(
q.var("term_index"),
q.var("comparison_value"),
),
convert_to_collection_ref_set(equality_range),
),
),
)
# In the building of Filter objects from SQL tokens, we enforce the convention
# of <column name> <operator> <value> for WHERE clauses, so we build the FQL queries
# assuming that '>' means 'column value greater than literal value'. I can't think
# of a good way to centralize the knowledge of this convention across
# all query translation, so I'm leaving this note as a warning.
if query_filter.checks_whether_greater_than:
inclusive_comparison_range = q.range(
q.match(q.index(index_name_for_field(IndexType.VALUE))),
[comparison_value],
[],
)
return convert_to_collection_ref_set(
q.difference(inclusive_comparison_range, equality_range))
if query_filter.checks_whether_greater_than_or_equal:
inclusive_comparison_range = q.range(
q.match(q.index(index_name_for_field(IndexType.VALUE))),
[comparison_value],
[],
)
return convert_to_collection_ref_set(inclusive_comparison_range)
if query_filter.checks_whether_less_than:
inclusive_comparison_range = q.range(
q.match(q.index(index_name_for_field(IndexType.VALUE))),
[],
[comparison_value],
)
return convert_to_collection_ref_set(
q.difference(inclusive_comparison_range, equality_range))
if query_filter.checks_whether_less_than_or_equal:
inclusive_comparison_range = q.range(
q.match(q.index(index_name_for_field(IndexType.VALUE))),
[],
[comparison_value],
)
return convert_to_collection_ref_set(inclusive_comparison_range)
raise exceptions.NotSupportedError(
f"Unsupported comparison {query_filter.comparison} was received.")
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)
