def _paginated(self, query, page_num, results_per_page, model_dict_kargs=None,
relload=None):
"""Returns a paginated JSONified response from the specified list of
model instances.
`instances` is either a Python list of model instances or a
:class:`~sqlalchemy.orm.Query`.
The response data is JSON of the form:
.. sourcecode:: javascript
{
"page": 2,
"total_pages": 3,
"num_results": 8,
"objects": [{"id": 1, "name": "Jeffrey", "age": 24}, ...]
}
"""
num_results = query.count()
if results_per_page > 0:
# get the page number (first page is page 1)
start = (page_num - 1) * results_per_page
end = min(num_results, start + results_per_page)
total_pages = int(math.ceil(float(num_results) / results_per_page))
else:
page_num = 1
start = 0
end = num_results
total_pages = 1
objects = [to_dict(x, **(model_dict_kargs or {})) for x in query[start:end]]
return dict(page=page_num, objects=objects, total_pages=total_pages,
num_results=num_results)
def select(self, modelName, queryDict=None, page=1, maxPerPage=None):
"""
Issue a SELECT statement on the table corresponding to modelName.
Results are paginaged and the page to be returned or the maximum
number of results per table may be specified.
:param modelName str: the name of the model within the Manager
:param queryDict dict: if not specified, then the whole table
will be queried. It is a dictionary of the form::
{
"filters": [{"name": "age", "op": "lt", "val": 20}, ...],
"order_by": [{"field": "age", "direction": "desc"}, ...],
"limit": 10,
"offset": 3,
"disjunction": True,
"to_dict": {"deep":{"employees":[]}},
"joinedload" : ["employees"],
}
where:
* ``filters`` is the list of filter specifications,
* ``order_by`` is the list of order by specifications,
* ``limit`` is the maximum number of total matching entries to return,
* ``offset`` is the number of initial entries to skip in
the matching result set,
* ``disjunction`` is whether the filters should be joined as a disjunction (AND) or conjunction (OR),
defaults to True (AND)
* ``to_dict`` specifies the configuration for the SQLAlchemy objects serializer.
* ``joinedload`` specifies a list of relations to be loaded using the
SQLAlchemy joinedload strategy (by default lazy load is used which
is not very efficient when serializing relations)
:param page int: the page number to be returned
:param maxPerPage int: the maximum number of results per page, defaults
to the maxResultsPerPage attribute,
:return dict: a dictionary of the form::
{
"page": 2,
"total_pages": 3,
"num_results": 8,
"objects": [{"id": 1, "name": "Jeffrey", "age": 24}, ...]
}
This may depends on some queryDict parameters,
to decide for instance whether related models should be returned
as well. Here num_results is the total number of results matching the queryDict.
As said, however, only maxPerPage results will be returned by each select.
"""
if not queryDict: queryDict = {}
model = self.get_model(modelName)
modelDictKargs = deepcopy(self.modelDictKargs[modelName])
with closing(self.dbConnection.get_session()) as session:
sp = SearchParameters.from_dictionary(queryDict)
q = create_query(session, model, sp)
is_single = queryDict.get('single')
functions = queryDict.get('functions')
todict = queryDict.get('to_dict', {})
modelDictKargs.update(todict)
jload = queryDict.pop('joinedload', None)
if jload:
q = q.options(*(joinedload(x) for x in jload))
if is_single:
return to_dict(q.one(), **modelDictKargs)
elif functions:
return self._evaluate_functions(session, model, functions,
sp)
else:
if maxPerPage is None:
maxPerPage = self._maxResultsPerPage
return self._paginated(q, page_num=page,
results_per_page=maxPerPage,
model_dict_kargs=modelDictKargs)
def select_by_unique(self, modelName, value, fieldName="id"):
model = self.get_model(modelName)
with closing(self.dbConnection.get_session()) as session:
inst = session.query(model).filter(getattr(model, fieldName) == value).\
one()
return to_dict(inst, **self.modelDictKargs[modelName])
def paginated(query, page_num, results_per_page, model_dict_kargs=None,
relload=None, num_results=None):
start, end, page_num, total_pages, num_results = get_pagination(query, page_num, results_per_page, num_results)
objects = [to_dict(x, **(model_dict_kargs or {})) for x in query[start:end]]
return dict(page=page_num, objects=objects, total_pages=total_pages,
num_results=num_results)
