parameters: (self, object_, *multiparams, **params)
docstring: r"""Executes a SQL statement construct and returns a
          :class:`.ResultProxy`.
  
          :param object: The statement to be executed.  May be
           one of:
  
           * a plain string
           * any :class:`.ClauseElement` construct that is also
             a subclass of :class:`.Executable`, such as a
             :func:`~.expression.select` construct
           * a :class:`.FunctionElement`, such as that generated
             by :data:`.func`, will be automatically wrapped in
             a SELECT statement, which is then executed.
           * a :class:`.DDLElement` object
           * a :class:`.DefaultGenerator` object
           * a :class:`.Compiled` object
  
          :param \*multiparams/\**params: represent bound parameter
           values to be used in the execution.   Typically,
           the format is either a collection of one or more
           dictionaries passed to \*multiparams::
  
               conn.execute(
                   table.insert(),
                   {"id":1, "value":"v1"},
                   {"id":2, "value":"v2"}
               )
  
           ...or individual key/values interpreted by \**params::
  
               conn.execute(
                   table.insert(), id=1, value="v1"
               )
  
           In the case that a plain SQL string is passed, and the underlying
           DBAPI accepts positional bind parameters, a collection of tuples
           or individual values in \*multiparams may be passed::
  
               conn.execute(
                   "INSERT INTO table (id, value) VALUES (?, ?)",
                   (1, "v1"), (2, "v2")
               )
  
               conn.execute(
                   "INSERT INTO table (id, value) VALUES (?, ?)",
                   1, "v1"
               )
  
           Note above, the usage of a question mark "?" or other
           symbol is contingent upon the "paramstyle" accepted by the DBAPI
           in use, which may be any of "qmark", "named", "pyformat", "format",
           "numeric".   See `pep-249 <http://www.python.org/dev/peps/pep-0249/>`_
           for details on paramstyle.
  
           To execute a textual SQL statement which uses bound parameters in a
           DBAPI-agnostic way, use the :func:`~.expression.text` construct.
docstring_summary: r"""Executes a SQL statement construct and returns a
          :class:`.ResultProxy`.
docstring_tokens: r Executes a SQL statement construct and returns a : class : . ResultProxy .
function: def execute(self, object_, *multiparams, **params):
          r"""Executes a SQL statement construct and returns a
          :class:`.ResultProxy`.
  
          :param object: The statement to be executed.  May be
           one of:
  
           * a plain string
           * any :class:`.ClauseElement` construct that is also
             a subclass of :class:`.Executable`, such as a
             :func:`~.expression.select` construct
           * a :class:`.FunctionElement`, such as that generated
             by :data:`.func`, will be automatically wrapped in
             a SELECT statement, which is then executed.
           * a :class:`.DDLElement` object
           * a :class:`.DefaultGenerator` object
           * a :class:`.Compiled` object
  
          :param \*multiparams/\**params: represent bound parameter
           values to be used in the execution.   Typically,
           the format is either a collection of one or more
           dictionaries passed to \*multiparams::
  
               conn.execute(
                   table.insert(),
                   {"id":1, "value":"v1"},
                   {"id":2, "value":"v2"}
               )
  
           ...or individual key/values interpreted by \**params::
  
               conn.execute(
                   table.insert(), id=1, value="v1"
               )
  
           In the case that a plain SQL string is passed, and the underlying
           DBAPI accepts positional bind parameters, a collection of tuples
           or individual values in \*multiparams may be passed::
  
               conn.execute(
                   "INSERT INTO table (id, value) VALUES (?, ?)",
                   (1, "v1"), (2, "v2")
               )
  
               conn.execute(
                   "INSERT INTO table (id, value) VALUES (?, ?)",
                   1, "v1"
               )
  
           Note above, the usage of a question mark "?" or other
           symbol is contingent upon the "paramstyle" accepted by the DBAPI
           in use, which may be any of "qmark", "named", "pyformat", "format",
           "numeric".   See `pep-249 <http://www.python.org/dev/peps/pep-0249/>`_
           for details on paramstyle.
  
           To execute a textual SQL statement which uses bound parameters in a
           DBAPI-agnostic way, use the :func:`~.expression.text` construct.
  
          """
          if isinstance(object_, util.string_types[0]):
              return self._execute_text(object_, multiparams, params)
          try:
              meth = object_._execute_on_connection
          except AttributeError as err:
              util.raise_(
                  exc.ObjectNotExecutableError(object_), replace_context=err
              )
          else:
              return meth(self, multiparams, params)
function_tokens: def execute ( self , object_ , * multiparams , * * params ) : if isinstance ( object_ , util . string_types [ 0 ] ) : return self . _execute_text ( object_ , multiparams , params ) try : meth = object_ . _execute_on_connection except AttributeError as err : util . raise_ ( exc . ObjectNotExecutableError ( object_ ) , replace_context = err ) else : return meth ( self , multiparams , params )