Remove jython code, remove all jython / pypy symbols

Removed all dialect code related to support for Jython and zxJDBC. Jython
has not been supported by SQLAlchemy for many years and it is not expected
that the current zxJDBC code is at all functional; for the moment it just
takes up space and adds confusion by showing up in documentation. At the
moment, it appears that Jython has achieved Python 2.7 support in its
releases but not Python 3.   If Jython were to be supported again, the form
it should take is against the Python 3 version of Jython, and the various
zxJDBC stubs for various backends should be implemented as a third party
dialect.

Additionally modernized logic that distinguishes between "cpython"
and "pypy" to instead look at platform.python_distribution() which
reliably tells us if we are cPython or not; all booleans which
previously checked for pypy and sometimes jython are now converted
to be "not cpython", this impacts the test suite for tests that are
cPython centric.

Fixes: #5094
Change-Id: I226cb55827f997daf6b4f4a755c18e7f4eb8d9ad

21 files changed, 25 insertions, 631 deletions

diff --git a/lib/sqlalchemy/connectors/zxJDBC.py b/lib/sqlalchemy/connectors/zxJDBC.py
deleted file mode 100644
index 36c3fbc67..000000000
--- a/lib/sqlalchemy/connectors/zxJDBC.py
+++ /dev/null
@@ -1,68 +0,0 @@
-# connectors/zxJDBC.py
-# Copyright (C) 2005-2020 the SQLAlchemy authors and contributors
-# <see AUTHORS file>
-#
-# This module is part of SQLAlchemy and is released under
-# the MIT License: http://www.opensource.org/licenses/mit-license.php
-
-import sys
-
-from . import Connector
-
-
-class ZxJDBCConnector(Connector):
-    driver = "zxjdbc"
-
-    supports_sane_rowcount = False
-    supports_sane_multi_rowcount = False
-
-    supports_unicode_binds = True
-    supports_unicode_statements = sys.version > "2.5.0+"
-    description_encoding = None
-    default_paramstyle = "qmark"
-
-    jdbc_db_name = None
-    jdbc_driver_name = None
-
-    @classmethod
-    def dbapi(cls):
-        from com.ziclix.python.sql import zxJDBC
-
-        return zxJDBC
-
-    def _driver_kwargs(self):
-        """Return kw arg dict to be sent to connect()."""
-        return {}
-
-    def _create_jdbc_url(self, url):
-        """Create a JDBC url from a :class:`~sqlalchemy.engine.url.URL`"""
-        return "jdbc:%s://%s%s/%s" % (
-            self.jdbc_db_name,
-            url.host,
-            url.port is not None and ":%s" % url.port or "",
-            url.database,
-        )
-
-    def create_connect_args(self, url):
-        opts = self._driver_kwargs()
-        opts.update(url.query)
-        return [
-            [
-                self._create_jdbc_url(url),
-                url.username,
-                url.password,
-                self.jdbc_driver_name,
-            ],
-            opts,
-        ]
-
-    def is_disconnect(self, e, connection, cursor):
-        if not isinstance(e, self.dbapi.ProgrammingError):
-            return False
-        e = str(e)
-        return "connection is closed" in e or "cursor is closed" in e
-
-    def _get_server_version_info(self, connection):
-        # use connection.connection.dbversion, and parse appropriately
-        # to get a tuple
-        raise NotImplementedError()
diff --git a/lib/sqlalchemy/dialects/mssql/__init__.py b/lib/sqlalchemy/dialects/mssql/__init__.py
index d8d577a65..67830affe 100644
--- a/lib/sqlalchemy/dialects/mssql/__init__.py
+++ b/lib/sqlalchemy/dialects/mssql/__init__.py
@@ -10,7 +10,6 @@ from . import base  # noqa
 from . import mxodbc  # noqa
 from . import pymssql  # noqa
 from . import pyodbc  # noqa
-from . import zxjdbc  # noqa
 from .base import BIGINT
 from .base import BINARY
 from .base import BIT
diff --git a/lib/sqlalchemy/dialects/mssql/zxjdbc.py b/lib/sqlalchemy/dialects/mssql/zxjdbc.py
deleted file mode 100644
index 98666445f..000000000
--- a/lib/sqlalchemy/dialects/mssql/zxjdbc.py
+++ /dev/null
@@ -1,71 +0,0 @@
-# mssql/zxjdbc.py
-# Copyright (C) 2005-2020 the SQLAlchemy authors and contributors
-# <see AUTHORS file>
-#
-# This module is part of SQLAlchemy and is released under
-# the MIT License: http://www.opensource.org/licenses/mit-license.php
-
-"""
-.. dialect:: mssql+zxjdbc
-    :name: zxJDBC for Jython
-    :dbapi: zxjdbc
-    :connectstring: mssql+zxjdbc://user:pass@host:port/dbname[?key=value&key=value...]
-    :driverurl: http://jtds.sourceforge.net/
-
-    .. note:: Jython is not supported by current versions of SQLAlchemy.  The
-       zxjdbc dialect should be considered as experimental.
-
-"""  # noqa
-from .base import MSDialect
-from .base import MSExecutionContext
-from ... import engine
-from ...connectors.zxJDBC import ZxJDBCConnector
-
-
-class MSExecutionContext_zxjdbc(MSExecutionContext):
-
-    _embedded_scope_identity = False
-
-    def pre_exec(self):
-        super(MSExecutionContext_zxjdbc, self).pre_exec()
-        # scope_identity after the fact returns null in jTDS so we must
-        # embed it
-        if self._select_lastrowid and self.dialect.use_scope_identity:
-            self._embedded_scope_identity = True
-            self.statement += "; SELECT scope_identity()"
-
-    def post_exec(self):
-        if self._embedded_scope_identity:
-            while True:
-                try:
-                    row = self.cursor.fetchall()[0]
-                    break
-                except self.dialect.dbapi.Error:
-                    self.cursor.nextset()
-            self._lastrowid = int(row[0])
-
-        if (
-            self.isinsert or self.isupdate or self.isdelete
-        ) and self.compiled.returning:
-            self._result_proxy = engine.FullyBufferedResultProxy(self)
-
-        if self._enable_identity_insert:
-            table = self.dialect.identifier_preparer.format_table(
-                self.compiled.statement.table
-            )
-            self.cursor.execute("SET IDENTITY_INSERT %s OFF" % table)
-
-
-class MSDialect_zxjdbc(ZxJDBCConnector, MSDialect):
-    jdbc_db_name = "jtds:sqlserver"
-    jdbc_driver_name = "net.sourceforge.jtds.jdbc.Driver"
-
-    execution_ctx_cls = MSExecutionContext_zxjdbc
-
-    def _get_server_version_info(self, connection):
-        return tuple(
-            int(x) for x in connection.connection.dbversion.split(".")
-        )
-
-
-dialect = MSDialect_zxjdbc
diff --git a/lib/sqlalchemy/dialects/mysql/__init__.py b/lib/sqlalchemy/dialects/mysql/__init__.py
index c9f3b43b4..f1f1cce37 100644
--- a/lib/sqlalchemy/dialects/mysql/__init__.py
+++ b/lib/sqlalchemy/dialects/mysql/__init__.py
@@ -13,7 +13,6 @@ from . import mysqldb  # noqa
 from . import oursql  # noqa
 from . import pymysql  # noqa
 from . import pyodbc  # noqa
-from . import zxjdbc  # noqa
 from .base import BIGINT
 from .base import BINARY
 from .base import BIT
diff --git a/lib/sqlalchemy/dialects/mysql/zxjdbc.py b/lib/sqlalchemy/dialects/mysql/zxjdbc.py
deleted file mode 100644
index cf947b905..000000000
--- a/lib/sqlalchemy/dialects/mysql/zxjdbc.py
+++ /dev/null
@@ -1,120 +0,0 @@
-# mysql/zxjdbc.py
-# Copyright (C) 2005-2020 the SQLAlchemy authors and contributors
-# <see AUTHORS file>
-#
-# This module is part of SQLAlchemy and is released under
-# the MIT License: http://www.opensource.org/licenses/mit-license.php
-
-r"""
-
-.. dialect:: mysql+zxjdbc
-    :name: zxjdbc for Jython
-    :dbapi: zxjdbc
-    :connectstring: mysql+zxjdbc://<user>:<password>@<hostname>[:<port>]/<database>
-    :driverurl: http://dev.mysql.com/downloads/connector/j/
-
-    .. note:: Jython is not supported by current versions of SQLAlchemy.  The
-       zxjdbc dialect should be considered as experimental.
-
-Character Sets
---------------
-
-SQLAlchemy zxjdbc dialects pass unicode straight through to the
-zxjdbc/JDBC layer. To allow multiple character sets to be sent from the
-MySQL Connector/J JDBC driver, by default SQLAlchemy sets its
-``characterEncoding`` connection property to ``UTF-8``. It may be
-overridden via a ``create_engine`` URL parameter.
-
-"""  # noqa
-import re
-
-from .base import BIT
-from .base import MySQLDialect
-from .base import MySQLExecutionContext
-from ... import types as sqltypes
-from ... import util
-from ...connectors.zxJDBC import ZxJDBCConnector
-
-
-class _ZxJDBCBit(BIT):
-    def result_processor(self, dialect, coltype):
-        """Converts boolean or byte arrays from MySQL Connector/J to longs."""
-
-        def process(value):
-            if value is None:
-                return value
-            if isinstance(value, bool):
-                return int(value)
-            v = 0
-            for i in value:
-                v = v << 8 | (i & 0xFF)
-            value = v
-            return value
-
-        return process
-
-
-class MySQLExecutionContext_zxjdbc(MySQLExecutionContext):
-    def get_lastrowid(self):
-        cursor = self.create_cursor()
-        cursor.execute("SELECT LAST_INSERT_ID()")
-        lastrowid = cursor.fetchone()[0]
-        cursor.close()
-        return lastrowid
-
-
-class MySQLDialect_zxjdbc(ZxJDBCConnector, MySQLDialect):
-    jdbc_db_name = "mysql"
-    jdbc_driver_name = "com.mysql.jdbc.Driver"
-
-    execution_ctx_cls = MySQLExecutionContext_zxjdbc
-
-    colspecs = util.update_copy(
-        MySQLDialect.colspecs, {sqltypes.Time: sqltypes.Time, BIT: _ZxJDBCBit}
-    )
-
-    def _detect_charset(self, connection):
-        """Sniff out the character set in use for connection results."""
-        # Prefer 'character_set_results' for the current connection over the
-        # value in the driver.  SET NAMES or individual variable SETs will
-        # change the charset without updating the driver's view of the world.
-        #
-        # If it's decided that issuing that sort of SQL leaves you SOL, then
-        # this can prefer the driver value.
-        rs = connection.execute("SHOW VARIABLES LIKE 'character_set%%'")
-        opts = {row[0]: row[1] for row in self._compat_fetchall(rs)}
-        for key in ("character_set_connection", "character_set"):
-            if opts.get(key, None):
-                return opts[key]
-
-        util.warn(
-            "Could not detect the connection character set.  "
-            "Assuming latin1."
-        )
-        return "latin1"
-
-    def _driver_kwargs(self):
-        """return kw arg dict to be sent to connect()."""
-        return dict(characterEncoding="UTF-8", yearIsDateType="false")
-
-    def _extract_error_code(self, exception):
-        # e.g.: DBAPIError: (Error) Table 'test.u2' doesn't exist
-        # [SQLCode: 1146], [SQLState: 42S02] 'DESCRIBE `u2`' ()
-        m = re.compile(r"\[SQLCode\: (\d+)\]").search(str(exception.args))
-        c = m.group(1)
-        if c:
-            return int(c)
-
-    def _get_server_version_info(self, connection):
-        dbapi_con = connection.connection
-        version = []
-        r = re.compile(r"[.\-]")
-        for n in r.split(dbapi_con.dbversion):
-            try:
-                version.append(int(n))
-            except ValueError:
-                version.append(n)
-        return tuple(version)
-
-
-dialect = MySQLDialect_zxjdbc
diff --git a/lib/sqlalchemy/dialects/oracle/__init__.py b/lib/sqlalchemy/dialects/oracle/__init__.py
index 849dd6924..a4dee02ff 100644
--- a/lib/sqlalchemy/dialects/oracle/__init__.py
+++ b/lib/sqlalchemy/dialects/oracle/__init__.py
@@ -7,7 +7,6 @@
 
 from . import base  # noqa
 from . import cx_oracle  # noqa
-from . import zxjdbc  # noqa
 from .base import BFILE
 from .base import BINARY_DOUBLE
 from .base import BINARY_FLOAT
diff --git a/lib/sqlalchemy/dialects/oracle/base.py b/lib/sqlalchemy/dialects/oracle/base.py
index abf3af821..9cb25b934 100644
--- a/lib/sqlalchemy/dialects/oracle/base.py
+++ b/lib/sqlalchemy/dialects/oracle/base.py
@@ -575,7 +575,7 @@ class INTERVAL(sqltypes.NativeForEmulated, sqltypes._AbstractInterval):
 
         Note that only DAY TO SECOND intervals are currently supported.
         This is due to a lack of support for YEAR TO MONTH intervals
-        within available DBAPIs (cx_oracle and zxjdbc).
+        within available DBAPIs.
 
         :param day_precision: the day precision value.  this is the number of
           digits to store for the day field.  Defaults to "2"
diff --git a/lib/sqlalchemy/dialects/oracle/zxjdbc.py b/lib/sqlalchemy/dialects/oracle/zxjdbc.py
deleted file mode 100644
index 66878b25f..000000000
--- a/lib/sqlalchemy/dialects/oracle/zxjdbc.py
+++ /dev/null
@@ -1,254 +0,0 @@
-# oracle/zxjdbc.py
-# Copyright (C) 2005-2020 the SQLAlchemy authors and contributors
-# <see AUTHORS file>
-#
-# This module is part of SQLAlchemy and is released under
-# the MIT License: http://www.opensource.org/licenses/mit-license.php
-
-"""
-.. dialect:: oracle+zxjdbc
-    :name: zxJDBC for Jython
-    :dbapi: zxjdbc
-    :connectstring: oracle+zxjdbc://user:pass@host/dbname
-    :driverurl: http://www.oracle.com/technetwork/database/features/jdbc/index-091264.html
-
-    .. note:: Jython is not supported by current versions of SQLAlchemy.  The
-       zxjdbc dialect should be considered as experimental.
-
-"""  # noqa
-import collections
-import decimal
-import re
-
-from .base import OracleCompiler
-from .base import OracleDialect
-from .base import OracleExecutionContext
-from ... import sql
-from ... import types as sqltypes
-from ... import util
-from ...connectors.zxJDBC import ZxJDBCConnector
-from ...engine import result as _result
-from ...sql import expression
-
-
-SQLException = zxJDBC = None
-
-
-class _ZxJDBCDate(sqltypes.Date):
-    def result_processor(self, dialect, coltype):
-        def process(value):
-            if value is None:
-                return None
-            else:
-                return value.date()
-
-        return process
-
-
-class _ZxJDBCNumeric(sqltypes.Numeric):
-    def result_processor(self, dialect, coltype):
-        # XXX: does the dialect return Decimal or not???
-        # if it does (in all cases), we could use a None processor as well as
-        # the to_float generic processor
-        if self.asdecimal:
-
-            def process(value):
-                if isinstance(value, decimal.Decimal):
-                    return value
-                else:
-                    return decimal.Decimal(str(value))
-
-        else:
-
-            def process(value):
-                if isinstance(value, decimal.Decimal):
-                    return float(value)
-                else:
-                    return value
-
-        return process
-
-
-class OracleCompiler_zxjdbc(OracleCompiler):
-    def returning_clause(self, stmt, returning_cols):
-        self.returning_cols = list(
-            expression._select_iterables(returning_cols)
-        )
-
-        # within_columns_clause=False so that labels (foo AS bar) don't render
-        columns = [
-            self.process(c, within_columns_clause=False)
-            for c in self.returning_cols
-        ]
-
-        if not hasattr(self, "returning_parameters"):
-            self.returning_parameters = []
-
-        binds = []
-        for i, col in enumerate(self.returning_cols):
-            dbtype = col.type.dialect_impl(self.dialect).get_dbapi_type(
-                self.dialect.dbapi
-            )
-            self.returning_parameters.append((i + 1, dbtype))
-
-            bindparam = sql.bindparam(
-                "ret_%d" % i, value=ReturningParam(dbtype)
-            )
-            self.binds[bindparam.key] = bindparam
-            binds.append(
-                self.bindparam_string(self._truncate_bindparam(bindparam))
-            )
-
-        return "RETURNING " + ", ".join(columns) + " INTO " + ", ".join(binds)
-
-
-class OracleExecutionContext_zxjdbc(OracleExecutionContext):
-    def pre_exec(self):
-        if hasattr(self.compiled, "returning_parameters"):
-            # prepare a zxJDBC statement so we can grab its underlying
-            # OraclePreparedStatement's getReturnResultSet later
-            self.statement = self.cursor.prepare(self.statement)
-
-    def get_result_proxy(self):
-        if hasattr(self.compiled, "returning_parameters"):
-            rrs = None
-            try:
-                try:
-                    rrs = self.statement.__statement__.getReturnResultSet()
-                    next(rrs)
-                except SQLException as sqle:
-                    msg = "%s [SQLCode: %d]" % (
-                        sqle.getMessage(),
-                        sqle.getErrorCode(),
-                    )
-                    if sqle.getSQLState() is not None:
-                        msg += " [SQLState: %s]" % sqle.getSQLState()
-                    raise zxJDBC.Error(msg)
-                else:
-                    row = tuple(
-                        self.cursor.datahandler.getPyObject(rrs, index, dbtype)
-                        for index, dbtype in self.compiled.returning_parameters
-                    )
-                    return ReturningResultProxy(self, row)
-            finally:
-                if rrs is not None:
-                    try:
-                        rrs.close()
-                    except SQLException:
-                        pass
-                self.statement.close()
-
-        return _result.ResultProxy(self)
-
-    def create_cursor(self):
-        cursor = self._dbapi_connection.cursor()
-        cursor.datahandler = self.dialect.DataHandler(cursor.datahandler)
-        return cursor
-
-
-class ReturningResultProxy(_result.FullyBufferedResultProxy):
-
-    """ResultProxy backed by the RETURNING ResultSet results."""
-
-    def __init__(self, context, returning_row):
-        self._returning_row = returning_row
-        super(ReturningResultProxy, self).__init__(context)
-
-    def _cursor_description(self):
-        ret = []
-        for c in self.context.compiled.returning_cols:
-            if hasattr(c, "name"):
-                ret.append((c.name, c.type))
-            else:
-                ret.append((c.anon_label, c.type))
-        return ret
-
-    def _buffer_rows(self):
-        return collections.deque([self._returning_row])
-
-
-class ReturningParam(object):
-
-    """A bindparam value representing a RETURNING parameter.
-
-    Specially handled by OracleReturningDataHandler.
-    """
-
-    def __init__(self, type_):
-        self.type = type_
-
-    def __eq__(self, other):
-        if isinstance(other, ReturningParam):
-            return self.type == other.type
-        return NotImplemented
-
-    def __ne__(self, other):
-        if isinstance(other, ReturningParam):
-            return self.type != other.type
-        return NotImplemented
-
-    def __repr__(self):
-        kls = self.__class__
-        return "<%s.%s object at 0x%x type=%s>" % (
-            kls.__module__,
-            kls.__name__,
-            id(self),
-            self.type,
-        )
-
-
-class OracleDialect_zxjdbc(ZxJDBCConnector, OracleDialect):
-    jdbc_db_name = "oracle"
-    jdbc_driver_name = "oracle.jdbc.OracleDriver"
-
-    statement_compiler = OracleCompiler_zxjdbc
-    execution_ctx_cls = OracleExecutionContext_zxjdbc
-
-    colspecs = util.update_copy(
-        OracleDialect.colspecs,
-        {sqltypes.Date: _ZxJDBCDate, sqltypes.Numeric: _ZxJDBCNumeric},
-    )
-
-    def __init__(self, *args, **kwargs):
-        super(OracleDialect_zxjdbc, self).__init__(*args, **kwargs)
-        global SQLException, zxJDBC
-        from java.sql import SQLException
-        from com.ziclix.python.sql import zxJDBC
-        from com.ziclix.python.sql.handler import OracleDataHandler
-
-        class OracleReturningDataHandler(OracleDataHandler):
-            """zxJDBC DataHandler that specially handles ReturningParam."""
-
-            def setJDBCObject(self, statement, index, object_, dbtype=None):
-                if type(object_) is ReturningParam:
-                    statement.registerReturnParameter(index, object_.type)
-                elif dbtype is None:
-                    OracleDataHandler.setJDBCObject(
-                        self, statement, index, object_
-                    )
-                else:
-                    OracleDataHandler.setJDBCObject(
-                        self, statement, index, object_, dbtype
-                    )
-
-        self.DataHandler = OracleReturningDataHandler
-
-    def initialize(self, connection):
-        super(OracleDialect_zxjdbc, self).initialize(connection)
-        self.implicit_returning = connection.connection.driverversion >= "10.2"
-
-    def _create_jdbc_url(self, url):
-        return "jdbc:oracle:thin:@%s:%s:%s" % (
-            url.host,
-            url.port or 1521,
-            url.database,
-        )
-
-    def _get_server_version_info(self, connection):
-        version = re.search(
-            r"Release ([\d\.]+)", connection.connection.dbversion
-        ).group(1)
-        return tuple(int(x) for x in version.split("."))
-
-
-dialect = OracleDialect_zxjdbc
diff --git a/lib/sqlalchemy/dialects/postgresql/__init__.py b/lib/sqlalchemy/dialects/postgresql/__init__.py
index 80875916a..06d22872a 100644
--- a/lib/sqlalchemy/dialects/postgresql/__init__.py
+++ b/lib/sqlalchemy/dialects/postgresql/__init__.py
@@ -11,7 +11,6 @@ from . import psycopg2  # noqa
 from . import psycopg2cffi  # noqa
 from . import pygresql  # noqa
 from . import pypostgresql  # noqa
-from . import zxjdbc  # noqa
 from .array import All
 from .array import Any
 from .array import ARRAY
diff --git a/lib/sqlalchemy/dialects/postgresql/base.py b/lib/sqlalchemy/dialects/postgresql/base.py
index 0f08d1f40..cbc750066 100644
--- a/lib/sqlalchemy/dialects/postgresql/base.py
+++ b/lib/sqlalchemy/dialects/postgresql/base.py
@@ -1156,9 +1156,6 @@ class INTERVAL(sqltypes.NativeForEmulated, sqltypes._AbstractInterval):
 
     """PostgreSQL INTERVAL type.
 
-    The INTERVAL type may not be supported on all DBAPIs.
-    It is known to work on psycopg2 and not pg8000 or zxjdbc.
-
     """
 
     __visit_name__ = "INTERVAL"
diff --git a/lib/sqlalchemy/dialects/postgresql/zxjdbc.py b/lib/sqlalchemy/dialects/postgresql/zxjdbc.py
deleted file mode 100644
index 6ca7fcf98..000000000
--- a/lib/sqlalchemy/dialects/postgresql/zxjdbc.py
+++ /dev/null
@@ -1,48 +0,0 @@
-# postgresql/zxjdbc.py
-# Copyright (C) 2005-2020 the SQLAlchemy authors and contributors
-# <see AUTHORS file>
-#
-# This module is part of SQLAlchemy and is released under
-# the MIT License: http://www.opensource.org/licenses/mit-license.php
-
-"""
-.. dialect:: postgresql+zxjdbc
-    :name: zxJDBC for Jython
-    :dbapi: zxjdbc
-    :connectstring: postgresql+zxjdbc://scott:tiger@localhost/db
-    :driverurl: http://jdbc.postgresql.org/
-
-
-"""
-from .base import PGDialect
-from .base import PGExecutionContext
-from ...connectors.zxJDBC import ZxJDBCConnector
-
-
-class PGExecutionContext_zxjdbc(PGExecutionContext):
-    def create_cursor(self):
-        cursor = self._dbapi_connection.cursor()
-        cursor.datahandler = self.dialect.DataHandler(cursor.datahandler)
-        return cursor
-
-
-class PGDialect_zxjdbc(ZxJDBCConnector, PGDialect):
-    jdbc_db_name = "postgresql"
-    jdbc_driver_name = "org.postgresql.Driver"
-
-    execution_ctx_cls = PGExecutionContext_zxjdbc
-
-    supports_native_decimal = True
-
-    def __init__(self, *args, **kwargs):
-        super(PGDialect_zxjdbc, self).__init__(*args, **kwargs)
-        from com.ziclix.python.sql.handler import PostgresqlDataHandler
-
-        self.DataHandler = PostgresqlDataHandler
-
-    def _get_server_version_info(self, connection):
-        parts = connection.connection.dbversion.split(".")
-        return tuple(int(x) for x in parts)
-
-
-dialect = PGDialect_zxjdbc
diff --git a/lib/sqlalchemy/engine/default.py b/lib/sqlalchemy/engine/default.py
index cc65a0c49..1c995f05f 100644
--- a/lib/sqlalchemy/engine/default.py
+++ b/lib/sqlalchemy/engine/default.py
@@ -410,9 +410,7 @@ class DefaultDialect(interfaces.Dialect):
             return results == {True}
 
     def _check_unicode_description(self, connection):
-        # all DBAPIs on Py2K return cursor.description as encoded,
-        # until pypy2.1beta2 with sqlite, so let's just check it -
-        # it's likely others will start doing this too in Py2k.
+        # all DBAPIs on Py2K return cursor.description as encoded
 
         if util.py2k and not self.supports_unicode_statements:
             cast_to = util.binary_type
diff --git a/lib/sqlalchemy/orm/__init__.py b/lib/sqlalchemy/orm/__init__.py
index 45a777a56..05fcc3fc9 100644
--- a/lib/sqlalchemy/orm/__init__.py
+++ b/lib/sqlalchemy/orm/__init__.py
@@ -233,12 +233,8 @@ def clear_mappers():
     """
     with mapperlib._CONFIGURE_MUTEX:
         while _mapper_registry:
-            try:
-                # can't even reliably call list(weakdict) in jython
-                mapper, b = _mapper_registry.popitem()
-                mapper.dispose()
-            except KeyError:
-                pass
+            mapper, b = _mapper_registry.popitem()
+            mapper.dispose()
 
 
 joinedload = strategy_options.joinedload._unbound_fn
diff --git a/lib/sqlalchemy/sql/sqltypes.py b/lib/sqlalchemy/sql/sqltypes.py
index 6d0d00409..52b9fa1a9 100644
--- a/lib/sqlalchemy/sql/sqltypes.py
+++ b/lib/sqlalchemy/sql/sqltypes.py
@@ -41,10 +41,6 @@ from ..util import compat
 from ..util import pickle
 
 
-if util.jython:
-    import array
-
-
 class _LookupExpressionAdapter(object):
 
     """Mixin expression adaptations based on lookup tables.
@@ -923,19 +919,7 @@ class _Binary(TypeEngine):
     if util.py2k:
 
         def result_processor(self, dialect, coltype):
-            if util.jython:
-
-                def process(value):
-                    if value is not None:
-                        if isinstance(value, array.array):
-                            return value.tostring()
-                        return str(value)
-                    else:
-                        return None
-
-            else:
-                process = processors.to_str
-            return process
+            return processors.to_str
 
     else:
 
diff --git a/lib/sqlalchemy/testing/engines.py b/lib/sqlalchemy/testing/engines.py
index 4aa5560bf..ff4f89606 100644
--- a/lib/sqlalchemy/testing/engines.py
+++ b/lib/sqlalchemy/testing/engines.py
@@ -58,7 +58,7 @@ class ConnectionKiller(object):
         # this can cause a deadlock with pg8000 - pg8000 acquires
         # prepared statement lock inside of rollback() - if async gc
         # is collecting in finalize_fairy, deadlock.
-        # not sure if this should be if pypy/jython only.
+        # not sure if this should be for non-cpython only.
         # note that firebird/fdb definitely needs this though
         for conn, rec in list(self.conns):
             if rec.connection is None:
diff --git a/lib/sqlalchemy/testing/profiling.py b/lib/sqlalchemy/testing/profiling.py
index 14a6fc4ac..cc6557018 100644
--- a/lib/sqlalchemy/testing/profiling.py
+++ b/lib/sqlalchemy/testing/profiling.py
@@ -15,13 +15,13 @@ in a more fine-grained way than nose's profiling plugin.
 import collections
 import contextlib
 import os
+import platform
 import pstats
 import sys
 
 from . import config
 from .util import gc_collect
-from ..util import jython
-from ..util import pypy
+from ..util import cpython
 from ..util import win32
 
 
@@ -91,12 +91,12 @@ class ProfileStatsFile(object):
         # keep it at 2.7, 3.1, 3.2, etc. for now.
         py_version = ".".join([str(v) for v in sys.version_info[0:2]])
 
-        platform_tokens = [py_version]
+        if not cpython:
+            platform_tokens = [platform.python_implementation(), py_version]
+        else:
+            platform_tokens = [py_version]
         platform_tokens.append(dbapi_key)
-        if jython:
-            platform_tokens.append("jython")
-        if pypy:
-            platform_tokens.append("pypy")
+
         if win32:
             platform_tokens.append("win")
         platform_tokens.append(
diff --git a/lib/sqlalchemy/testing/requirements.py b/lib/sqlalchemy/testing/requirements.py
index 4088c0cb1..b3375f6d5 100644
--- a/lib/sqlalchemy/testing/requirements.py
+++ b/lib/sqlalchemy/testing/requirements.py
@@ -1034,7 +1034,7 @@ class SuiteRequirements(Requirements):
         from sqlalchemy.util import pickle
 
         return exclusions.only_if(
-            lambda: not util.pypy
+            lambda: util.cpython
             and pickle.__name__ == "cPickle"
             or sys.version_info >= (3, 2),
             "Needs cPickle+cPython or newer Python 3 pickle",
diff --git a/lib/sqlalchemy/testing/suite/test_insert.py b/lib/sqlalchemy/testing/suite/test_insert.py
index fc535aa23..2cc8761b8 100644
--- a/lib/sqlalchemy/testing/suite/test_insert.py
+++ b/lib/sqlalchemy/testing/suite/test_insert.py
@@ -56,10 +56,6 @@ class LastrowidTest(fixtures.TablesTest):
         pk = config.db.scalar(select([self.tables.autoinc_pk.c.id]))
         eq_(r.inserted_primary_key, [pk])
 
-    # failed on pypy1.9 but seems to be OK on pypy 2.1
-    # @exclusions.fails_if(lambda: util.pypy,
-    #                      "lastrowid not maintained after "
-    #                      "connection close")
     @requirements.dbapi_lastrowid
     def test_native_lastrowid_autoinc(self):
         r = config.db.execute(
diff --git a/lib/sqlalchemy/testing/util.py b/lib/sqlalchemy/testing/util.py
index de20bb794..c52dc4a19 100644
--- a/lib/sqlalchemy/testing/util.py
+++ b/lib/sqlalchemy/testing/util.py
@@ -9,36 +9,22 @@ import decimal
 import gc
 import random
 import sys
-import time
 import types
 
 from . import mock
 from ..util import decorator
 from ..util import defaultdict
+from ..util import has_refcount_gc
 from ..util import inspect_getfullargspec
-from ..util import jython
 from ..util import py2k
-from ..util import pypy
 
-if jython:
+if not has_refcount_gc:
 
-    def jython_gc_collect(*args):
-        """aggressive gc.collect for tests."""
-        gc.collect()
-        time.sleep(0.1)
-        gc.collect()
-        gc.collect()
-        return 0
-
-    # "lazy" gc, for VM's that don't GC on refcount == 0
-    gc_collect = lazy_gc = jython_gc_collect
-elif pypy:
-
-    def pypy_gc_collect(*args):
+    def non_refcount_gc_collect(*args):
         gc.collect()
         gc.collect()
 
-    gc_collect = lazy_gc = pypy_gc_collect
+    gc_collect = lazy_gc = non_refcount_gc_collect
 else:
     # assume CPython - straight gc.collect, lazy_gc() is a pass
     gc_collect = gc.collect
diff --git a/lib/sqlalchemy/util/__init__.py b/lib/sqlalchemy/util/__init__.py
index a19636f62..30e384027 100644
--- a/lib/sqlalchemy/util/__init__.py
+++ b/lib/sqlalchemy/util/__init__.py
@@ -53,12 +53,12 @@ from .compat import cmp  # noqa
 from .compat import cpython  # noqa
 from .compat import decode_backslashreplace  # noqa
 from .compat import dottedgetter  # noqa
+from .compat import has_refcount_gc  # noqa
 from .compat import inspect_getfullargspec  # noqa
 from .compat import int_types  # noqa
 from .compat import iterbytes  # noqa
 from .compat import itertools_filter  # noqa
 from .compat import itertools_filterfalse  # noqa
-from .compat import jython  # noqa
 from .compat import namedtuple  # noqa
 from .compat import nested  # noqa
 from .compat import next  # noqa
@@ -69,7 +69,6 @@ from .compat import py2k  # noqa
 from .compat import py33  # noqa
 from .compat import py36  # noqa
 from .compat import py3k  # noqa
-from .compat import pypy  # noqa
 from .compat import quote_plus  # noqa
 from .compat import raise_from_cause  # noqa
 from .compat import reduce  # noqa
diff --git a/lib/sqlalchemy/util/compat.py b/lib/sqlalchemy/util/compat.py
index 2cb5db5d4..ea9ac0f11 100644
--- a/lib/sqlalchemy/util/compat.py
+++ b/lib/sqlalchemy/util/compat.py
@@ -11,6 +11,7 @@ import collections
 import contextlib
 import inspect
 import operator
+import platform
 import sys
 
 
@@ -21,10 +22,12 @@ py32 = sys.version_info >= (3, 2)
 py3k = sys.version_info >= (3, 0)
 py2k = sys.version_info < (3, 0)
 py265 = sys.version_info >= (2, 6, 5)
-jython = sys.platform.startswith("java")
-pypy = hasattr(sys, "pypy_version_info")
+
+
+cpython = platform.python_implementation() == "CPython"
 win32 = sys.platform.startswith("win")
-cpython = not pypy and not jython  # TODO: something better for this ?
+
+has_refcount_gc = bool(cpython)
 
 contextmanager = contextlib.contextmanager
 dottedgetter = operator.attrgetter