uw.sql package

Submodules

uw.sql.dbapi module

uw.sql.dbapi.fetch_none(cursor)

Fetch nothing from the cursor.

The result will be None. This is for running statements that do not produce a result. In future this may be modified to verify that no result is produced and complain if a result is produced.

uw.sql.dbapi.fetch_optional_value(cursor, *, required=False)

Fetch a single value result from the cursor.

The result must consist of at most one row containing exactly one field. If required is True, there must be exactly one row. If required is False, then None will be returned if there are no rows.

uw.sql.dbapi.fetch_required_value(cursor, *, required=True)

Fetch a single value result from the cursor.

The result must consist of at most one row containing exactly one field. If required is True, there must be exactly one row. If required is False, then None will be returned if there are no rows.

uw.sql.dbapi.fetch_values(cursor)

Fetch a multiple-value result from the cursor.

The result must consist of rows containing exactly one field.

uw.sql.dbapi.fetch_optional_tuple(cursor, *, required=False)

Fetch a single tuple result from the cursor.

The result must consist of at most one row. If required is True, there must be exactly one row. If required is False, then None will be returned if there are no rows. If there is a single row, the result will be a namedtuple instance.

uw.sql.dbapi.fetch_required_tuple(cursor, *, required=True)

Fetch a single tuple result from the cursor.

The result must consist of at most one row. If required is True, there must be exactly one row. If required is False, then None will be returned if there are no rows. If there is a single row, the result will be a namedtuple instance.

uw.sql.dbapi.fetch_tuples(cursor)

Fetch a multiple-tuple result from the cursor.

The result will be a list of namedtuple instances.

uw.sql.dbapi.execute_none(cursor, sql, **parameters)

uw.sql.dbapi.execute_optional_value(cursor, sql, **parameters)

uw.sql.dbapi.execute_required_value(cursor, sql, **parameters)

uw.sql.dbapi.execute_values(cursor, sql, **parameters)

uw.sql.dbapi.execute_optional_tuple(cursor, sql, **parameters)

uw.sql.dbapi.execute_required_tuple(cursor, sql, **parameters)

uw.sql.dbapi.execute_tuples(cursor, sql, **parameters)

uw.sql.dbapi.callproc_none(cursor, procname, *parameters)

uw.sql.dbapi.callproc_optional_value(cursor, procname, *parameters)

uw.sql.dbapi.callproc_required_value(cursor, procname, *parameters)

uw.sql.dbapi.callproc_values(cursor, procname, *parameters)

uw.sql.dbapi.callproc_optional_tuple(cursor, procname, *parameters)

uw.sql.dbapi.callproc_required_tuple(cursor, procname, *parameters)

uw.sql.dbapi.callproc_tuples(cursor, procname, *parameters)

uw.sql.dbapi.make_execute_none(sql)

uw.sql.dbapi.make_execute_optional_value(sql)

uw.sql.dbapi.make_execute_required_value(sql)

uw.sql.dbapi.make_execute_values(sql)

uw.sql.dbapi.make_execute_optional_tuple(sql)

uw.sql.dbapi.make_execute_required_tuple(sql)

uw.sql.dbapi.make_execute_tuples(sql)

uw.sql.dbapi.make_callproc_none(procname)

uw.sql.dbapi.make_callproc_optional_value(procname)

uw.sql.dbapi.make_callproc_required_value(procname)

uw.sql.dbapi.make_callproc_values(procname)

uw.sql.dbapi.make_callproc_optional_tuple(procname)

uw.sql.dbapi.make_callproc_required_tuple(procname)

uw.sql.dbapi.make_callproc_tuples(procname)

uw.sql.query module

Tools for generating SQL queries.

uw.sql.query.query_and(*items)

Join some supplied SQL predicates with AND.

Parameters

*items – Some SQL predicates; any None entries will be ignored.

Returns

The provided predicates, joined by AND; if there no non-None predicates, None.

uw.sql.query.query_or(*items)

Join some supplied SQL predicates with OR.

Parameters

*items – Some SQL predicates; any None entries will be ignored.

Returns

The provided predicates, joined by OR; if there no non-None predicates, None.

uw.sql.wrap module

class uw.sql.wrap.Connection(connection, pool)

Bases: object

close(ignore_duplicate_close=False)

property closed

cursor()

property pool

class uw.sql.wrap.ConnectionPool(open_connection, cursor_class)

Bases: object

connect()

Obtain an available connection from the pool.

Temporarily, just open a new connection every time.

property cursor_class

put(connection)

Release the connection back to the pool.

Temporarily, just forget about the connection (i.e., close it).

class uw.sql.wrap.Cursor(connection, cursor)

Bases: object

callproc_none(procname, *parameters)

callproc_optional_tuple(procname, *parameters)

callproc_optional_value(procname, *parameters)

callproc_required_tuple(procname, *parameters)

callproc_required_value(procname, *parameters)

callproc_tuples(procname, *parameters)

callproc_values(procname, *parameters)

property connection

execute_none(sql, **parameters)

execute_optional_tuple(sql, **parameters)

execute_optional_value(sql, **parameters)

execute_required_tuple(sql, **parameters)

execute_required_value(sql, **parameters)

execute_tuples(sql, **parameters)

execute_values(sql, **parameters)

fetch_none()

Fetch nothing from the cursor.

The result will be None. This is for running statements that do not produce a result. In future this may be modified to verify that no result is produced and complain if a result is produced.

fetch_optional_tuple = functools.partial(<function fetch_tuple>, required=False)

fetch_optional_value = functools.partial(<function fetch_value>, required=False)

fetch_required_tuple = functools.partial(<function fetch_tuple>, required=True)

fetch_required_value = functools.partial(<function fetch_value>, required=True)

fetch_tuples()

Fetch a multiple-tuple result from the cursor.

The result will be a list of namedtuple instances.

fetch_values()

Fetch a multiple-value result from the cursor.

The result must consist of rows containing exactly one field.

uw.sql.wrap.open_psycopg2_db_service_connection(service=None)

uw.sql.wrap.open_psycopg2_db_service_cursor(service=None, cursor_class=<class 'uw.sql.wrap.Cursor'>)

Open a connection and obtain a cursor on it.

This is intended for programs which just need a single cursor, such as command-line utilities or otherwise short-lived processes.

Module contents