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