def execute(self, sql_statement, parameters=None):
        """
        Execute the specified Structured Query Language (SQL) parameterized
        statement.


        @note: each result column MUST be named with distinct names.


        @param sql_statement: a string representation of a Structured Query
            Language (SQL) expression including Python extended format codes,
            also known as "pyformat", and extended pyformat code.  The
            following forms are accepted:

            * ``%(name)s``: indicate a simple value as for instance in::

                  INSERT INTO foo(bar)
                    VALUES (%(value)s)

              with ``parameters``::

                  { 'value': 'something' }


            * ``%[name]s``: indicate a list of simple values such as, for
              instance, in::

                  INSERT INTO foo(bar)
                    VALUES %[values]s

              with ``parameters``::

                  { 'values': [ i for i in range(8) ] }

            * ``%[name]s``: indicate a list of tuples as for instance in::

                  INSERT INTO foo(a, b, c)
                    VALUES %[values]s

              with ``parameters``::

                  { 'values': [ [ 0, 'a', '!' ],
                                [ 1, 'b', '@' ]
                                [ 2, 'c', '#' ] ] }

            * ``%[name]s``: indicate a list of tuples of ``(boolean, value)``
              where:

              * ``boolean``: ``True`` if the value MUST be used as it,
                ``False`` if the value needs to be quoted.

              * ``value``: the value itself.

              as for instance in::

                  INSERT INTO foo(id, coordinates)
                    VALUES %[values]s

              with ``parameters``::

                  { 'values': [ [ uuid.uuid1(), (False, 'ST_SetSRID(ST_MakePoint(160.1, 10.6), 4326)') ],
                                [ uuid.uuid1(), (False, 'ST_SetSRID(ST_MakePoint(160.1, 10.6), 4326)') ],
                                [ uuid.uuid1(), (False, 'ST_SetSRID(ST_MakePoint(160.1, 10.6), 4326)') ] ] }

        @param parameters: a dictionary of parameters.


        @return: a cursor object representing a database cursor, which is used
            to manage the context of a fetch operation.
        """
        if parameters:
            # Convert the simple value of parameters which the database adapter
            # cannot adapt to SQL type, such as enum values.
            # [http://initd.org/psycopg/docs/usage.html#query-parameters]
            #
            # @note: tuple is a special type used to indicate not to quote the
            #     underlying value which is a special SQL expression, such as a
            #     call of a stored procedure.
            for (name, value) in parameters.iteritems():
                if not isinstance(value, (types.NoneType, bool, int, long, float, basestring, tuple, list, set)):
                    parameters[name] = obj.stringify(value)

            # Replace the placeholders in the SQL statement for which the database
            # adapter cannot adapt the Python value to SQL types, for instance,
            # list and nested list.
            sql_statement = RdbmsConnection._prepare_statement(sql_statement, parameters)

        # Compact the SQL statement expression removing useless space and
        # newline characters, and stripping all SQL comments.
        sql_statement = ' '.join(
                [ line for line in [ line.strip() for line in REGEX_PATTERN_SQL_COMMENT.sub('\n', sql_statement.strip()).splitlines() ]
                      if len(line) > 0 ])

        self.logger.debug('[DEBUG] Executing SQL statement:\n%s\n\twith: %s' % (sql_statement, parameters))

        if self.__cursor is None:
            self.__cursor = self.__connection.cursor()

        execution_start_time = datetime.datetime.now()
        self.__cursor.execute(sql_statement, parameters)
        execution_end_time = datetime.datetime.now()
        execution_duration = execution_end_time - execution_start_time
        self.logger.debug('Time: %d ms' % ((execution_duration.seconds * 1000) + (execution_duration.microseconds / 1000)))

        return RdbmsConnection.RdbmsCursor(self.__cursor)