def testDecryptValues(self):
"""Test _DecryptValues()."""
cars_schema = test_util.GetCarsSchema()
jobs_schema = test_util.GetJobsSchema()
master_key = test_util.GetMasterKey()
field = '%sInvoice_Price' % util.HOMOMORPHIC_INT_PREFIX
table = [[1], [2], [3]]
cipher = ecrypto.HomomorphicIntCipher(master_key)
ciphers = {util.HOMOMORPHIC_INT_PREFIX: cipher}
table = self._EncryptTable(cipher, table, 0)
table.append([None])
column = encrypted_bigquery_client._DecryptValues(
field, table, 0, ciphers, cars_schema, util.HOMOMORPHIC_INT_PREFIX)
self.assertEqual(column, [1, 2, 3, util.LiteralToken('null', None)])
field = 'citiesLived.job.%sposition' % util.PSEUDONYM_PREFIX
table = [[0, unicode('Hello')], [1, unicode('My')],
[-1, unicode('job')]]
cipher = ecrypto.PseudonymCipher(master_key)
ciphers = {util.PSEUDONYM_PREFIX: cipher}
table = self._EncryptTable(cipher, table, 1)
table.insert(1, [100, None])
column = encrypted_bigquery_client._DecryptValues(
field, table, 1, ciphers, jobs_schema, util.PSEUDONYM_PREFIX)
self.assertEqual(column, [
util.StringLiteralToken('"Hello"'),
util.LiteralToken('null', None),
util.StringLiteralToken('"My"'),
util.StringLiteralToken('"job"')
])
field = '%snonexistent_field' % util.HOMOMORPHIC_FLOAT_PREFIX
self.assertRaises(ValueError, encrypted_bigquery_client._DecryptValues,
field, table, 1, ciphers, cars_schema,
util.HOMOMORPHIC_FLOAT_PREFIX)
def testFailOperationsOnEncryptions(self):
schema = test_util.GetCarsSchema()
key = test_util.GetMasterKey()
stack = [
util.PseudonymToken('Year'), 1,
util.OperatorToken('+', 2), 2000,
util.OperatorToken('>=', 2)
]
self.assertRaises(bigquery_client.BigqueryInvalidQueryError,
interpreter.RewriteSelectionCriteria, stack, schema,
key, _TABLE_ID)
stack = [
util.ProbabilisticToken('Model'), 2,
util.BuiltInFunctionToken('left')
]
self.assertRaises(bigquery_client.BigqueryInvalidQueryError,
interpreter.RewriteSelectionCriteria, stack, schema,
key, _TABLE_ID)
stack = [
util.HomomorphicIntToken('Invoice_Price'),
util.BuiltInFunctionToken('is_nan')
]
self.assertRaises(bigquery_client.BigqueryInvalidQueryError,
interpreter.RewriteSelectionCriteria, stack, schema,
key, _TABLE_ID)
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 testRewriteQueryWhenLocalEvaluate(self):
master_key = test_util.GetMasterKey()
schema = test_util.GetCarsSchema()
query = 'SELECT Price + 1 from test_dataset.cars'
clauses = parser.ParseQuery(query)
expect_rewritten_query = ('SELECT %sPrice FROM test_dataset.cars' %
util.PROBABILISTIC_PREFIX)
self.assertEqual(
expect_rewritten_query,
query_lib.RewriteQuery(clauses, schema, master_key, _TABLE_ID)[0])
def testRewriteQueryWhenSumYear(self):
master_key = test_util.GetMasterKey()
schema = test_util.GetCarsSchema()
query = 'SELECT SUM(Year) from test_dataset.cars having SUM(Year) > 7000'
clauses = parser.ParseQuery(query)
rewritten_query = ('SELECT SUM(Year) AS %s0_ FROM test_dataset.cars '
'HAVING (SUM(Year) > 7000)' %
util.UNENCRYPTED_ALIAS_PREFIX)
self.assertEqual(
query_lib.RewriteQuery(clauses, schema, master_key, _TABLE_ID)[0],
rewritten_query)
def testDecryptGroupConcatValues(self):
cars_schema = test_util.GetCarsSchema()
jobs_schema = test_util.GetJobsSchema()
master_key = test_util.GetMasterKey()
query = 'GROUP_CONCAT(%sModel)' % util.PROBABILISTIC_PREFIX
cipher = ecrypto.ProbabilisticCipher(master_key)
ciphers = {util.PROBABILISTIC_PREFIX: cipher}
unencrypted_values = ([['A', 'B', 'C', 'D'], ['1', '2', '3', '4'],
['Hello', 'Bye']])
table = []
for values in unencrypted_values:
encrypted_values = []
for token in values:
encrypted_values.append(cipher.Encrypt(unicode(token)))
table.append([','.join(encrypted_values), random.random()])
table.insert(0, [None, None])
column = encrypted_bigquery_client._DecryptGroupConcatValues(
query, table, 0, ciphers, cars_schema, util.PROBABILISTIC_PREFIX)
self.assertEqual(column, [
util.LiteralToken('null', None),
util.StringLiteralToken('"A,B,C,D"'),
util.StringLiteralToken('"1,2,3,4"'),
util.StringLiteralToken('"Hello,Bye"')
])
query = (
'GROUP_CONCAT(citiesLived.job.%sposition) within citiesLived.job' %
util.PSEUDONYM_PREFIX)
cipher = ecrypto.PseudonymCipher(master_key)
ciphers = {util.PSEUDONYM_PREFIX: cipher}
table = []
for values in unencrypted_values:
encrypted_values = []
for token in values:
encrypted_values.append(cipher.Encrypt(unicode(token)))
table.append([','.join(encrypted_values)])
column = encrypted_bigquery_client._DecryptGroupConcatValues(
query, table, 0, ciphers, jobs_schema, util.PSEUDONYM_PREFIX)
self.assertEqual(column, [
util.StringLiteralToken('"A,B,C,D"'),
util.StringLiteralToken('"1,2,3,4"'),
util.StringLiteralToken('"Hello,Bye"')
])
query = '%sModel' % util.PROBABILISTIC_PREFIX
self.assertRaises(ValueError,
encrypted_bigquery_client._DecryptGroupConcatValues,
query, table, 0, ciphers, cars_schema,
util.PROBABILISTIC_PREFIX)
query = (
'GROUP_CONCAT(citiesLived.%snumberOfYears) within citiesLived' %
util.HOMOMORPHIC_FLOAT_PREFIX)
self.assertRaises(bigquery_client.BigqueryInvalidQueryError,
encrypted_bigquery_client._DecryptGroupConcatValues,
query, table, 0, ciphers, jobs_schema,
util.HOMOMORPHIC_FLOAT_PREFIX)
def testRewriteQueryWhenMakeAlias(self):
master_key = test_util.GetMasterKey()
schema = test_util.GetCarsSchema()
query = 'SELECT Make AS alias_make FROM test_dataset.cars'
expect_rewritten_query = (
'SELECT %sMake AS alias_make FROM test_dataset.cars' %
(util.PSEUDONYM_PREFIX))
clauses = parser.ParseQuery(query)
self.assertEqual(clauses['AS'].get(0, None), 'alias_make')
self.assertEqual(
expect_rewritten_query,
query_lib.RewriteQuery(clauses, schema, master_key, _TABLE_ID)[0])
def testRewriteQueryWhenCountMakeAlias(self):
master_key = test_util.GetMasterKey()
schema = test_util.GetCarsSchema()
query = 'SELECT COUNT(Make) AS cnt_make FROM test_dataset.cars'
rewritten_query = (
'SELECT COUNT(%sMake) AS cnt_make FROM test_dataset.cars' %
(util.PSEUDONYM_PREFIX))
clauses = parser.ParseQuery(query)
self.assertEqual(clauses['AS'], {0: 'cnt_make'})
self.assertEqual(
query_lib.RewriteQuery(clauses, schema, master_key, _TABLE_ID)[0],
rewritten_query)
def testRewriteQueryWhenGroupBy(self):
master_key = test_util.GetMasterKey()
schema = test_util.GetCarsSchema()
query = (
'SELECT Year from test_dataset.cars WHERE Year > 1990 GROUP BY Year '
'ORDER BY Year LIMIT 2')
clauses = parser.ParseQuery(query)
rewritten_query = (
'SELECT Year AS %s0_ FROM test_dataset.cars WHERE (Year > 1990) '
'GROUP BY %s0_ LIMIT 2' %
(util.UNENCRYPTED_ALIAS_PREFIX, util.UNENCRYPTED_ALIAS_PREFIX))
self.assertEqual(
query_lib.RewriteQuery(clauses, schema, master_key, _TABLE_ID)[0],
rewritten_query)
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 testGetEntryFromSchema(self):
simple_schema = test_util.GetCarsSchema()
nested_schema = test_util.GetJobsSchema()
row = util.GetEntryFromSchema('Year', simple_schema)
self.assertEqual(row['name'], 'Year')
self.assertEqual(row['encrypt'], 'none')
row = util.GetEntryFromSchema('citiesLived.place', nested_schema)
self.assertEqual(row['name'], 'place')
self.assertEqual(row['encrypt'], 'searchwords')
row = util.GetEntryFromSchema('citiesLived.job.position',
nested_schema)
self.assertEqual(row['name'], 'position')
self.assertEqual(row['encrypt'], 'pseudonym')
row = util.GetEntryFromSchema('citiesLived.job', nested_schema)
self.assertEqual(row, None)
row = util.GetEntryFromSchema('citiesLived.non_existent_field',
nested_schema)
self.assertEqual(row, None)
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 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 testRewriteJoin(self):
master_key = test_util.GetMasterKey()
schema = test_util.GetCarsSchema()
query = ('SELECT Year '
'FROM test_dataset.cars '
'JOIN avg_yearly_car_costs ON '
'avg_yearly_car_costs.year = test_dataset.cars.Year '
'JOIN reliability_data ON '
'reliability_data.make = test_dataset.cars.Make')
clauses = parser.ParseQuery(query)
rewritten_query = (
'SELECT Year AS p698000442118338_ue0_ '
'FROM test_dataset.cars '
'JOIN avg_yearly_car_costs ON '
'(avg_yearly_car_costs.year = test_dataset.cars.Year) '
'JOIN reliability_data ON '
'(reliability_data.make = test_dataset.cars.Make)')
self.assertEqual(
query_lib.RewriteQuery(clauses, schema, master_key, _TABLE_ID)[0],
rewritten_query)
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 testRewriteQueryWhen(self):
master_key = test_util.GetMasterKey()
schema = test_util.GetCarsSchema()
query = ('SELECT SUM(Invoice_Price), GROUP_CONCAT(Make) '
'FROM test_dataset.cars')
clauses = parser.ParseQuery(query)
rewritten_query = (
'SELECT COUNT(%sInvoice_Price), %s%sInvoice_Price), '
'\'\\x44\\x08\\xb5\\xaa\\xcc\\x3f\\xf6\\xb3\\x36\\xe4'
'\\xb2\\xec\\xc7\\x75\\x1f\\xb2\\xdb\\xf3\\x3a\\x54\\xa1'
'\\x86\\xf3\\x66\\xcc\\xcb\\x49\\xc1\\x41\\xd2\\x05\\xe2'
'\\x8a\\x07\\xf2\\xe8\\x00\\x09\\x2e\\x6e\\x41\\x32\\x6c'
'\\xe8\\xa9\\x07\\x62\\x5c\\x94\\x7d\\x00\\x0e\\x5d\\x8d'
'\\xd0\\x1e\\x44\\x6d\\xe6\\x6a\\x2d\\x38\\x5e\\x53\\xfd'
'\\xbc\\x47\\x6a\\xdc\\xd7\\x35\\x09\\xa3\\x1d\\xdf\\x98'
'\\x17\\x6d\\x65\\xa1\\x7f\\xdd\\x6c\\x0e\\x26\\x06\\xc9'
'\\x6f\\x87\\x4d\\x0e\\x60\\x90\\x8f\\xe5\\x39\\xf6\\xfc'
'\\xd7\\x5a\\xea\\xd9\\x6d\\x44\\x51\\x23\\xee\\xaa\\xff'
'\\xd3\\xa5\\xae\\xa7\\x66\\xfd\\x5e\\xa9\\x16\\x4e\\x60'
'\\x86\\x83\\x44\\x83\\xb5\\x8c\\xdb\\x7f\\x06\\x8d\\x44'
'\\x10\\xa2\\x47\\x99\\x35\\xf0\\xe5\\x7d\\x1d\\x19\\x91'
'\\xc2\\x13\\x9e\\x18\\xdf\\x60\\xb1\\xca\\xf0\\xe9\\xe0'
'\\x9e\\xaa\\xb2\\x92\\x9f\\xac\\xfb\\x3a\\x18\\xc8\\xf4'
'\\xfe\\xb9\\x98\\xee\\x8a\\xcb\\x84\\x8e\\xc1\\x54\\xf2'
'\\x55\\x71\\xdc\\x0b\\xd2\\x86\\x4c\\xbc\\xc3\\x47\\x96'
'\\x1d\\x83\\xac\\x10\\x36\\x2c\\x81\\xd3\\x39\\x1e\\x64'
'\\x51\\xe2\\xd7\\x35\\x1b\\x54\\xb8\\xbe\\x2b\\x42\\xea'
'\\x51\\x58\\x1a\\x36\\xbe\\x45\\xe2\\xd1\\xd0\\x15\\x8f'
'\\xa4\\xa7\\xb4\\x34\\x19\\xa1\\x4d\\xd0\\x14\\x77\\x9d'
'\\xd8\\xab\\xc7\\xda\\x6f\\x15\\xae\\x42\\x12\\xfd\\x5c'
'\\x4d\\x6a\\x41\\xfb\\x06\\x6a\\x1c\\xf4\\x54\\x59\\xfe'
'\\xb1\\xc3\\xec\\x11\'))), GROUP_CONCAT(%sMake) '
'FROM test_dataset.cars' %
(util.HOMOMORPHIC_INT_PREFIX, util.PAILLIER_SUM_PREFIX,
util.HOMOMORPHIC_INT_PREFIX, util.PSEUDONYM_PREFIX))
self.assertEqual(
query_lib.RewriteQuery(clauses, schema, master_key, _TABLE_ID)[0],
rewritten_query)
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 testRewriteQuery(self):
master_key = test_util.GetMasterKey()
schema = test_util.GetCarsSchema()
query = (
'SELECT Year from test_dataset.cars WHERE Year > 1990 GROUP BY '
'Year ORDER BY Year LIMIT 2')
clauses = parser.ParseQuery(query)
rewritten_query = (
'SELECT Year AS %s0_ FROM test_dataset.cars WHERE '
'(Year > 1990) GROUP BY %s0_ LIMIT 2' %
(util.UNENCRYPTED_ALIAS_PREFIX, util.UNENCRYPTED_ALIAS_PREFIX))
self.assertEqual(
query_lib.RewriteQuery(clauses, schema, master_key, _TABLE_ID)[0],
rewritten_query)
query = 'SELECT SUM(Year) from test_dataset.cars having SUM(Year) > 7000'
clauses = parser.ParseQuery(query)
rewritten_query = ('SELECT SUM(Year) AS %s0_ FROM '
'test_dataset.cars HAVING (SUM(Year) > 7000)' %
util.UNENCRYPTED_ALIAS_PREFIX)
self.assertEqual(
query_lib.RewriteQuery(clauses, schema, master_key, _TABLE_ID)[0],
rewritten_query)
query = 'SELECT Price + 1 from test_dataset.cars'
clauses = parser.ParseQuery(query)
rewritten_query = (
'SELECT %sPrice AS %sPrice FROM test_dataset.cars' %
(util.PROBABILISTIC_PREFIX, util.PROBABILISTIC_PREFIX))
self.assertEqual(
query_lib.RewriteQuery(clauses, schema, master_key, _TABLE_ID)[0],
rewritten_query)
query = ('SELECT SUM(Invoice_Price), GROUP_CONCAT(Make) '
'FROM test_dataset.cars')
clauses = parser.ParseQuery(query)
rewritten_query = (
'SELECT COUNT(%sInvoice_Price), %s%sInvoice_Price), '
'\'\\x44\\x08\\xb5\\xaa\\xcc\\x3f\\xf6\\xb3\\x36\\xe4'
'\\xb2\\xec\\xc7\\x75\\x1f\\xb2\\xdb\\xf3\\x3a\\x54\\xa1'
'\\x86\\xf3\\x66\\xcc\\xcb\\x49\\xc1\\x41\\xd2\\x05\\xe2'
'\\x8a\\x07\\xf2\\xe8\\x00\\x09\\x2e\\x6e\\x41\\x32\\x6c'
'\\xe8\\xa9\\x07\\x62\\x5c\\x94\\x7d\\x00\\x0e\\x5d\\x8d'
'\\xd0\\x1e\\x44\\x6d\\xe6\\x6a\\x2d\\x38\\x5e\\x53\\xfd'
'\\xbc\\x47\\x6a\\xdc\\xd7\\x35\\x09\\xa3\\x1d\\xdf\\x98'
'\\x17\\x6d\\x65\\xa1\\x7f\\xdd\\x6c\\x0e\\x26\\x06\\xc9'
'\\x6f\\x87\\x4d\\x0e\\x60\\x90\\x8f\\xe5\\x39\\xf6\\xfc'
'\\xd7\\x5a\\xea\\xd9\\x6d\\x44\\x51\\x23\\xee\\xaa\\xff'
'\\xd3\\xa5\\xae\\xa7\\x66\\xfd\\x5e\\xa9\\x16\\x4e\\x60'
'\\x86\\x83\\x44\\x83\\xb5\\x8c\\xdb\\x7f\\x06\\x8d\\x44'
'\\x10\\xa2\\x47\\x99\\x35\\xf0\\xe5\\x7d\\x1d\\x19\\x91'
'\\xc2\\x13\\x9e\\x18\\xdf\\x60\\xb1\\xca\\xf0\\xe9\\xe0'
'\\x9e\\xaa\\xb2\\x92\\x9f\\xac\\xfb\\x3a\\x18\\xc8\\xf4'
'\\xfe\\xb9\\x98\\xee\\x8a\\xcb\\x84\\x8e\\xc1\\x54\\xf2'
'\\x55\\x71\\xdc\\x0b\\xd2\\x86\\x4c\\xbc\\xc3\\x47\\x96'
'\\x1d\\x83\\xac\\x10\\x36\\x2c\\x81\\xd3\\x39\\x1e\\x64'
'\\x51\\xe2\\xd7\\x35\\x1b\\x54\\xb8\\xbe\\x2b\\x42\\xea'
'\\x51\\x58\\x1a\\x36\\xbe\\x45\\xe2\\xd1\\xd0\\x15\\x8f'
'\\xa4\\xa7\\xb4\\x34\\x19\\xa1\\x4d\\xd0\\x14\\x77\\x9d'
'\\xd8\\xab\\xc7\\xda\\x6f\\x15\\xae\\x42\\x12\\xfd\\x5c'
'\\x4d\\x6a\\x41\\xfb\\x06\\x6a\\x1c\\xf4\\x54\\x59\\xfe'
'\\xb1\\xc3\\xec\\x11\'))), GROUP_CONCAT(%sMake) '
'FROM test_dataset.cars' %
(util.HOMOMORPHIC_INT_PREFIX, util.PAILLIER_SUM_PREFIX,
util.HOMOMORPHIC_INT_PREFIX, util.PSEUDONYM_PREFIX))
self.assertEqual(
query_lib.RewriteQuery(clauses, schema, master_key, _TABLE_ID)[0],
rewritten_query)
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 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==")')
