def find(self, query=None, fields=None, date=None, sort=None, descending=False, one=False, raw=False, limit=None, as_cursor=False, scalar=False, table=None, default_fields=True): table = self.get_table(table) limit = limit if limit and limit >= 1 else 0 fields = parse.parse_fields(fields) if default_fields: # force default_fields if we will return back Result (non-raw) fields = self._apply_default_fields(fields) query = self._parse_query(table, query=query, fields=fields, date=date, limit=limit, sort=sort, descending=descending) rows = self.session_auto.execute(query) if scalar: return rows.scalar() elif as_cursor: return rows elif one or limit == 1: row = dict(rows.first() or {}) # implies raw return row elif limit > 1: rows = rows.fetchmany(limit) else: rows = rows.fetchall() if raw: return [dict(r) for r in rows] else: if rows: return Result(rows, date, columns=rows[0].keys()) else: return Result(rows, date)
def _parse_query(self, table=None, query=None, fields=None, date=None, alias=None, distinct=None, limit=None, sort=None, descending=None): _table = self.get_table(table, except_=True) query = parse.parse(_table, query=query, date=date, fields=fields, distinct=distinct, alias=alias, limit=limit) if sort: order_by = parse.parse_fields(fields=sort)[0] if descending: query = query.order_by(desc(order_by)) else: query = query.order_by(order_by) return query
def _parse_fields(self, table=None, fields=None, reflect=False, **kwargs): table = self.get_table(table) fields = parse.parse_fields(fields) if fields in ([], {}): fields = [c.name for c in table.columns] if reflect: fields = [c for c in table.columns if c.name in fields] return fields
def _apply_default_fields(self, fields): fields = parse.parse_fields(fields) if not fields: # only add default fields if other fields # already set; if not fields are set, we # have '~' case and default fields are already # included return fields default_fields = self.config.get('default_fields') return fields + [f for f in default_fields if f not in fields]
def index(self, fields, name=None, table=None, **kwargs): ''' Build a new index on a cube. Examples: + index('field_name') :param fields: A single field or a list of (key, direction) pairs :param name: (optional) Custom name to use for this index :param collection: cube name :param owner: username of cube owner ''' table = self.get_table(table) name = self._index_default_name(fields, name) fields = parse.parse_fields(fields) fields = self.columns(table, fields, reflect=True) session = self.session_new() index = Index(name, *fields) logger.info('Writing new index %s: %s' % (name, fields)) result = index.create(self.engine) session.commit() return result
def test_parse_fields(): from metrique.parse import parse_fields OK_list = ['a', 'b', 'c'] OK_dct = {'a': 1, 'b': 1, 'c': 1} all_ = '~' fields_str = 'c , b , a ' fields_list = ['a ', 'c ', ' b'] fields_dct = {' a': 1, 'b ': 1, 'c ': 1} fields_dct_BAD = {' a': None, 'b ': 1, 'c ': 1} assert parse_fields(fields_list) == OK_list assert parse_fields(fields_str) == OK_list assert parse_fields(fields_str, as_dict=True) == OK_dct assert parse_fields(fields_dct, as_dict=True) == OK_dct try: # we expect values to be int! parse_fields(fields_dct_BAD, as_dict=True) except TypeError: pass else: assert False assert parse_fields(None) == [] assert parse_fields(False) == [] assert parse_fields(all_) == [] assert parse_fields(None, as_dict=True) == {} assert parse_fields(False, as_dict=True) == {} assert parse_fields(all_, as_dict=True) == {}