blinkster: comparison web/lib/django/db/backends/__init_

equal deleted inserted replaced

-:b758351d191f
+:cc9b7e14412b
-try:
+import decimal
-# Only exists in Python 2.4+
+from threading import local
-from threading import local
-except ImportError:
+from django.db import DEFAULT_DB_ALIAS
-# Import copy of _thread_local.py from Python 2.4
-from django.utils._threading_local import local
-try:
-set
-except NameError:
-# Python 2.3 compat
-from sets import Set as set
-try:
-import decimal
-except ImportError:
-# Python 2.3 fallback
-from django.utils import _decimal as decimal
 from django.db.backends import util
 from django.utils import datetime_safe
+from django.utils.importlib import import_module
 class BaseDatabaseWrapper(local):
 """
 Represents a database connection.
 """
 ops = None
-def __init__(self, settings_dict):
+def __init__(self, settings_dict, alias=DEFAULT_DB_ALIAS):
 # `settings_dict` should be a dictionary containing keys such as
-# DATABASE_NAME, DATABASE_USER, etc. It's called `settings_dict`
+# NAME, USER, etc. It's called `settings_dict` instead of `settings`
-# instead of `settings` to disambiguate it from Django settings
+# to disambiguate it from Django settings modules.
-# modules.
 self.connection = None
 self.queries = []
 self.settings_dict = settings_dict
+self.alias = alias
+def __eq__(self, other):
+return self.settings_dict == other.settings_dict
+def __ne__(self, other):
+return not self == other
 def _commit(self):
 if self.connection is not None:
 return self.connection.commit()
 class BaseDatabaseFeatures(object):
 allows_group_by_pk = False
 # True if django.db.backend.utils.typecast_timestamp is used on values
 # returned from dates() calls.
 needs_datetime_string_cast = True
-uses_custom_query_class = False
 empty_fetchmany_value = []
 update_can_self_select = True
 interprets_empty_strings_as_nulls = False
 can_use_chunked_reads = True
 can_return_id_from_insert = False
 uses_autocommit = False
 uses_savepoints = False
 # If True, don't use integer foreign keys referring to, e.g., positive
 # integer primary keys.
 related_fields_match_type = False
+allow_sliced_subqueries = True
 class BaseDatabaseOperations(object):
 """
 This class encapsulates all backend-specific differences, such as the way
 a backend performs ordering or calculates the ID of a recently-inserted
 row.
 """
+compiler_module = "django.db.models.sql.compiler"
+def __init__(self):
+self._cache = {}
 def autoinc_sql(self, table, column):
 """
 Returns any SQL needed to support auto-incrementing primary keys, or
 None if no SQL is necessary.
 according to their own quoting schemes.
 """
 from django.utils.encoding import smart_unicode, force_unicode
 # Convert params to contain Unicode values.
-to_unicode = lambda s: force_unicode(s, strings_only=True)
+to_unicode = lambda s: force_unicode(s, strings_only=True, errors='replace')
 if isinstance(params, (list, tuple)):
 u_params = tuple([to_unicode(val) for val in params])
 else:
 u_params = dict([(to_unicode(k), to_unicode(v)) for k, v in params.items()])
 append to the INSERT query. The returned fragment should
 contain a format string to hold the appropriate column.
 """
 pass
-def query_class(self, DefaultQueryClass):
+def compiler(self, compiler_name):
 """
-Given the default Query class, returns a custom Query class
+Returns the SQLCompiler class corresponding to the given name,
-to use for this backend. Returns None if a custom Query isn't used.
+in the namespace corresponding to the `compiler_module` attribute
-See also BaseDatabaseFeatures.uses_custom_query_class, which regulates
+on this backend.
-whether this method is called at all.
+"""
-"""
+if compiler_name not in self._cache:
-return None
+self._cache[compiler_name] = getattr(
+import_module(self.compiler_module), compiler_name
+)
+return self._cache[compiler_name]
 def quote_name(self, name):
 """
 Returns a quoted version of the given table, index or column name. Does
 not quote the given name if it's already been quoted.
 are in INSTALLED_APPS.
 If only_existing is True, the resulting list will only include the tables
 that actually exist in the database.
 """
-from django.db import models
+from django.db import models, router
 tables = set()
 for app in models.get_apps():
 for model in models.get_models(app):
 if not model._meta.managed:
+continue
+if not router.allow_syncdb(self.connection.alias, model):
 continue
 tables.add(model._meta.db_table)
 tables.update([f.m2m_db_table() for f in model._meta.local_many_to_many])
 if only_existing:
 tables = [t for t in tables if self.table_name_converter(t) in self.table_names()]
 return tables
 def installed_models(self, tables):
 "Returns a set of all models represented by the provided list of table names."
-from django.db import models
+from django.db import models, router
 all_models = []
 for app in models.get_apps():
 for model in models.get_models(app):
-all_models.append(model)
+if router.allow_syncdb(self.connection.alias, model):
+all_models.append(model)
 return set([m for m in all_models
 if self.table_name_converter(m._meta.db_table) in map(self.table_name_converter, tables)
 ])
 def sequence_list(self):
 "Returns a list of information about all DB sequences for all models in all apps."
-from django.db import models
+from django.db import models, router
 apps = models.get_apps()
 sequence_list = []
 for app in apps:
 for model in models.get_models(app):
 if not model._meta.managed:
+continue
+if not router.allow_syncdb(self.connection.alias, model):
 continue
 for f in model._meta.local_fields:
 if isinstance(f, models.AutoField):
 sequence_list.append({'table': model._meta.db_table, 'column': f.column})
 break # Only one AutoField is allowed per model, so don't bother continuing.
 class BaseDatabaseValidation(object):
 """
 This class encapsualtes all backend-specific model validation.
 """
+def __init__(self, connection):
+self.connection = connection
 def validate_field(self, errors, opts, f):
 "By default, there is no backend-specific validation"
 pass

changeset 29	cc9b7e14412b
parent 0	0d40e90630ef