if database['ENGINE'] == 'postgresql_psycopg2': full_engine = 'django.contrib.gis.db.backends.postgis' elif database['ENGINE'] == 'sqlite3': full_engine = 'django.contrib.gis.db.backends.spatialite' else: full_engine = 'django.contrib.gis.db.backends.%s' % database['ENGINE'] else: warnings.warn( "Short names for ENGINE in database configurations are deprecated. " "Prepend %s.ENGINE with 'django.db.backends.'" % alias, PendingDeprecationWarning ) full_engine = "django.db.backends.%s" % database['ENGINE'] database['ENGINE'] = full_engine connections = ConnectionHandler(settings.DATABASES) router = ConnectionRouter(settings.DATABASE_ROUTERS) # `connection`, `DatabaseError` and `IntegrityError` are convenient aliases # for backend bits. # DatabaseWrapper.__init__() takes a dictionary, not a settings module, so # we manually create the dictionary from the settings, passing only the # settings that the database backends care about. Note that TIME_ZONE is used # by the PostgreSQL backends. # we load all these up for backwards compatibility, you should use # connections['default'] instead. connection = connections[DEFAULT_DB_ALIAS] backend = load_backend(connection.settings_dict['ENGINE'])
from django.core import signals from django.db.utils import (DEFAULT_DB_ALIAS, DataError, OperationalError, IntegrityError, InternalError, ProgrammingError, NotSupportedError, DatabaseError, InterfaceError, Error, load_backend, ConnectionHandler, ConnectionRouter) from django.utils.functional import cached_property __all__ = [ 'backend', 'connection', 'connections', 'router', 'DatabaseError', 'IntegrityError', 'InternalError', 'ProgrammingError', 'DataError', 'NotSupportedError', 'Error', 'InterfaceError', 'OperationalError', 'DEFAULT_DB_ALIAS' ] connections = ConnectionHandler() router = ConnectionRouter() # `connection`, `DatabaseError` and `IntegrityError` are convenient aliases # for backend bits. # DatabaseWrapper.__init__() takes a dictionary, not a settings module, so # we manually create the dictionary from the settings, passing only the # settings that the database backends care about. Note that TIME_ZONE is used # by the PostgreSQL backends. # We load all these up for backwards compatibility, you should use # connections['default'] instead. class DefaultConnectionProxy(object): """
from django.db.utils import ConnectionHandler from django.test import SimpleTestCase, TestCase, TransactionTestCase from django_mysql.management.commands.fix_datetime_columns import ( parse_create_table, ) from django_mysql.utils import connection_is_mariadb # Can't use @override_settings to swap out DATABASES, instead just mock.patch # a new ConnectionHandler into the command module command_connections = ( 'django_mysql.management.commands.fix_datetime_columns.connections') sqlite = ConnectionHandler({ 'default': { 'ENGINE': 'django.db.backends.sqlite3' }, }) def run_it(*args, **kwargs): run_args = ['fix_datetime_columns'] run_args.extend(args) out = StringIO() run_kwargs = {'stdout': out, 'skip_checks': True} run_kwargs.update(kwargs) call_command(*run_args, **run_kwargs) return out.getvalue()
def handle_inspection(self, options): dbs = copy.copy(settings.DATABASES) dbs['brapischemadbfile'] = {'ENGINE': 'django.db.backends.sqlite3', 'NAME': options['dbfile']} conns = ConnectionHandler(dbs) connection = conns['brapischemadbfile'] # connection = connections[options['database']] # 'table_name_filter' is a stealth option table_name_filter = options.get('table_name_filter') def table2model(table_name): return re.sub(r'[^a-zA-Z0-9]', '', table_name.title()) def strip_prefix(s): return s[1:] if s.startswith("u'") else s with connection.cursor() as cursor: yield "# This is an auto-generated Django model module." yield "# You'll have to do the following manually to clean this up:" yield "# * Rearrange models' order" yield "# * Make sure each model has one field with primary_key=True" yield "# * Make sure each ForeignKey has `on_delete` set to the desired behavior." yield ( "# * Remove `managed = False` lines if you wish to allow " "Django to create, modify, and delete the table" ) yield "# Feel free to rename the models, but don't rename db_table values or field names." yield "from __future__ import unicode_literals" yield '' yield 'from %s import models' % self.db_module known_models = [] tables_to_introspect = options['table'] or connection.introspection.table_names(cursor) for table_name in tables_to_introspect: if table_name_filter is not None and callable(table_name_filter): if not table_name_filter(table_name): continue try: try: relations = connection.introspection.get_relations(cursor, table_name) except NotImplementedError: relations = {} try: constraints = connection.introspection.get_constraints(cursor, table_name) except NotImplementedError: constraints = {} primary_key_column = connection.introspection.get_primary_key_column(cursor, table_name) unique_columns = [ c['columns'][0] for c in constraints.values() if c['unique'] and len(c['columns']) == 1 ] table_description = connection.introspection.get_table_description(cursor, table_name) except Exception as e: yield "# Unable to inspect table '%s'" % table_name yield "# The error was: %s" % force_text(e) continue yield '' yield '' yield 'class %s(models.Model):' % table2model(table_name) known_models.append(table2model(table_name)) used_column_names = [] # Holds column names used in the table so far column_to_field_name = {} # Maps column names to names of model fields for row in table_description: comment_notes = [] # Holds Field notes, to be displayed in a Python comment. extra_params = OrderedDict() # Holds Field parameters such as 'db_column'. column_name = row[0] is_relation = column_name in relations att_name, params, notes = self.normalize_col_name( column_name, used_column_names, is_relation) extra_params.update(params) comment_notes.extend(notes) used_column_names.append(att_name) column_to_field_name[column_name] = att_name # Add primary_key and unique, if necessary. # print (('------>', column_name, primary_key_column)) if column_name == primary_key_column or ('dbid' in column_name.lower() and column_name.lower().replace('dbid', '') == table_name.lower()) or column_name == 'id': extra_params['primary_key'] = True # extra_params['unique'] = True # extra_params['blank'] = True # print (('--->',column_name)) elif column_name in unique_columns: extra_params['unique'] = True if is_relation: rel_to = ( "self" if relations[column_name][1] == table_name else table2model(relations[column_name][1]) ) if rel_to in known_models: field_type = "ForeignKey('%s', on_delete=models.CASCADE" % rel_to else: field_type = "ForeignKey('%s', on_delete=models.CASCADE" % rel_to else: # Calling `get_field_type` to get the field type string and any # additional parameters and notes. field_type, field_params, field_notes = self.get_field_type(connection, table_name, row) extra_params.update(field_params) comment_notes.extend(field_notes) field_type += '(' # Don't output 'id = meta.AutoField(primary_key=True)', because # that's assumed if it doesn't exist. if att_name == 'id' and extra_params == {'primary_key': True}: if field_type == 'AutoField(': continue elif field_type == 'IntegerField(' and not connection.features.can_introspect_autofield: comment_notes.append('AutoField?') # Add 'null' and 'blank', if the 'null_ok' flag was present in the # table description. if row[6]: # If it's NULL... if field_type == 'BooleanField(': field_type = 'NullBooleanField(' else: if not field_type.startswith('ForeignKey'): extra_params['blank'] = True # extra_params['null'] = True field_desc = '%s = %s%s' % ( att_name, # Custom fields will have a dotted path '' if '.' in field_type else 'models.', field_type, ) # if field_type.startswith('ForeignKey('): # field_desc += ', models.DO_NOTHING' extra_params['verbose_name'] = ' ' + column_name # add one initial space to avoid capitalization in admin UI if extra_params: if not field_desc.endswith('('): field_desc += ', ' field_desc += ', '.join( '%s=%s' % (k, strip_prefix(repr(v))) for k, v in extra_params.items()) field_desc += ')' if comment_notes: field_desc += ' # ' + ' '.join(comment_notes) yield ' %s' % field_desc for meta_line in self.get_meta(table_name, constraints, column_to_field_name): yield meta_line
def override_database_connections(databases): with mock.patch('analyticsdataserver.views.connections', ConnectionHandler(databases)): yield
def setUp(self): super(DBTestSettingsRenamedTests, self).setUp() self.handler = ConnectionHandler() self.db_settings = {'default': {}}
from django.core.management import CommandError, call_command from django.db import connection from django.db.utils import ConnectionHandler from django.test import SimpleTestCase, TestCase, TransactionTestCase from django_mysql.management.commands.fix_datetime_columns import parse_create_table from django_mysql.utils import connection_is_mariadb # Can't use @override_settings to swap out DATABASES, instead just mock.patch # a new ConnectionHandler into the command module command_connections = ( "django_mysql.management.commands.fix_datetime_columns.connections") sqlite = ConnectionHandler( {"default": { "ENGINE": "django.db.backends.sqlite3" }}) def run_it(*args, **kwargs): run_args = ["fix_datetime_columns"] run_args.extend(args) out = StringIO() run_kwargs = {"stdout": out, "skip_checks": True} run_kwargs.update(kwargs) call_command(*run_args, **run_kwargs) return out.getvalue()
def test_no_default_database(self): DATABASES = {"other": {}} conns = ConnectionHandler(DATABASES) msg = "You must define a 'default' database." with self.assertRaisesMessage(ImproperlyConfigured, msg): conns["other"].ensure_connection()
def reload_settings(settings, databases=None): """Special routine to reload django settings. Including: urlconf module, context processor, templatetags settings, database settings. """ if databases: settings.DATABASES.update(databases) # check if there's settings to reload if hasattr(settings, 'ROOT_URLCONF'): if settings.ROOT_URLCONF in sys.modules: imp.reload(sys.modules[settings.ROOT_URLCONF]) import django if hasattr(django, 'setup'): django.setup() import_module(settings.ROOT_URLCONF) set_urlconf(settings.ROOT_URLCONF) settings.LANGUAGE_CODE = 'en' # all tests should be run with English by default # Make the ConnectionHandler use the new settings, otherwise the ConnectionHandler will have old configuraton. from django.db.utils import ConnectionHandler import django.db from django.db.utils import load_backend import django.db.transaction import django.db.models import django.db.models.sql.query import django.core.management.commands.syncdb import django.db.models.sql.compiler import django.db.backends import django.db.backends.mysql.base import django.core.management.commands.loaddata # all modules which imported django.db.connections should be changed to get new ConnectionHanlder django.db.models.sql.compiler.connections = django.db.models.connections = \ django.core.management.commands.loaddata.connections = \ django.db.backends.connections = django.db.backends.mysql.base.connections = \ django.core.management.commands.syncdb.connections = django.db.transaction.connections = \ django.db.connections = django.db.models.base.connections = django.db.models.sql.query.connections = \ ConnectionHandler(settings.DATABASES) # default django connection and backend should be also changed django.db.connection = django.db.connections[ django.db.DEFAULT_DB_ALIAS] django.db.backend = load_backend( django.db.connection.settings_dict['ENGINE']) import django.core.cache django.core.cache.cache = django.core.cache._create_cache( django.core.cache.DEFAULT_CACHE_ALIAS) # clear django urls cache clear_url_caches() # clear django contextprocessors cache context._standard_context_processors = None # clear django templatetags cache base.templatetags_modules = None # reload translation files imp.reload(translation) imp.reload(trans_real) # clear django template loaders cache loader.template_source_loaders = None from django.template.loaders import app_directories imp.reload(app_directories) from django.template.base import get_templatetags_modules get_templatetags_modules.cache_clear() import django.apps import django import django.template django.template.engines.__dict__.pop('templates', None) django.template.engines._templates = None django.template.engines._engines = {} if django.apps.apps.ready: django.apps.apps.set_installed_apps(settings.INSTALLED_APPS) django.setup()