Python sqlalchemy.sql.ClauseElement() Examples

The following are 12 code examples of sqlalchemy.sql.ClauseElement(). You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may also want to check out all available functions/classes of the module sqlalchemy.sql , or try the search function .
Example #1
Source File: render.py    From jbox with MIT License 6 votes vote down vote up
def _render_potential_expr(value, autogen_context, wrap_in_text=True):
    if isinstance(value, sql.ClauseElement):
        if compat.sqla_08:
            compile_kw = dict(compile_kwargs={
                'literal_binds': True, "include_table": False})
        else:
            compile_kw = {}

        if wrap_in_text:
            template = "%(prefix)stext(%(sql)r)"
        else:
            template = "%(sql)r"

        return template % {
            "prefix": _sqlalchemy_autogenerate_prefix(autogen_context),
            "sql": compat.text_type(
                value.compile(dialect=autogen_context.dialect,
                              **compile_kw)
            )
        }

    else:
        return repr(value) 
Example #2
Source File: render.py    From alembic with MIT License 6 votes vote down vote up
def _render_potential_expr(
    value, autogen_context, wrap_in_text=True, is_server_default=False
):
    if isinstance(value, sql.ClauseElement):

        if wrap_in_text:
            template = "%(prefix)stext(%(sql)r)"
        else:
            template = "%(sql)r"

        return template % {
            "prefix": _sqlalchemy_autogenerate_prefix(autogen_context),
            "sql": autogen_context.migration_context.impl.render_ddl_sql_expr(
                value, is_server_default=is_server_default
            ),
        }

    else:
        return repr(value) 
Example #3
Source File: subscriber_subsetter.py    From FlowKit with Mozilla Public License 2.0 6 votes vote down vote up
def apply_subset_if_needed(self, sql, *, subscriber_identifier):
        """
        Return a modified version of the input SQL query which has the subset applied.

        Parameters
        ----------
        sql : sqlalchemy.sql.ClauseElement
            The SQL query to which the subset should be applied.

        subscriber_identifier : str
            The column in the parent table which contains the subscriber information.

        Returns
        ----------
        sqlalchemy.sql.ClauseElement
        """
        assert isinstance(sql, ClauseElement)
        assert len(sql.froms) == 1
        parent_table = sql.froms[0]
        return sql.where(parent_table.c[subscriber_identifier].in_(self.subscribers)) 
Example #4
Source File: render.py    From android_universal with MIT License 6 votes vote down vote up
def _render_potential_expr(value, autogen_context, wrap_in_text=True):
    if isinstance(value, sql.ClauseElement):
        compile_kw = dict(compile_kwargs={
            'literal_binds': True, "include_table": False})

        if wrap_in_text:
            template = "%(prefix)stext(%(sql)r)"
        else:
            template = "%(sql)r"

        return template % {
            "prefix": _sqlalchemy_autogenerate_prefix(autogen_context),
            "sql": compat.text_type(
                value.compile(dialect=autogen_context.dialect,
                              **compile_kw)
            )
        }

    else:
        return repr(value) 
Example #5
Source File: subscriber_subsetter.py    From FlowKit with Mozilla Public License 2.0 5 votes vote down vote up
def apply_subset_if_needed(self, sql, *, subscriber_identifier=None):
        """
        Return the input query unchanged, since no subsetting is applied.

        Parameters
        ----------
        sql : sqlalchemy.sql.ClauseElement
            The SQL query to which the subset should be applied.

        subscriber_identifier : str
            This argument is ignored for subsets of type 'AllSubscribers'.
        """
        return sql 
Example #6
Source File: db.py    From sitemap-generator with Apache License 2.0 5 votes vote down vote up
def get_or_create(session, model, defaults=None, **kwargs):
    instance = session.query(model).filter_by(**kwargs).first()
    if instance:
        return instance, False
    else:
        params = dict((k, v) for k, v in kwargs.items() if not isinstance(v, ClauseElement))
        params.update(defaults or {})
        instance = model(**params)
        session.add(instance)
        session.commit()
        return instance, True 
Example #7
Source File: test_inspect.py    From sqlalchemy with MIT License 5 votes vote down vote up
def test_no_clause_element_on_clauseelement(self):
        # re [ticket:3802], there are in the wild examples
        # of looping over __clause_element__, therefore the
        # absence of __clause_element__ as a test for "this is the clause
        # element" must be maintained

        class Foo(ClauseElement):
            pass

        assert not hasattr(Foo(), "__clause_element__") 
Example #8
Source File: connection.py    From asyncpgsa with Apache License 2.0 5 votes vote down vote up
def compile_query(query, dialect=_dialect, inline=False):
    if isinstance(query, str):
        query_logger.debug(query)
        return query, ()
    elif isinstance(query, DDLElement):
        compiled = query.compile(dialect=dialect)
        new_query = compiled.string
        query_logger.debug(new_query)
        return new_query, ()
    elif isinstance(query, ClauseElement):
        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)}
        new_query = compiled.string % mapping

        processors = compiled._bind_processors
        new_params = [processors[key](val) if key in processors else val
                      for key, val in compiled_params]

        query_logger.debug(new_query)

        if inline:
            return new_query
        return new_query, new_params 
Example #9
Source File: connection.py    From aiomysql with MIT License 5 votes vote down vote up
def _executemany(self, query, dps, cursor):
        """
        executemany
        """
        result_map = None
        if isinstance(query, str):
            await cursor.executemany(query, dps)
        elif isinstance(query, DDLElement):
            raise exc.ArgumentError(
                    "Don't mix sqlalchemy DDL clause "
                    "and execution with parameters"
                )
        elif isinstance(query, ClauseElement):
            compiled = query.compile(dialect=self._dialect)
            params = []
            is_update = isinstance(query, UpdateBase)
            for dp in dps:
                params.append(
                    self._base_params(
                        query,
                        dp,
                        compiled,
                        is_update,
                    )
                )
            await cursor.executemany(str(compiled), params)
            result_map = compiled._result_columns
        else:
            raise exc.ArgumentError(
                "sql statement should be str or "
                "SQLAlchemy data "
                "selection/modification clause"
            )
        ret = await create_result_proxy(
            self,
            cursor,
            self._dialect,
            result_map
        )
        self._weak_results.add(ret)
        return ret 
Example #10
Source File: subscriber_subsetter.py    From FlowKit with Mozilla Public License 2.0 4 votes vote down vote up
def apply_subset_if_needed(self, sql, *, subscriber_identifier=None):
        """
        Return a modified version of the input SQL query which has the subset applied.

        Parameters
        ----------
        sql : sqlalchemy.sql.ClauseElement
            The SQL query to which the subset should be applied.

        subscriber_identifier : str
            This argument is ignored for subsets of type 'SubscriberSubsetterForFlowmachineQuery'.

        Returns
        ----------
        sqlalchemy.sql.ClauseElement
        """
        assert isinstance(sql, ClauseElement)

        tbl = sql.alias("tbl")

        # Create a sqlalchemy "Textual SQL" object from the flowmachine SQL string
        textual_sql = text(self.flowmachine_query.get_query())

        # Create sqlalchemy column objects for each of the columns
        # in the output of the flowmachine query
        sqlalchemy_columns = [
            column(colname) for colname in self.flowmachine_query.column_names
        ]

        # Explicitly inform the textual query about the output columns we expect
        # and provide an alias. This allows the generated SQL string to be embedded
        # as a subquery in other queries.
        sqlalchemy_subset_query = textual_sql.columns(*sqlalchemy_columns).alias(
            "subset_query"
        )

        # Actually perform the subsetting (via a join with the subset query)
        res = select(tbl.columns).select_from(
            tbl.join(
                sqlalchemy_subset_query,
                tbl.c.subscriber == sqlalchemy_subset_query.c.subscriber,
            )
        )

        return res 
Example #11
Source File: connection.py    From aiopg with BSD 2-Clause "Simplified" License 4 votes vote down vote up
def _execute(self, query, *multiparams, **params):
        cursor = await self._get_cursor()
        dp = _distill_params(multiparams, params)
        if len(dp) > 1:
            raise exc.ArgumentError("aiopg doesn't support executemany")
        elif dp:
            dp = dp[0]

        result_map = None

        if isinstance(query, str):
            await cursor.execute(query, dp)
        elif isinstance(query, ClauseElement):
            compiled = query.compile(dialect=self._dialect)
            # parameters = compiled.params
            if not isinstance(query, DDLElement):
                if dp and isinstance(dp, (list, tuple)):
                    if isinstance(query, UpdateBase):
                        dp = {c.key: pval
                              for c, pval in zip(query.table.c, dp)}
                    else:
                        raise exc.ArgumentError("Don't mix sqlalchemy SELECT "
                                                "clause with positional "
                                                "parameters")

                compiled_parameters = [compiled.construct_params(dp)]
                processed_parameters = []
                processors = compiled._bind_processors
                for compiled_params in compiled_parameters:
                    params = {key: (processors[key](compiled_params[key])
                                    if key in processors
                                    else compiled_params[key])
                              for key in compiled_params}
                    processed_parameters.append(params)
                post_processed_params = self._dialect.execute_sequence_format(
                    processed_parameters)

                # _result_columns is a private API of Compiled,
                # but I couldn't find any public API exposing this data.
                result_map = compiled._result_columns

            else:
                if dp:
                    raise exc.ArgumentError("Don't mix sqlalchemy DDL clause "
                                            "and execution with parameters")
                post_processed_params = [compiled.construct_params()]
                result_map = None

            await cursor.execute(str(compiled), post_processed_params[0])
        else:
            raise exc.ArgumentError("sql statement should be str or "
                                    "SQLAlchemy data "
                                    "selection/modification clause")

        return ResultProxy(self, cursor, self._dialect, result_map) 
Example #12
Source File: connection.py    From aiomysql with MIT License 4 votes vote down vote up
def _execute(self, query, *multiparams, **params):
        cursor = await self._connection.cursor()
        dp = _distill_params(multiparams, params)
        if len(dp) > 1:
            return await self._executemany(query, dp, cursor)
        elif dp:
            dp = dp[0]

        result_map = None
        if isinstance(query, str):
            await cursor.execute(query, dp or None)
        elif isinstance(query, ClauseElement):
            if self._compiled_cache is not None:
                key = query
                compiled = self._compiled_cache.get(key)
                if not compiled:
                    compiled = query.compile(dialect=self._dialect)
                    if dp and dp.keys() == compiled.params.keys() \
                            or not (dp or compiled.params):
                        # we only want queries with bound params in cache
                        self._compiled_cache[key] = compiled
            else:
                compiled = query.compile(dialect=self._dialect)

            if not isinstance(query, DDLElement):
                post_processed_params = self._base_params(
                    query,
                    dp,
                    compiled,
                    isinstance(query, UpdateBase)
                )
                result_map = compiled._result_columns
            else:
                if dp:
                    raise exc.ArgumentError("Don't mix sqlalchemy DDL clause "
                                            "and execution with parameters")
                post_processed_params = compiled.construct_params()
                result_map = None
            await cursor.execute(str(compiled), post_processed_params)
        else:
            raise exc.ArgumentError("sql statement should be str or "
                                    "SQLAlchemy data "
                                    "selection/modification clause")

        ret = await create_result_proxy(
            self, cursor, self._dialect, result_map
        )
        self._weak_results.add(ret)
        return ret