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 _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 _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 _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 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 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 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) == {}
