gino.dialects package

Submodules

gino.dialects.asyncpg module

class gino.dialects.asyncpg.AsyncEnum(*enums, **kw)

Bases: sqlalchemy.dialects.postgresql.base.ENUM

Construct an ENUM.

Arguments are the same as that of types.Enum, but also including the following parameters.

Parameters:create_type –

Defaults to True. Indicates that CREATE TYPE should be emitted, after optionally checking for the presence of the type, when the parent table is being created; and additionally that DROP TYPE is called when the table is dropped. When False, no check will be performed and no CREATE TYPE or DROP TYPE is emitted, unless create() or drop() are called directly. Setting to False is helpful when invoking a creation scheme to a SQL file without access to the actual database - the create() and drop() methods can be used to emit SQL to a target bind.

New in version 0.7.4.

coroutine create_async(bind=None, checkfirst=True)

coroutine drop_async(bind=None, checkfirst=True)

class gino.dialects.asyncpg.AsyncpgCompiler(dialect, statement, column_keys=None, inline=False, **kwargs)

Bases: sqlalchemy.dialects.postgresql.base.PGCompiler

Construct a new SQLCompiler object.

Parameters:

• dialect – Dialect to be used
• statement – ClauseElement to be compiled
• column_keys – a list of column names to be compiled into an INSERT or UPDATE statement.
• inline – whether to generate INSERT statements as “inline”, e.g. not formatted to return any generated defaults
• kwargs – additional keyword arguments to be consumed by the superclass.

bindtemplate

class gino.dialects.asyncpg.AsyncpgCursor(context, cursor)

Bases: gino.dialects.base.Cursor

coroutine forward(n, *, timeout=<object object>)

coroutine many(n, *, timeout=<object object>)

coroutine next(*, timeout=<object object>)

class gino.dialects.asyncpg.AsyncpgDBAPI

Bases: gino.dialects.base.BaseDBAPI

Error = (<class 'asyncpg.exceptions._base.PostgresError'>, <class 'asyncpg.exceptions._base.InterfaceError'>)

class gino.dialects.asyncpg.AsyncpgDialect(*args, **kwargs)

Bases: sqlalchemy.dialects.postgresql.base.PGDialect, gino.dialects.base.AsyncDialectMixin

colspecs = {<class 'sqlalchemy.sql.sqltypes.Interval'>: <class 'sqlalchemy.dialects.postgresql.base.INTERVAL'>, <class 'sqlalchemy.sql.sqltypes.Enum'>: <class 'gino.dialects.asyncpg.AsyncEnum'>, <class 'sqlalchemy.sql.sqltypes.ARRAY'>: <class 'sqlalchemy.dialects.postgresql.array.ARRAY'>, <class 'sqlalchemy.sql.sqltypes.JSON.JSONPathType'>: <class 'sqlalchemy.dialects.postgresql.json.JSONPathType'>, <class 'sqlalchemy.sql.sqltypes.JSON'>: <class 'sqlalchemy.dialects.postgresql.json.JSON'>, <class 'sqlalchemy.dialects.postgresql.base.ENUM'>: <class 'gino.dialects.asyncpg.AsyncEnum'>, <class 'sqlalchemy.sql.sqltypes.NullType'>: <class 'gino.dialects.asyncpg.GinoNullType'>}

cursor_cls

alias of DBAPICursor

dbapi_class

alias of AsyncpgDBAPI

driver = 'asyncpg'

execution_ctx_cls

alias of AsyncpgExecutionContext

coroutine get_isolation_level(connection)

Given an asyncpg connection, return its isolation level.

coroutine has_schema(connection, schema)

coroutine has_sequence(connection, sequence_name, schema=None)

Check the existence of a particular sequence in the database.

Given a Connection object and a string sequence_name, return True if the given sequence exists in the database, False otherwise.

coroutine has_table(connection, table_name, schema=None)

Check the existence of a particular table in the database.

Given a Connection object and a string table_name, return True if the given table (possibly within the specified schema) exists in the database, False otherwise.

coroutine has_type(connection, type_name, schema=None)

init_kwargs = {'command_timeout', 'connection_class', 'database', 'host', 'init', 'loop', 'max_cacheable_statement_size', 'max_cached_statement_lifetime', 'max_inactive_connection_lifetime', 'max_queries', 'max_size', 'min_size', 'passfile', 'password', 'port', 'server_settings', 'setup', 'ssl', 'statement_cache_size', 'timeout', 'user'}

coroutine init_pool(url, loop)

on_connect()

return a callable which sets up a newly created DBAPI connection.

This is used to set dialect-wide per-connection options such as isolation modes, unicode modes, etc.

If a callable is returned, it will be assembled into a pool listener that receives the direct DBAPI connection, with all wrappers removed.

If None is returned, no listener will be generated.

coroutine set_isolation_level(connection, level)

Given an asyncpg connection, set its isolation level.

statement_compiler

alias of AsyncpgCompiler

supports_native_decimal = True

transaction(raw_conn, args, kwargs)

class gino.dialects.asyncpg.AsyncpgExecutionContext

Bases: gino.dialects.base.ExecutionContextOverride, sqlalchemy.dialects.postgresql.base.PGExecutionContext

class gino.dialects.asyncpg.AsyncpgIterator(context, iterator)

Bases: object

class gino.dialects.asyncpg.DBAPICursor(dbapi_conn)

Bases: gino.dialects.base.DBAPICursor

coroutine async_execute(query, timeout, args, limit=0, many=False)

description

get_statusmsg()

coroutine prepare(context, clause=None)

class gino.dialects.asyncpg.GinoNullType

Bases: sqlalchemy.sql.sqltypes.NullType

result_processor(dialect, coltype)

Return a conversion function for processing result row values.

Returns a callable which will receive a result row column value as the sole positional argument and will return a value to return to the user.

If processing is not necessary, the method should return None.

Parameters:

• dialect – Dialect instance in use.
• coltype – DBAPI coltype argument received in cursor.description.

class gino.dialects.asyncpg.Pool(url, loop, **kwargs)

Bases: gino.dialects.base.Pool

coroutine acquire(*, timeout=None)

coroutine close()

raw_pool

coroutine release(conn)

class gino.dialects.asyncpg.PreparedStatement(prepared, clause=None)

Bases: gino.dialects.base.PreparedStatement

class gino.dialects.asyncpg.Transaction(tx)

Bases: gino.dialects.base.Transaction

coroutine begin()

coroutine commit()

raw_transaction

coroutine rollback()

gino.dialects.base module

class gino.dialects.base.AsyncDialectMixin

Bases: object

compile(elem, *multiparams, **params)

cursor_cls

alias of DBAPICursor

classmethod dbapi()

dbapi_class

alias of BaseDBAPI

coroutine init_pool(url, loop)

transaction(raw_conn, args, kwargs)

class gino.dialects.base.BaseDBAPI

Bases: object

static Binary(x)

Error

alias of builtins.Exception

paramstyle = 'numeric'

class gino.dialects.base.Cursor

Bases: object

coroutine forward(n, *, timeout=<object object>)

coroutine many(n, *, timeout=<object object>)

coroutine next(*, timeout=<object object>)

class gino.dialects.base.DBAPICursor

Bases: object

coroutine async_execute(query, timeout, args, limit=0, many=False)

description

execute(statement, parameters)

executemany(statement, parameters)

get_statusmsg()

coroutine prepare(context, clause=None)

class gino.dialects.base.ExecutionContextOverride

Bases: object

get_result_proxy()

loader

model

process_rows(rows, return_model=True)

return_model

timeout

class gino.dialects.base.Pool

Bases: object

coroutine acquire(*, timeout=None)

coroutine close()

raw_pool

coroutine release(conn)

class gino.dialects.base.PreparedStatement(clause=None)

Bases: object

coroutine all(*multiparams, **params)

coroutine first(*multiparams, **params)

iterate(*params, **kwargs)

coroutine scalar(*multiparams, **params)

coroutine status(*multiparams, **params)

class gino.dialects.base.Transaction

Bases: object

coroutine begin()

coroutine commit()

raw_transaction

coroutine rollback()

Module contents