608 lines
24 KiB
Python
608 lines
24 KiB
Python
"""
|
|
Oracle database backend for Django.
|
|
|
|
Requires cx_Oracle: http://cx-oracle.sourceforge.net/
|
|
"""
|
|
from __future__ import unicode_literals
|
|
|
|
import datetime
|
|
import decimal
|
|
import os
|
|
import platform
|
|
import sys
|
|
import warnings
|
|
|
|
from django.conf import settings
|
|
from django.db import utils
|
|
from django.db.backends.base.base import BaseDatabaseWrapper
|
|
from django.db.backends.base.validation import BaseDatabaseValidation
|
|
from django.utils import six, timezone
|
|
from django.utils.deprecation import RemovedInDjango21Warning
|
|
from django.utils.duration import duration_string
|
|
from django.utils.encoding import force_bytes, force_text
|
|
from django.utils.functional import cached_property
|
|
|
|
|
|
def _setup_environment(environ):
|
|
# Cygwin requires some special voodoo to set the environment variables
|
|
# properly so that Oracle will see them.
|
|
if platform.system().upper().startswith('CYGWIN'):
|
|
try:
|
|
import ctypes
|
|
except ImportError as e:
|
|
from django.core.exceptions import ImproperlyConfigured
|
|
raise ImproperlyConfigured("Error loading ctypes: %s; "
|
|
"the Oracle backend requires ctypes to "
|
|
"operate correctly under Cygwin." % e)
|
|
kernel32 = ctypes.CDLL('kernel32')
|
|
for name, value in environ:
|
|
kernel32.SetEnvironmentVariableA(name, value)
|
|
else:
|
|
os.environ.update(environ)
|
|
|
|
_setup_environment([
|
|
# Oracle takes client-side character set encoding from the environment.
|
|
('NLS_LANG', '.UTF8'),
|
|
# This prevents unicode from getting mangled by getting encoded into the
|
|
# potentially non-unicode database character set.
|
|
('ORA_NCHAR_LITERAL_REPLACE', 'TRUE'),
|
|
])
|
|
|
|
|
|
try:
|
|
import cx_Oracle as Database
|
|
except ImportError as e:
|
|
from django.core.exceptions import ImproperlyConfigured
|
|
raise ImproperlyConfigured("Error loading cx_Oracle module: %s" % e)
|
|
|
|
# Some of these import cx_Oracle, so import them after checking if it's installed.
|
|
from .client import DatabaseClient # isort:skip
|
|
from .creation import DatabaseCreation # isort:skip
|
|
from .features import DatabaseFeatures # isort:skip
|
|
from .introspection import DatabaseIntrospection # isort:skip
|
|
from .operations import DatabaseOperations # isort:skip
|
|
from .schema import DatabaseSchemaEditor # isort:skip
|
|
from .utils import Oracle_datetime, convert_unicode # isort:skip
|
|
|
|
DatabaseError = Database.DatabaseError
|
|
IntegrityError = Database.IntegrityError
|
|
|
|
|
|
class _UninitializedOperatorsDescriptor(object):
|
|
|
|
def __get__(self, instance, owner):
|
|
# If connection.operators is looked up before a connection has been
|
|
# created, transparently initialize connection.operators to avert an
|
|
# AttributeError.
|
|
if instance is None:
|
|
raise AttributeError("operators not available as class attribute")
|
|
# Creating a cursor will initialize the operators.
|
|
instance.cursor().close()
|
|
return instance.__dict__['operators']
|
|
|
|
|
|
class DatabaseWrapper(BaseDatabaseWrapper):
|
|
vendor = 'oracle'
|
|
# This dictionary maps Field objects to their associated Oracle column
|
|
# types, as strings. Column-type strings can contain format strings; they'll
|
|
# be interpolated against the values of Field.__dict__ before being output.
|
|
# If a column type is set to None, it won't be included in the output.
|
|
#
|
|
# Any format strings starting with "qn_" are quoted before being used in the
|
|
# output (the "qn_" prefix is stripped before the lookup is performed.
|
|
data_types = {
|
|
'AutoField': 'NUMBER(11)',
|
|
'BinaryField': 'BLOB',
|
|
'BooleanField': 'NUMBER(1)',
|
|
'CharField': 'NVARCHAR2(%(max_length)s)',
|
|
'CommaSeparatedIntegerField': 'VARCHAR2(%(max_length)s)',
|
|
'DateField': 'DATE',
|
|
'DateTimeField': 'TIMESTAMP',
|
|
'DecimalField': 'NUMBER(%(max_digits)s, %(decimal_places)s)',
|
|
'DurationField': 'INTERVAL DAY(9) TO SECOND(6)',
|
|
'FileField': 'NVARCHAR2(%(max_length)s)',
|
|
'FilePathField': 'NVARCHAR2(%(max_length)s)',
|
|
'FloatField': 'DOUBLE PRECISION',
|
|
'IntegerField': 'NUMBER(11)',
|
|
'BigIntegerField': 'NUMBER(19)',
|
|
'IPAddressField': 'VARCHAR2(15)',
|
|
'GenericIPAddressField': 'VARCHAR2(39)',
|
|
'NullBooleanField': 'NUMBER(1)',
|
|
'OneToOneField': 'NUMBER(11)',
|
|
'PositiveIntegerField': 'NUMBER(11)',
|
|
'PositiveSmallIntegerField': 'NUMBER(11)',
|
|
'SlugField': 'NVARCHAR2(%(max_length)s)',
|
|
'SmallIntegerField': 'NUMBER(11)',
|
|
'TextField': 'NCLOB',
|
|
'TimeField': 'TIMESTAMP',
|
|
'URLField': 'VARCHAR2(%(max_length)s)',
|
|
'UUIDField': 'VARCHAR2(32)',
|
|
}
|
|
data_type_check_constraints = {
|
|
'BooleanField': '%(qn_column)s IN (0,1)',
|
|
'NullBooleanField': '(%(qn_column)s IN (0,1)) OR (%(qn_column)s IS NULL)',
|
|
'PositiveIntegerField': '%(qn_column)s >= 0',
|
|
'PositiveSmallIntegerField': '%(qn_column)s >= 0',
|
|
}
|
|
|
|
operators = _UninitializedOperatorsDescriptor()
|
|
|
|
_standard_operators = {
|
|
'exact': '= %s',
|
|
'iexact': '= UPPER(%s)',
|
|
'contains': "LIKE TRANSLATE(%s USING NCHAR_CS) ESCAPE TRANSLATE('\\' USING NCHAR_CS)",
|
|
'icontains': "LIKE UPPER(TRANSLATE(%s USING NCHAR_CS)) ESCAPE TRANSLATE('\\' USING NCHAR_CS)",
|
|
'gt': '> %s',
|
|
'gte': '>= %s',
|
|
'lt': '< %s',
|
|
'lte': '<= %s',
|
|
'startswith': "LIKE TRANSLATE(%s USING NCHAR_CS) ESCAPE TRANSLATE('\\' USING NCHAR_CS)",
|
|
'endswith': "LIKE TRANSLATE(%s USING NCHAR_CS) ESCAPE TRANSLATE('\\' USING NCHAR_CS)",
|
|
'istartswith': "LIKE UPPER(TRANSLATE(%s USING NCHAR_CS)) ESCAPE TRANSLATE('\\' USING NCHAR_CS)",
|
|
'iendswith': "LIKE UPPER(TRANSLATE(%s USING NCHAR_CS)) ESCAPE TRANSLATE('\\' USING NCHAR_CS)",
|
|
}
|
|
|
|
_likec_operators = _standard_operators.copy()
|
|
_likec_operators.update({
|
|
'contains': "LIKEC %s ESCAPE '\\'",
|
|
'icontains': "LIKEC UPPER(%s) ESCAPE '\\'",
|
|
'startswith': "LIKEC %s ESCAPE '\\'",
|
|
'endswith': "LIKEC %s ESCAPE '\\'",
|
|
'istartswith': "LIKEC UPPER(%s) ESCAPE '\\'",
|
|
'iendswith': "LIKEC UPPER(%s) ESCAPE '\\'",
|
|
})
|
|
|
|
# The patterns below are used to generate SQL pattern lookup clauses when
|
|
# the right-hand side of the lookup isn't a raw string (it might be an expression
|
|
# or the result of a bilateral transformation).
|
|
# In those cases, special characters for LIKE operators (e.g. \, *, _) should be
|
|
# escaped on database side.
|
|
#
|
|
# Note: we use str.format() here for readability as '%' is used as a wildcard for
|
|
# the LIKE operator.
|
|
pattern_esc = r"REPLACE(REPLACE(REPLACE({}, '\', '\\'), '%%', '\%%'), '_', '\_')"
|
|
_pattern_ops = {
|
|
'contains': "'%%' || {} || '%%'",
|
|
'icontains': "'%%' || UPPER({}) || '%%'",
|
|
'startswith': "{} || '%%'",
|
|
'istartswith': "UPPER({}) || '%%'",
|
|
'endswith': "'%%' || {}",
|
|
'iendswith': "'%%' || UPPER({})",
|
|
}
|
|
|
|
_standard_pattern_ops = {k: "LIKE TRANSLATE( " + v + " USING NCHAR_CS)"
|
|
" ESCAPE TRANSLATE('\\' USING NCHAR_CS)"
|
|
for k, v in _pattern_ops.items()}
|
|
_likec_pattern_ops = {k: "LIKEC " + v + " ESCAPE '\\'"
|
|
for k, v in _pattern_ops.items()}
|
|
|
|
Database = Database
|
|
SchemaEditorClass = DatabaseSchemaEditor
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
super(DatabaseWrapper, self).__init__(*args, **kwargs)
|
|
|
|
self.features = DatabaseFeatures(self)
|
|
use_returning_into = self.settings_dict["OPTIONS"].get('use_returning_into', True)
|
|
self.features.can_return_id_from_insert = use_returning_into
|
|
self.ops = DatabaseOperations(self)
|
|
self.client = DatabaseClient(self)
|
|
self.creation = DatabaseCreation(self)
|
|
self.introspection = DatabaseIntrospection(self)
|
|
self.validation = BaseDatabaseValidation(self)
|
|
|
|
def _connect_string(self):
|
|
settings_dict = self.settings_dict
|
|
if not settings_dict['HOST'].strip():
|
|
settings_dict['HOST'] = 'localhost'
|
|
if settings_dict['PORT'].strip():
|
|
dsn = Database.makedsn(settings_dict['HOST'],
|
|
int(settings_dict['PORT']),
|
|
settings_dict['NAME'])
|
|
else:
|
|
dsn = settings_dict['NAME']
|
|
return "%s/%s@%s" % (settings_dict['USER'],
|
|
settings_dict['PASSWORD'], dsn)
|
|
|
|
def get_connection_params(self):
|
|
conn_params = self.settings_dict['OPTIONS'].copy()
|
|
if 'use_returning_into' in conn_params:
|
|
del conn_params['use_returning_into']
|
|
return conn_params
|
|
|
|
def get_new_connection(self, conn_params):
|
|
conn_string = convert_unicode(self._connect_string())
|
|
return Database.connect(conn_string, **conn_params)
|
|
|
|
def init_connection_state(self):
|
|
cursor = self.create_cursor()
|
|
# Set the territory first. The territory overrides NLS_DATE_FORMAT
|
|
# and NLS_TIMESTAMP_FORMAT to the territory default. When all of
|
|
# these are set in single statement it isn't clear what is supposed
|
|
# to happen.
|
|
cursor.execute("ALTER SESSION SET NLS_TERRITORY = 'AMERICA'")
|
|
# Set Oracle date to ANSI date format. This only needs to execute
|
|
# once when we create a new connection. We also set the Territory
|
|
# to 'AMERICA' which forces Sunday to evaluate to a '1' in
|
|
# TO_CHAR().
|
|
cursor.execute(
|
|
"ALTER SESSION SET NLS_DATE_FORMAT = 'YYYY-MM-DD HH24:MI:SS'"
|
|
" NLS_TIMESTAMP_FORMAT = 'YYYY-MM-DD HH24:MI:SS.FF'"
|
|
+ (" TIME_ZONE = 'UTC'" if settings.USE_TZ else ''))
|
|
cursor.close()
|
|
if 'operators' not in self.__dict__:
|
|
# Ticket #14149: Check whether our LIKE implementation will
|
|
# work for this connection or we need to fall back on LIKEC.
|
|
# This check is performed only once per DatabaseWrapper
|
|
# instance per thread, since subsequent connections will use
|
|
# the same settings.
|
|
cursor = self.create_cursor()
|
|
try:
|
|
cursor.execute("SELECT 1 FROM DUAL WHERE DUMMY %s"
|
|
% self._standard_operators['contains'],
|
|
['X'])
|
|
except DatabaseError:
|
|
self.operators = self._likec_operators
|
|
self.pattern_ops = self._likec_pattern_ops
|
|
else:
|
|
self.operators = self._standard_operators
|
|
self.pattern_ops = self._standard_pattern_ops
|
|
cursor.close()
|
|
|
|
try:
|
|
self.connection.stmtcachesize = 20
|
|
except AttributeError:
|
|
# Django docs specify cx_Oracle version 4.3.1 or higher, but
|
|
# stmtcachesize is available only in 4.3.2 and up.
|
|
pass
|
|
# Ensure all changes are preserved even when AUTOCOMMIT is False.
|
|
if not self.get_autocommit():
|
|
self.commit()
|
|
|
|
def create_cursor(self):
|
|
return FormatStylePlaceholderCursor(self.connection)
|
|
|
|
def _commit(self):
|
|
if self.connection is not None:
|
|
try:
|
|
return self.connection.commit()
|
|
except Database.DatabaseError as e:
|
|
# cx_Oracle 5.0.4 raises a cx_Oracle.DatabaseError exception
|
|
# with the following attributes and values:
|
|
# code = 2091
|
|
# message = 'ORA-02091: transaction rolled back
|
|
# 'ORA-02291: integrity constraint (TEST_DJANGOTEST.SYS
|
|
# _C00102056) violated - parent key not found'
|
|
# We convert that particular case to our IntegrityError exception
|
|
x = e.args[0]
|
|
if hasattr(x, 'code') and hasattr(x, 'message') \
|
|
and x.code == 2091 and 'ORA-02291' in x.message:
|
|
six.reraise(utils.IntegrityError, utils.IntegrityError(*tuple(e.args)), sys.exc_info()[2])
|
|
raise
|
|
|
|
# Oracle doesn't support releasing savepoints. But we fake them when query
|
|
# logging is enabled to keep query counts consistent with other backends.
|
|
def _savepoint_commit(self, sid):
|
|
if self.queries_logged:
|
|
self.queries_log.append({
|
|
'sql': '-- RELEASE SAVEPOINT %s (faked)' % self.ops.quote_name(sid),
|
|
'time': '0.000',
|
|
})
|
|
|
|
def _set_autocommit(self, autocommit):
|
|
with self.wrap_database_errors:
|
|
self.connection.autocommit = autocommit
|
|
|
|
def check_constraints(self, table_names=None):
|
|
"""
|
|
To check constraints, we set constraints to immediate. Then, when, we're done we must ensure they
|
|
are returned to deferred.
|
|
"""
|
|
self.cursor().execute('SET CONSTRAINTS ALL IMMEDIATE')
|
|
self.cursor().execute('SET CONSTRAINTS ALL DEFERRED')
|
|
|
|
def is_usable(self):
|
|
try:
|
|
self.connection.ping()
|
|
except Database.Error:
|
|
return False
|
|
else:
|
|
return True
|
|
|
|
@cached_property
|
|
def oracle_full_version(self):
|
|
with self.temporary_connection():
|
|
return self.connection.version
|
|
|
|
@cached_property
|
|
def oracle_version(self):
|
|
try:
|
|
return int(self.oracle_full_version.split('.')[0])
|
|
except ValueError:
|
|
return None
|
|
|
|
|
|
class OracleParam(object):
|
|
"""
|
|
Wrapper object for formatting parameters for Oracle. If the string
|
|
representation of the value is large enough (greater than 4000 characters)
|
|
the input size needs to be set as CLOB. Alternatively, if the parameter
|
|
has an `input_size` attribute, then the value of the `input_size` attribute
|
|
will be used instead. Otherwise, no input size will be set for the
|
|
parameter when executing the query.
|
|
"""
|
|
|
|
def __init__(self, param, cursor, strings_only=False):
|
|
# With raw SQL queries, datetimes can reach this function
|
|
# without being converted by DateTimeField.get_db_prep_value.
|
|
if settings.USE_TZ and (isinstance(param, datetime.datetime) and
|
|
not isinstance(param, Oracle_datetime)):
|
|
if timezone.is_aware(param):
|
|
warnings.warn(
|
|
"The Oracle database adapter received an aware datetime (%s), "
|
|
"probably from cursor.execute(). Update your code to pass a "
|
|
"naive datetime in the database connection's time zone (UTC by "
|
|
"default).", RemovedInDjango21Warning)
|
|
param = param.astimezone(timezone.utc).replace(tzinfo=None)
|
|
param = Oracle_datetime.from_datetime(param)
|
|
|
|
if isinstance(param, datetime.timedelta):
|
|
param = duration_string(param)
|
|
if ' ' not in param:
|
|
param = '0 ' + param
|
|
|
|
string_size = 0
|
|
# Oracle doesn't recognize True and False correctly in Python 3.
|
|
# The conversion done below works both in 2 and 3.
|
|
if param is True:
|
|
param = 1
|
|
elif param is False:
|
|
param = 0
|
|
if hasattr(param, 'bind_parameter'):
|
|
self.force_bytes = param.bind_parameter(cursor)
|
|
elif isinstance(param, Database.Binary):
|
|
self.force_bytes = param
|
|
else:
|
|
# To transmit to the database, we need Unicode if supported
|
|
# To get size right, we must consider bytes.
|
|
self.force_bytes = convert_unicode(param, cursor.charset,
|
|
strings_only)
|
|
if isinstance(self.force_bytes, six.string_types):
|
|
# We could optimize by only converting up to 4000 bytes here
|
|
string_size = len(force_bytes(param, cursor.charset, strings_only))
|
|
if hasattr(param, 'input_size'):
|
|
# If parameter has `input_size` attribute, use that.
|
|
self.input_size = param.input_size
|
|
elif string_size > 4000:
|
|
# Mark any string param greater than 4000 characters as a CLOB.
|
|
self.input_size = Database.CLOB
|
|
else:
|
|
self.input_size = None
|
|
|
|
|
|
class VariableWrapper(object):
|
|
"""
|
|
An adapter class for cursor variables that prevents the wrapped object
|
|
from being converted into a string when used to instantiate an OracleParam.
|
|
This can be used generally for any other object that should be passed into
|
|
Cursor.execute as-is.
|
|
"""
|
|
|
|
def __init__(self, var):
|
|
self.var = var
|
|
|
|
def bind_parameter(self, cursor):
|
|
return self.var
|
|
|
|
def __getattr__(self, key):
|
|
return getattr(self.var, key)
|
|
|
|
def __setattr__(self, key, value):
|
|
if key == 'var':
|
|
self.__dict__[key] = value
|
|
else:
|
|
setattr(self.var, key, value)
|
|
|
|
|
|
class FormatStylePlaceholderCursor(object):
|
|
"""
|
|
Django uses "format" (e.g. '%s') style placeholders, but Oracle uses ":var"
|
|
style. This fixes it -- but note that if you want to use a literal "%s" in
|
|
a query, you'll need to use "%%s".
|
|
|
|
We also do automatic conversion between Unicode on the Python side and
|
|
UTF-8 -- for talking to Oracle -- in here.
|
|
"""
|
|
charset = 'utf-8'
|
|
|
|
def __init__(self, connection):
|
|
self.cursor = connection.cursor()
|
|
# Necessary to retrieve decimal values without rounding error.
|
|
self.cursor.numbersAsStrings = True
|
|
# Default arraysize of 1 is highly sub-optimal.
|
|
self.cursor.arraysize = 100
|
|
|
|
def _format_params(self, params):
|
|
try:
|
|
return {k: OracleParam(v, self, True) for k, v in params.items()}
|
|
except AttributeError:
|
|
return tuple(OracleParam(p, self, True) for p in params)
|
|
|
|
def _guess_input_sizes(self, params_list):
|
|
# Try dict handling; if that fails, treat as sequence
|
|
if hasattr(params_list[0], 'keys'):
|
|
sizes = {}
|
|
for params in params_list:
|
|
for k, value in params.items():
|
|
if value.input_size:
|
|
sizes[k] = value.input_size
|
|
self.setinputsizes(**sizes)
|
|
else:
|
|
# It's not a list of dicts; it's a list of sequences
|
|
sizes = [None] * len(params_list[0])
|
|
for params in params_list:
|
|
for i, value in enumerate(params):
|
|
if value.input_size:
|
|
sizes[i] = value.input_size
|
|
self.setinputsizes(*sizes)
|
|
|
|
def _param_generator(self, params):
|
|
# Try dict handling; if that fails, treat as sequence
|
|
if hasattr(params, 'items'):
|
|
return {k: v.force_bytes for k, v in params.items()}
|
|
else:
|
|
return [p.force_bytes for p in params]
|
|
|
|
def _fix_for_params(self, query, params):
|
|
# cx_Oracle wants no trailing ';' for SQL statements. For PL/SQL, it
|
|
# it does want a trailing ';' but not a trailing '/'. However, these
|
|
# characters must be included in the original query in case the query
|
|
# is being passed to SQL*Plus.
|
|
if query.endswith(';') or query.endswith('/'):
|
|
query = query[:-1]
|
|
if params is None:
|
|
params = []
|
|
query = convert_unicode(query, self.charset)
|
|
elif hasattr(params, 'keys'):
|
|
# Handle params as dict
|
|
args = {k: ":%s" % k for k in params.keys()}
|
|
query = convert_unicode(query % args, self.charset)
|
|
else:
|
|
# Handle params as sequence
|
|
args = [(':arg%d' % i) for i in range(len(params))]
|
|
query = convert_unicode(query % tuple(args), self.charset)
|
|
return query, self._format_params(params)
|
|
|
|
def execute(self, query, params=None):
|
|
query, params = self._fix_for_params(query, params)
|
|
self._guess_input_sizes([params])
|
|
try:
|
|
return self.cursor.execute(query, self._param_generator(params))
|
|
except Database.DatabaseError as e:
|
|
# cx_Oracle <= 4.4.0 wrongly raises a DatabaseError for ORA-01400.
|
|
if hasattr(e.args[0], 'code') and e.args[0].code == 1400 and not isinstance(e, IntegrityError):
|
|
six.reraise(utils.IntegrityError, utils.IntegrityError(*tuple(e.args)), sys.exc_info()[2])
|
|
raise
|
|
|
|
def executemany(self, query, params=None):
|
|
if not params:
|
|
# No params given, nothing to do
|
|
return None
|
|
# uniform treatment for sequences and iterables
|
|
params_iter = iter(params)
|
|
query, firstparams = self._fix_for_params(query, next(params_iter))
|
|
# we build a list of formatted params; as we're going to traverse it
|
|
# more than once, we can't make it lazy by using a generator
|
|
formatted = [firstparams] + [self._format_params(p) for p in params_iter]
|
|
self._guess_input_sizes(formatted)
|
|
try:
|
|
return self.cursor.executemany(query,
|
|
[self._param_generator(p) for p in formatted])
|
|
except Database.DatabaseError as e:
|
|
# cx_Oracle <= 4.4.0 wrongly raises a DatabaseError for ORA-01400.
|
|
if hasattr(e.args[0], 'code') and e.args[0].code == 1400 and not isinstance(e, IntegrityError):
|
|
six.reraise(utils.IntegrityError, utils.IntegrityError(*tuple(e.args)), sys.exc_info()[2])
|
|
raise
|
|
|
|
def fetchone(self):
|
|
row = self.cursor.fetchone()
|
|
if row is None:
|
|
return row
|
|
return _rowfactory(row, self.cursor)
|
|
|
|
def fetchmany(self, size=None):
|
|
if size is None:
|
|
size = self.arraysize
|
|
return tuple(_rowfactory(r, self.cursor) for r in self.cursor.fetchmany(size))
|
|
|
|
def fetchall(self):
|
|
return tuple(_rowfactory(r, self.cursor) for r in self.cursor.fetchall())
|
|
|
|
def close(self):
|
|
try:
|
|
self.cursor.close()
|
|
except Database.InterfaceError:
|
|
# already closed
|
|
pass
|
|
|
|
def var(self, *args):
|
|
return VariableWrapper(self.cursor.var(*args))
|
|
|
|
def arrayvar(self, *args):
|
|
return VariableWrapper(self.cursor.arrayvar(*args))
|
|
|
|
def __getattr__(self, attr):
|
|
if attr in self.__dict__:
|
|
return self.__dict__[attr]
|
|
else:
|
|
return getattr(self.cursor, attr)
|
|
|
|
def __iter__(self):
|
|
return CursorIterator(self.cursor)
|
|
|
|
|
|
class CursorIterator(six.Iterator):
|
|
|
|
"""Cursor iterator wrapper that invokes our custom row factory."""
|
|
|
|
def __init__(self, cursor):
|
|
self.cursor = cursor
|
|
self.iter = iter(cursor)
|
|
|
|
def __iter__(self):
|
|
return self
|
|
|
|
def __next__(self):
|
|
return _rowfactory(next(self.iter), self.cursor)
|
|
|
|
|
|
def _rowfactory(row, cursor):
|
|
# Cast numeric values as the appropriate Python type based upon the
|
|
# cursor description, and convert strings to unicode.
|
|
casted = []
|
|
for value, desc in zip(row, cursor.description):
|
|
if value is not None and desc[1] is Database.NUMBER:
|
|
precision, scale = desc[4:6]
|
|
if scale == -127:
|
|
if precision == 0:
|
|
# NUMBER column: decimal-precision floating point
|
|
# This will normally be an integer from a sequence,
|
|
# but it could be a decimal value.
|
|
if '.' in value:
|
|
value = decimal.Decimal(value)
|
|
else:
|
|
value = int(value)
|
|
else:
|
|
# FLOAT column: binary-precision floating point.
|
|
# This comes from FloatField columns.
|
|
value = float(value)
|
|
elif precision > 0:
|
|
# NUMBER(p,s) column: decimal-precision fixed point.
|
|
# This comes from IntField and DecimalField columns.
|
|
if scale == 0:
|
|
value = int(value)
|
|
else:
|
|
value = decimal.Decimal(value)
|
|
elif '.' in value:
|
|
# No type information. This normally comes from a
|
|
# mathematical expression in the SELECT list. Guess int
|
|
# or Decimal based on whether it has a decimal point.
|
|
value = decimal.Decimal(value)
|
|
else:
|
|
value = int(value)
|
|
elif desc[1] in (Database.STRING, Database.FIXED_CHAR,
|
|
Database.LONG_STRING):
|
|
value = to_unicode(value)
|
|
casted.append(value)
|
|
return tuple(casted)
|
|
|
|
|
|
def to_unicode(s):
|
|
"""
|
|
Convert strings to Unicode objects (and return all other data types
|
|
unchanged).
|
|
"""
|
|
if isinstance(s, six.string_types):
|
|
return force_text(s)
|
|
return s
|