diff options
Diffstat (limited to 'python-buildpg.spec')
| -rw-r--r-- | python-buildpg.spec | 657 |
1 files changed, 657 insertions, 0 deletions
diff --git a/python-buildpg.spec b/python-buildpg.spec new file mode 100644 index 0000000..8cf924f --- /dev/null +++ b/python-buildpg.spec @@ -0,0 +1,657 @@ +%global _empty_manifest_terminate_build 0 +Name: python-buildpg +Version: 0.4 +Release: 1 +Summary: Query building for the postgresql prepared statements and asyncpg. +License: MIT +URL: https://github.com/samuelcolvin/buildpg +Source0: https://mirrors.nju.edu.cn/pypi/web/packages/48/f2/ff0e51a3c2390538da6eb4f85e30d87aafbcc6d057c6c9bb9fa222c8f2fc/buildpg-0.4.tar.gz +BuildArch: noarch + + +%description +# buildpg + +[](https://github.com/samuelcolvin/buildpg/actions?query=event%3Apush+branch%3Amaster+workflow%3Aci) +[](https://codecov.io/gh/samuelcolvin/buildpg) +[](https://pypi.python.org/pypi/buildpg) +[](https://github.com/samuelcolvin/buildpg) +[](https://github.com/samuelcolvin/buildpg/blob/master/LICENSE) + +Query building for the postgresql prepared statements and asyncpg. + +Lots of more powerful features, including full clause construction, multiple values, logic functions, +query pretty-printing and different variable substitution - below is just a very quick summary. +Please check the code and tests for examples. + +## Building Queries + +Simple variable substitution: + +```py +from buildpg import render + +render('select * from mytable where x=:foo and y=:bar', foo=123, bar='whatever') +>> 'select * from mytable where x=$1 and y=$2', [123, 'whatever'] +``` + + +Use of `V` to substitute constants: + +```py +from buildpg import V, render + +render('select * from mytable where :col=:foo', col=V('x'), foo=456) +>> 'select * from mytable where x=$1', [456] +``` + +Complex logic: + +```py +from buildpg import V, funcs, render + +where_logic = V('foo.bar') == 123 +if spam_value: + where_logic &= V('foo.spam') <= spam_value + +if exclude_cake: + where_logic &= funcs.not_(V('foo.cake').in_([1, 2, 3])) + +render('select * from foo :where', where=where_logic) +>> 'select * from foo foo.bar = $1 AND foo.spam <= $2 AND not(foo.cake in $3)', [123, 123, ['x', 'y']] +``` + +Values usage: + +```py +from buildpg import Values, render + +render('insert into the_table (:values__names) values :values', values=Values(a=123, b=456, c='hello')) +>> 'insert into the_table (a, b, c) values ($1, $2, $3)', [123, 456, 'hello'] +``` + +## With asyncpg + +As a wrapper around *asyncpg*: + +```py +import asyncio +from buildpg import asyncpg + +async def main(): + async with asyncpg.create_pool_b('postgres://postgres@localhost:5432/db') as pool: + await pool.fetchval_b('select spam from mytable where x=:foo and y=:bar', foo=123, bar='whatever') + >> 42 + +asyncio.run(main()) +``` + + +Both the pool and connections have `*_b` variants of all common query methods: + +- `execute_b` +- `executemany_b` +- `fetch_b` +- `fetchval_b` +- `fetchrow_b` +- `cursor_b` + + +## Operators + +| Python operator/function | SQL operator | +| ------------------------ | ------------ | +| `&` | `AND` | +| `|` | `OR` | +| `=` | `=` | +| `!=` | `!=` | +| `<` | `<` | +| `<=` | `<=` | +| `>` | `>` | +| `>=` | `>=` | +| `+` | `+` | +| `-` | `-` | +| `*` | `*` | +| `/` | `/` | +| `%` | `%` | +| `**` | `^` | +| `-` | `-` | +| `~` | `not(...)` | +| `sqrt` | `|/` | +| `abs` | `@` | +| `contains` | `@>` | +| `contained_by` | `<@` | +| `overlap` | `&&` | +| `like` | `LIKE` | +| `ilike` | `ILIKE` | +| `cat` | `||` | +| `in_` | `in` | +| `from_` | `from` | +| `at_time_zone` | `AT TIME ZONE` | +| `matches` | `@@` | +| `is_` | `is` | +| `is_not` | `is not` | +| `for_` | `for` | +| `factorial` | `!` | +| `cast` | `::` | +| `asc` | `ASC` | +| `desc` | `DESC` | +| `comma` | `,` | +| `on` | `ON` | +| `as_` | `AS` | +| `nulls_first` | `NULLS FIRST` | +| `nulls_last` | `NULLS LAST` | + +Usage: + +```py +from buildpg import V, S, render + +def show(component): + sql, params = render(':c', c=component) + print(f'sql="{sql}" params={params}') + +show(V('foobar').contains([1, 2, 3])) +#> sql="foobar @> $1" params=[[1, 2, 3]] +show(V('foobar') == 4) +#> sql="foobar = $1" params=[4] +show(~V('foobar')) +#> sql="not(foobar)" params=[] +show(S(625).sqrt()) +#> sql="|/ $1" params=[625] +show(V('foo').is_not('true')) +#> sql="foo is not true" params=[] +``` + +## Functions + +| Python function | SQL function | +| ------------------------------------------- | ------------- | +| `AND(*args)` | `<arg1> and <arg2> ...` | +| `OR(*args)` | `<arg1> or <arg2> ...` | +| `NOT(arg)` | `not(<arg>)` | +| `comma_sep(*args)` | `<arg1>, <arg2>, ...` | +| `count(expr)` | `count(expr)` | +| `any(arg)` | `any(<arg1>)` | +| `now()` | `now()` | +| `cast(v, cast_type)` | `<v>::<cast_type>` | +| `upper(string)` | `upper(<string>)` | +| `lower(string)` | `lower(<string>)` | +| `length(string)` | `length(<string>)` | +| `left(string, n)` | `left(<string>, <n>)` | +| `right(string, n)` | `right(<string>, <n>)` | +| `extract(expr)` | `extract(<expr>)` | +| `sqrt(n)` | `|/<n>` | +| `abs(n)` | `@<n>` | +| `factorial(n)` | `!<n>` | +| `position(substring, string)` | `position(<substring> in <st`... | +| `substring(string, pattern, escape-None)` | `substring(<string> from <pa`... | +| `to_tsvector(arg1, document-None)` | `to_tsvector(<arg1>)` | +| `to_tsquery(arg1, text-None)` | `to_tsquery(<arg1>)` | + +Usage: + +```py +from buildpg import V, render, funcs + +def show(component): + sql, params = render(':c', c=component) + print(f'sql="{sql}" params={params}') + +show(funcs.AND(V('x') == 4, V('y') > 6)) +#> sql="x = $1 AND y > $2" params=[4, 6] +show(funcs.position('foo', 'this has foo in it')) +#> sql="position($1 in $2)" params=['foo', 'this has foo in it'] +``` + + + + +%package -n python3-buildpg +Summary: Query building for the postgresql prepared statements and asyncpg. +Provides: python-buildpg +BuildRequires: python3-devel +BuildRequires: python3-setuptools +BuildRequires: python3-pip +%description -n python3-buildpg +# buildpg + +[](https://github.com/samuelcolvin/buildpg/actions?query=event%3Apush+branch%3Amaster+workflow%3Aci) +[](https://codecov.io/gh/samuelcolvin/buildpg) +[](https://pypi.python.org/pypi/buildpg) +[](https://github.com/samuelcolvin/buildpg) +[](https://github.com/samuelcolvin/buildpg/blob/master/LICENSE) + +Query building for the postgresql prepared statements and asyncpg. + +Lots of more powerful features, including full clause construction, multiple values, logic functions, +query pretty-printing and different variable substitution - below is just a very quick summary. +Please check the code and tests for examples. + +## Building Queries + +Simple variable substitution: + +```py +from buildpg import render + +render('select * from mytable where x=:foo and y=:bar', foo=123, bar='whatever') +>> 'select * from mytable where x=$1 and y=$2', [123, 'whatever'] +``` + + +Use of `V` to substitute constants: + +```py +from buildpg import V, render + +render('select * from mytable where :col=:foo', col=V('x'), foo=456) +>> 'select * from mytable where x=$1', [456] +``` + +Complex logic: + +```py +from buildpg import V, funcs, render + +where_logic = V('foo.bar') == 123 +if spam_value: + where_logic &= V('foo.spam') <= spam_value + +if exclude_cake: + where_logic &= funcs.not_(V('foo.cake').in_([1, 2, 3])) + +render('select * from foo :where', where=where_logic) +>> 'select * from foo foo.bar = $1 AND foo.spam <= $2 AND not(foo.cake in $3)', [123, 123, ['x', 'y']] +``` + +Values usage: + +```py +from buildpg import Values, render + +render('insert into the_table (:values__names) values :values', values=Values(a=123, b=456, c='hello')) +>> 'insert into the_table (a, b, c) values ($1, $2, $3)', [123, 456, 'hello'] +``` + +## With asyncpg + +As a wrapper around *asyncpg*: + +```py +import asyncio +from buildpg import asyncpg + +async def main(): + async with asyncpg.create_pool_b('postgres://postgres@localhost:5432/db') as pool: + await pool.fetchval_b('select spam from mytable where x=:foo and y=:bar', foo=123, bar='whatever') + >> 42 + +asyncio.run(main()) +``` + + +Both the pool and connections have `*_b` variants of all common query methods: + +- `execute_b` +- `executemany_b` +- `fetch_b` +- `fetchval_b` +- `fetchrow_b` +- `cursor_b` + + +## Operators + +| Python operator/function | SQL operator | +| ------------------------ | ------------ | +| `&` | `AND` | +| `|` | `OR` | +| `=` | `=` | +| `!=` | `!=` | +| `<` | `<` | +| `<=` | `<=` | +| `>` | `>` | +| `>=` | `>=` | +| `+` | `+` | +| `-` | `-` | +| `*` | `*` | +| `/` | `/` | +| `%` | `%` | +| `**` | `^` | +| `-` | `-` | +| `~` | `not(...)` | +| `sqrt` | `|/` | +| `abs` | `@` | +| `contains` | `@>` | +| `contained_by` | `<@` | +| `overlap` | `&&` | +| `like` | `LIKE` | +| `ilike` | `ILIKE` | +| `cat` | `||` | +| `in_` | `in` | +| `from_` | `from` | +| `at_time_zone` | `AT TIME ZONE` | +| `matches` | `@@` | +| `is_` | `is` | +| `is_not` | `is not` | +| `for_` | `for` | +| `factorial` | `!` | +| `cast` | `::` | +| `asc` | `ASC` | +| `desc` | `DESC` | +| `comma` | `,` | +| `on` | `ON` | +| `as_` | `AS` | +| `nulls_first` | `NULLS FIRST` | +| `nulls_last` | `NULLS LAST` | + +Usage: + +```py +from buildpg import V, S, render + +def show(component): + sql, params = render(':c', c=component) + print(f'sql="{sql}" params={params}') + +show(V('foobar').contains([1, 2, 3])) +#> sql="foobar @> $1" params=[[1, 2, 3]] +show(V('foobar') == 4) +#> sql="foobar = $1" params=[4] +show(~V('foobar')) +#> sql="not(foobar)" params=[] +show(S(625).sqrt()) +#> sql="|/ $1" params=[625] +show(V('foo').is_not('true')) +#> sql="foo is not true" params=[] +``` + +## Functions + +| Python function | SQL function | +| ------------------------------------------- | ------------- | +| `AND(*args)` | `<arg1> and <arg2> ...` | +| `OR(*args)` | `<arg1> or <arg2> ...` | +| `NOT(arg)` | `not(<arg>)` | +| `comma_sep(*args)` | `<arg1>, <arg2>, ...` | +| `count(expr)` | `count(expr)` | +| `any(arg)` | `any(<arg1>)` | +| `now()` | `now()` | +| `cast(v, cast_type)` | `<v>::<cast_type>` | +| `upper(string)` | `upper(<string>)` | +| `lower(string)` | `lower(<string>)` | +| `length(string)` | `length(<string>)` | +| `left(string, n)` | `left(<string>, <n>)` | +| `right(string, n)` | `right(<string>, <n>)` | +| `extract(expr)` | `extract(<expr>)` | +| `sqrt(n)` | `|/<n>` | +| `abs(n)` | `@<n>` | +| `factorial(n)` | `!<n>` | +| `position(substring, string)` | `position(<substring> in <st`... | +| `substring(string, pattern, escape-None)` | `substring(<string> from <pa`... | +| `to_tsvector(arg1, document-None)` | `to_tsvector(<arg1>)` | +| `to_tsquery(arg1, text-None)` | `to_tsquery(<arg1>)` | + +Usage: + +```py +from buildpg import V, render, funcs + +def show(component): + sql, params = render(':c', c=component) + print(f'sql="{sql}" params={params}') + +show(funcs.AND(V('x') == 4, V('y') > 6)) +#> sql="x = $1 AND y > $2" params=[4, 6] +show(funcs.position('foo', 'this has foo in it')) +#> sql="position($1 in $2)" params=['foo', 'this has foo in it'] +``` + + + + +%package help +Summary: Development documents and examples for buildpg +Provides: python3-buildpg-doc +%description help +# buildpg + +[](https://github.com/samuelcolvin/buildpg/actions?query=event%3Apush+branch%3Amaster+workflow%3Aci) +[](https://codecov.io/gh/samuelcolvin/buildpg) +[](https://pypi.python.org/pypi/buildpg) +[](https://github.com/samuelcolvin/buildpg) +[](https://github.com/samuelcolvin/buildpg/blob/master/LICENSE) + +Query building for the postgresql prepared statements and asyncpg. + +Lots of more powerful features, including full clause construction, multiple values, logic functions, +query pretty-printing and different variable substitution - below is just a very quick summary. +Please check the code and tests for examples. + +## Building Queries + +Simple variable substitution: + +```py +from buildpg import render + +render('select * from mytable where x=:foo and y=:bar', foo=123, bar='whatever') +>> 'select * from mytable where x=$1 and y=$2', [123, 'whatever'] +``` + + +Use of `V` to substitute constants: + +```py +from buildpg import V, render + +render('select * from mytable where :col=:foo', col=V('x'), foo=456) +>> 'select * from mytable where x=$1', [456] +``` + +Complex logic: + +```py +from buildpg import V, funcs, render + +where_logic = V('foo.bar') == 123 +if spam_value: + where_logic &= V('foo.spam') <= spam_value + +if exclude_cake: + where_logic &= funcs.not_(V('foo.cake').in_([1, 2, 3])) + +render('select * from foo :where', where=where_logic) +>> 'select * from foo foo.bar = $1 AND foo.spam <= $2 AND not(foo.cake in $3)', [123, 123, ['x', 'y']] +``` + +Values usage: + +```py +from buildpg import Values, render + +render('insert into the_table (:values__names) values :values', values=Values(a=123, b=456, c='hello')) +>> 'insert into the_table (a, b, c) values ($1, $2, $3)', [123, 456, 'hello'] +``` + +## With asyncpg + +As a wrapper around *asyncpg*: + +```py +import asyncio +from buildpg import asyncpg + +async def main(): + async with asyncpg.create_pool_b('postgres://postgres@localhost:5432/db') as pool: + await pool.fetchval_b('select spam from mytable where x=:foo and y=:bar', foo=123, bar='whatever') + >> 42 + +asyncio.run(main()) +``` + + +Both the pool and connections have `*_b` variants of all common query methods: + +- `execute_b` +- `executemany_b` +- `fetch_b` +- `fetchval_b` +- `fetchrow_b` +- `cursor_b` + + +## Operators + +| Python operator/function | SQL operator | +| ------------------------ | ------------ | +| `&` | `AND` | +| `|` | `OR` | +| `=` | `=` | +| `!=` | `!=` | +| `<` | `<` | +| `<=` | `<=` | +| `>` | `>` | +| `>=` | `>=` | +| `+` | `+` | +| `-` | `-` | +| `*` | `*` | +| `/` | `/` | +| `%` | `%` | +| `**` | `^` | +| `-` | `-` | +| `~` | `not(...)` | +| `sqrt` | `|/` | +| `abs` | `@` | +| `contains` | `@>` | +| `contained_by` | `<@` | +| `overlap` | `&&` | +| `like` | `LIKE` | +| `ilike` | `ILIKE` | +| `cat` | `||` | +| `in_` | `in` | +| `from_` | `from` | +| `at_time_zone` | `AT TIME ZONE` | +| `matches` | `@@` | +| `is_` | `is` | +| `is_not` | `is not` | +| `for_` | `for` | +| `factorial` | `!` | +| `cast` | `::` | +| `asc` | `ASC` | +| `desc` | `DESC` | +| `comma` | `,` | +| `on` | `ON` | +| `as_` | `AS` | +| `nulls_first` | `NULLS FIRST` | +| `nulls_last` | `NULLS LAST` | + +Usage: + +```py +from buildpg import V, S, render + +def show(component): + sql, params = render(':c', c=component) + print(f'sql="{sql}" params={params}') + +show(V('foobar').contains([1, 2, 3])) +#> sql="foobar @> $1" params=[[1, 2, 3]] +show(V('foobar') == 4) +#> sql="foobar = $1" params=[4] +show(~V('foobar')) +#> sql="not(foobar)" params=[] +show(S(625).sqrt()) +#> sql="|/ $1" params=[625] +show(V('foo').is_not('true')) +#> sql="foo is not true" params=[] +``` + +## Functions + +| Python function | SQL function | +| ------------------------------------------- | ------------- | +| `AND(*args)` | `<arg1> and <arg2> ...` | +| `OR(*args)` | `<arg1> or <arg2> ...` | +| `NOT(arg)` | `not(<arg>)` | +| `comma_sep(*args)` | `<arg1>, <arg2>, ...` | +| `count(expr)` | `count(expr)` | +| `any(arg)` | `any(<arg1>)` | +| `now()` | `now()` | +| `cast(v, cast_type)` | `<v>::<cast_type>` | +| `upper(string)` | `upper(<string>)` | +| `lower(string)` | `lower(<string>)` | +| `length(string)` | `length(<string>)` | +| `left(string, n)` | `left(<string>, <n>)` | +| `right(string, n)` | `right(<string>, <n>)` | +| `extract(expr)` | `extract(<expr>)` | +| `sqrt(n)` | `|/<n>` | +| `abs(n)` | `@<n>` | +| `factorial(n)` | `!<n>` | +| `position(substring, string)` | `position(<substring> in <st`... | +| `substring(string, pattern, escape-None)` | `substring(<string> from <pa`... | +| `to_tsvector(arg1, document-None)` | `to_tsvector(<arg1>)` | +| `to_tsquery(arg1, text-None)` | `to_tsquery(<arg1>)` | + +Usage: + +```py +from buildpg import V, render, funcs + +def show(component): + sql, params = render(':c', c=component) + print(f'sql="{sql}" params={params}') + +show(funcs.AND(V('x') == 4, V('y') > 6)) +#> sql="x = $1 AND y > $2" params=[4, 6] +show(funcs.position('foo', 'this has foo in it')) +#> sql="position($1 in $2)" params=['foo', 'this has foo in it'] +``` + + + + +%prep +%autosetup -n buildpg-0.4 + +%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-buildpg -f filelist.lst +%dir %{python3_sitelib}/* + +%files help -f doclist.lst +%{_docdir}/* + +%changelog +* Thu May 18 2023 Python_Bot <Python_Bot@openeuler.org> - 0.4-1 +- Package Spec generated |