def _compile(
self, query: ClauseElement
) -> typing.Tuple[str, dict, CompilationContext]:
compiled = query.compile(dialect=self._dialect)
execution_context = self._dialect.execution_ctx_cls()
execution_context.dialect = self._dialect
if not isinstance(query, DDLElement):
args = compiled.construct_params()
for key, val in args.items():
if key in compiled._bind_processors:
args[key] = compiled._bind_processors[key](val)
execution_context.result_column_struct = (
compiled._result_columns,
compiled._ordered_columns,
compiled._textual_ordered_columns,
)
else:
args = {}
query_message = compiled.string.replace(" \n", " ").replace("\n", " ")
logger.debug("Query: %s Args: %s", query_message, repr(args), extra=LOG_EXTRA)
return compiled.string, args, CompilationContext(execution_context)
def _compile(self, query: ClauseElement) -> typing.Tuple[str, list, tuple]:
compiled = query.compile(dialect=self._dialect)
if not isinstance(query, DDLElement):
compiled_params = sorted(compiled.params.items())
mapping = {
key: "$" + str(i)
for i, (key, _) in enumerate(compiled_params, start=1)
}
compiled_query = compiled.string % mapping
processors = compiled._bind_processors
args = [
processors[key](val) if key in processors else val
for key, val in compiled_params
]
result_map = compiled._result_columns
else:
compiled_query = compiled.string
args = []
result_map = None
query_message = compiled_query.replace(" \n", " ").replace("\n", " ")
logger.debug("Query: %s Args: %s",
query_message,
repr(tuple(args)),
extra=LOG_EXTRA)
return compiled_query, args, result_map
def _compile(
self, query: ClauseElement
) -> typing.Tuple[str, list, CompilationContext]:
compiled = query.compile(dialect=self._dialect)
args = []
for key, raw_val in compiled.construct_params().items():
if key in compiled._bind_processors:
val = compiled._bind_processors[key](raw_val)
else:
val = raw_val
args.append(val)
execution_context = self._dialect.execution_ctx_cls()
execution_context.dialect = self._dialect
execution_context.result_column_struct = (
compiled._result_columns,
compiled._ordered_columns,
compiled._textual_ordered_columns,
)
query_message = compiled.string.replace(" \n", " ").replace("\n", " ")
logger.debug("Query: %s Args: %s",
query_message,
repr(tuple(args)),
extra=LOG_EXTRA)
return compiled.string, args, CompilationContext(execution_context)
async def execute(self, query: ClauseElement, values: dict = None) -> None:
assert self._connection is not None, "Connection is not acquired"
if values is not None:
query = query.values(values)
query, args, context = self._compile(query)
cursor = await self._connection.execute(query, args)
await cursor.close()
def _compile(self, query: ClauseElement) -> typing.Tuple[str, list, tuple]:
compiled = query.compile(dialect=self.dialect)
args = compiled.construct_params()
logger.debug(compiled.string, args)
for key, val in args.items():
if key in compiled._bind_processors:
args[key] = compiled._bind_processors[key](val)
return compiled.string, args, compiled._result_columns
async def execute(self,
query: ClauseElement,
values: dict = None) -> typing.Any:
assert self._connection is not None, "Connection is not acquired"
if values is not None:
query = query.values(values)
query, args, result_columns = self._compile(query)
return await self._connection.fetchval(query, *args)
async def execute_many(self, query: ClauseElement, values: list) -> None:
assert self._connection is not None, "Connection is not acquired"
# asyncpg uses prepared statements under the hood, so we just
# loop through multiple executes here, which should all end up
# using the same prepared statement.
for item in values:
single_query = query.values(item)
single_query, args, result_columns = self._compile(single_query)
await self._connection.execute(single_query, *args)
async def execute_many(self, query: ClauseElement, values: list) -> None:
assert self._connection is not None, "Connection is not acquired"
cursor = await self._connection.cursor()
try:
for item in values:
single_query = query.values(item)
single_query, args, context = self._compile(single_query)
await cursor.execute(single_query, args)
finally:
await cursor.close()
async def execute(self, query: ClauseElement, values: dict = None) -> None:
assert self._connection is not None, "Connection is not acquired"
if values is not None:
query = query.values(values)
query, args, result_columns = self._compile(query)
cursor = await self._connection.cursor()
try:
await cursor.execute(query, args)
finally:
await cursor.close()
async def execute(self, query: ClauseElement, values: dict = None) -> None:
if values is not None:
query = query.values(values)
query, args, result_columns = self._compile(query)
conn = await self.acquire_connection()
try:
await conn.execute(query, *args)
finally:
await self.release_connection()
class AlterTableVisitor(SchemaVisitor):
"""Common operations for ``ALTER TABLE`` statements."""
if SQLA_06:
# engine.Compiler looks for .statement
# when it spawns off a new compiler
statement = ClauseElement()
def append(self, s):
"""Append content to the SchemaIterator's query buffer."""
self.buffer.write(s)
def execute(self):
"""Execute the contents of the SchemaIterator's buffer."""
try:
return self.connection.execute(self.buffer.getvalue())
finally:
self.buffer.truncate(0)
def __init__(self, dialect, connection, **kw):
self.connection = connection
self.buffer = StringIO.StringIO()
self.preparer = dialect.identifier_preparer
self.dialect = dialect
def traverse_single(self, elem):
ret = super(AlterTableVisitor, self).traverse_single(elem)
if ret:
# adapt to 0.6 which uses a string-returning
# object
self.append(" %s" % ret)
def _to_table(self, param):
"""Returns the table object for the given param object."""
if isinstance(param, (sa.Column, sa.Index, sa.schema.Constraint)):
ret = param.table
else:
ret = param
return ret
def start_alter_table(self, param):
"""Returns the start of an ``ALTER TABLE`` SQL-Statement.
Use the param object to determine the table name and use it
for building the SQL statement.
:param param: object to determine the table from
:type param: :class:`sqlalchemy.Column`, :class:`sqlalchemy.Index`,
:class:`sqlalchemy.schema.Constraint`, :class:`sqlalchemy.Table`,
or string (table name)
"""
table = self._to_table(param)
self.append('\nALTER TABLE %s ' % self.preparer.format_table(table))
return table
async def executemany(self, query: ClauseElement, values: list) -> None:
conn = await self.acquire_connection()
cursor = await conn.cursor()
try:
for item in values:
single_query = query.values(item)
single_query, args, result_columns = self._compile(single_query)
await cursor.execute(single_query, args)
finally:
await cursor.close()
await self.release_connection()
async def executemany(self, query: ClauseElement, values: list) -> None:
conn = await self.acquire_connection()
try:
# asyncpg uses prepared statements under the hood, so we just
# loop through multiple executes here, which should all end up
# using the same prepared statement.
for item in values:
single_query = query.values(item)
single_query, args = self._compile(single_query)
await conn.execute(single_query, *args)
finally:
await self.release_connection()
async def execute(self,
query: ClauseElement,
values: dict = None) -> typing.Any:
assert self._connection is not None, "Connection is not acquired"
if values is not None:
query = query.values(values)
query, args, context = self._compile(query)
cursor = await self._connection.cursor()
try:
await cursor.execute(query, args)
return cursor.lastrowid
finally:
await cursor.close()
def compile_query(
clause: ClauseElement,
dialect: default.DefaultDialect = RUNTIME_DIALECTS[HuskyQueryRuntime.snowflake],
literal_binds: bool = True,
) -> str:
"""
Compile the query and bind all parameters to it.
!!! WARNING !!!
Do not execute the returned query
"""
if clause is not None and isinstance(clause, ClauseElement):
return str(clause.compile(compile_kwargs={"literal_binds": literal_binds}, dialect=dialect))
else:
return clause
def compile(query: ClauseElement, dialect: Dialect) -> typing.Tuple[str, list]:
# query = execute_defaults(query) # default values for Insert/Update
compiled = query.compile(dialect=dialect)
compiled_params = sorted(compiled.params.items())
mapping = {key: "$" + str(i) for i, (key, _) in enumerate(compiled_params, start=1)}
compiled_query = compiled.string % mapping
processors = compiled._bind_processors
args = [
processors[key](val) if key in processors else val
for key, val in compiled_params
]
logger.debug(compiled_query)
return compiled_query, args
def _compile(self, query: ClauseElement) -> typing.Tuple[str, list, tuple]:
compiled = query.compile(dialect=self._dialect)
compiled_params = sorted(compiled.params.items())
mapping = {
key: "$" + str(i) for i, (key, _) in enumerate(compiled_params, start=1)
}
compiled_query = compiled.string % mapping
processors = compiled._bind_processors
args = [
processors[key](val) if key in processors else val
for key, val in compiled_params
]
logger.debug("Query: %s\nArgs: %s", compiled_query, args)
return compiled_query, args, compiled._result_columns
def _compile(
self, query: ClauseElement
) -> typing.Tuple[str, dict, CompilationContext]:
compiled = query.compile(dialect=self._dialect)
args = compiled.construct_params()
for key, val in args.items():
if key in compiled._bind_processors:
args[key] = compiled._bind_processors[key](val)
execution_context = self._dialect.execution_ctx_cls()
execution_context.dialect = self._dialect
execution_context.result_column_struct = (
compiled._result_columns,
compiled._ordered_columns,
compiled._textual_ordered_columns,
)
logger.debug("Query: %s\nArgs: %s", compiled.string, args)
return compiled.string, args, CompilationContext(execution_context)
def get_compiled_expression(statement: ClauseElement,
bind: Connectable) -> str:
"""Return the statement in a form where any placeholders have been filled in."""
return str(statement.compile(bind, compile_kwargs={"literal_binds": True}))
def _compile(self, query: ClauseElement) -> typing.Tuple[str, list, tuple]:
compiled = query.compile(dialect=self.dialect)
args = compiled.construct_params()
logger.debug(compiled.string, args)
return compiled.string, args, compiled._result_columns
