def testWhereRewriteWithRelated(self):
"""Test WHERE when pseudonym value exists in two different tables."""
schema = test_util.GetCarsSchema()
# add 'related' field just for this test
for field in schema:
if field['name'] == 'Make':
field['related'] = 'cars_name'
break
# this value determined by running the test, not by manual calc
ciphertext = 'sspWKAH/NKuUyX8ji1mmSw=='
# test 1, use table_id
table_id = _TABLE_ID
master_key = test_util.GetMasterKey()
as_clause = query_lib._AsClause({})
stack = [
util.FieldToken('Make'),
util.StringLiteralToken('"Hello"'),
util.OperatorToken('==', 2)
]
where_clause_1 = query_lib._WhereClause(stack,
as_clause=as_clause,
schema=schema,
nsquare=_TEST_NSQUARE,
master_key=master_key,
table_id=table_id)
rewritten_sql_1 = where_clause_1.Rewrite()
self.assertEqual(
rewritten_sql_1,
'WHERE (%sMake == "%s")' % (util.PSEUDONYM_PREFIX, ciphertext))
# test 2, change table_id, query should be same as test #1
table_id = _TABLE_ID + '_other'
master_key = test_util.GetMasterKey()
as_clause = query_lib._AsClause({})
stack = [
util.FieldToken('Make'),
util.StringLiteralToken('"Hello"'),
util.OperatorToken('==', 2)
]
where_clause_2 = query_lib._WhereClause(stack,
as_clause=as_clause,
schema=schema,
nsquare=_TEST_NSQUARE,
master_key=master_key,
table_id=table_id)
rewritten_sql_2 = where_clause_2.Rewrite()
self.assertEqual(
rewritten_sql_2,
'WHERE (%sMake == "%s")' % (util.PSEUDONYM_PREFIX, ciphertext))
# verify different tables were used
self.assertNotEqual(where_clause_1.table_id, where_clause_2.table_id)
# and verify that same WHERE query="literal" was generated
self.assertEqual(rewritten_sql_1, rewritten_sql_2)
def testExtractUnencryptedQueries(self):
stacks = [
[util.FieldToken('Year')], [1],
[util.FieldToken('Year'), 1,
util.OperatorToken('+', 2)], [util.ProbabilisticToken('Price')],
[util.FieldToken('GROUP_CONCAT(%sModel)' % util.PSEUDONYM_PREFIX)],
[util.FieldToken('SUM(Year + 1)')]
]
unencrypted_expression_list = [
'Year AS ' + util.UNENCRYPTED_ALIAS_PREFIX + '0_',
'1 AS ' + util.UNENCRYPTED_ALIAS_PREFIX + '1_',
'(Year + 1) AS ' + util.UNENCRYPTED_ALIAS_PREFIX + '2_',
'SUM(Year + 1) AS ' + util.UNENCRYPTED_ALIAS_PREFIX + '3_'
]
self.assertEqual(query_lib._ExtractUnencryptedQueries(stacks, {}),
unencrypted_expression_list)
stacks = [
[util.FieldToken('Year')], [1],
[util.FieldToken('Year'), 1,
util.OperatorToken('+', 2)], [util.ProbabilisticToken('Price')],
[util.FieldToken('GROUP_CONCAT(%sModel)' % util.PSEUDONYM_PREFIX)],
[util.FieldToken('SUM(Year + 1)')]
]
within = {4: 'w1', 5: 'w2'}
unencrypted_expression_list = [
'Year AS ' + util.UNENCRYPTED_ALIAS_PREFIX + '0_',
'1 AS ' + util.UNENCRYPTED_ALIAS_PREFIX + '1_',
'(Year + 1) AS ' + util.UNENCRYPTED_ALIAS_PREFIX + '2_',
'SUM(Year + 1) WITHIN w2 AS ' + util.UNENCRYPTED_ALIAS_PREFIX +
'3_'
]
self.assertEqual(query_lib._ExtractUnencryptedQueries(stacks, within),
unencrypted_expression_list)
def testHavingRewrite(self):
schema = test_util.GetCarsSchema()
master_key = test_util.GetMasterKey()
as_clause = query_lib._AsClause({})
stack = [util.FieldToken('SUM(Year)'), 1, util.OperatorToken('<', 2)]
having_clause = query_lib._HavingClause(stack,
as_clause=as_clause,
schema=schema,
nsquare=_TEST_NSQUARE,
master_key=master_key,
table_id=_TABLE_ID)
self.assertEqual(having_clause.Rewrite(), 'HAVING (SUM(Year) < 1)')
stack = [
1000,
util.AggregationQueryToken(
'TO_BASE64(BYTES(PAILLIER_SUM(FROM_BASE64(' +
util.HOMOMORPHIC_INT_PREFIX + 'Invoice_Price), \'0\')))'),
util.OperatorToken('==', 2)
]
having_clause = query_lib._HavingClause(stack,
as_clause=as_clause,
schema=schema,
nsquare=_TEST_NSQUARE,
master_key=master_key,
table_id=_TABLE_ID)
self.assertRaises(bigquery_client.BigqueryInvalidQueryError,
having_clause.Rewrite)
stack = [
util.FieldToken('GROUP_CONCAT(' + util.PSEUDONYM_PREFIX +
'Model)'),
util.BuiltInFunctionToken('len'), 5,
util.OperatorToken('>', 2)
]
having_clause = query_lib._HavingClause(stack,
as_clause=as_clause,
schema=schema,
nsquare=_TEST_NSQUARE,
master_key=master_key,
table_id=_TABLE_ID)
self.assertRaises(bigquery_client.BigqueryInvalidQueryError,
having_clause.Rewrite)
stack = []
having_clause = query_lib._HavingClause(stack,
as_clause=as_clause,
schema=schema,
nsquare=_TEST_NSQUARE,
master_key=master_key,
table_id=_TABLE_ID)
self.assertEqual(having_clause.Rewrite(), '')
def testRewrittenAggregation(self):
stack = [
util.FieldToken('Year'),
util.AggregationFunctionToken('DISTINCTCOUNT', 1)
]
self.assertEqual(interpreter.ToInfix(list(stack)),
'COUNT(DISTINCT Year)')
def testComputeRowsEvaluate2(self):
# Query is 'SELECT 1 + a, 1 * b, "hello"'
# There are two rows of values for a and b (shown in query).
# Result becomes as below:
# 1 + a | 1 * b | "hello"
# 2 3 "hello"
# 4 5 "hello"
stack = [[1, util.FieldToken('a'),
util.OperatorToken('+', 2)],
[1, util.FieldToken('b'),
util.OperatorToken('*', 2)],
[util.StringLiteralToken('"hello"')]]
query = {'a': [1, 3], 'b': [3, 5]}
real_result = [['2', '3', 'hello'], ['4', '5', 'hello']]
result = encrypted_bigquery_client._ComputeRows(stack, query)
self.assertEqual(result, real_result)
def testReplaceAliasWhenNested(self):
# Query is 'SELECT a + b as a, a + b as b'
stacks = [[
util.FieldToken('a'),
util.FieldToken('b'),
util.OperatorToken('+', 2)
],
[
util.FieldToken('a'),
util.FieldToken('b'),
util.OperatorToken('+', 2)
]]
alias = {0: 'a', 1: 'b'}
new_stack = query_lib._ReplaceAlias(stacks, alias)
real_stack = [['a', 'b', '+'], ['a', 'b', '+', 'b', '+']]
self.assertEqual(new_stack, real_stack)
def testGroupByRewrite(self):
test_schema = test_util.GetCarsSchema()
as_clause = query_lib._AsClause({})
within_clause = query_lib._WithinClause({})
select_clause = query_lib._SelectClause([['1']],
as_clause=as_clause,
within_clause=within_clause,
schema=test_schema,
nsquare=_TEST_NSQUARE)
select_clause.Rewrite()
fields = [util.FieldToken('Price')]
clause = query_lib._GroupByClause(fields,
schema=test_schema,
nsquare=_TEST_NSQUARE,
select_clause=select_clause)
self.assertRaises(bigquery_client.BigqueryInvalidQueryError,
clause.Rewrite)
fields = [util.FieldToken('Invoice_Price'), util.FieldToken('Make')]
clause = query_lib._GroupByClause(fields,
schema=test_schema,
nsquare=_TEST_NSQUARE,
select_clause=select_clause)
self.assertRaises(bigquery_client.BigqueryInvalidQueryError,
clause.Rewrite)
fields = [util.FieldToken('Make')]
clause = query_lib._GroupByClause(fields,
schema=test_schema,
nsquare=_TEST_NSQUARE,
select_clause=select_clause)
self.assertEqual(clause.Rewrite(),
'GROUP BY %sMake' % util.PSEUDONYM_PREFIX)
fields = [util.FieldToken('Year')]
clause = query_lib._GroupByClause(fields,
schema=test_schema,
nsquare=_TEST_NSQUARE,
select_clause=select_clause)
self.assertEqual(clause.Rewrite(), 'GROUP BY Year')
fields = []
clause = query_lib._GroupByClause(fields,
schema=test_schema,
nsquare=_TEST_NSQUARE,
select_clause=select_clause)
self.assertEqual(clause.Rewrite(), '')
def testWhereRewrite(self):
schema = test_util.GetCarsSchema()
master_key = test_util.GetMasterKey()
as_clause = query_lib._AsClause({})
stack = [
util.FieldToken('Make'),
util.StringLiteralToken('"Hello"'),
util.OperatorToken('==', 2)
]
where_clause = query_lib._WhereClause(stack,
as_clause=as_clause,
schema=schema,
nsquare=_TEST_NSQUARE,
master_key=master_key,
table_id=_TABLE_ID)
self.assertEqual(
where_clause.Rewrite(),
'WHERE (%sMake == "HS57DHbh2KlkqNJREmu1wQ==")' %
util.PSEUDONYM_PREFIX)
stack = [
util.FieldToken('Model'),
util.StringLiteralToken('"A"'),
util.OperatorToken('contains', 2)
]
where_clause = query_lib._WhereClause(stack,
as_clause=as_clause,
schema=schema,
nsquare=_TEST_NSQUARE,
master_key=master_key,
table_id=_TABLE_ID)
self.assertEqual(
where_clause.Rewrite(),
'WHERE (%sModel contains to_base64(left(bytes(sha1(concat(left('
'%sModel, 24), \'yB9HY2qv+DI=\'))), 8)))' %
(util.SEARCHWORDS_PREFIX, util.SEARCHWORDS_PREFIX))
stack = []
where_clause = query_lib._WhereClause(stack,
as_clause=as_clause,
schema=schema,
nsquare=_TEST_NSQUARE,
master_key=master_key,
table_id=_TABLE_ID)
self.assertEqual(where_clause.Rewrite(), '')
def testAsConstructColumnNames(self):
alias = {0: 'a'}
columns = [[util.FieldToken('b')], [1, 2, util.OperatorToken('+', 2)]]
as_clause = query_lib._AsClause(alias)
self.assertEqual(as_clause.ConstructColumnNames(columns),
[{
'name': 'a'
}, {
'name': '(1 + 2)'
}])
def testSimpleWhere(self):
schema = test_util.GetCarsSchema()
key = test_util.GetMasterKey()
stack = [1, 2, util.OperatorToken('>', 2)]
self.assertEqual(
interpreter.RewriteSelectionCriteria(stack, schema, key,
_TABLE_ID), '(1 > 2)')
stack = [1, 2, util.OperatorToken('=', 2)]
self.assertEqual(
interpreter.RewriteSelectionCriteria(stack, schema, key,
_TABLE_ID), '(1 = 2)')
stack = [util.FieldToken('PI()'), 1, util.OperatorToken('>', 2)]
self.assertEqual(
interpreter.RewriteSelectionCriteria(stack, schema, key,
_TABLE_ID), '(PI() > 1)')
stack = [1, util.OperatorToken('>', 2)]
self.assertRaises(bigquery_client.BigqueryInvalidQueryError,
interpreter.RewriteSelectionCriteria, stack, schema,
key, _TABLE_ID)
stack = [util.FieldToken('Year'), 2000, util.OperatorToken('<', 2)]
self.assertEqual(
interpreter.RewriteSelectionCriteria(stack, schema, key,
_TABLE_ID), '(Year < 2000)')
def testExtractEncryptedQueries(self):
# Original query is 'SELECT (111 + a_1) * a, TRUE OR False, null, PI(),
# FUNC_PI, a1'
# Query sent to server becomes 'SELECT a, a_1, FUNC_PI, a1'
stacks = [[
util.FieldToken('a'), 111,
util.FieldToken('a_1'),
util.OperatorToken('+', 2),
util.OperatorToken('*', 2)
], ['TRUE', 'False', util.OperatorToken('OR', 2)], ['null'],
[util.BuiltInFunctionToken('PI')],
[util.FieldToken('FUNC_PI')], [util.FieldToken('a1')],
[util.FieldToken('a.b')],
[
util.UnencryptedQueryToken('%s0_' %
util.UNENCRYPTED_ALIAS_PREFIX)
]]
query_list = query_lib._ExtractFieldQueries(stacks, strize=True)
expect_query_list = set([
'a', 'a_1', 'FUNC_PI', 'a1',
'a.b AS a' + util.PERIOD_REPLACEMENT + 'b'
])
self.assertEqual(expect_query_list, query_list)
def PushSingleToken(tokens):
"""Push the topmost token onto the stack."""
if util.IsFloat(tokens[0]):
try:
token = int(tokens[0])
except ValueError:
token = float(tokens[0])
elif tokens[0].startswith('\'') or tokens[0].startswith('"'):
token = util.StringLiteralToken(tokens[0])
elif tokens[0].lower() in util.BIGQUERY_CONSTANTS:
token = util.LiteralToken(tokens[0].lower(),
util.BIGQUERY_CONSTANTS[tokens[0].lower()])
else:
token = util.FieldToken(tokens[0])
math_stack.append(token)
def testCheckValidSumAverageArgument(self):
stack = [
util.FieldToken('Year'),
util.FieldToken('Year'),
util.OperatorToken('*', 2),
util.HomomorphicIntToken('Invoice_Price'),
util.OperatorToken('+', 2)
]
expected_stack = [[['Year', 'Year', '*'],
[util.HOMOMORPHIC_INT_PREFIX + 'Invoice_Price']],
True, True]
self.assertEqual(interpreter.CheckValidSumAverageArgument(stack),
expected_stack)
stack = [
2,
util.FieldToken('Year'),
util.FieldToken('Year'),
util.OperatorToken('*', 2),
util.HomomorphicIntToken('Invoice_Price'),
util.OperatorToken('+', 2),
util.OperatorToken('*', 2)
]
expected_stack = [[
[2, 'Year', 'Year', '*', '*'],
[2, util.HOMOMORPHIC_INT_PREFIX + 'Invoice_Price', '*']
], True, True]
self.assertEqual(interpreter.CheckValidSumAverageArgument(stack),
expected_stack)
stack = [util.ProbabilisticToken('Price')]
self.assertRaises(bigquery_client.BigqueryInvalidQueryError,
interpreter.CheckValidSumAverageArgument, stack)
stack = [
util.HomomorphicIntToken('Invoice_Price'),
util.HomomorphicFloatToken('Holdback_Percentage'),
util.OperatorToken('*', 2)
]
self.assertRaises(bigquery_client.BigqueryInvalidQueryError,
interpreter.CheckValidSumAverageArgument, stack)
stack = [
util.HomomorphicIntToken('Invoice_Price'),
util.FieldToken('Year'),
util.OperatorToken('*', 2)
]
self.assertRaises(bigquery_client.BigqueryInvalidQueryError,
interpreter.CheckValidSumAverageArgument, stack)
stack = [
util.HomomorphicIntToken('Invoice_Price'),
util.FieldToken('Year'),
util.OperatorToken('/', 2)
]
self.assertRaises(bigquery_client.BigqueryInvalidQueryError,
interpreter.CheckValidSumAverageArgument, stack)
def _CollapseFunctions(stack):
"""Collapses functions by evaluating them for actual values.
Replaces a function's postfix expression with a single token. If the function
can be evaluated (no fields included as arguments), the single token is
the value of function's evaluation. Otherwise, the function is collapsed
into a single token without evaluation.
Arguments:
stack: The stack whose functions are to be collapsed and resolved.
Raises:
bigquery_client.BigqueryInvalidQueryError: If a field exists inside
the arguments of a function.
Returns:
True iff a function is found and collapsed. In other words, another
potential function can still exist.
"""
for i in xrange(len(stack)):
if isinstance(stack[i], util.BuiltInFunctionToken):
start_idx, postfix_expr = interpreter.GetSingleValue(stack[:i + 1])
if util.IsEncryptedExpression(postfix_expr):
raise bigquery_client.BigqueryInvalidQueryError(
'Invalid aggregation function argument: Cannot put an encrypted '
'field as an argument to a built-in function.', None, None,
None)
# If the expression has no fields, we want to get the actual value.
# But, if the field has a field, we have to get the infix string instead.
try:
result = interpreter.Evaluate(list(postfix_expr))
if isinstance(result, basestring):
result = util.StringLiteralToken('"%s"' % result)
elif result is None:
result = util.LiteralToken('NULL', None)
elif str(result).lower() in ['true', 'false']:
result = util.LiteralToken(str(result).lower(), result)
stack[start_idx:i + 1] = [result]
except bigquery_client.BigqueryInvalidQueryError:
result = interpreter.ToInfix(list(postfix_expr))
stack[start_idx:i + 1] = [util.FieldToken(result)]
return True
return False
def testRewriteEncryptedFields(self):
queries = [
util.FieldToken('Year'),
util.FieldToken('Model'),
util.FieldToken('Make'),
util.FieldToken('Invoice_Price'),
util.FieldToken('Price'),
util.FieldToken('Website'),
util.FieldToken('Description')
]
rewritten_queries = [
util.FieldToken('Year'),
util.ProbabilisticToken('Model'),
util.PseudonymToken('Make'),
util.HomomorphicIntToken('Invoice_Price'),
util.ProbabilisticToken('Price'),
util.SearchwordsToken('Website'),
util.SearchwordsToken('Description')
]
test_schema = test_util.GetCarsSchema()
new_queries = query_lib._RewriteEncryptedFields([queries], test_schema)
self.assertEqual(new_queries, [rewritten_queries])
def testExpandExpression(self):
stack = [
util.FieldToken('x'),
util.FieldToken('y'),
util.OperatorToken('+', 2),
util.FieldToken('x'),
util.OperatorToken('+', 2), 2,
util.FieldToken('z'),
util.OperatorToken('*', 2),
util.OperatorToken('-', 2), 5,
util.OperatorToken('-', 2), 3,
util.OperatorToken('+', 2)
]
list_fields, constant = interpreter._ExpandExpression(stack)
self.assertEqual(
list_fields,
[[2.0, util.FieldToken('x')], [1.0, util.FieldToken('y')],
[-2.0, util.FieldToken('z')]])
self.assertEqual(constant, -2.0)
stack = [
util.FieldToken('x'), 4,
util.OperatorToken('+', 2), 6,
util.OperatorToken('*', 2), 2,
util.OperatorToken('/', 2)
]
list_fields, constant = interpreter._ExpandExpression(stack)
self.assertEqual(list_fields, [[3.0, util.FieldToken('x')]])
self.assertEqual(constant, 12.0)
stack = [
util.FieldToken('x'), 1,
util.OperatorToken('+', 2),
util.FieldToken('y'),
util.OperatorToken('*', 2)
]
self.assertRaises(bigquery_client.BigqueryInvalidQueryError,
interpreter._ExpandExpression, stack)
stack = [
util.FieldToken('x'),
util.FieldToken('y'),
util.OperatorToken('/', 2)
]
self.assertRaises(bigquery_client.BigqueryInvalidQueryError,
interpreter._ExpandExpression, stack)
def testEncryptedContains(self):
schema = test_util.GetCarsSchema()
key = test_util.GetMasterKey()
stack = [
util.FieldToken('Year'),
util.BuiltInFunctionToken('string'),
util.StringLiteralToken('"1"'),
util.OperatorToken('CONTAINS', 2)
]
self.assertEqual(
interpreter.RewriteSelectionCriteria(stack, schema, key,
_TABLE_ID),
'(string(Year) contains "1")')
stack = [
util.SearchwordsToken('Model'),
util.StringLiteralToken('"A"'),
util.OperatorToken('contains', 2)
]
self.assertEqual(
interpreter.RewriteSelectionCriteria(stack, schema, key,
_TABLE_ID),
'(' + util.SEARCHWORDS_PREFIX + 'Model contains '
'to_base64(left(bytes(sha1(concat(left(' +
util.SEARCHWORDS_PREFIX + 'Model, 24), \'yB9HY2qv+DI=\'))), 8)))')
stack = [
util.SearchwordsToken('Model'),
util.FieldToken('Year'),
util.OperatorToken('contains', 2)
]
self.assertRaises(bigquery_client.BigqueryInvalidQueryError,
interpreter.RewriteSelectionCriteria, stack, schema,
key, _TABLE_ID)
stack = [
util.PseudonymToken('Make'), 'A',
util.OperatorToken('contains', 2)
]
self.assertRaises(bigquery_client.BigqueryInvalidQueryError,
interpreter.RewriteSelectionCriteria, stack, schema,
key, _TABLE_ID)
stack = [
util.SearchwordsToken('Model'),
util.SearchwordsToken('Model'),
util.OperatorToken('contains', 2)
]
self.assertRaises(bigquery_client.BigqueryInvalidQueryError,
interpreter.RewriteSelectionCriteria, stack, schema,
key, _TABLE_ID)
stack = [
'Hello',
util.SearchwordsToken('Model'),
util.OperatorToken('contains', 2)
]
self.assertRaises(bigquery_client.BigqueryInvalidQueryError,
interpreter.RewriteSelectionCriteria, stack, schema,
key, _TABLE_ID)
stack = [
util.SearchwordsToken('Model'),
util.StringLiteralToken('"A"'),
util.OperatorToken('contains', 2),
util.OperatorToken('not', 1)
]
self.assertEqual(
interpreter.RewriteSelectionCriteria(stack, schema, key,
_TABLE_ID),
'not (' + util.SEARCHWORDS_PREFIX + 'Model contains '
'to_base64(left(bytes(sha1(concat(left(' +
util.SEARCHWORDS_PREFIX + 'Model, 24), \'yB9HY2qv+DI=\'))), 8)))')
schema = test_util.GetPlacesSchema()
stack = [
util.SearchwordsToken('citiesLived.place'),
util.StringLiteralToken('"A"'),
util.OperatorToken('contains', 2)
]
self.assertEqual(
interpreter.RewriteSelectionCriteria(stack, schema, key,
_TABLE_ID),
'(citiesLived.' + util.SEARCHWORDS_PREFIX + 'place contains '
'to_base64(left(bytes(sha1(concat(left(citiesLived.' +
util.SEARCHWORDS_PREFIX + 'place, 24), \'cBKPKGiY2cg=\'))), 8)))')
def testEncryptedEquality(self):
schema = test_util.GetCarsSchema()
key = test_util.GetMasterKey()
stack = [
util.FieldToken('Year'), 1,
util.OperatorToken('+', 2), 2000,
util.OperatorToken('=', 2)
]
self.assertEqual(
interpreter.RewriteSelectionCriteria(stack, schema, key,
_TABLE_ID),
'((Year + 1) = 2000)')
stack = [
util.FieldToken('Year'),
util.PseudonymToken('Make'),
util.OperatorToken('=', 2)
]
self.assertEqual(
interpreter.RewriteSelectionCriteria(stack, schema, key,
_TABLE_ID),
'(Year = ' + util.PSEUDONYM_PREFIX + 'Make)')
stack = [
util.PseudonymToken('Make'),
util.StringLiteralToken('"Hello"'),
util.OperatorToken('==', 2)
]
self.assertEqual(
interpreter.RewriteSelectionCriteria(stack, schema, key,
_TABLE_ID), '(' +
util.PSEUDONYM_PREFIX + 'Make == "HS57DHbh2KlkqNJREmu1wQ==")')
stack = [
util.StringLiteralToken('"Hello"'),
util.PseudonymToken('Make'),
util.OperatorToken('==', 2)
]
self.assertEqual(
interpreter.RewriteSelectionCriteria(stack, schema, key,
_TABLE_ID),
'("HS57DHbh2KlkqNJREmu1wQ==" == ' + util.PSEUDONYM_PREFIX +
'Make)')
stack = [
util.StringLiteralToken('"Hello"'),
util.PseudonymToken('Make'),
util.OperatorToken('!=', 2)
]
self.assertEqual(
interpreter.RewriteSelectionCriteria(stack, schema, key,
_TABLE_ID),
'("HS57DHbh2KlkqNJREmu1wQ==" != ' + util.PSEUDONYM_PREFIX +
'Make)')
stack = [
util.PseudonymToken('Make'),
util.PseudonymToken('Make2'),
util.OperatorToken('==', 2)
]
self.assertEqual(
interpreter.RewriteSelectionCriteria(stack, schema, key,
_TABLE_ID),
'(' + util.PSEUDONYM_PREFIX + 'Make == ' + util.PSEUDONYM_PREFIX +
'Make2)')
stack = [
util.HomomorphicIntToken('Invoice_Price'), 2,
util.OperatorToken('==', 2)
]
self.assertRaises(bigquery_client.BigqueryInvalidQueryError,
interpreter.RewriteSelectionCriteria, stack, schema,
key, _TABLE_ID)
stack = [
util.PseudonymToken('Make'),
util.ProbabilisticToken('Price'),
util.OperatorToken('=', 2)
]
self.assertRaises(bigquery_client.BigqueryInvalidQueryError,
interpreter.RewriteSelectionCriteria, stack, schema,
key, _TABLE_ID)
schema = test_util.GetPlacesSchema()
stack = [
util.PseudonymToken('spouse.spouseName'),
util.StringLiteralToken('"Hello"'),
util.OperatorToken('=', 2)
]
self.assertEqual(
interpreter.RewriteSelectionCriteria(stack, schema, key,
_TABLE_ID), '(spouse.' +
util.PSEUDONYM_PREFIX + 'spouseName = "HS57DHbh2KlkqNJREmu1wQ==")')
def testRewriteAggregations(self):
stack = [
util.CountStarToken(),
util.AggregationFunctionToken('COUNT', 1)
]
rewritten_stack = ['COUNT(*)']
self.assertEqual(
query_lib._RewriteAggregations([stack], _TEST_NSQUARE),
[rewritten_stack])
stack = [
util.ProbabilisticToken('Price'),
util.AggregationFunctionToken('COUNT', 1)
]
rewritten_stack = ['COUNT(' + util.PROBABILISTIC_PREFIX + 'Price)']
self.assertEqual(
query_lib._RewriteAggregations([stack], _TEST_NSQUARE),
[rewritten_stack])
stack = [
util.ProbabilisticToken('Price'), 4,
util.AggregationFunctionToken('COUNT', 2)
]
rewritten_stack = ['COUNT(' + util.PROBABILISTIC_PREFIX + 'Price, 4)']
self.assertEqual(
query_lib._RewriteAggregations([stack], _TEST_NSQUARE),
[rewritten_stack])
stack = [
util.FieldToken('Year'), 5,
util.AggregationFunctionToken('DISTINCTCOUNT', 2),
util.FieldToken('Year'),
util.AggregationFunctionToken('COUNT', 1),
util.OperatorToken('+', 2)
]
rewritten_stack = ['COUNT(DISTINCT Year, 5)', 'COUNT(Year)', '+']
self.assertEqual(
query_lib._RewriteAggregations([stack], _TEST_NSQUARE),
[rewritten_stack])
stack = [
0,
util.BuiltInFunctionToken('cos'),
util.AggregationFunctionToken('COUNT', 1)
]
rewritten_stack = ['COUNT(1.0)']
self.assertEqual(
query_lib._RewriteAggregations([stack], _TEST_NSQUARE),
[rewritten_stack])
stack = [
util.StringLiteralToken('"Hello"'), 2,
util.BuiltInFunctionToken('left'),
util.StringLiteralToken('"y"'),
util.BuiltInFunctionToken('concat'),
util.AggregationFunctionToken('GROUP_CONCAT', 1)
]
rewritten_stack = ['GROUP_CONCAT("Hey")']
self.assertEqual(
query_lib._RewriteAggregations([stack], _TEST_NSQUARE),
[rewritten_stack])
stack = [
util.FieldToken('Year'),
util.FieldToken('Year'),
util.OperatorToken('*', 2),
util.AggregationFunctionToken('SUM', 1)
]
rewritten_stack = ['SUM((Year * Year))']
self.assertEqual(
query_lib._RewriteAggregations([stack], _TEST_NSQUARE),
[rewritten_stack])
stack = [
util.HomomorphicIntToken('Invoice_Price'),
util.AggregationFunctionToken('SUM', 1)
]
rewritten_stack = [
0.0, 'COUNT(' + util.HOMOMORPHIC_INT_PREFIX + 'Invoice_Price)',
'*', 1.0, 'TO_BASE64(BYTES(PAILLIER_SUM(FROM_BASE64(' +
util.HOMOMORPHIC_INT_PREFIX + 'Invoice_Price), \'0\')))', '*', '+'
]
self.assertEqual(
query_lib._RewriteAggregations([stack], _TEST_NSQUARE),
[rewritten_stack])
stack = [
util.HomomorphicFloatToken('Holdback_Percentage'),
util.AggregationFunctionToken('AVG', 1)
]
rewritten_stack = [
0.0,
'COUNT(' + util.HOMOMORPHIC_FLOAT_PREFIX + 'Holdback_Percentage)',
'*', 1.0, 'TO_BASE64(BYTES(PAILLIER_SUM(FROM_BASE64(' +
util.HOMOMORPHIC_FLOAT_PREFIX + 'Holdback_Percentage), \'0\')))',
'*', '+',
'COUNT(' + util.HOMOMORPHIC_FLOAT_PREFIX + 'Holdback_Percentage)',
'/'
]
self.assertEqual(
query_lib._RewriteAggregations([stack], _TEST_NSQUARE),
[rewritten_stack])
stack = [
util.HomomorphicIntToken('Invoice_Price'), 2,
util.OperatorToken('+', 2), 5,
util.OperatorToken('*', 2),
util.AggregationFunctionToken('SUM', 1)
]
rewritten_stack = [
0.0, 'COUNT(' + util.HOMOMORPHIC_INT_PREFIX + 'Invoice_Price)',
'*', 5.0, 'TO_BASE64(BYTES(PAILLIER_SUM(FROM_BASE64(' +
util.HOMOMORPHIC_INT_PREFIX + 'Invoice_Price), \'0\')))', '*', '+',
0.0, 'COUNT(' + util.HOMOMORPHIC_INT_PREFIX + 'Invoice_Price)',
'*', 1.0, 'SUM((2 * 5))', '*', '+', '+'
]
self.assertEqual(
query_lib._RewriteAggregations([stack], _TEST_NSQUARE),
[rewritten_stack])
stack = [
util.PseudonymToken('Make'), 2,
util.AggregationFunctionToken('DISTINCTCOUNT', 2)
]
rewritten_stack = [
'COUNT(DISTINCT ' + util.PSEUDONYM_PREFIX + 'Make, 2)'
]
self.assertEqual(
query_lib._RewriteAggregations([stack], _TEST_NSQUARE),
[rewritten_stack])
stack = [
util.FieldToken('Year'),
util.AggregationFunctionToken('TOP', 1)
]
rewritten_stack = ['TOP(Year)']
self.assertEqual(
query_lib._RewriteAggregations([stack], _TEST_NSQUARE),
[rewritten_stack])
stack = [
util.PseudonymToken('Make'), 5, 1,
util.AggregationFunctionToken('TOP', 3)
]
rewritten_stack = ['TOP(' + util.PSEUDONYM_PREFIX + 'Make, 5, 1)']
self.assertEqual(
query_lib._RewriteAggregations([stack], _TEST_NSQUARE),
[rewritten_stack])
stack = [
util.FieldToken('Year'),
util.BuiltInFunctionToken('cos'),
util.HomomorphicIntToken('Invoice_Price'),
util.OperatorToken('+', 2),
util.AggregationFunctionToken('SUM', 1)
]
rewritten_stack = [
0.0, 'COUNT(' + util.HOMOMORPHIC_INT_PREFIX + 'Invoice_Price)',
'*', 1.0, 'SUM(cos(Year))', '*', '+', 0.0,
'COUNT(' + util.HOMOMORPHIC_INT_PREFIX + 'Invoice_Price)', '*',
1.0, 'TO_BASE64(BYTES(PAILLIER_SUM(FROM_BASE64(' +
util.HOMOMORPHIC_INT_PREFIX + 'Invoice_Price),'
' \'0\')))', '*', '+', '+'
]
self.assertEqual(
query_lib._RewriteAggregations([stack], _TEST_NSQUARE),
[rewritten_stack])
stack = [
util.ProbabilisticToken('Model'),
util.AggregationFunctionToken('DISTINCTCOUNT', 1)
]
self.assertRaises(bigquery_client.BigqueryInvalidQueryError,
query_lib._RewriteAggregations, [stack],
_TEST_NSQUARE)
stack = [
util.ProbabilisticToken('Price'),
util.AggregationFunctionToken('SUM', 1)
]
self.assertRaises(bigquery_client.BigqueryInvalidQueryError,
query_lib._RewriteAggregations, [stack],
_TEST_NSQUARE)
stack = [
util.HomomorphicIntToken('Invoice_Price'),
util.HomomorphicFloatToken('Holdback_Percentage'),
util.OperatorToken('*', 2),
util.AggregationFunctionToken('SUM', 1)
]
self.assertRaises(bigquery_client.BigqueryInvalidQueryError,
query_lib._RewriteAggregations, [stack],
_TEST_NSQUARE)
stack = [
util.HomomorphicFloatToken('Holdback_Percentage'),
util.BuiltInFunctionToken('cos'),
util.AggregationFunctionToken('SUM', 1)
]
self.assertRaises(bigquery_client.BigqueryInvalidQueryError,
query_lib._RewriteAggregations, [stack],
_TEST_NSQUARE)
stack = [
util.HomomorphicIntToken('Invoice_Price'),
util.AggregationFunctionToken('TOP', 1)
]
self.assertRaises(bigquery_client.BigqueryInvalidQueryError,
query_lib._RewriteAggregations, [stack],
_TEST_NSQUARE)
stack = [
util.FieldToken('Year'),
util.AggregationFunctionToken('SUM', 1),
util.AggregationFunctionToken('SUM', 1)
]
rewritten_stack = ['SUM(SUM(Year))']
self.assertEqual(
query_lib._RewriteAggregations([stack], _TEST_NSQUARE),
[rewritten_stack])
stack = [
util.HomomorphicIntToken('Invoice_Price'),
util.AggregationFunctionToken('SUM', 1),
util.AggregationFunctionToken('SUM', 1)
]
self.assertRaises(bigquery_client.BigqueryInvalidQueryError,
query_lib._RewriteAggregations, [stack],
_TEST_NSQUARE)
stack = [
util.FieldToken('Year'),
util.AggregationFunctionToken('GROUP_CONCAT', 1),
util.AggregationFunctionToken('GROUP_CONCAT', 1)
]
rewritten_stack = ['GROUP_CONCAT(GROUP_CONCAT(Year))']
self.assertEqual(
query_lib._RewriteAggregations([stack], _TEST_NSQUARE),
[rewritten_stack])
stack = [
util.PseudonymToken('Make'),
util.AggregationFunctionToken('GROUP_CONCAT', 1),
util.AggregationFunctionToken('GROUP_CONCAT', 1)
]
self.assertRaises(bigquery_client.BigqueryInvalidQueryError,
query_lib._RewriteAggregations, [stack],
_TEST_NSQUARE)
def testInit(self):
"""Test __init__()."""
f = util.FieldToken('foo')
self.assertEqual(f, 'foo')
def testSetAlias(self):
"""Test property alias SetAlias()."""
f = util.FieldToken('foo')
ret = f.SetAlias('bar')
self.assertEqual(f._alias, 'bar')
self.assertEqual(ret, f)
def testEncryptedEquality(self):
schema = test_util.GetCarsSchema()
key = test_util.GetMasterKey()
stack = [
util.FieldToken('Year'), 1,
util.OperatorToken('+', 2), 2000,
util.OperatorToken('=', 2)
]
self.assertEqual(
interpreter.RewriteSelectionCriteria(stack, schema, key,
_TABLE_ID),
'((Year + 1) = 2000)')
stack = [
util.FieldToken('Year'),
util.PseudonymToken('Make'),
util.OperatorToken('=', 2)
]
self.assertEqual(
interpreter.RewriteSelectionCriteria(stack, schema, key,
_TABLE_ID),
'(Year = ' + util.PSEUDONYM_PREFIX + 'Make)')
stack = [
util.PseudonymToken('Make'),
util.StringLiteralToken('"Hello"'),
util.OperatorToken('==', 2)
]
self.assertEqual(
interpreter.RewriteSelectionCriteria(stack, schema, key,
_TABLE_ID), '(' +
util.PSEUDONYM_PREFIX + 'Make == "HS57DHbh2KlkqNJREmu1wQ==")')
# begin: tests about 'related' schema option
schema2 = test_util.GetCarsSchema()
for field in schema2:
if field['name'] == 'Make':
field['related'] = 'cars_name'
# value is deterministic calc with related instead of _TABLE_ID
stack = [
util.PseudonymToken('Make', related=_RELATED),
util.StringLiteralToken('"Hello"'),
util.OperatorToken('==', 2)
]
self.assertEqual(
interpreter.RewriteSelectionCriteria(stack, schema2, key,
_TABLE_ID), '(' +
util.PSEUDONYM_PREFIX + 'Make == "sspWKAH/NKuUyX8ji1mmSw==")')
# token with related attribute makes no sense if schema doesn't have it
stack = [
util.StringLiteralToken('"Hello"'),
util.PseudonymToken('Make', related=_RELATED),
util.OperatorToken('==', 2)
]
self.assertRaises(bigquery_client.BigqueryInvalidQueryError,
interpreter.RewriteSelectionCriteria, stack, schema,
key, _TABLE_ID)
# end: tests about 'related' schema option
stack = [
util.StringLiteralToken('"Hello"'),
util.PseudonymToken('Make'),
util.OperatorToken('==', 2)
]
self.assertEqual(
interpreter.RewriteSelectionCriteria(stack, schema, key,
_TABLE_ID),
'("HS57DHbh2KlkqNJREmu1wQ==" == ' + util.PSEUDONYM_PREFIX +
'Make)')
stack = [
util.StringLiteralToken('"Hello"'),
util.PseudonymToken('Make'),
util.OperatorToken('!=', 2)
]
self.assertEqual(
interpreter.RewriteSelectionCriteria(stack, schema, key,
_TABLE_ID),
'("HS57DHbh2KlkqNJREmu1wQ==" != ' + util.PSEUDONYM_PREFIX +
'Make)')
stack = [
util.PseudonymToken('Make'),
util.PseudonymToken('Make2'),
util.OperatorToken('==', 2)
]
self.assertEqual(
interpreter.RewriteSelectionCriteria(stack, schema, key,
_TABLE_ID),
'(' + util.PSEUDONYM_PREFIX + 'Make == ' + util.PSEUDONYM_PREFIX +
'Make2)')
stack = [
util.HomomorphicIntToken('Invoice_Price'), 2,
util.OperatorToken('==', 2)
]
self.assertRaises(bigquery_client.BigqueryInvalidQueryError,
interpreter.RewriteSelectionCriteria, stack, schema,
key, _TABLE_ID)
stack = [
util.PseudonymToken('Make'),
util.ProbabilisticToken('Price'),
util.OperatorToken('=', 2)
]
self.assertRaises(bigquery_client.BigqueryInvalidQueryError,
interpreter.RewriteSelectionCriteria, stack, schema,
key, _TABLE_ID)
schema = test_util.GetPlacesSchema()
stack = [
util.PseudonymToken('spouse.spouseName'),
util.StringLiteralToken('"Hello"'),
util.OperatorToken('=', 2)
]
self.assertEqual(
interpreter.RewriteSelectionCriteria(stack, schema, key,
_TABLE_ID), '(spouse.' +
util.PSEUDONYM_PREFIX + 'spouseName = "HS57DHbh2KlkqNJREmu1wQ==")')
