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 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 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 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 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 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 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 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 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 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==")')
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==")')