def test_parse_filter_10(self):
"""Verify parse_filter() recognizes values with apostrophes.
"""
filter = "gene.Notes = 'Cro (control of repressor's operator)'"
parsed_filter = parsing.parse_filter(filter)
self.assertEqual(parsed_filter[3],
"Cro (control of repressor's operator)")
filter = "gene.Notes = '5' nucleotidase'"
parsed_filter = parsing.parse_filter(filter)
self.assertEqual(parsed_filter[3], "5' nucleotidase")
def test_parse_filter_6(self):
"""Verify parse_filter() recognizes empty quote values.
"""
filter = "gene.Notes = ''"
parsed_filter = parsing.parse_filter(filter)
self.assertEqual(parsed_filter[3], "")
def build_where_clause(db_graph, filter_expression):
filter_params = parsing.parse_filter(filter_expression)
table_object = db_graph.nodes[filter_params[0]]["table"]
column_object = table_object.columns[filter_params[1]]
parsing.check_operator(filter_params[2], column_object)
right = filter_params[3]
if column_object.type.python_type == bytes:
right = right.encode("utf-8")
where_clause = None
if filter_params[2] == "=":
where_clause = (column_object == right)
elif filter_params[2] == "LIKE":
where_clause = (column_object.like(right))
elif filter_params[2] == "!=" or filter_params[2] == "IS NOT":
where_clause = (column_object != right)
elif filter_params[2] == ">":
where_clause = (column_object > right)
elif filter_params[2] == ">=":
where_clause = (column_object >= right)
elif filter_params[2] == "<":
where_clause = (column_object < right)
elif filter_params[2] == "<=":
where_clause = (column_object <= right)
return where_clause
def test_parse_filter_4(self):
"""Verify parse_filter() raises ValueError from incomplete expression.
"""
filter = "phage.PhageID Trixie = "
with self.assertRaises(ValueError):
parsed_filter = parsing.parse_filter(filter)
def test_parse_filter_3(self):
"""Verify parse_column() raises ValueError from bad column format
"""
filter = "phage. PhageID = Trixie"
with self.assertRaises(ValueError):
parsed_filter = parsing.parse_filter(filter)
def test_parse_filter_11(self):
"""Verify parse_filter() handles hyphen characters.
"""
filter = "gene.Notes LIKE 'MerR-like%'"
parsed_filter = parsing.parse_filter(filter)
self.assertTrue("MerR-like%" in parsed_filter[3])
def build_where_clause(db_graph, filter_expression):
"""Creates a SQLAlchemy BinaryExpression object from a MySQL WHERE
clause expression.
:param db_graph: SQLAlchemy structured NetworkX Graph object.
:type db_graph: Graph
:param filter_expression: MySQL where clause expression.
:type filter_expression: str
:returns: MySQL expression-related SQLAlchemy BinaryExpression object.
:rtype: BinaryExpression
"""
filter_params = parsing.parse_filter(filter_expression)
# Retrieve Table and Column objects from split filter expression strings
table_object = db_graph.nodes[filter_params[0]]["table"]
column_name = parsing.translate_column(
db_graph.graph["metadata"],
f"{table_object.name}.{filter_params[1]}")
column_object = table_object.columns[column_name]
# Checks the operator and Column type compatability
parsing.check_operator(filter_params[2], column_object)
right = filter_params[3] # Stores the expressions 'right' value
if column_object.type.python_type == bytes:
if isinstance(right, list):
for i in range(len(right)):
right[i] = right[i].encode("utf-8")
else:
right = right.encode("utf-8")
if right == "None":
right = None
where_clause = None
if filter_params[2] == "=":
where_clause = (column_object == right)
elif filter_params[2] == "LIKE":
where_clause = (column_object.like(right))
elif filter_params[2] == "!=" or filter_params[2] == "IS NOT":
where_clause = (column_object != right)
elif filter_params[2] == ">":
where_clause = (column_object > right)
elif filter_params[2] == ">=":
where_clause = (column_object >= right)
elif filter_params[2] == "<":
where_clause = (column_object < right)
elif filter_params[2] == "<=":
where_clause = (column_object <= right)
elif filter_params[2] == "IN":
where_clause = (column_object.in_(right))
elif filter_params[2] == "NOT IN":
where_clause = (column_object.notin_(right))
return where_clause
def test_parse_filter_8(self):
"""Verify parse_filter() excludes commas in IN value operations.
"""
filter = "gene.Notes IN ('terminase, small subunit', terminase)"
parsed_filter = parsing.parse_filter(filter)
self.assertTrue(len(parsed_filter[3]) == 2)
self.assertTrue("terminase" in parsed_filter[3])
self.assertTrue("terminase, small subunit" in parsed_filter[3])
def test_parse_filter_5(self):
"""Verify parse_filter() recognizes quoted conditional value.
"""
filter = "gene.Notes = 'helix-turn-helix DNA binding domain protein'"
parsed_filter = parsing.parse_filter(filter)
self.assertEqual(parsed_filter[3],
"helix-turn-helix DNA binding domain protein")
def test_parse_filter_2(self):
filter = "phage.PhageID = Trixie"
parsed_filter = parsing.parse_filter(filter)
self.assertTrue(len(parsed_filter) == 4)
self.assertEqual(parsed_filter[0], "phage")
self.assertEqual(parsed_filter[1], "PhageID")
self.assertEqual(parsed_filter[2], "=")
self.assertEqual(parsed_filter[3], "Trixie")
def test_parse_filter_12(self):
"""Verify parse_filter() IN clauses handle apostrophes
"""
filter = "gene.Notes IN ('5' nucleotidase', 'G-I-Y Y-I-G endonuclease')"
parsed_filter = parsing.parse_filter(filter)
self.assertTrue(len(parsed_filter[3]) == 2)
self.assertTrue("5' nucleotidase" in parsed_filter[3])
self.assertTrue("G-I-Y Y-I-G endonuclease" in parsed_filter[3])
def test_parse_filter_9(self):
"""Verify parse_filter() excludes quotations in quoted values.
"""
filter = "phage.PhageID IN ('D29', 'Trixie')"
parsed_filter = parsing.parse_filter(filter)
print(parsed_filter)
self.assertTrue(len(parsed_filter[3]) == 2)
self.assertTrue("D29" in parsed_filter[3])
self.assertTrue("Trixie" in parsed_filter[3])
def test_parse_filter_1(self):
"""Verify parse_filter() recognizes filter operands and operator.
"""
filter = "phage.PhageID=Trixie"
parsed_filter = parsing.parse_filter(filter)
self.assertTrue(len(parsed_filter) == 4)
self.assertEqual(parsed_filter[0], "phage")
self.assertEqual(parsed_filter[1], "PhageID")
self.assertEqual(parsed_filter[2], "=")
self.assertEqual(parsed_filter[3], "Trixie")
def test_parse_filter_2(self):
"""Verify parse_filter() recognizes acceptable internal whitespaces.
"""
filter = "phage.PhageID = Trixie"
parsed_filter = parsing.parse_filter(filter)
self.assertTrue(len(parsed_filter) == 4)
self.assertEqual(parsed_filter[0], "phage")
self.assertEqual(parsed_filter[1], "PhageID")
self.assertEqual(parsed_filter[2], "=")
self.assertEqual(parsed_filter[3], "Trixie")
def add(self, filter):
where_clause = q.build_where_clause(self.graph, filter)
parsed_filter = parsing.parse_filter(filter)
filter_left = parsed_filter[0] + "." + parsed_filter[1]\
+ parsed_filter[2]
if filter_left not in self._filters.keys():
self._filters.update({filter_left: [where_clause]})
else:
self._filters[filter_left].append(where_clause)
self._updated = False
def test_parse_filter_7(self):
"""Verify parse_filter() recognizes IN value operations.
"""
filter = "phage.PhageID IN (Trixie, D29, Myrna)"
parsed_filter = parsing.parse_filter(filter)
self.assertTrue(isinstance(parsed_filter[3], list))
self.assertTrue(isinstance(parsed_filter[3][0], str))
self.assertTrue(len(parsed_filter[3]) == 3)
self.assertTrue("Trixie" in parsed_filter[3])
self.assertTrue("D29" in parsed_filter[3])
self.assertTrue("Myrna" in parsed_filter[3])
def remove(self, filter):
parsed_filter = parsing.parse_filter(filter)
filter_left = parsed_filter[0] + "." + parsed_filter[1]\
+ parsed_filter[2]
if filter_left in self._filters.keys():
filters = self._filters[filter_left]
if len(filters) == 1:
self._filters.pop(filter_left)
else:
for clause in filters:
if clause.right.value == parsed_filter[3]:
filters.remove(clause)
self._updated = False
def test_parse_filter_13(self):
"""Verify IN clauses is robust in handling edge-cases.
"""
pass
filter = ("gene.Notes NOT IN ("
"'Cro (control of repressor's operator)', "
"'terminase, small subunit', "
"'G-I-Y Y-I-G endonuclease', "
"'5' nucleotidase', "
"'DnaE-like DNA polymerase III (alpha)')")
parsed_filter = parsing.parse_filter(filter)
self.assertTrue(len(parsed_filter[3]) == 5)
self.assertTrue("Cro (control of repressor's operator)" \
in parsed_filter[3])
self.assertTrue("terminase, small subunit" in parsed_filter[3])
self.assertTrue("G-I-Y Y-I-G endonuclease" in parsed_filter[3])
self.assertTrue("5' nucleotidase" in parsed_filter[3])
self.assertTrue("DnaE-like DNA polymerase III (alpha)" \
in parsed_filter[3])
def test_parse_filter3(self):
filter = "phage.PhageID Trixie = "
with self.assertRaises(ValueError):
parsed_filter = parsing.parse_filter(filter)
