asyncqlio.orm.query

Classes for query objects.

Classes

BaseQuery(sess)	A base query object.
BulkDeleteQuery(sess)	Represents a bulk delete query.
BulkQuery(sess)	Represents a bulk query.
BulkUpdateQuery(sess)	Represents a bulk update query.
InsertQuery(sess)	Represents an INSERT query.
ResultGenerator(q)	A helper class that will generate new results from a query when iterated over.
RowDeleteQuery(sess)	Represents a row deletion query.
RowUpdateQuery(sess)	Represents a row update query.
SelectQuery(session)	Represents a SELECT query, which fetches data from the database.
UpsertQuery(sess, *columns, rows)	Represents an UPSERT query.

class asyncqlio.orm.query.BaseQuery(sess)

Bases: asyncqlio.meta.AsyncABC

A base query object.

Parameters:sess (Session) – The Session associated with this query.

generate_sql()

Generates the SQL for this query. :rtype: Tuple[str, Mapping[str, Any]] :return: A two item tuple, the SQL to use and a mapping of params to pass.

coroutine run()

Runs this query.

class asyncqlio.orm.query.ResultGenerator(q)

Bases: collections.abc.AsyncIterator

A helper class that will generate new results from a query when iterated over.

Parameters:q (SelectQuery) – The SelectQuery to use.

coroutine flatten(self)

Flattens this query into a single list.

Return type:List[Table]

class asyncqlio.orm.query.SelectQuery(session)

Bases: asyncqlio.orm.query.BaseQuery

Represents a SELECT query, which fetches data from the database.

This is not normally created by user code directly, but rather as a result of a Session.select() call.

sess = db.get_session()
async with sess:
    query = sess.select.from_(User)  # query is instance of SelectQuery
    # alternatively, but not recommended
    query = sess.select(User)

However, it is possible to create this class manually:

query = SelectQuery(db.get_session()
query.set_table(User)
query.add_condition(User.id == 2)
user = await query.first()

table = None

The table being queried.

conditions = None

A list of conditions to fulfil.

row_limit = None

The limit on the number of rows returned from this query.

row_offset = None

The offset to start fetching rows from.

orderer = None

The column to order by.

get_required_join_paths()

Gets the required join paths for this query.

generate_sql()

Generates the SQL for this query.

Return type:Tuple[str, dict]

map_columns(results)

Maps columns in a result row to a Table instance object.

Parameters:results (Mapping[str, Any]) – A single row of results from the query cursor. Return type:Table Returns:A new Table instance that represents the row returned.

map_many(*rows)

Maps many records to one row.

This will group the records by the primary key of the main query table, then add additional columns as appropriate.

from_(tbl)

Sets the table this query is selecting from.

Parameters:tbl – The Table object to select. Return type:SelectQuery Returns:This query.

where(*conditions)

Adds a WHERE clause to the query. This is a shortcut for SelectQuery.add_condition().

sess.select.from_(User).where(User.id == 1)

Parameters:conditions (BaseOperator) – The conditions to use for this WHERE clause. Return type:SelectQuery Returns:This query.

limit(row_limit)

Sets a limit of the number of rows that can be returned from this query.

Parameters:row_limit (int) – The maximum number of rows to return. Return type:SelectQuery Returns:This query.

offset(offset)

Sets the offset of rows to start returning results from/

Parameters:offset (int) – The row offset. Return type:SelectQuery Returns:This query.

order_by(*col, sort_order='asc')

Sets the order by clause for this query.

The argument provided can either be a Column, or a Sorter which is provided by Column.asc() / Column.desc(). By default, asc is used when passing a column.

set_table(tbl)

Sets the table to query on.

Parameters:tbl – The Table object to set. Return type:SelectQuery Returns:This query.

add_condition(condition)

Adds a condition to the query/

Parameters:condition (BaseOperator) – The BaseOperator to add. Return type:SelectQuery Returns:This query.

coroutine all(self)

Gets all results that match from this query.

Return type:ResultGenerator Returns:A ResultGenerator that can be iterated over.

coroutine first(self)

Gets the first result that matches from this query.

Return type:Table Returns:A Table instance representing the first item, or None if no item matched.

coroutine run()

Runs this query.

class asyncqlio.orm.query.InsertQuery(sess)

Bases: asyncqlio.orm.query.BaseQuery

Represents an INSERT query.

rows_to_insert = None

A list of rows to generate the insert statements for.

rows(*rows)

Adds a set of rows to the query.

Parameters:rows (Table) – The rows to insert. Return type:InsertQuery Returns:This query.

add_row(row)

Adds a row to this query, allowing it to be executed later.

Parameters:row (Table) – The Table instance to use for this query. Return type:InsertQuery Returns:This query.

on_conflict(*columns)

Get an UpsertQuery to react upon a conflict.

Parameters:columns (Column) – The Column objects upon which to check for a conflict. Return type:UpsertQuery

generate_sql()

Generates the SQL statements for this insert query.

Return type:List[Tuple[str, tuple]] Returns:A list of two-item tuples to execute: - The SQL query+params to emit to actually insert the row

coroutine run(self)

Runs this query.

Return type:List[Table] Returns:A list of inserted md_table.Table.

class asyncqlio.orm.query.UpsertQuery(sess, *columns, rows)

Bases: asyncqlio.orm.query.InsertQuery

Represents an UPSERT query.

New in version 0.2.0.

Parameters:

• sess (Session) – The Session this query is attached to.
• column – The Column objects on which the conflict might happen.
• rows (Table) – The Table objects that are to be added.

on_conflict(*columns)

Add more conflict columns to this query.

Parameters:column – The Column objects upon which to check for a conflict. Return type:UpsertQuery

update(*cols)

Used to specify which Column objects to update on a conflict.

Parameters:cols (Column) – The Column objects to update. Return type:UpsertQuery

nothing()

Specify that this query should do nothing if there’s a conflict.

This is the default behavior.

Return type:UpsertQuery

generate_sql()

Generates the SQL statements for this upsert query.

Return type:List[Tuple[str, tuple]] Returns:A list of two-item tuples: - The SQL query to use - The params to use with the query

add_row(row)

Adds a row to this query, allowing it to be executed later.

Parameters:row (Table) – The Table instance to use for this query. Return type:InsertQuery Returns:This query.

rows(*rows)

Adds a set of rows to the query.

Parameters:rows (Table) – The rows to insert. Return type:InsertQuery Returns:This query.

coroutine run(self)

Runs this query.

Return type:List[Table] Returns:A list of inserted md_table.Table.

class asyncqlio.orm.query.BulkQuery(sess)

Bases: asyncqlio.orm.query.BaseQuery

Represents a bulk query.

This allows adding conditionals to the query.

conditions = None

The list of conditions to query by.

table(table)

Sets the table for this query.

where(*conditions)

Sets the conditions for this query.

set_table(table)

Sets a table on this query.

add_condition(condition)

Adds a condition to this query.

generate_sql()

Generates the SQL for this query. :rtype: Tuple[str, Mapping[str, Any]] :return: A two item tuple, the SQL to use and a mapping of params to pass.

coroutine run()

Runs this query.

class asyncqlio.orm.query.BulkUpdateQuery(sess)

Bases: asyncqlio.orm.query.BulkQuery

Represents a bulk update query. This updates many rows based on certain criteria.

query = BulkUpdateQuery(session)

# style 1: manual
query.set_table(User)
query.add_condition(User.xp < 300)
# add on a value
query.set_update(User.xp + 100)
# or set a value
query.set_update(User.xp.set(300))
await query.run()

# style 2: builder
await query.table(User).where(User.xp < 300).set(User.xp + 100).run()
await query.table(User).where(User.xp < 300).set(User.xp, 300).run()

setting = None

The thing to set on the updated rows.

set(setter, value=None)

Sets a column in this query.

set_update(update)

Sets the update for this query.

generate_sql()

Generates the SQL for this query.

add_condition(condition)

Adds a condition to this query.

coroutine run()

Runs this query.

set_table(table)

Sets a table on this query.

table(table)

Sets the table for this query.

where(*conditions)

Sets the conditions for this query.

class asyncqlio.orm.query.BulkDeleteQuery(sess)

Bases: asyncqlio.orm.query.BulkQuery

Represents a bulk delete query. This deletes many rows based on criteria.

query = BulkDeleteQuery(session)

# style 1: manual
query.set_table(User)
query.add_condition(User.xp < 300)
await query.run()

# style 2: builder
await query.table(User).where(User.xp < 300).run()
await query.table(User).where(User.xp < 300).run()

generate_sql()

Generates the SQL for this query. :return: A two item tuple, the SQL to use and a mapping of params to pass.

add_condition(condition)

Adds a condition to this query.

coroutine run()

Runs this query.

set_table(table)

Sets a table on this query.

table(table)

Sets the table for this query.

where(*conditions)

Sets the conditions for this query.

class asyncqlio.orm.query.RowUpdateQuery(sess)

Bases: asyncqlio.orm.query.BaseQuery

Represents a row update query. This is NOT a bulk update query - it is used for updating specific rows.

rows_to_update = None

The list of rows to update.

rows(*rows)

Adds a set of rows to the query.

Parameters:rows (Table) – The rows to insert. Return type:RowUpdateQuery Returns:This query.

add_row(row)

Adds a row to this query, allowing it to be executed later.

Parameters:row (Table) – The Table instance to use for this query. Return type:RowUpdateQuery Returns:This query.

generate_sql()

Generates the SQL statements for this row update query.

This will return a list of two-item tuples to execute:

• The SQL query+params to emit to actually insert the row

Return type:List[Tuple[str, tuple]]

coroutine run()

Executes this query.

class asyncqlio.orm.query.RowDeleteQuery(sess)

Bases: asyncqlio.orm.query.BaseQuery

Represents a row deletion query. This is NOT a bulk delete query - it is used for deleting specific rows.

rows_to_delete = None

The list of rows to delete.

rows(*rows)

Adds a set of rows to the query.

Parameters:rows (Table) – The rows to insert. Return type:RowDeleteQuery Returns:This query.

coroutine run()

Runs this query.

add_row(row)

Adds a row to this query.

Parameters:row (Table) – The Table instance

generate_sql()

Generates the SQL statements for this row delete query.

This will return a list of two-item tuples to execute:

• The SQL query+params to emit to actually insert the row

Return type:List[Tuple[str, tuple]]