%global _empty_manifest_terminate_build 0 Name: python-rqlalchemy Version: 0.4.5 Release: 1 Summary: "Resource Query Language for SQLAlchemy" License: MIT URL: https://github.com/pjwerneck/rqlalchemy Source0: https://mirrors.nju.edu.cn/pypi/web/packages/ee/1a/2ce61928d7af68c85a779272dc454284cee3ada7c95988d75f0d62b9ac04/rqlalchemy-0.4.5.tar.gz BuildArch: noarch Requires: python3-pyrql Requires: python3-sqlalchemy %description # RQLAlchemy [![Build Status](https://travis-ci.org/pjwerneck/rqlalchemy.svg?branch=develop)](https://travis-ci.org/pjwerneck/rqlalchemy) Resource Query Language extension for SQLAlchemy ## Overview Resource Query Language (RQL) is a query language designed for use in URIs, with object-style data structures. rqlalchemy is an RQL extension for SQLAlchemy. It easily allows exposing SQLAlchemy tables or models as an HTTP API endpoint and performing complex queries using only querystring parameters. ## Installing ``` pip install rqlalchemy ``` ## Usage RQL queries can be supported by an application using SQLAlchemy by adding the `rqlalchemy.RQLQueryMixIn` class as a mix-in class to your base `Query` class: ```python from sqlalchemy import sessionmaker from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm import Query as BaseQuery from rqlalchemy import RQLQueryMixIn # create the declarative base Base = declarative_base() # create the custom query class class RQLQuery(BaseQuery, RQLQueryMixIn): _rql_default_limit = 10 _rql_max_limit = 100 # pass the custom query class as a keyworkd argument to the sessionmaker session = sessionmaker(bind=engine, query_cls=RQLQuery) ``` If you're using Flask-SQLAlchemy, you can pass it as a session option: ``` from flask_sqlalchemy import SQLAlchemy db = SQLAlchemy(session_options={"query_cls": RQLQuery}) ``` With that in place, you can perform RQL queries by passing the querystring to the query `rql()` method. For example, if you have a Flask HTTP API with an users collection endpoint querying your `User` model: ```python from urllib.parse import unquote from flask import request @app.route('/users') def get_users_collection(): qs = unquote(request.query_string.decode(request.charset)) query = session.query(User).rql(qs) users = query.rql_all() return render_response(users) ``` ### Aggregates As with the base SQLAlchemy Query class, you can retrieve results with the `all()` method, or by iterating over the query, however, if you want to support RQL expressions with aggregate functions or querying functions that result in a subset of columns, you must retrieve the results with `rql_all()`. ### Pagination RQLAlchemy offers limit/offset pagination with the `rql_paginate()` method, which returns the requested page, the RQL expressions for previous and next pages if available, and the total number of items. ```python from urllib.parse import unquote from flask import request @app.route('/users') def get_users_collection(): qs = unquote(request.query_string.decode(request.charset)) query = session.query(User).rql(qs) page, previous_page, next_page, total = query.rql_paginate() response = {"data": page, "total": total, } if previous_page: response["previous"] = '/users?' + previous_page if next_page: response["next"] = '/users?' + next_page return render_response(response) ``` Keep in mind that pagination requires a limit, either a `_rql_default_limit` value, a querystring `limit(x)`, or the `limit` parameter to the `rql()` method. Calling `rql_paginate()` without a limit will raise `RQLQueryError`. ## Reference Table | RQL | SQLAlchemy | Obs. | |-------------------------|----------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------| | QUERYING | | | | select(a,b,c,...) | .query(Model.a, Model.b, Model.c,...) | | | values(a) | [o.a for o in query.from_self(a)] | | | limit(count,start?) | .limit(count).offset(start) | | | sort(attr1) | .order_by(attr) | | | sort(-attr1) | .order_by(attr.desc()) | | | distinct() | .distinct() | | | first() | .limit(1) | | | one() | [query.one()] | | | FILTERING | | | | eq(attr,value) | .filter(Model.attr == value) | | | ne(attr,value) | .filter(Model.attr != value) | | | lt(attr,value) | .filter(Model.attr < value) | | | le(attr,value) | .filter(Model.attr <= value) | | | gt(attr,value) | .filter(Model.attr > value) | | | ge(attr,value) | .filter(Model.attr >= value) | | | in(attr,value) | .filter(Model.attr.in_(value) | | | out(attr,value) | .filter(not_(Model.attr.in_(value))) | | | contains(attr,value) | .filter(Model.contains(value)) | Produces a LIKE expression when filtering against a string, or an IN expression when filtering against an iterable relationship | | excludes(attr,value) | .filter(not_(Model.contains(value))) | See above. | | and(expr1,expr2,...) | .filter(and_(expr1, expr2, ...)) | | | or(expr1,expr2,...) | .filter(or_(expr1, expr2, ...)) | | | AGGREGATING | | All aggregation functions return scalar results. | | aggregate(a,b\(c\),...) | .query(Model.a, func.b(Model.c)).group_by(Model.a) | | | sum(attr) | .query(func.sum(Model.attr)) | | | mean(attr) | .query(func.avg(Model.attr)) | | | max(attr) | .query(func.max(Model.attr)) | | | min(attr) | .query(func.min(Model.attr)) | | | count() | .query(func.count()) | | %package -n python3-rqlalchemy Summary: "Resource Query Language for SQLAlchemy" Provides: python-rqlalchemy BuildRequires: python3-devel BuildRequires: python3-setuptools BuildRequires: python3-pip %description -n python3-rqlalchemy # RQLAlchemy [![Build Status](https://travis-ci.org/pjwerneck/rqlalchemy.svg?branch=develop)](https://travis-ci.org/pjwerneck/rqlalchemy) Resource Query Language extension for SQLAlchemy ## Overview Resource Query Language (RQL) is a query language designed for use in URIs, with object-style data structures. rqlalchemy is an RQL extension for SQLAlchemy. It easily allows exposing SQLAlchemy tables or models as an HTTP API endpoint and performing complex queries using only querystring parameters. ## Installing ``` pip install rqlalchemy ``` ## Usage RQL queries can be supported by an application using SQLAlchemy by adding the `rqlalchemy.RQLQueryMixIn` class as a mix-in class to your base `Query` class: ```python from sqlalchemy import sessionmaker from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm import Query as BaseQuery from rqlalchemy import RQLQueryMixIn # create the declarative base Base = declarative_base() # create the custom query class class RQLQuery(BaseQuery, RQLQueryMixIn): _rql_default_limit = 10 _rql_max_limit = 100 # pass the custom query class as a keyworkd argument to the sessionmaker session = sessionmaker(bind=engine, query_cls=RQLQuery) ``` If you're using Flask-SQLAlchemy, you can pass it as a session option: ``` from flask_sqlalchemy import SQLAlchemy db = SQLAlchemy(session_options={"query_cls": RQLQuery}) ``` With that in place, you can perform RQL queries by passing the querystring to the query `rql()` method. For example, if you have a Flask HTTP API with an users collection endpoint querying your `User` model: ```python from urllib.parse import unquote from flask import request @app.route('/users') def get_users_collection(): qs = unquote(request.query_string.decode(request.charset)) query = session.query(User).rql(qs) users = query.rql_all() return render_response(users) ``` ### Aggregates As with the base SQLAlchemy Query class, you can retrieve results with the `all()` method, or by iterating over the query, however, if you want to support RQL expressions with aggregate functions or querying functions that result in a subset of columns, you must retrieve the results with `rql_all()`. ### Pagination RQLAlchemy offers limit/offset pagination with the `rql_paginate()` method, which returns the requested page, the RQL expressions for previous and next pages if available, and the total number of items. ```python from urllib.parse import unquote from flask import request @app.route('/users') def get_users_collection(): qs = unquote(request.query_string.decode(request.charset)) query = session.query(User).rql(qs) page, previous_page, next_page, total = query.rql_paginate() response = {"data": page, "total": total, } if previous_page: response["previous"] = '/users?' + previous_page if next_page: response["next"] = '/users?' + next_page return render_response(response) ``` Keep in mind that pagination requires a limit, either a `_rql_default_limit` value, a querystring `limit(x)`, or the `limit` parameter to the `rql()` method. Calling `rql_paginate()` without a limit will raise `RQLQueryError`. ## Reference Table | RQL | SQLAlchemy | Obs. | |-------------------------|----------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------| | QUERYING | | | | select(a,b,c,...) | .query(Model.a, Model.b, Model.c,...) | | | values(a) | [o.a for o in query.from_self(a)] | | | limit(count,start?) | .limit(count).offset(start) | | | sort(attr1) | .order_by(attr) | | | sort(-attr1) | .order_by(attr.desc()) | | | distinct() | .distinct() | | | first() | .limit(1) | | | one() | [query.one()] | | | FILTERING | | | | eq(attr,value) | .filter(Model.attr == value) | | | ne(attr,value) | .filter(Model.attr != value) | | | lt(attr,value) | .filter(Model.attr < value) | | | le(attr,value) | .filter(Model.attr <= value) | | | gt(attr,value) | .filter(Model.attr > value) | | | ge(attr,value) | .filter(Model.attr >= value) | | | in(attr,value) | .filter(Model.attr.in_(value) | | | out(attr,value) | .filter(not_(Model.attr.in_(value))) | | | contains(attr,value) | .filter(Model.contains(value)) | Produces a LIKE expression when filtering against a string, or an IN expression when filtering against an iterable relationship | | excludes(attr,value) | .filter(not_(Model.contains(value))) | See above. | | and(expr1,expr2,...) | .filter(and_(expr1, expr2, ...)) | | | or(expr1,expr2,...) | .filter(or_(expr1, expr2, ...)) | | | AGGREGATING | | All aggregation functions return scalar results. | | aggregate(a,b\(c\),...) | .query(Model.a, func.b(Model.c)).group_by(Model.a) | | | sum(attr) | .query(func.sum(Model.attr)) | | | mean(attr) | .query(func.avg(Model.attr)) | | | max(attr) | .query(func.max(Model.attr)) | | | min(attr) | .query(func.min(Model.attr)) | | | count() | .query(func.count()) | | %package help Summary: Development documents and examples for rqlalchemy Provides: python3-rqlalchemy-doc %description help # RQLAlchemy [![Build Status](https://travis-ci.org/pjwerneck/rqlalchemy.svg?branch=develop)](https://travis-ci.org/pjwerneck/rqlalchemy) Resource Query Language extension for SQLAlchemy ## Overview Resource Query Language (RQL) is a query language designed for use in URIs, with object-style data structures. rqlalchemy is an RQL extension for SQLAlchemy. It easily allows exposing SQLAlchemy tables or models as an HTTP API endpoint and performing complex queries using only querystring parameters. ## Installing ``` pip install rqlalchemy ``` ## Usage RQL queries can be supported by an application using SQLAlchemy by adding the `rqlalchemy.RQLQueryMixIn` class as a mix-in class to your base `Query` class: ```python from sqlalchemy import sessionmaker from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm import Query as BaseQuery from rqlalchemy import RQLQueryMixIn # create the declarative base Base = declarative_base() # create the custom query class class RQLQuery(BaseQuery, RQLQueryMixIn): _rql_default_limit = 10 _rql_max_limit = 100 # pass the custom query class as a keyworkd argument to the sessionmaker session = sessionmaker(bind=engine, query_cls=RQLQuery) ``` If you're using Flask-SQLAlchemy, you can pass it as a session option: ``` from flask_sqlalchemy import SQLAlchemy db = SQLAlchemy(session_options={"query_cls": RQLQuery}) ``` With that in place, you can perform RQL queries by passing the querystring to the query `rql()` method. For example, if you have a Flask HTTP API with an users collection endpoint querying your `User` model: ```python from urllib.parse import unquote from flask import request @app.route('/users') def get_users_collection(): qs = unquote(request.query_string.decode(request.charset)) query = session.query(User).rql(qs) users = query.rql_all() return render_response(users) ``` ### Aggregates As with the base SQLAlchemy Query class, you can retrieve results with the `all()` method, or by iterating over the query, however, if you want to support RQL expressions with aggregate functions or querying functions that result in a subset of columns, you must retrieve the results with `rql_all()`. ### Pagination RQLAlchemy offers limit/offset pagination with the `rql_paginate()` method, which returns the requested page, the RQL expressions for previous and next pages if available, and the total number of items. ```python from urllib.parse import unquote from flask import request @app.route('/users') def get_users_collection(): qs = unquote(request.query_string.decode(request.charset)) query = session.query(User).rql(qs) page, previous_page, next_page, total = query.rql_paginate() response = {"data": page, "total": total, } if previous_page: response["previous"] = '/users?' + previous_page if next_page: response["next"] = '/users?' + next_page return render_response(response) ``` Keep in mind that pagination requires a limit, either a `_rql_default_limit` value, a querystring `limit(x)`, or the `limit` parameter to the `rql()` method. Calling `rql_paginate()` without a limit will raise `RQLQueryError`. ## Reference Table | RQL | SQLAlchemy | Obs. | |-------------------------|----------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------| | QUERYING | | | | select(a,b,c,...) | .query(Model.a, Model.b, Model.c,...) | | | values(a) | [o.a for o in query.from_self(a)] | | | limit(count,start?) | .limit(count).offset(start) | | | sort(attr1) | .order_by(attr) | | | sort(-attr1) | .order_by(attr.desc()) | | | distinct() | .distinct() | | | first() | .limit(1) | | | one() | [query.one()] | | | FILTERING | | | | eq(attr,value) | .filter(Model.attr == value) | | | ne(attr,value) | .filter(Model.attr != value) | | | lt(attr,value) | .filter(Model.attr < value) | | | le(attr,value) | .filter(Model.attr <= value) | | | gt(attr,value) | .filter(Model.attr > value) | | | ge(attr,value) | .filter(Model.attr >= value) | | | in(attr,value) | .filter(Model.attr.in_(value) | | | out(attr,value) | .filter(not_(Model.attr.in_(value))) | | | contains(attr,value) | .filter(Model.contains(value)) | Produces a LIKE expression when filtering against a string, or an IN expression when filtering against an iterable relationship | | excludes(attr,value) | .filter(not_(Model.contains(value))) | See above. | | and(expr1,expr2,...) | .filter(and_(expr1, expr2, ...)) | | | or(expr1,expr2,...) | .filter(or_(expr1, expr2, ...)) | | | AGGREGATING | | All aggregation functions return scalar results. | | aggregate(a,b\(c\),...) | .query(Model.a, func.b(Model.c)).group_by(Model.a) | | | sum(attr) | .query(func.sum(Model.attr)) | | | mean(attr) | .query(func.avg(Model.attr)) | | | max(attr) | .query(func.max(Model.attr)) | | | min(attr) | .query(func.min(Model.attr)) | | | count() | .query(func.count()) | | %prep %autosetup -n rqlalchemy-0.4.5 %build %py3_build %install %py3_install install -d -m755 %{buildroot}/%{_pkgdocdir} if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi pushd %{buildroot} if [ -d usr/lib ]; then find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst fi if [ -d usr/lib64 ]; then find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst fi if [ -d usr/bin ]; then find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst fi if [ -d usr/sbin ]; then find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst fi touch doclist.lst if [ -d usr/share/man ]; then find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst fi popd mv %{buildroot}/filelist.lst . mv %{buildroot}/doclist.lst . %files -n python3-rqlalchemy -f filelist.lst %dir %{python3_sitelib}/* %files help -f doclist.lst %{_docdir}/* %changelog * Fri May 05 2023 Python_Bot - 0.4.5-1 - Package Spec generated