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]])