Method startswith

lib/sqlalchemy/sql/operators.py:1267–1356

r"""Implement the ``startswith`` operator. Produces a LIKE expression that tests against a match for the start of a string value: .. sourcecode:: sql column LIKE <other> || '%' E.g.:: stmt = select(sometable).where(sometable.c.column.start

(
        self,
        other: Any,
        escape: Optional[str] = None,
        autoescape: bool = False,
    )

        isnot = is_not

    def startswith(
        self,
        other: Any,
        escape: Optional[str] = None,
        autoescape: bool = False,
    ) -> ColumnOperators:
        rclass="st">"""Implement the ``startswith`` operator.

        Produces a LIKE expression that tests against a match for the start
        of a string value:

        .. sourcecode:: sql

            column LIKE <other> || &class="cm">#x27;%'

        E.g.::

            stmt = select(sometable).where(sometable.c.column.startswith(class="st">"foobar"))

        Since the operator uses ``LIKE``, wildcard characters
        ``class="st">"%"`` and ``class="st">"_"`` that are present inside the <other> expression
        will behave like wildcards as well.   For literal string
        values, the :paramref:`.ColumnOperators.startswith.autoescape` flag
        may be set to ``True`` to apply escaping to occurrences of these
        characters within the string value so that they match as themselves
        and not as wildcard characters.  Alternatively, the
        :paramref:`.ColumnOperators.startswith.escape` parameter will establish
        a given character as an escape character which can be of use when
        the target expression is not a literal string.

        :param other: expression to be compared.   This is usually a plain
          string value, but can also be an arbitrary SQL expression.  LIKE
          wildcard characters ``%`` and ``_`` are not escaped by default unless
          the :paramref:`.ColumnOperators.startswith.autoescape` flag is
          set to True.

        :param autoescape: boolean; when True, establishes an escape character
          within the LIKE expression, then applies it to all occurrences of
          ``class="st">"%"``, ``class="st">"_"`` and the escape character itself within the
          comparison value, which is assumed to be a literal string and not a
          SQL expression.

          An expression such as::

            somecolumn.startswith(class="st">"foo%bar", autoescape=True)

          Will render as:

          .. sourcecode:: sql

            somecolumn LIKE :param || &class="cm">#x27;%class="st">' ESCAPE '/'

          With the value of ``:param`` as ``class="st">"foo/%bar"``.

        :param escape: a character which when given will render with the
          ``ESCAPE`` keyword to establish that character as the escape
          character.  This character can then be placed preceding occurrences
          of ``%`` and ``_`` to allow them to act as themselves and not