def test_first_column_1(self):
"""Verify function structure of first_column().
"""
querying.first_column(self.mock_engine, self.mock_executable)
self.mock_engine.execute.assert_called()
self.mock_proxy.fetchall.assert_called()
def test_first_column_3(self, subqueries_mock):
"""Verify that first_column() calls first_column_value_subqueries().
"""
querying.first_column(self.mock_engine,
self.mock_executable,
in_column=self.mock_in_column,
values=self.values,
limit=8001)
subqueries_mock.assert_called_with(self.mock_engine,
self.mock_executable,
self.mock_in_column,
self.values,
limit=8001)
def get_distinct_phams_from_organism(alchemist, organism_id):
gene_obj = alchemist.metadata.tables["gene"]
phageid_obj = gene_obj.c.PhageID
phamid_obj = gene_obj.c.PhamID
phams_query = select([phamid_obj
]).where(phageid_obj == organism_id).distinct()
phams = querying.first_column(alchemist.engine, phams_query)
return phams
def get_genes_from_pham(alchemist, pham):
gene_obj = alchemist.metadata.tables["gene"]
geneid_obj = gene_obj.c.GeneID
phamid_obj = gene_obj.c.PhamID
genes_query = select([geneid_obj]).where(phamid_obj == pham).distinct()
genes = querying.first_column(alchemist.engine, genes_query)
return genes
def test_first_column_1(self):
"""Verify first_column() returns expected data type.
"""
where_clause = querying.build_where_clause(self.graph,
"phage.Cluster=A")
phageid = querying.get_column(self.metadata, "phage.PhageID")
select = querying.build_select(self.graph, phageid, where=where_clause)
results = querying.first_column(self.engine, select)
self.assertTrue(isinstance(results, list))
self.assertTrue(isinstance(results[0], str))
def build_values(self,
where=None,
column=None,
raw_bytes=False,
limit=8000):
"""Queries for values from stored WHERE clauses and Filter key.
:param where: MySQL WHERE clause_related SQLAlchemy object(s).
:type where: BinaryExpression
:type where: list
:param order_by: MySQL ORDER BY clause-related SQLAlchemy object(s).
:type order_by: Column
:type order_by: list
:param column: SQLAlchemy Column object or object name.
:type column: Column
:type column: str
:param limit: SQLAlchemy IN clause query length limiter.
:type limit: int
:returns: Distinct values fetched from given and innate constraints.
:rtype: list
"""
self.check()
if column is None:
column_obj = self._key
else:
column_obj = self.get_column(column)
if not where is None:
if isinstance(where, list) or isinstance(where, BooleanClauseList):
base_clauses = where
else:
base_clauses = [where]
else:
base_clauses = []
query = q.build_distinct(self.graph,
column_obj,
where=base_clauses,
add_in=self._key)
values = q.first_column(self.engine,
query,
in_column=self._key,
values=self._values,
limit=limit)
if not raw_bytes:
if column_obj.type.python_type is bytes:
values = parsing.convert_to_decoded(values)
return values
def test_first_column_2(self):
"""Verify first_column() retrieves expected data.
"""
where_clause = querying.build_where_clause(self.graph,
"phage.Cluster=A")
phageid = querying.get_column(self.metadata, "phage.PhageID")
select = querying.build_select(self.graph, phageid, where=where_clause)
results = querying.first_column(self.engine, select)
self.assertTrue("Trixie" in results)
self.assertTrue("D29" in results)
self.assertFalse("Myrna" in results)
def get_distinct_phams_from_genes(alchemist, geneids):
gene_obj = alchemist.metadata.tables["gene"]
geneid_obj = gene_obj.c.GeneID
phamid_obj = gene_obj.c.PhamID
phams_query = select([phamid_obj]).distinct()
phams = querying.first_column(alchemist.engine,
phams_query,
in_column=geneid_obj,
values=geneids)
return phams
def get_distinct_annotations_from_genes(alchemist, geneids):
gene_obj = alchemist.metadata.tables["gene"]
geneid_obj = gene_obj.c.GeneID
notes_obj = gene_obj.c.Notes
notes_query = select([notes_obj]).distinct()
bytes_annotations = querying.first_column(alchemist.engine,
notes_query,
in_column=geneid_obj,
values=geneids)
annotations = basic.convert_to_decoded(bytes_annotations)
return annotations
def retrieve(self, raw_columns, raw_bytes=False, filter=False):
"""Queries for distinct data for each value in the Filter object.
:param columns: SQLAlchemy Column object(s)
:type columns: Column
:type columns: str
:type columns: list[Column]
:type columns: list[str]
:returns: Distinct values for each Filter value.
:rtype: dict{dict}
"""
self.check()
if not self._values:
return {}
columns = self.get_columns(raw_columns)
where_clauses = []
if filter:
where_clauses = self.build_where_clauses()
values = {}
for value in self._values:
compare_value = value
if self._key.type.python_type == bytes and value is not None:
compare_value = value.encode("utf-8")
value_clauses = where_clauses + [(self._key == compare_value)]
values.update({value: {}})
# For each column for each value, add the respective data to a dict
for i in range(len(columns)):
query = q.build_distinct(self._graph,
columns[i],
where=value_clauses)
value_data = q.first_column(self._engine, query)
if not raw_bytes:
if columns[i].type.python_type == bytes:
value_data = basic.convert_to_decoded(value_data)
values[value].update({columns[i].name: value_data})
return values
def sort(self, raw_columns):
"""Re-queries for the Filter's values, applying a ORDER BY clause.
:param raw_column: SQLAlchemy Column object(s) or object name(s).
:type raw_columns: Column
:type raw_columns: str
:type raw_columns: list[Column]
:type raw_columns: list[str]
"""
self.check()
columns = self.get_columns(raw_columns)
query = q.build_select(self._graph, self._key, order_by=columns)
values = q.first_column(self._engine,
query,
in_column=self._key,
values=self._values)
self._values = values
self._values_valid = True
def test_first_column_2(self):
"""Verify that first_column() retreives the first value from each row.
"""
results = querying.first_column(self.mock_engine, self.mock_executable)
self.assertEqual(results, [self.data_tuple[0]])