Context Navigation

Back to Ticket #4747

Ticket #4747: mymultidb_trunk7534_20080520.2.diff

File mymultidb_trunk7534_20080520.2.diff, 139.8 KB (added by Koen Biermans <koen.biermans@…>, 9 years ago)
effort to get multidb into trunk r7534

Line
1	=== django/test/simple.py
2	==================================================================
3	--- django/test/simple.py (/mirror/django/trunk) (revision 5420)
4
5	+++ django/test/simple.py (/local/django/mymultidb) (revision 5420)
6
7	@@ -138,10 +138,11 @@
8
9	for test in extra_tests:
10	suite.addTest(test)
11
12	- old_name = settings.DATABASE_NAME
13	+ old_database_name = settings.DATABASE_NAME
14	+ old_other_databases = settings.OTHER_DATABASES
15	create_test_db(verbosity, autoclobber=not interactive)
16	result = unittest.TextTestRunner(verbosity=verbosity).run(suite)
17	- destroy_test_db(old_name, verbosity)
18	+ destroy_test_db(old_database_name, old_other_databases, verbosity)
19
20	teardown_test_environment()
21
22	=== django/test/utils.py
23	==================================================================
24	--- django/test/utils.py (/mirror/django/trunk) (revision 5420)
25
26	+++ django/test/utils.py (/local/django/mymultidb) (revision 5420)
27
28	@@ -1,6 +1,6 @@
29
30	import sys, time, os
31	-from django.conf import settings
32	-from django.db import connection, get_creation_module
33	+from django.conf import settings, UserSettingsHolder
34	+from django.db import connections, get_creation_module, _default
35	from django.core import mail
36	from django.core.management import call_command
37	from django.dispatch import dispatcher
38	@@ -78,27 +78,74 @@
39
40	elif hasattr(connection.connection, "set_isolation_level"):
41	connection.connection.set_isolation_level(0)
42
43	-def get_mysql_create_suffix():
44	+def get_mysql_create_suffix(settings):
45	suffix = []
46	- if settings.TEST_DATABASE_CHARSET:
47	- suffix.append('CHARACTER SET %s' % settings.TEST_DATABASE_CHARSET)
48	- if settings.TEST_DATABASE_COLLATION:
49	- suffix.append('COLLATE %s' % settings.TEST_DATABASE_COLLATION)
50	+ if settings.DATABASE_CHARSET:
51	+ suffix.append('CHARACTER SET %s' % settings.DATABASE_CHARSET)
52	+ if settings.DATABASE_COLLATION:
53	+ suffix.append('COLLATE %s' % settings.DATABASE_COLLATION)
54	return ' '.join(suffix)
55
56	def get_postgresql_create_suffix():
57	- assert settings.TEST_DATABASE_COLLATION is None, "PostgreSQL does not support collation setting at database creation time."
58	- if settings.TEST_DATABASE_CHARSET:
59	- return "WITH ENCODING '%s'" % settings.TEST_DATABASE_CHARSET
60	+ assert settings.DATABASE_COLLATION is None, "PostgreSQL does not support collation setting at database creation time."
61	+ if settings.DATABASE_CHARSET:
62	+ return "WITH ENCODING '%s'" % settings.DATABASE_CHARSET
63	return ''
64
65	def create_test_db(verbosity=1, autoclobber=False):
66	+
67	+ if settings.DATABASE_ENGINE == "sqlite3":
68	+ if settings.TEST_DATABASE_NAME and settings.TEST_DATABASE_NAME != ":memory:":
69	+ TEST_DATABASE_NAME = settings.TEST_DATABASE_NAME
70	+ else:
71	+ TEST_DATABASE_NAME = ":memory:"
72	+ else:
73	+ if settings.TEST_DATABASE_NAME:
74	+ TEST_DATABASE_NAME = settings.TEST_DATABASE_NAME
75	+ else:
76	+ TEST_DATABASE_NAME = TEST_DATABASE_PREFIX + settings.DATABASE_NAME
77	+
78	+ settings.DATABASE_NAME = TEST_DATABASE_NAME
79	+ settings.DATABASE_CHARSET = settings.TEST_DATABASE_CHARSET
80	+ settings.DATABASE_COLLATION = settings.TEST_DATABASE_COLLATION
81	+
82	+ # default database
83	+ _create_test_db(settings, verbosity=verbosity, autoclobber=autoclobber)
84	+
85	+ # other databases
86	+ settings.OTHER_DATABASES = settings.TEST_OTHER_DATABASES
87	+ for db in settings.OTHER_DATABASES:
88	+ info = settings.OTHER_DATABASES[db]
89	+ database = UserSettingsHolder(settings)
90	+ for k, v in info.items():
91	+ setattr(database, k, v)
92	+ _create_test_db(database, verbosity=verbosity, autoclobber=autoclobber, connection_name=db)
93	+
94	+## for cnx in connections:
95	+## connections[cnx].connection.close()
96	+
97	+ call_command('syncdb', verbosity=verbosity, interactive=False)
98	+
99	+ if settings.CACHE_BACKEND.startswith('db://'):
100	+ cache_name = settings.CACHE_BACKEND[len('db://'):]
101	+ call_command('createcachetable', cache_name)
102	+
103	+ # Get a cursor (even though we don't need one yet). This has
104	+ # the side effect of initializing the test database.
105	+## for cnx in connections:
106	+## cursor = connections[cnx].connection.cursor()
107	+## cursor = connection.cursor()
108	+
109	+ return TEST_DATABASE_NAME
110	+
111	+def _create_test_db(settings, verbosity=1, autoclobber=False, connection_name=_default):
112	"""
113	Creates a test database, prompting the user for confirmation if the
114	database already exists. Returns the name of the test database created.
115	"""
116	+ connection = connections[connection_name].connection
117	# If the database backend wants to create the test DB itself, let it
118	- creation_module = get_creation_module()
119	+ creation_module = connections[connection_name].get_creation_module()
120	if hasattr(creation_module, "create_test_db"):
121	creation_module.create_test_db(settings, connection, verbosity, autoclobber)
122	return
123	@@ -109,19 +156,18 @@
124
125	# in-memory database. Using the TEST_DATABASE_NAME setting you can still choose
126	# to run on a physical database.
127	if settings.DATABASE_ENGINE == "sqlite3":
128	- if settings.TEST_DATABASE_NAME and settings.TEST_DATABASE_NAME != ":memory:":
129	- TEST_DATABASE_NAME = settings.TEST_DATABASE_NAME
130	+ if settings.DATABASE_NAME != ":memory:":
131	# Erase the old test database
132	if verbosity >= 1:
133	print "Destroying old test database..."
134	- if os.access(TEST_DATABASE_NAME, os.F_OK):
135	+ if os.access(settings.DATABASE_NAME, os.F_OK):
136	if not autoclobber:
137	- confirm = raw_input("Type 'yes' if you would like to try deleting the test database '%s', or 'no' to cancel: " % TEST_DATABASE_NAME)
138	+ confirm = raw_input("Type 'yes' if you would like to try deleting the test database '%s', or 'no' to cancel: " % settings.DATABASE_NAME)
139	if autoclobber or confirm == 'yes':
140	try:
141	if verbosity >= 1:
142	print "Destroying old test database..."
143	- os.remove(TEST_DATABASE_NAME)
144	+ os.remove(settings.DATABASE_NAME)
145	except Exception, e:
146	sys.stderr.write("Got an error deleting the old test database: %s\n" % e)
147	sys.exit(2)
148	@@ -130,20 +176,15 @@
149
150	sys.exit(1)
151	if verbosity >= 1:
152	print "Creating test database..."
153	- else:
154	- TEST_DATABASE_NAME = ":memory:"
155	else:
156	suffix = {
157	'postgresql': get_postgresql_create_suffix,
158	'postgresql_psycopg2': get_postgresql_create_suffix,
159	'mysql': get_mysql_create_suffix,
160	'mysql_old': get_mysql_create_suffix,
161	- }.get(settings.DATABASE_ENGINE, lambda: '')()
162	- if settings.TEST_DATABASE_NAME:
163	- TEST_DATABASE_NAME = settings.TEST_DATABASE_NAME
164	- else:
165	- TEST_DATABASE_NAME = TEST_DATABASE_PREFIX + settings.DATABASE_NAME
166	+ }.get(settings.DATABASE_ENGINE, lambda: '')(settings)
167
168	+ connection = connections[connection_name].connection
169	qn = connection.ops.quote_name
170
171	# Create the test database and connect to it. We need to autocommit
172	@@ -172,37 +213,40 @@
173
174	print "Tests cancelled."
175	sys.exit(1)
176
177	- connection.close()
178	- settings.DATABASE_NAME = TEST_DATABASE_NAME
179
180	- call_command('syncdb', verbosity=verbosity, interactive=False)
181	+def destroy_test_db(old_database_name, old_databases, verbosity=1):
182	+ if verbosity >= 1:
183	+ print "Destroying test database(s)..."
184	+## connection.close()
185	+ for cnx in connections.keys():
186	+ connections[cnx].close()
187	+## connections.reset()
188	+ TEST_DATABASE_NAME = settings.DATABASE_NAME
189	+ settings.DATABASE_NAME = old_database_name
190	+ _destroy_test_db(settings, TEST_DATABASE_NAME, verbosity=verbosity)
191	+ TEST_OTHER_DATABASES = settings.OTHER_DATABASES
192	+ settings.OTHER_DATABASES = old_databases
193	+ for db in TEST_OTHER_DATABASES:
194	+ info = TEST_OTHER_DATABASES[db]
195	+ database = UserSettingsHolder(settings)
196	+ for k, v in info.items():
197	+ setattr(database, k, v)
198	+ if db in old_databases:
199	+ _destroy_test_db(database, info['DATABASE_NAME'], verbosity=verbosity, connection_name=db)
200
201	- if settings.CACHE_BACKEND.startswith('db://'):
202	- cache_name = settings.CACHE_BACKEND[len('db://'):]
203	- call_command('createcachetable', cache_name)
204	-
205	- # Get a cursor (even though we don't need one yet). This has
206	- # the side effect of initializing the test database.
207	- cursor = connection.cursor()
208	-
209	- return TEST_DATABASE_NAME
210	-
211	-def destroy_test_db(old_database_name, verbosity=1):
212	+def _destroy_test_db(settings, TEST_DATABASE_NAME, verbosity=1, connection_name=_default):
213	+ connection = connections[connection_name].connection
214	# If the database wants to drop the test DB itself, let it
215	- creation_module = get_creation_module()
216	+ creation_module = connections[connection_name].get_creation_module()
217	if hasattr(creation_module, "destroy_test_db"):
218	creation_module.destroy_test_db(settings, connection, old_database_name, verbosity)
219	return
220
221	- if verbosity >= 1:
222	- print "Destroying test database..."
223	- connection.close()
224	- TEST_DATABASE_NAME = settings.DATABASE_NAME
225	- settings.DATABASE_NAME = old_database_name
226	if settings.DATABASE_ENGINE == "sqlite3":
227	if TEST_DATABASE_NAME and TEST_DATABASE_NAME != ":memory:":
228	# Remove the SQLite database file
229	- os.remove(TEST_DATABASE_NAME)
230	+## os.remove(TEST_DATABASE_NAME)
231	+ pass
232	else:
233	# Remove the test database to clean up after
234	# ourselves. Connect to the previous database (not the test database)
235	=== django/db/models/sql/where.py
236	==================================================================
237	--- django/db/models/sql/where.py (/mirror/django/trunk) (revision 5420)
238
239	+++ django/db/models/sql/where.py (/local/django/mymultidb) (revision 5420)
240
241	@@ -4,11 +4,12 @@
242
243	import datetime
244
245	from django.utils import tree
246	-from django.db import connection
247	from django.db.models.fields import Field
248	from django.db.models.query_utils import QueryWrapper
249	from datastructures import EmptyResultSet, FullResultSet
250
251	+from copy import deepcopy
252	+
253	# Connection types
254	AND = 'AND'
255	OR = 'OR'
256	@@ -26,6 +27,20 @@
257
258	"""
259	default = AND
260
261	+ def __init__(self, connection, args, *kwargs):
262	+ self.connection = connection
263	+ super(WhereNode, self).__init__(args, *kwargs)
264	+
265	+ def __deepcopy__(self, memo):
266	+ x = WhereNode.__new__(WhereNode)
267	+ memo[id(self)] = x
268	+ for n, v in self.__dict__.iteritems():
269	+ if n != 'connection':
270	+ setattr(x, n, deepcopy(v, memo))
271	+ else:
272	+ setattr(x, n, self.connection)
273	+ return x
274	+
275	def as_sql(self, node=None, qn=None):
276	"""
277	Returns the SQL version of the where clause and the value to be
278	@@ -38,7 +53,7 @@
279
280	if node is None:
281	node = self
282	if not qn:
283	- qn = connection.ops.quote_name
284	+ qn = self.connection.ops.quote_name
285	if not node.children:
286	return None, []
287	result = []
288	@@ -99,11 +114,12 @@
289
290	lhs = '%s.%s' % (qn(table_alias), qn(name))
291	else:
292	lhs = qn(name)
293	- db_type = field and field.db_type() or None
294	- field_sql = connection.ops.field_cast_sql(db_type) % lhs
295
296	+ db_type = field and field.db_type(self.connection.connection_name) or None
297	+ field_sql = self.connection.ops.field_cast_sql(db_type) % lhs
298	+
299	if isinstance(value, datetime.datetime):
300	- cast_sql = connection.ops.datetime_cast_sql()
301	+ cast_sql = self.connection.ops.datetime_cast_sql()
302	else:
303	cast_sql = '%s'
304
305	@@ -116,11 +132,11 @@
306
307	else:
308	extra = ''
309
310	- if lookup_type in connection.operators:
311	- format = "%s %%s %s" % (connection.ops.lookup_cast(lookup_type),
312	+ if lookup_type in self.connection.operators:
313	+ format = "%s %%s %s" % (self.connection.ops.lookup_cast(lookup_type),
314	extra)
315	return (format % (field_sql,
316	- connection.operators[lookup_type] % cast_sql), params)
317	+ self.connection.operators[lookup_type] % cast_sql), params)
318
319	if lookup_type == 'in':
320	if not value:
321	@@ -132,15 +148,15 @@
322
323	elif lookup_type in ('range', 'year'):
324	return ('%s BETWEEN %%s and %%s' % field_sql, params)
325	elif lookup_type in ('month', 'day'):
326	- return ('%s = %%s' % connection.ops.date_extract_sql(lookup_type,
327	+ return ('%s = %%s' % self.connection.ops.date_extract_sql(lookup_type,
328	field_sql), params)
329	elif lookup_type == 'isnull':
330	return ('%s IS %sNULL' % (field_sql, (not value and 'NOT ' or '')),
331	params)
332	elif lookup_type == 'search':
333	- return (connection.ops.fulltext_search_sql(field_sql), params)
334	+ return (self.connection.ops.fulltext_search_sql(field_sql), params)
335	elif lookup_type in ('regex', 'iregex'):
336	- return connection.ops.regex_lookup(lookup_type) % (field_sql, cast_sql), params
337	+ return self.connection.ops.regex_lookup(lookup_type) % (field_sql, cast_sql), params
338
339	raise TypeError('Invalid lookup_type: %r' % lookup_type)
340
341	=== django/db/models/sql/query.py
342	==================================================================
343	--- django/db/models/sql/query.py (/mirror/django/trunk) (revision 5420)
344
345	+++ django/db/models/sql/query.py (/local/django/mymultidb) (revision 5420)
346
347	@@ -60,7 +60,7 @@
348
349	# SQL-related attributes
350	self.select = []
351	self.tables = [] # Aliases in the order they are created.
352	- self.where = where()
353	+ self.where = where(self.connection)
354	self.where_class = where
355	self.group_by = []
356	self.having = []
357	@@ -215,7 +215,7 @@
358
359	obj.related_select_cols = []
360	obj.related_select_fields = []
361	if obj.distinct and len(obj.select) > 1:
362	- obj = self.clone(CountQuery, _query=obj, where=self.where_class(),
363	+ obj = self.clone(CountQuery, _query=obj, where=self.where_class(self.connection),
364	distinct=False)
365	obj.select = []
366	obj.extra_select = {}
367	@@ -346,10 +346,10 @@
368
369	self.where.add(EverythingNode(), AND)
370	elif self.where:
371	# rhs has an empty where clause.
372	- w = self.where_class()
373	+ w = self.where_class(self.connection)
374	w.add(EverythingNode(), AND)
375	else:
376	- w = self.where_class()
377	+ w = self.where_class(self.connection)
378	self.where.add(w, connector)
379
380	# Selection columns and extra extensions are those provided by 'rhs'.
381	=== django/db/models/sql/subqueries.py
382	==================================================================
383	--- django/db/models/sql/subqueries.py (/mirror/django/trunk) (revision 5420)
384
385	+++ django/db/models/sql/subqueries.py (/local/django/mymultidb) (revision 5420)
386
387	@@ -47,7 +47,7 @@
388
389	for related in cls._meta.get_all_related_many_to_many_objects():
390	if not isinstance(related.field, generic.GenericRelation):
391	for offset in range(0, len(pk_list), GET_ITERATOR_CHUNK_SIZE):
392	- where = self.where_class()
393	+ where = self.where_class(self.connection)
394	where.add((None, related.field.m2m_reverse_name(),
395	related.field, 'in',
396	pk_list[offset : offset+GET_ITERATOR_CHUNK_SIZE]),
397	@@ -55,14 +55,14 @@
398
399	self.do_query(related.field.m2m_db_table(), where)
400
401	for f in cls._meta.many_to_many:
402	- w1 = self.where_class()
403	+ w1 = self.where_class(self.connection)
404	if isinstance(f, generic.GenericRelation):
405	from django.contrib.contenttypes.models import ContentType
406	field = f.rel.to._meta.get_field(f.content_type_field_name)
407	w1.add((None, field.column, field, 'exact',
408	ContentType.objects.get_for_model(cls).id), AND)
409	for offset in range(0, len(pk_list), GET_ITERATOR_CHUNK_SIZE):
410	- where = self.where_class()
411	+ where = self.where_class(self.connection)
412	where.add((None, f.m2m_column_name(), f, 'in',
413	pk_list[offset : offset + GET_ITERATOR_CHUNK_SIZE]),
414	AND)
415	@@ -79,7 +79,7 @@
416
417	lot of values in pk_list.
418	"""
419	for offset in range(0, len(pk_list), GET_ITERATOR_CHUNK_SIZE):
420	- where = self.where_class()
421	+ where = self.where_class(self.connection)
422	field = self.model._meta.pk
423	where.add((None, field.column, field, 'in',
424	pk_list[offset : offset + GET_ITERATOR_CHUNK_SIZE]), AND)
425	@@ -178,7 +178,7 @@
426
427
428	# Now we adjust the current query: reset the where clause and get rid
429	# of all the tables we don't need (since they're in the sub-select).
430	- self.where = self.where_class()
431	+ self.where = self.where_class(self.connection)
432	if self.related_updates or must_pre_select:
433	# Either we're using the idents in multiple update queries (so
434	# don't want them to change), or the db backend doesn't support
435	@@ -202,7 +202,7 @@
436
437	This is used by the QuerySet.delete_objects() method.
438	"""
439	for offset in range(0, len(pk_list), GET_ITERATOR_CHUNK_SIZE):
440	- self.where = self.where_class()
441	+ self.where = self.where_class(self.connection)
442	f = self.model._meta.pk
443	self.where.add((None, f.column, f, 'in',
444	pk_list[offset : offset + GET_ITERATOR_CHUNK_SIZE]),
445	=== django/db/models/base.py
446	==================================================================
447	--- django/db/models/base.py (/mirror/django/trunk) (revision 5420)
448
449	+++ django/db/models/base.py (/local/django/mymultidb) (revision 5420)
450
451	@@ -12,7 +12,7 @@
452
453	from django.db.models.fields.related import OneToOneRel, ManyToOneRel, OneToOneField
454	from django.db.models.query import delete_objects, Q
455	from django.db.models.options import Options, AdminOptions
456	-from django.db import connection, transaction
457	+from django.db import transaction
458	from django.db.models import signals
459	from django.db.models.loading import register_models, get_model
460	from django.dispatch import dispatcher
461	@@ -329,7 +329,7 @@
462
463	result = manager._insert(values, return_id=update_pk)
464	else:
465	# Create a new record with defaults for everything.
466	- result = manager._insert([(meta.pk, connection.ops.pk_default_value())], return_id=update_pk, raw_values=True)
467	+ result = manager._insert([(meta.pk, manager.db.connection.ops.pk_default_value())], return_id=update_pk, raw_values=True)
468
469	if update_pk:
470	setattr(self, meta.pk.attname, result)
471	@@ -419,7 +419,7 @@
472
473	def _get_next_or_previous_in_order(self, is_next):
474	cachename = "__%s_order_cache" % is_next
475	if not hasattr(self, cachename):
476	- qn = connection.ops.quote_name
477	+ qn = self._default_manager.db.connection.ops.quote_name
478	op = is_next and '>' or '<'
479	order = not is_next and '-_order' or '_order'
480	order_field = self._meta.order_with_respect_to
481	=== django/db/models/manager.py
482	==================================================================
483	--- django/db/models/manager.py (/mirror/django/trunk) (revision 5420)
484
485	+++ django/db/models/manager.py (/local/django/mymultidb) (revision 5420)
486
487	@@ -1,8 +1,9 @@
488
489	import copy
490
491	from django.db.models.query import QuerySet, EmptyQuerySet, insert_query
492	+from django.db import ConnectionInfoDescriptor
493	from django.dispatch import dispatcher
494	-from django.db.models import signals
495	+from django.db.models import signals, get_apps, get_models
496	from django.db.models.fields import FieldDoesNotExist
497
498	def ensure_default_manager(sender):
499	@@ -22,6 +23,8 @@
500
501	# Tracks each time a Manager instance is created. Used to retain order.
502	creation_counter = 0
503
504	+ db = ConnectionInfoDescriptor()
505	+
506	def __init__(self):
507	super(Manager, self).__init__()
508	# Increase the creation counter, and save our local copy.
509	=== django/db/models/options.py
510	==================================================================
511	--- django/db/models/options.py (/mirror/django/trunk) (revision 5420)
512
513	+++ django/db/models/options.py (/local/django/mymultidb) (revision 5420)
514
515	@@ -53,6 +53,8 @@
516
517	self.module_name = self.object_name.lower()
518	self.verbose_name = get_verbose_name(self.object_name)
519
520	+ self.model = cls
521	+
522	# Next, apply any overridden values from 'class Meta'.
523	if self.meta:
524	meta_attrs = self.meta.__dict__.copy()
525	@@ -84,8 +86,8 @@
526
527	del self.meta
528
529	def _prepare(self, model):
530	- from django.db import connection
531	from django.db.backends.util import truncate_name
532	+ from django.db import connections, connection_name_app_model
533	if self.order_with_respect_to:
534	self.order_with_respect_to = self.get_field(self.order_with_respect_to)
535	self.ordering = ('_order',)
536	@@ -107,7 +109,8 @@
537
538	# If the db_table wasn't provided, use the app_label + module_name.
539	if not self.db_table:
540	self.db_table = "%s_%s" % (self.app_label, self.module_name)
541	- self.db_table = truncate_name(self.db_table, connection.ops.max_name_length())
542	+ connection_name = connection_name_app_model(self.app_label, self.object_name)
543	+ self.db_table = truncate_name(self.db_table, connections[connection_name].connection.ops.max_name_length())
544
545	def add_field(self, field):
546	# Insert the given field in the order in which it was created, using
547	=== django/db/models/__init__.py
548	==================================================================
549	--- django/db/models/__init__.py (/mirror/django/trunk) (revision 5420)
550
551	+++ django/db/models/__init__.py (/local/django/mymultidb) (revision 5420)
552
553	@@ -1,7 +1,6 @@
554
555	from django.conf import settings
556	from django.core.exceptions import ObjectDoesNotExist, ImproperlyConfigured
557	from django.core import validators
558	-from django.db import connection
559	from django.db.models.loading import get_apps, get_app, get_models, get_model, register_models
560	from django.db.models.query import Q
561	from django.db.models.manager import Manager
562	=== django/db/models/fields/__init__.py
563	==================================================================
564	--- django/db/models/fields/__init__.py (/mirror/django/trunk) (revision 5420)
565
566	+++ django/db/models/fields/__init__.py (/local/django/mymultidb) (revision 5420)
567
568	@@ -7,7 +7,7 @@
569
570	except ImportError:
571	from django.utils import _decimal as decimal # for Python 2.3
572
573	-from django.db import get_creation_module
574	+from django.db import connections
575	from django.db.models import signals
576	from django.db.models.query_utils import QueryWrapper
577	from django.dispatch import dispatcher
578	@@ -144,7 +144,7 @@
579
580	"""
581	return value
582
583	- def db_type(self):
584	+ def db_type(self, connection):
585	"""
586	Returns the database column data type for this field, taking into
587	account the DATABASE_ENGINE setting.
588	@@ -165,7 +165,7 @@
589
590	# can implement db_type() instead of get_internal_type() to specify
591	# exactly which wacky database column type you want to use.
592	try:
593	- return get_creation_module().DATA_TYPES[self.get_internal_type()] % self.__dict__
594	+ return connections[connection].get_creation_module().DATA_TYPES[self.get_internal_type()] % self.__dict__
595	except KeyError:
596	return None
597
598	=== django/db/models/fields/related.py
599	==================================================================
600	--- django/db/models/fields/related.py (/mirror/django/trunk) (revision 5420)
601
602	+++ django/db/models/fields/related.py (/local/django/mymultidb) (revision 5420)
603
604	@@ -1,4 +1,4 @@
605
606	-from django.db import connection, transaction
607	+from django.db import transaction
608	from django.db.models import signals, get_model
609	from django.db.models.fields import AutoField, Field, IntegerField, PositiveIntegerField, PositiveSmallIntegerField, get_ul_class
610	from django.db.models.related import RelatedObject
611	@@ -368,6 +368,8 @@
612
613	# target_col_name: the PK colname in join_table for the target object
614	# *objs - objects to add. Either object instances, or primary keys of object instances.
615
616	+ connection = self.model._default_manager.db.connection
617	+
618	# If there aren't any objects, there is nothing to do.
619	if objs:
620	# Check that all the objects are of the right type
621	@@ -391,13 +393,15 @@
622
623	cursor.execute("INSERT INTO %s (%s, %s) VALUES (%%s, %%s)" % \
624	(self.join_table, source_col_name, target_col_name),
625	[self._pk_val, obj_id])
626	- transaction.commit_unless_managed()
627	+ transaction.commit_unless_managed(connection)
628
629	def _remove_items(self, source_col_name, target_col_name, *objs):
630	# source_col_name: the PK colname in join_table for the source object
631	# target_col_name: the PK colname in join_table for the target object
632	# *objs - objects to remove
633
634	+ connection = self.model._default_manager.db.connection
635	+
636	# If there aren't any objects, there is nothing to do.
637	if objs:
638	# Check that all the objects are of the right type
639	@@ -413,15 +417,16 @@
640
641	(self.join_table, source_col_name,
642	target_col_name, ",".join(['%s'] * len(old_ids))),
643	[self._pk_val] + list(old_ids))
644	- transaction.commit_unless_managed()
645	+ transaction.commit_unless_managed(connection)
646
647	def _clear_items(self, source_col_name):
648	# source_col_name: the PK colname in join_table for the source object
649	+ connection = self.model._default_manager.db.connection
650	cursor = connection.cursor()
651	cursor.execute("DELETE FROM %s WHERE %s = %%s" % \
652	(self.join_table, source_col_name),
653	[self._pk_val])
654	- transaction.commit_unless_managed()
655	+ transaction.commit_unless_managed(connection)
656
657	return ManyRelatedManager
658
659	@@ -445,7 +450,7 @@
660
661	superclass = rel_model._default_manager.__class__
662	RelatedManager = create_many_related_manager(superclass)
663
664	- qn = connection.ops.quote_name
665	+ qn = rel_model._default_manager.db.connection.ops.quote_name
666	manager = RelatedManager(
667	model=rel_model,
668	core_filters={'%s__pk' % self.related.field.name: instance._get_pk_val()},
669	@@ -486,7 +491,7 @@
670
671	superclass = rel_model._default_manager.__class__
672	RelatedManager = create_many_related_manager(superclass)
673
674	- qn = connection.ops.quote_name
675	+ qn = rel_model._default_manager.db.connection.ops.quote_name
676	manager = RelatedManager(
677	model=rel_model,
678	core_filters={'%s__pk' % self.field.related_query_name(): instance._get_pk_val()},
679	@@ -673,15 +678,15 @@
680
681	defaults.update(kwargs)
682	return super(ForeignKey, self).formfield(**defaults)
683
684	- def db_type(self):
685	+ def db_type(self, connection):
686	# The database column type of a ForeignKey is the column type
687	# of the field to which it points. An exception is if the ForeignKey
688	# points to an AutoField/PositiveIntegerField/PositiveSmallIntegerField,
689	# in which case the column type is simply that of an IntegerField.
690	rel_field = self.rel.get_related_field()
691	if isinstance(rel_field, (AutoField, PositiveIntegerField, PositiveSmallIntegerField)):
692	- return IntegerField().db_type()
693	- return rel_field.db_type()
694	+ return IntegerField().db_type(connection)
695	+ return rel_field.db_type(connection)
696
697	class OneToOneField(ForeignKey):
698	"""
699	@@ -828,7 +833,7 @@
700
701	defaults['initial'] = [i._get_pk_val() for i in defaults['initial']]
702	return super(ManyToManyField, self).formfield(**defaults)
703
704	- def db_type(self):
705	+ def db_type(self, connection):
706	# A ManyToManyField is not represented by a single column,
707	# so return None.
708	return None
709	=== django/db/models/query.py
710	==================================================================
711	--- django/db/models/query.py (/mirror/django/trunk) (revision 5420)
712
713	+++ django/db/models/query.py (/local/django/mymultidb) (revision 5420)
714
715	@@ -1,7 +1,7 @@
716
717	import warnings
718
719	from django.conf import settings
720	-from django.db import connection, transaction, IntegrityError
721	+from django.db import transaction, IntegrityError
722	from django.db.models.fields import DateField, FieldDoesNotExist
723	from django.db.models.query_utils import Q
724	from django.db.models import signals, sql
725	@@ -20,7 +20,7 @@
726
727	"Represents a lazy database lookup for a set of objects"
728	def __init__(self, model=None, query=None):
729	self.model = model
730	- self.query = query or sql.Query(self.model, connection)
731	+ self.query = query or sql.Query(self.model, self.model._default_manager.db.connection)
732	self._result_cache = None
733	self._iter = None
734
735	@@ -689,10 +689,10 @@
736
737	instance=instance)
738
739	pk_list = [pk for pk,instance in seen_objs[cls]]
740	- del_query = sql.DeleteQuery(cls, connection)
741	+ del_query = sql.DeleteQuery(cls, cls._default_manager.db.connection)
742	del_query.delete_batch_related(pk_list)
743
744	- update_query = sql.UpdateQuery(cls, connection)
745	+ update_query = sql.UpdateQuery(cls, cls._default_manager.db.connection)
746	for field in cls._meta.fields:
747	if field.rel and field.null and field.rel.to in seen_objs:
748	update_query.clear_related(field, pk_list)
749	@@ -701,7 +701,7 @@
750
751	for cls in ordered_classes:
752	seen_objs[cls].reverse()
753	pk_list = [pk for pk,instance in seen_objs[cls]]
754	- del_query = sql.DeleteQuery(cls, connection)
755	+ del_query = sql.DeleteQuery(cls, cls._default_manager.db.connection)
756	del_query.delete_batch(pk_list)
757
758	# Last cleanup; set NULLs where there once was a reference to the
759	@@ -724,7 +724,7 @@
760
761	the InsertQuery class and is how Model.save() is implemented. It is not
762	part of the public API.
763	"""
764	- query = sql.InsertQuery(model, connection)
765	+ query = sql.InsertQuery(model, model._default_manager.db.connection)
766	query.insert_values(values, raw_values)
767	return query.execute_sql(return_id)
768
769	=== django/db/__init__.py
770	==================================================================
771	--- django/db/__init__.py (/mirror/django/trunk) (revision 5420)
772
773	+++ django/db/__init__.py (/local/django/mymultidb) (revision 5420)
774
775	@@ -1,74 +1,428 @@
776
777	import os
778	-from django.conf import settings
779	+from django.conf import settings, UserSettingsHolder
780	from django.core import signals
781	from django.core.exceptions import ImproperlyConfigured
782	from django.dispatch import dispatcher
783	from django.utils.functional import curry
784
785	+try:
786	+ # Only exists in Python 2.4+
787	+ from threading import local
788	+except ImportError:
789	+ # Import copy of _thread_local.py from Python 2.4
790	+ from django.utils._threading_local import local
791	+
792	__all__ = ('backend', 'connection', 'DatabaseError', 'IntegrityError')
793
794	+
795	+# singleton to represent the default connection in connections
796	+class dummy(object):
797	+ def __repr__(self):
798	+ return self.__str__()
799	+ def __str__(self):
800	+ return '<default>'
801	+_default = dummy()
802	+del dummy
803	+
804	+
805	+# storage for local default connection
806	+_local = local()
807	+
808	if not settings.DATABASE_ENGINE:
809	settings.DATABASE_ENGINE = 'dummy'
810
811	-try:
812	- # Most of the time, the database backend will be one of the official
813	- # backends that ships with Django, so look there first.
814	- _import_path = 'django.db.backends.'
815	- backend = __import__('%s%s.base' % (_import_path, settings.DATABASE_ENGINE), {}, {}, [''])
816	- creation = __import__('%s%s.creation' % (_import_path, settings.DATABASE_ENGINE), {}, {}, [''])
817	-except ImportError, e:
818	- # If the import failed, we might be looking for a database backend
819	- # distributed external to Django. So we'll try that next.
820	- try:
821	- _import_path = ''
822	- backend = __import__('%s.base' % settings.DATABASE_ENGINE, {}, {}, [''])
823	- creation = __import__('%s.creation' % settings.DATABASE_ENGINE, {}, {}, [''])
824	- except ImportError, e_user:
825	- # The database backend wasn't found. Display a helpful error message
826	- # listing all possible (built-in) database backends.
827	- backend_dir = os.path.join(__path__[0], 'backends')
828	- available_backends = [f for f in os.listdir(backend_dir) if not f.startswith('_') and not f.startswith('.') and not f.endswith('.py') and not f.endswith('.pyc')]
829	- available_backends.sort()
830	- if settings.DATABASE_ENGINE not in available_backends:
831	- raise ImproperlyConfigured, "%r isn't an available database backend. Available options are: %s" % \
832	- (settings.DATABASE_ENGINE, ", ".join(map(repr, available_backends)))
833	+
834	+def connect(settings, name, **kw):
835	+ """Connect to the database specified in settings. Returns a
836	+ ConnectionInfo on success, raises ImproperlyConfigured if the
837	+ settings don't specify a valid database connection.
838	+ """
839	+ return ConnectionInfo(settings, name, **kw)
840	+
841	+
842	+class ConnectionInfo(object):
843	+ """Encapsulates all information about a connection and the backend
844	+ to which it belongs. Provides methods for loading backend
845	+ creation, introspection, and shell modules, closing the
846	+ connection, and resetting the connection's query log.
847	+ """
848	+ def __init__(self, settings=None, name=_default, **kw):
849	+ super(ConnectionInfo, self).__init__(**kw)
850	+ if settings is None:
851	+ from django.conf import settings
852	+ if not settings.DATABASE_OPTIONS:
853	+ settings.DATABASE_OPTIONS = {}
854	+ self.settings = settings
855	+ self.name = name
856	+ self.backend = self.load_backend()
857	+ self.connection = self.backend.DatabaseWrapper(settings, name)
858	+ self.DatabaseError = self.backend.DatabaseError
859	+
860	+ # Register an event that closes the database connection
861	+ # when a Django request is finished.
862	+ dispatcher.connect(self.close, signal=signals.request_finished)
863	+
864	+ # Register an event that resets connection.queries
865	+ # when a Django request is started.
866	+ dispatcher.connect(self.reset_queries, signal=signals.request_started)
867	+
868	+ def __repr__(self):
869	+ return "Connection: %s, %r (ENGINE=%s NAME=%s)" \
870	+ % (self.name, self.connection,
871	+ self.settings.DATABASE_ENGINE,
872	+ self.settings.DATABASE_NAME)
873	+
874	+ def name(self):
875	+ return self.name
876	+
877	+ def close(self):
878	+ """Close connection"""
879	+ self.connection.close()
880	+
881	+ def _import_database_module(self, import_path='', module_name=''):
882	+ """Lazily import a database module when requested."""
883	+ return __import__('%s%s.%s' % (import_path, self.settings.DATABASE_ENGINE, module_name), {}, {}, [''])
884	+
885	+ # We don't want to import the introspect module unless someone asks for it, so
886	+ # lazily load it on demmand.
887	+ def get_introspection_module(self):
888	+ return self._import_database_module(self._import_path, 'introspection')
889	+
890	+ def get_creation_module(self):
891	+ return self._import_database_module(self._import_path, 'creation')
892	+
893	+ def load_backend(self):
894	+ try:
895	+ # Most of the time, the database backend will be one of the official
896	+ # backends that ships with Django, so look there first.
897	+ self._import_path = 'django.db.backends.'
898	+ backend = __import__('%s%s.base' % (self._import_path,
899	+ self.settings.DATABASE_ENGINE), {}, {}, [''])
900	+ except ImportError, e:
901	+ # If the import failed, we might be looking for a database backend
902	+ # distributed external to Django. So we'll try that next.
903	+ try:
904	+ _import_path = ''
905	+ backend = __import__('%s.base' % self.settings.DATABASE_ENGINE, {}, {}, [''])
906	+ except ImportError, e_user:
907	+ # The database backend wasn't found. Display a helpful error message
908	+ # listing all possible (built-in) database backends.
909	+ backend_dir = os.path.join(__path__[0], 'backends')
910	+ available_backends = [f for f in os.listdir(backend_dir) if not f.startswith('_') and not f.startswith('.') and not f.endswith('.py') and not f.endswith('.pyc')]
911	+ available_backends.sort()
912	+ if self.settings.DATABASE_ENGINE not in available_backends:
913	+ raise ImproperlyConfigured, "%r isn't an available database backend. Available options are: %s" % \
914	+ (self.settings.DATABASE_ENGINE, ", ".join(map(repr, available_backends)))
915	+ else:
916	+ raise # If there's some other error, this must be an error in Django itself.
917	+ return backend
918	+
919	+ # We want runshell() to work the same way, but we have to treat it a
920	+ # little differently (since it just runs instead of returning a module like
921	+ # the above) and wrap the lazily-loaded runshell() method.
922	+ def runshell(self):
923	+ return lambda: _import_database_module(_import_path, "client").runshell()
924	+
925	+ def reset_queries(self):
926	+ """Reset log of queries executed by connection"""
927	+ self.connection.queries = []
928	+
929	+class LazyConnectionManager(object):
930	+ """Manages named connections lazily, instantiating them as
931	+ they are requested.
932	+ """
933	+ def __init__(self):
934	+ self.local = local()
935	+ self.local.connections = {}
936	+
937	+ # Reset connections on request finish, to make sure each request can
938	+ # load the correct connections for its settings
939	+ dispatcher.connect(self.reset, signal=signals.request_finished)
940	+
941	+ def __iter__(self):
942	+ # Iterates only over active connections, not all possible
943	+ # connections
944	+ return iter(self.local.connections.keys())
945	+
946	+ def __getattr__(self, attr):
947	+ return getattr(self.local.connections, attr)
948	+
949	+ def __getitem__(self, k):
950	+ try:
951	+ return self.local.connections[k]
952	+ except (AttributeError, KeyError):
953	+ return self.connect(k)
954	+
955	+ def __setitem__(self, k, v):
956	+ try:
957	+ self.local.connections[k] = v
958	+ except AttributeError:
959	+ # First access in thread
960	+ self.local.connections = {k: v}
961	+
962	+ def connect(self, name):
963	+ """Return the connection with this name in
964	+ settings.OTHER_DATABASES. Creates the connection if it doesn't yet
965	+ exist. Reconnects if it does. If the name requested is the default
966	+ connection (a singleton defined in django.db), then the default
967	+ connection is returned.
968	+ """
969	+ try:
970	+ cnx = self.local.connections
971	+ except AttributeError:
972	+ cnx = self.local.connections = {}
973	+ if name in cnx:
974	+ cnx[name].close()
975	+ if name is _default:
976	+ cnx[name] = connect(settings, _default)
977	+ return cnx[name]
978	+ try:
979	+ info = settings.OTHER_DATABASES[name]
980	+ except KeyError:
981	+ raise ImproperlyConfigured, \
982	+ "No database connection '%s' has been configured" % name
983	+ except AttributeError:
984	+ raise ImproperlyConfigured, \
985	+ "No OTHER_DATABASES in settings."
986	+
987	+ # In settings it's a dict, but connect() needs an object:
988	+ # pass global settings so that the default connection settings
989	+ # can be defaults for the named connections.
990	+ database = UserSettingsHolder(settings)
991	+ for k, v in info.items():
992	+ setattr(database, k, v)
993	+ cnx[name] = connect(database, name)
994	+ return cnx[name]
995	+
996	+ def items(self):
997	+ # Iterates over all possible connections
998	+ items = []
999	+ for key in self.keys():
1000	+ items.append((key, self[key]))
1001	+ return items
1002	+
1003	+ def keys(self):
1004	+ # Iterates over all possible connections
1005	+ keys = [_default]
1006	+ try:
1007	+ keys.extend(settings.OTHER_DATABASES.keys())
1008	+ except AttributeError:
1009	+ pass
1010	+ return keys
1011	+
1012	+ def reset(self):
1013	+ if not hasattr(self.local, 'connections'):
1014	+ return
1015	+ if settings.DATABASE_NAME == ':memory:':
1016	+## try:
1017	+## cnx = self.local.connections
1018	+## except AttributeError:
1019	+## cnx = self.local.connections = {}
1020	+ self.local.connections = {_default: self.local.connections[_default]}
1021	+## for c in cnx:
1022	+## if c != _default:
1023	+## del self.local.connections[c]
1024	else:
1025	- raise # If there's some other error, this must be an error in Django itself.
1026	+ self.local.connections = {}
1027
1028	-def _import_database_module(import_path='', module_name=''):
1029	- """Lazily import a database module when requested."""
1030	- return __import__('%s%s.%s' % (import_path, settings.DATABASE_ENGINE, module_name), {}, {}, [''])
1031	+def model_connection_name(klass):
1032	+ """Get the connection name that a model is configured to use, with the
1033	+ current settings.
1034	+ """
1035	+ app = klass._meta.app_label
1036	+ model = klass.__name__
1037	+ app_model = "%s.%s" % (app, model)
1038
1039	-# We don't want to import the introspect module unless someone asks for it, so
1040	-# lazily load it on demmand.
1041	-get_introspection_module = curry(_import_database_module, _import_path, 'introspection')
1042	+ # Quick exit if no OTHER_DATABASES defined
1043	+ if (not hasattr(settings, 'OTHER_DATABASES')
1044	+ or not settings.OTHER_DATABASES):
1045	+ return _default
1046	+ # Look in MODELS for the best match: app_label.Model. If that isn't
1047	+ # found, take just app_label. If nothing is found, use the default
1048	+ maybe = None
1049	+ for name, db_def in settings.OTHER_DATABASES.items():
1050	+ if not 'MODELS' in db_def:
1051	+ continue
1052	+ mods = db_def['MODELS']
1053	+ # Can't get a better match than this
1054	+ if app_model in mods:
1055	+ return name
1056	+ elif app in mods:
1057	+ if maybe is not None:
1058	+ raise ImproperlyConfigured, \
1059	+ "App %s appears in more than one OTHER_DATABASES " \
1060	+ "setting (%s and %s)" % (maybe, name)
1061	+ maybe = name
1062	+ if maybe:
1063	+ return maybe
1064	+ # No named connection for this model; use the default
1065	+ return _default
1066
1067	-def get_creation_module():
1068	- return creation
1069	+def connection_name_app_model(app_label, model_name):
1070	+ """Get the connection name that a model is configured to use, with the
1071	+ current settings.
1072	+ """
1073	+ app_model = "%s.%s" % (app_label, model_name)
1074
1075	-# We want runshell() to work the same way, but we have to treat it a
1076	-# little differently (since it just runs instead of returning a module like
1077	-# the above) and wrap the lazily-loaded runshell() method.
1078	-runshell = lambda: _import_database_module(_import_path, "client").runshell()
1079	+ # Quick exit if no OTHER_DATABASES defined
1080	+ if (not hasattr(settings, 'OTHER_DATABASES')
1081	+ or not settings.OTHER_DATABASES):
1082	+ return _default
1083	+ # Look in MODELS for the best match: app_label.Model. If that isn't
1084	+ # found, take just app_label. If nothing is found, use the default
1085	+ maybe = None
1086	+ for name, db_def in settings.OTHER_DATABASES.items():
1087	+ if not 'MODELS' in db_def:
1088	+ continue
1089	+ mods = db_def['MODELS']
1090	+ # Can't get a better match than this
1091	+ if app_model in mods:
1092	+ return name
1093	+ elif app_label in mods:
1094	+ if maybe is not None:
1095	+ raise ImproperlyConfigured, \
1096	+ "App %s appears in more than one OTHER_DATABASES " \
1097	+ "setting (%s and %s)" % (maybe, name)
1098	+ maybe = name
1099	+ if maybe:
1100	+ return maybe
1101	+ # No named connection for this model; use the default
1102	+ return _default
1103
1104	-# Convenient aliases for backend bits.
1105	-connection = backend.DatabaseWrapper(**settings.DATABASE_OPTIONS)
1106	-DatabaseError = backend.DatabaseError
1107	-IntegrityError = backend.IntegrityError
1108	+class ConnectionInfoDescriptor(object):
1109	+ """Descriptor used to access database connection information from a
1110	+ manager or other connection holder. Keeps a thread-local cache of
1111	+ connections per instance, and always returns the same connection for an
1112	+ instance in particular thread during a particular request.
1113
1114	-# Register an event that closes the database connection
1115	-# when a Django request is finished.
1116	-dispatcher.connect(connection.close, signal=signals.request_finished)
1117	+ Any object that includes a ``model`` attribute that holds a model class
1118	+ can use this descriptor to manage connections.
1119	+ """
1120
1121	-# Register an event that resets connection.queries
1122	-# when a Django request is started.
1123	+ def __init__(self):
1124	+ self.local = local()
1125	+ self.local.cnx = {}
1126	+ dispatcher.connect(self.reset, signal=signals.request_finished)
1127	+
1128	+ def __get__(self, instance, type=None):
1129	+ if instance is None:
1130	+ raise AttributeError, \
1131	+ "ConnectionInfo is accessible only through an instance"
1132	+ try:
1133	+ instance_connection = self.local.cnx.get(instance, None)
1134	+ except AttributeError:
1135	+ # First access in this thread
1136	+ self.local.cnx = {}
1137	+ instance_connection = None
1138	+ if instance_connection is None:
1139	+ instance_connection = self.get_connection(instance)
1140	+ self.local.cnx[instance] = instance_connection
1141	+ return instance_connection
1142	+
1143	+ def __set__(self, instance, value):
1144	+ try:
1145	+ self.local.cnx[instance] = value
1146	+ except AttributeError:
1147	+ # First access in thread
1148	+ self.local.cnx = {instance: value}
1149	+
1150	+ def __delete__(self, instance):
1151	+ try:
1152	+ del self.local.cnx[instance]
1153	+ except (AttributeError, KeyError):
1154	+ # Not stored, no need to reset
1155	+ pass
1156	+
1157	+ def get_connection(self, instance):
1158	+ return connections[model_connection_name(instance.model)]
1159	+
1160	+ def reset(self):
1161	+ if not hasattr(self.local, 'cnx'):
1162	+ return
1163	+ self.local.cnx = {}
1164	+
1165	+class LocalizingProxy:
1166	+ """A lazy-initializing proxy. The proxied object is not
1167	+ initialized until the first attempt to access it. This is used to
1168	+ attach module-level properties to local storage.
1169	+ """
1170	+ def __init__(self, name, storage, func, arg, *kw):
1171	+ self.__name = name
1172	+ self.__storage = storage
1173	+ self.__func = func
1174	+ self.__arg = arg
1175	+ self.__kw = kw
1176	+
1177	+ # We need to clear out this thread's storage at the end of each
1178	+ # request, in case new settings are loaded with the next
1179	+ def reset(stor=storage, name=name):
1180	+ if hasattr(stor, name):
1181	+ delattr(stor, name)
1182	+ dispatcher.connect(reset, signal=signals.request_finished)
1183	+
1184	+ def __getattr__(self, attr):
1185	+ # Private (__*) attributes are munged
1186	+ if attr.startswith('_LocalizingProxy'):
1187	+ return self.__dict__[attr]
1188	+ try:
1189	+ return getattr(getattr(self.__storage, self.__name), attr)
1190	+ except AttributeError:
1191	+ setattr(self.__storage, self.__name, self.__func(*self.__arg,
1192	+ **self.__kw))
1193	+ return getattr(getattr(self.__storage, self.__name), attr)
1194	+
1195	+ def __setattr__(self, attr, val):
1196	+ # Private (__*) attributes are munged
1197	+ if attr.startswith('_LocalizingProxy'):
1198	+ self.__dict__[attr] = val
1199	+ return
1200	+ try:
1201	+ stor = getattr(self.__storage, self.__name)
1202	+ except AttributeError:
1203	+ stor = self.__func(*self.__arg)
1204	+ setattr(self.__storage, self.__name, stor)
1205	+ setattr(stor, attr, val)
1206	+
1207	+
1208	+# Create a manager for named connections
1209	+connections = LazyConnectionManager()
1210	+
1211	+# Backwards compatibility: establish the default connection and set the
1212	+# default connection properties at module level, using the lazy proxy so that
1213	+# each thread may have a different default connection, if so configured
1214	+connection_info = LocalizingProxy('connection_info', _local,
1215	+ lambda: connections[_default])
1216	+connection = LocalizingProxy('connection', _local,
1217	+ lambda: connections[_default].connection)
1218	+backend = LocalizingProxy('backend', _local,
1219	+ lambda: connections[_default].backend)
1220	+DatabaseError = LocalizingProxy('DatabaseError', _local,
1221	+ lambda: connections[_default].DatabaseError)
1222	+IntegrityError = LocalizingProxy('IntegrityError', _local,
1223	+ lambda: connections[_default].IntegrityError)
1224	+get_introspection_module = LocalizingProxy(
1225	+ 'get_introspection_module', _local,
1226	+ lambda: connections[_default].get_introspection_module)
1227	+get_creation_module = LocalizingProxy(
1228	+ 'get_creation_module', _local,
1229	+ lambda: connections[_default].get_creation_module)
1230	+runshell = LocalizingProxy('runshell', _local,
1231	+ lambda: connections[_default].runshell)
1232	+
1233	+
1234	def reset_queries():
1235	- connection.queries = []
1236	-dispatcher.connect(reset_queries, signal=signals.request_started)
1237	+ connections[_default].reset_queries()
1238	+ for c in connections:
1239	+ try:
1240	+ c.reset_queries()
1241	+ except:
1242	+ pass
1243
1244	-# Register an event that rolls back the connection
1245	+# Register an event that rolls back all connections
1246	# when a Django request has an exception.
1247	def _rollback_on_exception():
1248	from django.db import transaction
1249	transaction.rollback_unless_managed()
1250	-dispatcher.connect(_rollback_on_exception, signal=signals.got_request_exception)
1251	+dispatcher.connect(_rollback_on_exception,
1252	+ signal=signals.got_request_exception)
1253	+
1254	=== django/db/backends/sqlite3/base.py
1255	==================================================================
1256	--- django/db/backends/sqlite3/base.py (/mirror/django/trunk) (revision 5420)
1257
1258	+++ django/db/backends/sqlite3/base.py (/local/django/mymultidb) (revision 5420)
1259
1260	@@ -118,7 +118,7 @@
1261
1262	return self.connection.cursor(factory=SQLiteCursorWrapper)
1263
1264	def close(self):
1265	- from django.conf import settings
1266	+ settings = self.settings
1267	# If database is in memory, closing the connection destroys the
1268	# database. To prevent accidental data loss, ignore close requests on
1269	# an in-memory db.
1270	=== django/db/backends/__init__.py
1271	==================================================================
1272	--- django/db/backends/__init__.py (/mirror/django/trunk) (revision 5420)
1273
1274	+++ django/db/backends/__init__.py (/local/django/mymultidb) (revision 5420)
1275
1276	@@ -5,15 +5,17 @@
1277
1278	# Import copy of _thread_local.py from Python 2.4
1279	from django.utils._threading_local import local
1280
1281	-class BaseDatabaseWrapper(local):
1282	+class BaseDatabaseWrapper(object):
1283	"""
1284	Represents a database connection.
1285	"""
1286	ops = None
1287	- def __init__(self, **kwargs):
1288	+ def __init__(self, settings, connection_name):
1289	+ self.settings = settings
1290	+ self.connection_name = connection_name
1291	+ self.options = settings.DATABASE_OPTIONS
1292	self.connection = None
1293	self.queries = []
1294	- self.options = kwargs
1295
1296	def _commit(self):
1297	if self.connection is not None:
1298	@@ -29,7 +31,7 @@
1299
1300	self.connection = None
1301
1302	def cursor(self):
1303	- from django.conf import settings
1304	+ settings = self.settings
1305	cursor = self._cursor(settings)
1306	if settings.DEBUG:
1307	return self.make_debug_cursor(cursor)
1308	=== django/db/transaction.py
1309	==================================================================
1310	--- django/db/transaction.py (/mirror/django/trunk) (revision 5420)
1311
1312	+++ django/db/transaction.py (/local/django/mymultidb) (revision 5420)
1313
1314	@@ -16,7 +16,6 @@
1315
1316	import thread
1317	except ImportError:
1318	import dummy_thread as thread
1319	-from django.db import connection
1320	from django.conf import settings
1321
1322	class TransactionManagementError(Exception):
1323	@@ -116,48 +115,69 @@
1324
1325	Puts the transaction manager into a manual state: managed transactions have
1326	to be committed explicitly by the user. If you switch off transaction
1327	management and there is a pending commit/rollback, the data will be
1328	- commited.
1329	+ commited. Note that managed state applies across all connections.
1330	"""
1331	thread_ident = thread.get_ident()
1332	top = state.get(thread_ident, None)
1333	if top:
1334	top[-1] = flag
1335	if not flag and is_dirty():
1336	- connection._commit()
1337	+ for cx in all_connections():
1338	+ cx._commit()
1339	set_clean()
1340	else:
1341	raise TransactionManagementError("This code isn't under transaction management")
1342
1343	-def commit_unless_managed():
1344	+def commit_unless_managed(conns=None):
1345	"""
1346	Commits changes if the system is not in managed transaction mode.
1347	"""
1348	if not is_managed():
1349	- connection._commit()
1350	+ if conns is None:
1351	+ conns = all_connections()
1352	+ else:
1353	+ conns = ensure_connections(conns)
1354	+ for cx in conns:
1355	+ cx._commit()
1356	else:
1357	set_dirty()
1358
1359	-def rollback_unless_managed():
1360	+def rollback_unless_managed(conns=None):
1361	"""
1362	Rolls back changes if the system is not in managed transaction mode.
1363	"""
1364	if not is_managed():
1365	- connection._rollback()
1366	+ if conns is None:
1367	+ conns = all_connections()
1368	+ else:
1369	+ conns = ensure_connections(conns)
1370	+ for cx in conns:
1371	+ cx._rollback()
1372	else:
1373	set_dirty()
1374
1375	-def commit():
1376	+def commit(conns=None):
1377	"""
1378	Does the commit itself and resets the dirty flag.
1379	"""
1380	- connection._commit()
1381	+ if conns is None:
1382	+ conns = all_connections()
1383	+ else:
1384	+ conns = ensure_connections(conns)
1385	+ for cx in conns:
1386	+ cx._commit()
1387	set_clean()
1388
1389	-def rollback():
1390	+def rollback(conns=None):
1391	"""
1392	This function does the rollback itself and resets the dirty flag.
1393	"""
1394	- connection._rollback()
1395	+ if conns is None:
1396	+ conns = all_connections()
1397	+ else:
1398	+ conns = ensure_connections(conns)
1399	+ for cx in conns:
1400	+ cx._rollback()
1401	set_clean()
1402
1403	##############
1404	@@ -179,7 +199,7 @@
1405
1406	leave_transaction_management()
1407	return _autocommit
1408
1409	-def commit_on_success(func):
1410	+def commit_on_success(func, conns = None):
1411	"""
1412	This decorator activates commit on response. This way, if the view function
1413	runs successfully, a commit is made; if the viewfunc produces an exception,
1414	@@ -198,7 +218,7 @@
1415
1416	raise
1417	else:
1418	if is_dirty():
1419	- commit()
1420	+ commit(conns)
1421	return res
1422	finally:
1423	leave_transaction_management()
1424	@@ -220,3 +240,31 @@
1425
1426	leave_transaction_management()
1427
1428	return _commit_manually
1429	+
1430	+###########
1431	+# HELPERS #
1432	+###########
1433	+
1434	+def all_connections():
1435	+ from django.db import connection, connections
1436	+ return [connection] + [ c.connection
1437	+ for c in connections.values() ]
1438	+
1439	+def ensure_connections(val):
1440	+ from django.db import connections
1441	+ conns = []
1442	+ if isinstance(val, basestring):
1443	+ val = [val]
1444	+ try:
1445	+ iter(val)
1446	+ except:
1447	+ val = [val]
1448	+ for cx in val:
1449	+ if hasattr(cx, 'cursor'):
1450	+ conns.append(cx)
1451	+ elif hasattr(cx, 'connection'):
1452	+ conns.append(cx.connection)
1453	+ elif isinstance(cx, basestring):
1454	+ conns.append(connections[cx].connection)
1455	+ return conns
1456	+
1457	=== django/conf/global_settings.py
1458	==================================================================
1459	--- django/conf/global_settings.py (/mirror/django/trunk) (revision 5420)
1460
1461	+++ django/conf/global_settings.py (/local/django/mymultidb) (revision 5420)
1462
1463	@@ -122,6 +122,9 @@
1464
1465	DATABASE_PORT = '' # Set to empty string for default. Not used with sqlite3.
1466	DATABASE_OPTIONS = {} # Set to empty dictionary for default.
1467
1468	+# Optional named database connections in addition to the default.
1469	+OTHER_DATABASES = {}
1470	+
1471	# Host for sending e-mail.
1472	EMAIL_HOST = 'localhost'
1473
1474	@@ -352,6 +355,16 @@
1475
1476	# If None, a name of 'test_' + DATABASE_NAME will be assumed
1477	TEST_DATABASE_NAME = None
1478
1479	+# Tuple of other test databases to create. Names in this tuple
1480	+# are suffixes that will be appended to TEST_DATABASE_NAME
1481	+TEST_DATABASES = []
1482	+
1483	+# Models to assign to each test database. This must be a list of
1484	+# dicts, with each dict key being a name from TEST_DATABASES and value
1485	+# a list of models or app_labels that will use that database.
1486	+TEST_DATABASE_MODELS = []
1487	+
1488	+
1489	# Strings used to set the character set and collation order for the test
1490	# database. These values are passed literally to the server, so they are
1491	# backend-dependent. If None, no special settings are sent (system defaults are
1492	=== django/core/cache/backends/db.py
1493	==================================================================
1494	--- django/core/cache/backends/db.py (/mirror/django/trunk) (revision 5420)
1495
1496	+++ django/core/cache/backends/db.py (/local/django/mymultidb) (revision 5420)
1497
1498	@@ -1,7 +1,7 @@
1499
1500	"Database cache backend."
1501
1502	from django.core.cache.backends.base import BaseCache
1503	-from django.db import connection, transaction, DatabaseError
1504	+from django.db import connections, _default, transaction, DatabaseError
1505	import base64, time
1506	from datetime import datetime
1507	try:
1508	@@ -25,7 +25,7 @@
1509
1510	self._cull_frequency = 3
1511
1512	def get(self, key, default=None):
1513	- cursor = connection.cursor()
1514	+ cursor = connections[_default].connection.cursor()
1515	cursor.execute("SELECT cache_key, value, expires FROM %s WHERE cache_key = %%s" % self._table, [key])
1516	row = cursor.fetchone()
1517	if row is None:
1518	@@ -46,7 +46,7 @@
1519
1520	def _base_set(self, mode, key, value, timeout=None):
1521	if timeout is None:
1522	timeout = self.default_timeout
1523	- cursor = connection.cursor()
1524	+ cursor = connections[_default].connection.cursor()
1525	cursor.execute("SELECT COUNT(*) FROM %s" % self._table)
1526	num = cursor.fetchone()[0]
1527	now = datetime.now().replace(microsecond=0)
1528	@@ -67,12 +67,12 @@
1529
1530	transaction.commit_unless_managed()
1531
1532	def delete(self, key):
1533	- cursor = connection.cursor()
1534	+ cursor = connections[_default].connection.cursor()
1535	cursor.execute("DELETE FROM %s WHERE cache_key = %%s" % self._table, [key])
1536	transaction.commit_unless_managed()
1537
1538	def has_key(self, key):
1539	- cursor = connection.cursor()
1540	+ cursor = connections[_default].connection.cursor()
1541	cursor.execute("SELECT cache_key FROM %s WHERE cache_key = %%s" % self._table, [key])
1542	return cursor.fetchone() is not None
1543
1544	=== django/core/management/base.py
1545	==================================================================
1546	--- django/core/management/base.py (/mirror/django/trunk) (revision 5420)
1547
1548	+++ django/core/management/base.py (/local/django/mymultidb) (revision 5420)
1549
1550	@@ -85,14 +85,7 @@
1551
1552	self.validate()
1553	output = self.handle(args, *options)
1554	if output:
1555	- if self.output_transaction:
1556	- # This needs to be imported here, because it relies on settings.
1557	- from django.db import connection
1558	- if connection.ops.start_transaction_sql():
1559	- print self.style.SQL_KEYWORD(connection.ops.start_transaction_sql())
1560	print output
1561	- if self.output_transaction:
1562	- print self.style.SQL_KEYWORD("COMMIT;")
1563	except CommandError, e:
1564	sys.stderr.write(self.style.ERROR(str('Error: %s\n' % e)))
1565	sys.exit(1)
1566	@@ -124,23 +117,70 @@
1567
1568	args = '<appname appname ...>'
1569
1570	def handle(self, app_labels, *options):
1571	- from django.db import models
1572	+ from django.db import models, _default, connections
1573	+ from django.core.management.sql import sql_collate
1574	if not app_labels:
1575	raise CommandError('Enter at least one appname.')
1576	try:
1577	app_list = [models.get_app(app_label) for app_label in app_labels]
1578	except (ImproperlyConfigured, ImportError), e:
1579	raise CommandError("%s. Are you sure your INSTALLED_APPS setting is correct?" % e)
1580	- output = []
1581	+ output = {}
1582	for app in app_list:
1583	app_output = self.handle_app(app, **options)
1584	- if app_output:
1585	- output.append(app_output)
1586	- return '\n'.join(output)
1587	+ if isinstance(app_output, dict):
1588	+ for connection_name, statements in app_output.items():
1589	+ f_output = output.setdefault(connection_name, [])
1590	+ if self.output_transaction:
1591	+ if connections[connection_name].connection.ops.start_transaction_sql():
1592	+ f_output.append(self.style.SQL_KEYWORD(connections[connection_name].connection.ops.start_transaction_sql()))
1593	+ f_output.extend(statements)
1594	+ if self.output_transaction:
1595	+ f_output.append(self.style.SQL_KEYWORD("COMMIT;"))
1596	+ else:
1597	+ f_output = output.setdefault(_default, [])
1598	+ f_output.append(app_output)
1599
1600	+ return sql_collate(output)
1601	+## return '\n'.join(output)
1602	+
1603	def handle_app(self, app, **options):
1604	raise NotImplementedError()
1605
1606	+class ConnectionCommand(BaseCommand):
1607	+ args = '<connectionname connectionname ...>'
1608	+
1609	+ def handle(self, connection_labels, *options):
1610	+ from django.conf import settings
1611	+ from django.db import _default, connections
1612	+ from django.core.management.sql import sql_collate
1613	+ if not connection_labels:
1614	+ connection_list = [_default]
1615	+ connection_list.extend(settings.OTHER_DATABASES.keys())
1616	+ else:
1617	+ # add check connection exists
1618	+ connection_list = []
1619	+ for name in connection_labels:
1620	+ if name == '_default':
1621	+ connection_list.append(_default)
1622	+ elif name in settings.OTHER_DATABASES:
1623	+ connection_list.append(name)
1624	+ output = {}
1625	+ for connection_name in connection_list:
1626	+ f_output = output.setdefault(connection_name, [])
1627	+ connection_output = self.handle_connection(connection_name, **options)
1628	+ if connection_output:
1629	+ if self.output_transaction:
1630	+ if connections[connection_name].connection.ops.start_transaction_sql():
1631	+ f_output.append(self.style.SQL_KEYWORD(connections[connection_name].connection.ops.start_transaction_sql()))
1632	+ f_output.extend(connection_output)
1633	+ if self.output_transaction:
1634	+ f_output.append(self.style.SQL_KEYWORD("COMMIT;"))
1635	+ return sql_collate(output)
1636	+
1637	+ def handle_connection(self, connection_name, **options):
1638	+ raise NotImplementedError()
1639	+
1640	class LabelCommand(BaseCommand):
1641	args = '<label label ...>'
1642	label = 'label'
1643	=== django/core/management/commands/sqlall.py
1644	==================================================================
1645	--- django/core/management/commands/sqlall.py (/mirror/django/trunk) (revision 5420)
1646
1647	+++ django/core/management/commands/sqlall.py (/local/django/mymultidb) (revision 5420)
1648
1649	@@ -7,4 +7,4 @@
1650
1651
1652	def handle_app(self, app, **options):
1653	from django.core.management.sql import sql_all
1654	- return '\n'.join(sql_all(app, self.style))
1655	+ return sql_all(app, self.style)
1656	=== django/core/management/commands/sqlcustom.py
1657	==================================================================
1658	--- django/core/management/commands/sqlcustom.py (/mirror/django/trunk) (revision 5420)
1659
1660	+++ django/core/management/commands/sqlcustom.py (/local/django/mymultidb) (revision 5420)
1661
1662	@@ -7,4 +7,5 @@
1663
1664
1665	def handle_app(self, app, **options):
1666	from django.core.management.sql import sql_custom
1667	- return '\n'.join(sql_custom(app))
1668	+ return sql_custom(app)
1669	+
1670	=== django/core/management/commands/sql.py
1671	==================================================================
1672	--- django/core/management/commands/sql.py (/mirror/django/trunk) (revision 5420)
1673
1674	+++ django/core/management/commands/sql.py (/local/django/mymultidb) (revision 5420)
1675
1676	@@ -7,4 +7,4 @@
1677
1678
1679	def handle_app(self, app, **options):
1680	from django.core.management.sql import sql_create
1681	- return '\n'.join(sql_create(app, self.style))
1682	+ return sql_create(app, self.style)
1683	=== django/core/management/commands/createcachetable.py
1684	==================================================================
1685	--- django/core/management/commands/createcachetable.py (/mirror/django/trunk) (revision 5420)
1686
1687	+++ django/core/management/commands/createcachetable.py (/local/django/mymultidb) (revision 5420)
1688
1689	@@ -8,7 +8,7 @@
1690
1691	requires_model_validation = False
1692
1693	def handle_label(self, tablename, **options):
1694	- from django.db import connection, transaction, models
1695	+ from django.db import connections, transaction, models, _default
1696	fields = (
1697	# "key" is a reserved word in MySQL, so use "cache_key" instead.
1698	models.CharField(name='cache_key', max_length=255, unique=True, primary_key=True),
1699	@@ -17,9 +17,9 @@
1700
1701	)
1702	table_output = []
1703	index_output = []
1704	- qn = connection.ops.quote_name
1705	+ qn = connections[_default].connection.ops.quote_name
1706	for f in fields:
1707	- field_output = [qn(f.name), f.db_type()]
1708	+ field_output = [qn(f.name), f.db_type(_default)]
1709	field_output.append("%sNULL" % (not f.null and "NOT " or ""))
1710	if f.unique:
1711	field_output.append("UNIQUE")
1712	@@ -35,7 +35,7 @@
1713
1714	for i, line in enumerate(table_output):
1715	full_statement.append(' %s%s' % (line, i < len(table_output)-1 and ',' or ''))
1716	full_statement.append(');')
1717	- curs = connection.cursor()
1718	+ curs = connection[_default].connection.cursor()
1719	curs.execute("\n".join(full_statement))
1720	for statement in index_output:
1721	curs.execute(statement)
1722	=== django/core/management/commands/sqlflush.py
1723	==================================================================
1724	--- django/core/management/commands/sqlflush.py (/mirror/django/trunk) (revision 5420)
1725
1726	+++ django/core/management/commands/sqlflush.py (/local/django/mymultidb) (revision 5420)
1727
1728	@@ -1,10 +1,10 @@
1729
1730	-from django.core.management.base import NoArgsCommand
1731	+from django.core.management.base import ConnectionCommand
1732
1733	-class Command(NoArgsCommand):
1734	+class Command(ConnectionCommand):
1735	help = "Returns a list of the SQL statements required to return all tables in the database to the state they were in just after they were installed."
1736
1737	output_transaction = True
1738
1739	- def handle_noargs(self, **options):
1740	+ def handle_connection(self, connection, **options):
1741	from django.core.management.sql import sql_flush
1742	- return '\n'.join(sql_flush(self.style, only_django=True))
1743	+ return sql_flush(connection, self.style, only_django=True)
1744	=== django/core/management/commands/sqlreset.py
1745	==================================================================
1746	--- django/core/management/commands/sqlreset.py (/mirror/django/trunk) (revision 5420)
1747
1748	+++ django/core/management/commands/sqlreset.py (/local/django/mymultidb) (revision 5420)
1749
1750	@@ -7,4 +7,4 @@
1751
1752
1753	def handle_app(self, app, **options):
1754	from django.core.management.sql import sql_reset
1755	- return '\n'.join(sql_reset(app, self.style))
1756	+ return sql_reset(app, self.style)
1757	=== django/core/management/commands/sqlclear.py
1758	==================================================================
1759	--- django/core/management/commands/sqlclear.py (/mirror/django/trunk) (revision 5420)
1760
1761	+++ django/core/management/commands/sqlclear.py (/local/django/mymultidb) (revision 5420)
1762
1763	@@ -7,4 +7,4 @@
1764
1765
1766	def handle_app(self, app, **options):
1767	from django.core.management.sql import sql_delete
1768	- return '\n'.join(sql_delete(app, self.style))
1769	+ return sql_delete(app, self.style)
1770	=== django/core/management/commands/loaddata.py
1771	==================================================================
1772	--- django/core/management/commands/loaddata.py (/mirror/django/trunk) (revision 5420)
1773
1774	+++ django/core/management/commands/loaddata.py (/local/django/mymultidb) (revision 5420)
1775
1776	@@ -21,7 +21,9 @@
1777
1778	def handle(self, fixture_labels, *options):
1779	from django.db.models import get_apps
1780	from django.core import serializers
1781	- from django.db import connection, transaction
1782	+ from django.db import connections, model_connection_name, transaction
1783	+# MULTIDB: TO REMOVE
1784	+ from django.db import connection
1785	from django.conf import settings
1786
1787	self.style = no_style()
1788	@@ -39,7 +41,7 @@
1789
1790	# Get a cursor (even though we don't need one yet). This has
1791	# the side effect of initializing the test database (if
1792	# it isn't already initialized).
1793	- cursor = connection.cursor()
1794	+## cursor = connection.cursor()
1795
1796	# Start transaction management. All fixtures are installed in a
1797	# single transaction to ensure that all references are resolved.
1798	@@ -121,6 +123,7 @@
1799
1800	print "No %s fixture '%s' in %s." % \
1801	(format, fixture_name, humanize(fixture_dir))
1802
1803	+# MULTIDB TODO: use sql_sequence_reset
1804	if object_count > 0:
1805	sequence_sql = connection.ops.sequence_reset_sql(self.style, models)
1806	if sequence_sql:
1807	=== django/core/management/commands/inspectdb.py
1808	==================================================================
1809	--- django/core/management/commands/inspectdb.py (/mirror/django/trunk) (revision 5420)
1810
1811	+++ django/core/management/commands/inspectdb.py (/local/django/mymultidb) (revision 5420)
1812
1813	@@ -1,22 +1,23 @@
1814
1815	-from django.core.management.base import NoArgsCommand, CommandError
1816	+from django.core.management.base import ConnectionCommand, CommandError
1817
1818	-class Command(NoArgsCommand):
1819	+class Command(ConnectionCommand):
1820	help = "Introspects the database tables in the given database and outputs a Django model module."
1821
1822	requires_model_validation = False
1823
1824	- def handle_noargs(self, **options):
1825	+ def handle_connection(self, connection, **options):
1826	try:
1827	- for line in self.handle_inspection():
1828	+ for line in self.handle_inspection(connection):
1829	print line
1830	except NotImplementedError:
1831	raise CommandError("Database inspection isn't supported for the currently selected database backend.")
1832
1833	- def handle_inspection(self):
1834	- from django.db import connection, get_introspection_module
1835	+ def handle_inspection(self, conn):
1836	+ from django.db import connections, get_introspection_module
1837	import keyword
1838
1839	- introspection_module = get_introspection_module()
1840	+ connection = connections[conn].connection
1841	+ introspection_module = connections[conn].get_introspection_module()
1842
1843	table2model = lambda table_name: table_name.title().replace('_', '')
1844
1845	=== django/core/management/commands/sqlindexes.py
1846	==================================================================
1847	--- django/core/management/commands/sqlindexes.py (/mirror/django/trunk) (revision 5420)
1848
1849	+++ django/core/management/commands/sqlindexes.py (/local/django/mymultidb) (revision 5420)
1850
1851	@@ -7,4 +7,4 @@
1852
1853
1854	def handle_app(self, app, **options):
1855	from django.core.management.sql import sql_indexes
1856	- return '\n'.join(sql_indexes(app, self.style))
1857	+ return sql_indexes(app, self.style)
1858	=== django/core/management/commands/flush.py
1859	==================================================================
1860	--- django/core/management/commands/flush.py (/mirror/django/trunk) (revision 5420)
1861
1862	+++ django/core/management/commands/flush.py (/local/django/mymultidb) (revision 5420)
1863
1864	@@ -1,9 +1,9 @@
1865
1866	-from django.core.management.base import NoArgsCommand, CommandError
1867	+from django.core.management.base import ConnectionCommand, CommandError
1868	from django.core.management.color import no_style
1869	from optparse import make_option
1870
1871	-class Command(NoArgsCommand):
1872	- option_list = NoArgsCommand.option_list + (
1873	+class Command(ConnectionCommand):
1874	+ option_list = ConnectionCommand.option_list + (
1875	make_option('--verbosity', action='store', dest='verbosity', default='1',
1876	type='choice', choices=['0', '1', '2'],
1877	help='Verbosity level; 0=minimal output, 1=normal output, 2=all output'),
1878	@@ -12,9 +12,9 @@
1879
1880	)
1881	help = "Executes ``sqlflush`` on the current database."
1882
1883	- def handle_noargs(self, **options):
1884	+ def handle_connection(self, connection, **options):
1885	from django.conf import settings
1886	- from django.db import connection, transaction, models
1887	+ from django.db import transaction, models, connections
1888	from django.dispatch import dispatcher
1889	from django.core.management.sql import sql_flush, emit_post_sync_signal
1890
1891	@@ -31,7 +31,7 @@
1892
1893	except ImportError:
1894	pass
1895
1896	- sql_list = sql_flush(self.style, only_django=True)
1897	+ sql_list = sql_flush(connection, self.style, only_django=True)
1898
1899	if interactive:
1900	confirm = raw_input("""You have requested a flush of the database.
1901	@@ -39,14 +39,14 @@
1902
1903	and return each table to the state it was in after syncdb.
1904	Are you sure you want to do this?
1905
1906	- Type 'yes' to continue, or 'no' to cancel: """ % settings.DATABASE_NAME)
1907	+ Type 'yes' to continue, or 'no' to cancel: """ % connection)
1908	else:
1909	confirm = 'yes'
1910
1911	if confirm == 'yes':
1912	try:
1913	- cursor = connection.cursor()
1914	for sql in sql_list:
1915	+ cursor = connections[connection].connection.cursor()
1916	cursor.execute(sql)
1917	except Exception, e:
1918	transaction.rollback_unless_managed()
1919	@@ -55,7 +55,7 @@
1920
1921	* At least one of the expected database tables doesn't exist.
1922	* The SQL was invalid.
1923	Hint: Look at the output of 'django-admin.py sqlflush'. That's the SQL this command wasn't able to run.
1924	- The full error: %s""" % (settings.DATABASE_NAME, e))
1925	+ The full error: %s""" % (connection, e))
1926	transaction.commit_unless_managed()
1927
1928	# Emit the post sync signal. This allows individual
1929	=== django/core/management/commands/reset.py
1930	==================================================================
1931	--- django/core/management/commands/reset.py (/mirror/django/trunk) (revision 5420)
1932
1933	+++ django/core/management/commands/reset.py (/local/django/mymultidb) (revision 5420)
1934
1935	@@ -10,10 +10,8 @@
1936
1937	help = "Executes ``sqlreset`` for the given app(s) in the current database."
1938	args = '[appname ...]'
1939
1940	- output_transaction = True
1941	-
1942	def handle_app(self, app, **options):
1943	- from django.db import connection, transaction
1944	+ from django.db import connections, transaction, _default
1945	from django.conf import settings
1946	from django.core.management.sql import sql_reset
1947
1948	@@ -21,32 +19,37 @@
1949
1950
1951	self.style = no_style()
1952
1953	- sql_list = sql_reset(app, self.style)
1954	+ sql_dict = sql_reset(app, self.style)
1955
1956	- if options.get('interactive'):
1957	- confirm = raw_input("""
1958	+ for connection_name, sql_list in sql_dict.items():
1959	+ if options.get('interactive'):
1960	+ if connection_name == _default:
1961	+ dbname = settings.DATABASE_NAME
1962	+ else:
1963	+ dbname = settings.OTHER_DATABASES[connection_name][DATABASE_NAME]
1964	+ confirm = raw_input("""
1965	You have requested a database reset.
1966	This will IRREVERSIBLY DESTROY any data for
1967	the "%s" application in the database "%s".
1968	Are you sure you want to do this?
1969
1970	-Type 'yes' to continue, or 'no' to cancel: """ % (app_name, settings.DATABASE_NAME))
1971	- else:
1972	- confirm = 'yes'
1973	+Type 'yes' to continue, or 'no' to cancel: """ % (app_name, dbname))
1974	+ else:
1975	+ confirm = 'yes'
1976
1977	- if confirm == 'yes':
1978	- try:
1979	- cursor = connection.cursor()
1980	- for sql in sql_list:
1981	- cursor.execute(sql)
1982	- except Exception, e:
1983	- transaction.rollback_unless_managed()
1984	- raise CommandError("""Error: %s couldn't be reset. Possible reasons:
1985	+ if confirm == 'yes':
1986	+ try:
1987	+ cursor = connections[connection_name].connection.cursor()
1988	+ for sql in sql_list:
1989	+ cursor.execute(sql)
1990	+ except Exception, e:
1991	+ transaction.rollback_unless_managed()
1992	+ raise CommandError("""Error: %s couldn't be reset. Possible reasons:
1993	* The database isn't running or isn't configured correctly.
1994	* At least one of the database tables doesn't exist.
1995	* The SQL was invalid.
1996	Hint: Look at the output of 'django-admin.py sqlreset %s'. That's the SQL this command wasn't able to run.
1997	The full error: %s""" % (app_name, app_name, e))
1998	- transaction.commit_unless_managed()
1999	- else:
2000	- print "Reset cancelled."
2001	+ transaction.commit_unless_managed()
2002	+ else:
2003	+ print "Reset cancelled."
2004	=== django/core/management/commands/syncdb.py
2005	==================================================================
2006	--- django/core/management/commands/syncdb.py (/mirror/django/trunk) (revision 5420)
2007
2008	+++ django/core/management/commands/syncdb.py (/local/django/mymultidb) (revision 5420)
2009
2010	@@ -19,7 +19,7 @@
2011
2012	help = "Create the database tables for all apps in INSTALLED_APPS whose tables haven't already been created."
2013
2014	def handle_noargs(self, **options):
2015	- from django.db import connection, transaction, models
2016	+ from django.db import model_connection_name, transaction, models, connections
2017	from django.conf import settings
2018	from django.core.management.sql import table_list, installed_models, sql_model_create, sql_for_pending_references, many_to_many_sql_for_model, custom_sql_for_model, sql_indexes_for_model, emit_post_sync_signal
2019
2020	@@ -37,16 +37,10 @@
2021
2022	if not exc.args[0].startswith('No module named management'):
2023	raise
2024
2025	- cursor = connection.cursor()
2026	-
2027	- if connection.features.uses_case_insensitive_names:
2028	- table_name_converter = lambda x: x.upper()
2029	- else:
2030	- table_name_converter = lambda x: x
2031	# Get a list of all existing database tables, so we know what needs to
2032	# be added.
2033	- tables = [table_name_converter(name) for name in table_list()]
2034	-
2035	+ tables = table_list()
2036	+
2037	# Get a list of already installed models so that references work right.
2038	seen_models = installed_models(tables)
2039	created_models = set()
2040	@@ -59,8 +53,15 @@
2041
2042	for model in model_list:
2043	# Create the model's database table, if it doesn't already exist.
2044	if verbosity >= 2:
2045	- print "Processing %s.%s model" % (app_name, model._meta.object_name)
2046	- if table_name_converter(model._meta.db_table) in tables:
2047	+ print "Processing %s.%s model (%s))" % (app_name, model._meta.object_name, model_connection_name(model))
2048	+ connection = model._default_manager.db.connection
2049	+ cursor = connection.cursor()
2050	+ if connection.features.uses_case_insensitive_names:
2051	+ table_name_converter = lambda x: x.upper()
2052	+ else:
2053	+ table_name_converter = lambda x: x
2054	+ ctables = [table_name_converter(name) for name in tables]
2055	+ if table_name_converter(model._meta.db_table) in ctables:
2056	continue
2057	sql, references = sql_model_create(model, self.style, seen_models)
2058	seen_models.add(model)
2059	@@ -83,6 +84,8 @@
2060
2061	model_list = models.get_models(app)
2062	for model in model_list:
2063	if model in created_models:
2064	+ connection = model._default_manager.db.connection
2065	+ cursor = connection.cursor()
2066	sql = many_to_many_sql_for_model(model, self.style)
2067	if sql:
2068	if verbosity >= 2:
2069	@@ -102,6 +105,8 @@
2070
2071	app_name = app.__name__.split('.')[-2]
2072	for model in models.get_models(app):
2073	if model in created_models:
2074	+ connection = model._default_manager.db.connection
2075	+ cursor = connection.cursor()
2076	custom_sql = custom_sql_for_model(model)
2077	if custom_sql:
2078	if verbosity >= 1:
2079	@@ -121,6 +126,8 @@
2080
2081	app_name = app.__name__.split('.')[-2]
2082	for model in models.get_models(app):
2083	if model in created_models:
2084	+ connection = model._default_manager.db.connection
2085	+ cursor = connection.cursor()
2086	index_sql = sql_indexes_for_model(model, self.style)
2087	if index_sql:
2088	if verbosity >= 1:
2089	=== django/core/management/validation.py
2090	==================================================================
2091	--- django/core/management/validation.py (/mirror/django/trunk) (revision 5420)
2092
2093	+++ django/core/management/validation.py (/local/django/mymultidb) (revision 5420)
2094
2095	@@ -19,7 +19,7 @@
2096
2097	Returns number of errors.
2098	"""
2099	from django.conf import settings
2100	- from django.db import models, connection
2101	+ from django.db import connections, models, model_connection_name
2102	from django.db.models.loading import get_app_errors
2103	from django.db.models.fields.related import RelatedObject
2104
2105	@@ -30,6 +30,8 @@
2106
2107
2108	for cls in models.get_models(app):
2109	opts = cls._meta
2110	+ connection_name = model_connection_name(cls)
2111	+ connection = connections[connection_name].connection
2112
2113	# Do field-specific validation.
2114	for f in opts.local_fields:
2115	@@ -74,6 +76,12 @@
2116
2117	if f.rel:
2118	if f.rel.to not in models.get_models():
2119	e.add(opts, "'%s' has relation with model %s, which has not been installed" % (f.name, f.rel.to))
2120	+
2121	+#MULTIDB TODO: Fix this to allow relations that span databases by splitting querys up
2122	+ rel_connection = model_connection_name(f.rel.to)
2123	+ if rel_connection != connection_name:
2124	+ e.add(opts, "'%s' is configured to use connection '%s' but has relation with '%s', which is configured to use connection '%s'" % (cls.__name__, connection_name, f.rel.to.__name__, rel_connection))
2125	+
2126	# it is a string and we could not find the model it refers to
2127	# so skip the next section
2128	if isinstance(f.rel.to, (str, unicode)):
2129	=== django/core/management/sql.py
2130	==================================================================
2131	--- django/core/management/sql.py (/mirror/django/trunk) (revision 5420)
2132
2133	+++ django/core/management/sql.py (/local/django/mymultidb) (revision 5420)
2134
2135	@@ -8,11 +8,21 @@
2136
2137	from sets import Set as set # Python 2.3 fallback
2138
2139	def table_list():
2140	- "Returns a list of all table names that exist in the database."
2141	- from django.db import connection, get_introspection_module
2142	- cursor = connection.cursor()
2143	- return get_introspection_module().get_table_list(cursor)
2144	+ """Returns a list of all table names that exist in the database."""
2145	+ from django.db import connections
2146	+ table_list = []
2147	+ for conn in connections:
2148	+ table_list.extend(table_list_conn(conn))
2149	+ return table_list
2150
2151	+def table_list_conn(conn):
2152	+ from django.db import connections
2153	+ try:
2154	+ cursor = connections[conn].connection.cursor()
2155	+ return connections[conn].get_introspection_module().get_table_list(cursor)
2156	+ except:
2157	+ return []
2158	+
2159	def django_table_list(only_existing=False):
2160	"""
2161	Returns a list of all table names that have associated Django models and
2162	@@ -32,18 +42,34 @@
2163
2164	tables = [t for t in tables if t in existing]
2165	return tables
2166
2167	+def django_table_list_conn(conn, only_existing=False):
2168	+ from django.db import models
2169	+ from django.db import model_connection_name
2170	+ tables = []
2171	+ for app in models.get_apps():
2172	+ for model in models.get_models(app):
2173	+ if model_connection_name(model)==conn:
2174	+ tables.append(model._meta.db_table)
2175	+ tables.extend([f.m2m_db_table() for f in model._meta.many_to_many])
2176	+ if only_existing:
2177	+ existing = table_list_conn(conn)
2178	+ tables = [t for t in tables if t in existing]
2179	+ return tables
2180	+
2181	def installed_models(table_list):
2182	"Returns a set of all models that are installed, given a list of existing table names."
2183	- from django.db import connection, models
2184	+ from django.db import models
2185	all_models = []
2186	for app in models.get_apps():
2187	for model in models.get_models(app):
2188	- all_models.append(model)
2189	- if connection.features.uses_case_insensitive_names:
2190	- converter = lambda x: x.upper()
2191	- else:
2192	- converter = lambda x: x
2193	- return set([m for m in all_models if converter(m._meta.db_table) in map(converter, table_list)])
2194	+ connection = model._default_manager.db.connection
2195	+ if connection.features.uses_case_insensitive_names:
2196	+ converter = lambda x: x.upper()
2197	+ else:
2198	+ converter = lambda x: x
2199	+ if converter(model._meta.db_table) in map(converter, table_list):
2200	+ all_models.append(converter(model))
2201	+ return set(all_models)
2202
2203	def sequence_list():
2204	"Returns a list of information about all DB sequences for all models in all apps."
2205	@@ -66,7 +92,7 @@
2206
2207
2208	def sql_create(app, style):
2209	"Returns a list of the CREATE TABLE SQL statements for the given app."
2210	- from django.db import models
2211	+ from django.db import models, model_connection_name, _default
2212	from django.conf import settings
2213
2214	if settings.DATABASE_ENGINE == 'dummy':
2215	@@ -81,71 +107,79 @@
2216
2217	# generate invalid SQL (leaving models out of known_models is harmless, so
2218	# we can be conservative).
2219	app_models = models.get_models(app)
2220	- final_output = []
2221	known_models = set([model for model in installed_models(table_list()) if model not in app_models])
2222	pending_references = {}
2223
2224	+ connection_output = {}
2225	+
2226	for model in app_models:
2227	+ connection_name = model_connection_name(model)
2228	+ f_output = connection_output.setdefault(connection_name, [])
2229	output, references = sql_model_create(model, style, known_models)
2230	- final_output.extend(output)
2231	+ f_output.extend(output)
2232	for refto, refs in references.items():
2233	pending_references.setdefault(refto, []).extend(refs)
2234	if refto in known_models:
2235	- final_output.extend(sql_for_pending_references(refto, style, pending_references))
2236	- final_output.extend(sql_for_pending_references(model, style, pending_references))
2237	+ f_output.extend(sql_for_pending_references(refto, style, pending_references))
2238	+ f_output.extend(sql_for_pending_references(model, style, pending_references))
2239	# Keep track of the fact that we've created the table for this model.
2240	known_models.add(model)
2241
2242	# Create the many-to-many join tables.
2243	for model in app_models:
2244	- final_output.extend(many_to_many_sql_for_model(model, style))
2245	+ connection_name = model_connection_name(model)
2246	+ f_output = connection_output.setdefault(connection_name, [])
2247	+ f_output.extend(many_to_many_sql_for_model(model,style))
2248
2249	+
2250	# Handle references to tables that are from other apps
2251	# but don't exist physically.
2252	not_installed_models = set(pending_references.keys())
2253	if not_installed_models:
2254	+ f_output = connection_output.setdefault(_default, [])
2255	alter_sql = []
2256	for model in not_installed_models:
2257	alter_sql.extend(['-- ' + sql for sql in
2258	sql_for_pending_references(model, style, pending_references)])
2259	if alter_sql:
2260	- final_output.append('-- The following references should be added but depend on non-existent tables:')
2261	- final_output.extend(alter_sql)
2262	+ f_output.append('-- The following references should be added but depend on non-existent tables:')
2263	+ f_output.extend(alter_sql)
2264
2265	- return final_output
2266	+ return connection_output
2267
2268	def sql_delete(app, style):
2269	"Returns a list of the DROP TABLE SQL statements for the given app."
2270	- from django.db import connection, models, get_introspection_module
2271	+ from django.db import models, model_connection_name
2272	from django.db.backends.util import truncate_name
2273	from django.contrib.contenttypes import generic
2274	- introspection = get_introspection_module()
2275
2276	- # This should work even if a connection isn't available
2277	- try:
2278	- cursor = connection.cursor()
2279	- except:
2280	- cursor = None
2281	+ connection_output = {}
2282
2283	- # Figure out which tables already exist
2284	- if cursor:
2285	- table_names = introspection.get_table_list(cursor)
2286	- else:
2287	- table_names = []
2288	- if connection.features.uses_case_insensitive_names:
2289	- table_name_converter = lambda x: x.upper()
2290	- else:
2291	- table_name_converter = lambda x: x
2292	-
2293	- output = []
2294	- qn = connection.ops.quote_name
2295	-
2296	# Output DROP TABLE statements for standard application tables.
2297	to_delete = set()
2298
2299	references_to_delete = {}
2300	app_models = models.get_models(app)
2301	for model in app_models:
2302	+ connection = model._default_manager.db.connection
2303	+ introspection = model._default_manager.db.get_introspection_module()
2304	+ # This should work even if a connection isn't available
2305	+ try:
2306	+ cursor = connection.cursor()
2307	+ except:
2308	+ cursor = None
2309	+ # Figure out which tables already exist
2310	+ if cursor:
2311	+ table_names = introspection.get_table_list(cursor)
2312	+ else:
2313	+ table_names = []
2314	+ if connection.features.uses_case_insensitive_names:
2315	+ table_name_converter = lambda x: x.upper()
2316	+ else:
2317	+ table_name_converter = lambda x: x
2318	+
2319	+ qn = connection.ops.quote_name
2320	+
2321	if cursor and table_name_converter(model._meta.db_table) in table_names:
2322	# The table exists, so it needs to be dropped
2323	opts = model._meta
2324	@@ -156,6 +190,29 @@
2325
2326	to_delete.add(model)
2327
2328	for model in app_models:
2329	+ connection = model._default_manager.db.connection
2330	+ connection_name = model_connection_name(model)
2331	+ introspection = model._default_manager.db.get_introspection_module()
2332	+
2333	+ output = connection_output.setdefault(connection_name, [])
2334	+
2335	+ # This should work even if a connection isn't available
2336	+ try:
2337	+ cursor = connection.cursor()
2338	+ except:
2339	+ cursor = None
2340	+ # Figure out which tables already exist
2341	+ if cursor:
2342	+ table_names = introspection.get_table_list(cursor)
2343	+ else:
2344	+ table_names = []
2345	+ if connection.features.uses_case_insensitive_names:
2346	+ table_name_converter = str.upper
2347	+ else:
2348	+ table_name_converter = lambda x: x
2349	+
2350	+ qn = connection.ops.quote_name
2351	+
2352	if cursor and table_name_converter(model._meta.db_table) in table_names:
2353	# Drop the table now
2354	output.append('%s %s;' % (style.SQL_KEYWORD('DROP TABLE'),
2355	@@ -180,6 +237,29 @@
2356
2357
2358	# Output DROP TABLE statements for many-to-many tables.
2359	for model in app_models:
2360	+ connection = model._default_manager.db.connection
2361	+ connection_name = model_connection_name(model)
2362	+ introspection = model._default_manager.db.get_introspection_module()
2363	+
2364	+ output = connection_output.setdefault(connection_name, [])
2365	+
2366	+ # This should work even if a connection isn't available
2367	+ try:
2368	+ cursor = connection.cursor()
2369	+ except:
2370	+ cursor = None
2371	+ # Figure out which tables already exist
2372	+ if cursor:
2373	+ table_names = introspection.get_table_list(cursor)
2374	+ else:
2375	+ table_names = []
2376	+ if connection.features.uses_case_insensitive_names:
2377	+ table_name_converter = str.upper
2378	+ else:
2379	+ table_name_converter = lambda x: x
2380	+
2381	+ qn = connection.ops.quote_name
2382	+
2383	opts = model._meta
2384	for f in opts.local_many_to_many:
2385	if isinstance(f.rel, generic.GenericRel):
2386	@@ -195,71 +275,106 @@
2387
2388
2389	# Close database connection explicitly, in case this output is being piped
2390	# directly into a database client, to avoid locking issues.
2391	- if cursor:
2392	- cursor.close()
2393	- connection.close()
2394	+ for model in app_models:
2395	+ connection = model._default_manager.db.connection
2396	+ try:
2397	+ cursor = connection.cursor()
2398	+ except:
2399	+ cursor = None
2400	+ if cursor:
2401	+ cursor.close()
2402	+ connection.close()
2403
2404	- return output[::-1] # Reverse it, to deal with table dependencies.
2405	+ return connection_output
2406
2407	def sql_reset(app, style):
2408	"Returns a list of the DROP TABLE SQL, then the CREATE TABLE SQL, for the given module."
2409	- return sql_delete(app, style) + sql_all(app, style)
2410	+ connection_output = {}
2411	+ sql_dict = sql_delete(app, style)
2412	+ for connection_name, sql_list in sql_dict.items():
2413	+ output = connection_output.setdefault(connection_name, [])
2414	+ output.extend(sql_list)
2415	+ sql_dict = sql_all(app, style)
2416	+ for connection_name, sql_list in sql_dict.items():
2417	+ output = connection_output.setdefault(connection_name, [])
2418	+ output.extend(sql_list)
2419	+ return connection_output
2420
2421	-def sql_flush(style, only_django=False):
2422	+def sql_flush(connection, style, only_django=False):
2423	"""
2424	Returns a list of the SQL statements used to flush the database.
2425
2426	If only_django is True, then only table names that have associated Django
2427	models and are in INSTALLED_APPS will be included.
2428	"""
2429	- from django.db import connection
2430	+ from django.db import connections
2431	if only_django:
2432	- tables = django_table_list()
2433	+ tables = django_table_list_conn(connection)
2434	else:
2435	- tables = table_list()
2436	- statements = connection.ops.sql_flush(style, tables, sequence_list())
2437	- return statements
2438	+ tables = table_list_conn(connection)
2439	+ return [f for f in connections[connection].connection.ops.sql_flush(style, tables, sequence_list())]
2440
2441	def sql_custom(app):
2442	"Returns a list of the custom table modifying SQL statements for the given app."
2443	from django.db.models import get_models
2444	- output = []
2445	+ from django.db import model_connection_name
2446	+ connection_output = {}
2447
2448	app_models = get_models(app)
2449	app_dir = os.path.normpath(os.path.join(os.path.dirname(app.__file__), 'sql'))
2450
2451	for model in app_models:
2452	- output.extend(custom_sql_for_model(model))
2453	+ connection_name = model_connection_name(model)
2454	+ output = connection_output.setdefault(connection_name, [])
2455	+ output.extend(map(str, custom_sql_for_model(model)))
2456	+ return connection_output
2457
2458	- return output
2459	-
2460	def sql_indexes(app, style):
2461	"Returns a list of the CREATE INDEX SQL statements for all models in the given app."
2462	- from django.db import models
2463	- output = []
2464	- for model in models.get_models(app):
2465	- output.extend(sql_indexes_for_model(model, style))
2466	- return output
2467	+ from django.db import model_connection_name
2468	+ from django.db.models import get_models
2469	+ connection_output = {}
2470	+ for model in get_models(app):
2471	+ opts = model._meta
2472	+ connection_name = model_connection_name(model)
2473	+ output = connection_output.setdefault(connection_name, [])
2474	+ output.extend(map(str, sql_indexes_for_model(model, style)))
2475	+ return connection_output
2476
2477	def sql_all(app, style):
2478	"Returns a list of CREATE TABLE SQL, initial-data inserts, and CREATE INDEX SQL for the given module."
2479	- return sql_create(app, style) + sql_custom(app) + sql_indexes(app, style)
2480	+ connection_output = {}
2481	+ sql_dict = sql_create(app, style)
2482	+ for connection_name, sql_list in sql_dict.items():
2483	+ output = connection_output.setdefault(connection_name, [])
2484	+ output.extend(sql_list)
2485	+ sql_dict = sql_custom(app)
2486	+ for connection_name, sql_list in sql_dict.items():
2487	+ output = connection_output.setdefault(connection_name, [])
2488	+ output.extend(sql_list)
2489	+ sql_dict = sql_indexes(app, style)
2490	+ for connection_name, sql_list in sql_dict.items():
2491	+ output = connection_output.setdefault(connection_name, [])
2492	+ output.extend(sql_list)
2493	+ return connection_output
2494
2495	def sql_model_create(model, style, known_models=set()):
2496	"""
2497	Returns the SQL required to create a single model, as a tuple of:
2498	(list_of_sql, pending_references_dict)
2499	"""
2500	- from django.db import connection, models
2501	+ from django.db import models, model_connection_name, connections
2502
2503	opts = model._meta
2504	final_output = []
2505	table_output = []
2506	pending_references = {}
2507	+ connection_name = model_connection_name(model)
2508	+ connection = connections[connection_name].connection
2509	qn = connection.ops.quote_name
2510	inline_references = connection.features.inline_fk_references
2511	for f in opts.local_fields:
2512	- col_type = f.db_type()
2513	+ col_type = f.db_type(connection_name)
2514	tablespace = f.db_tablespace or opts.db_tablespace
2515	if col_type is None:
2516	# Skip ManyToManyFields, because they're not represented as
2517	@@ -291,7 +406,7 @@
2518
2519	table_output.append(' '.join(field_output))
2520	if opts.order_with_respect_to:
2521	table_output.append(style.SQL_FIELD(qn('_order')) + ' ' + \
2522	- style.SQL_COLTYPE(models.IntegerField().db_type()) + ' ' + \
2523	+ style.SQL_COLTYPE(models.IntegerField().db_type(connection_name)) + ' ' + \
2524	style.SQL_KEYWORD('NULL'))
2525	for field_constraints in opts.unique_together:
2526	table_output.append(style.SQL_KEYWORD('UNIQUE') + ' (%s)' % \
2527	@@ -320,10 +435,16 @@
2528
2529	"""
2530	Returns any ALTER TABLE statements to add constraints after the fact.
2531	"""
2532	- from django.db import connection
2533	+ from django.db import connections, model_connection_name
2534	from django.db.backends.util import truncate_name
2535
2536	+ connection_name = model_connection_name(model)
2537	+ connection = connections[connection_name].connection
2538	qn = connection.ops.quote_name
2539	+## if hasattr(connection.ops, 'max_constraint_length'):
2540	+## mnl = connection.ops.max_constraint_length
2541	+## else:
2542	+## mnl = connection.ops.max_name_length
2543	final_output = []
2544	if connection.features.supports_constraints:
2545	opts = model._meta
2546	@@ -345,12 +466,14 @@
2547
2548	return final_output
2549
2550	def many_to_many_sql_for_model(model, style):
2551	- from django.db import connection, models
2552	+ from django.db import models, connections, model_connection_name
2553	from django.contrib.contenttypes import generic
2554	from django.db.backends.util import truncate_name
2555
2556	opts = model._meta
2557	final_output = []
2558	+ connection_name = model_connection_name(model)
2559	+ connection = connections[connection_name].connection
2560	qn = connection.ops.quote_name
2561	inline_references = connection.features.inline_fk_references
2562	for f in opts.local_many_to_many:
2563	@@ -364,21 +487,21 @@
2564
2565	style.SQL_TABLE(qn(f.m2m_db_table())) + ' (']
2566	table_output.append(' %s %s %s%s,' %
2567	(style.SQL_FIELD(qn('id')),
2568	- style.SQL_COLTYPE(models.AutoField(primary_key=True).db_type()),
2569	+ style.SQL_COLTYPE(models.AutoField(primary_key=True).db_type(connection_name)),
2570	style.SQL_KEYWORD('NOT NULL PRIMARY KEY'),
2571	tablespace_sql))
2572	if inline_references:
2573	deferred = []
2574	table_output.append(' %s %s %s %s (%s)%s,' %
2575	(style.SQL_FIELD(qn(f.m2m_column_name())),
2576	- style.SQL_COLTYPE(models.ForeignKey(model).db_type()),
2577	+ style.SQL_COLTYPE(models.ForeignKey(model).db_type(connection_name)),
2578	style.SQL_KEYWORD('NOT NULL REFERENCES'),
2579	style.SQL_TABLE(qn(opts.db_table)),
2580	style.SQL_FIELD(qn(opts.pk.column)),
2581	connection.ops.deferrable_sql()))
2582	table_output.append(' %s %s %s %s (%s)%s,' %
2583	(style.SQL_FIELD(qn(f.m2m_reverse_name())),
2584	- style.SQL_COLTYPE(models.ForeignKey(f.rel.to).db_type()),
2585	+ style.SQL_COLTYPE(models.ForeignKey(f.rel.to).db_type(connection_name)),
2586	style.SQL_KEYWORD('NOT NULL REFERENCES'),
2587	style.SQL_TABLE(qn(f.rel.to._meta.db_table)),
2588	style.SQL_FIELD(qn(f.rel.to._meta.pk.column)),
2589	@@ -386,11 +509,11 @@
2590
2591	else:
2592	table_output.append(' %s %s %s,' %
2593	(style.SQL_FIELD(qn(f.m2m_column_name())),
2594	- style.SQL_COLTYPE(models.ForeignKey(model).db_type()),
2595	+ style.SQL_COLTYPE(models.ForeignKey(model).db_type(connection_name)),
2596	style.SQL_KEYWORD('NOT NULL')))
2597	table_output.append(' %s %s %s,' %
2598	(style.SQL_FIELD(qn(f.m2m_reverse_name())),
2599	- style.SQL_COLTYPE(models.ForeignKey(f.rel.to).db_type()),
2600	+ style.SQL_COLTYPE(models.ForeignKey(f.rel.to).db_type(connection_name)),
2601	style.SQL_KEYWORD('NOT NULL')))
2602	deferred = [
2603	(f.m2m_db_table(), f.m2m_column_name(), opts.db_table,
2604	@@ -456,9 +579,9 @@
2605
2606
2607	def sql_indexes_for_model(model, style):
2608	"Returns the CREATE INDEX SQL statements for a single model"
2609	- from django.db import connection
2610	output = []
2611
2612	+ connection = model._default_manager.db.connection
2613	qn = connection.ops.quote_name
2614	for f in model._meta.local_fields:
2615	if f.db_index and not ((f.primary_key or f.unique) and connection.features.autoindexes_primary_keys):
2616	@@ -489,3 +612,24 @@
2617
2618	dispatcher.send(signal=models.signals.post_syncdb, sender=app,
2619	app=app, created_models=created_models,
2620	verbosity=verbosity, interactive=interactive)
2621	+
2622	+def sql_collate(connection_output, reverse=False):
2623	+ from django.db import _default
2624	+ final_output = []
2625	+ if len(connection_output.keys()) == 1:
2626	+ # all for the default connection
2627	+ for statements in connection_output.values():
2628	+ final_output.extend(statements)
2629	+ if reverse:
2630	+ final_output.reverse()
2631	+ else:
2632	+ for connection_name, statements in connection_output.items():
2633	+ if not statements:
2634	+ continue
2635	+ final_output.append(' -- The following statements are for connection: %s' % connection_name)
2636	+ if reverse:
2637	+ statements.reverse()
2638	+ final_output.extend(statements)
2639	+ final_output.append(' -- END statements for %s\n' %
2640	+ connection_name)
2641	+ return '\n'.join(map(str, final_output))
2642	=== django/core/context_processors.py
2643	==================================================================
2644	--- django/core/context_processors.py (/mirror/django/trunk) (revision 5420)
2645
2646	+++ django/core/context_processors.py (/local/django/mymultidb) (revision 5420)
2647
2648	@@ -33,8 +33,11 @@
2649
2650	context_extras = {}
2651	if settings.DEBUG and request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS:
2652	context_extras['debug'] = True
2653	- from django.db import connection
2654	- context_extras['sql_queries'] = connection.queries
2655	+ from django.db import connections
2656	+ queries = []
2657	+ for conn in connections:
2658	+ queries.extend(connections[conn].connection.queries)
2659	+ context_extras['sql_queries'] = queries
2660	return context_extras
2661
2662	def i18n(request):
2663	=== django/contrib/contenttypes/generic.py
2664	==================================================================
2665	--- django/contrib/contenttypes/generic.py (/mirror/django/trunk) (revision 5420)
2666
2667	+++ django/contrib/contenttypes/generic.py (/local/django/mymultidb) (revision 5420)
2668
2669	@@ -4,7 +4,6 @@
2670
2671
2672	from django import oldforms
2673	from django.core.exceptions import ObjectDoesNotExist
2674	-from django.db import connection
2675	from django.db.models import signals
2676	from django.db.models.fields.related import RelatedField, Field, ManyToManyRel
2677	from django.db.models.loading import get_model
2678	@@ -154,7 +153,7 @@
2679
2680	def get_internal_type(self):
2681	return "ManyToManyField"
2682
2683	- def db_type(self):
2684	+ def db_type(self, connection):
2685	# Since we're simulating a ManyToManyField, in effect, best return the
2686	# same db_type as well.
2687	return None
2688	@@ -184,7 +183,7 @@
2689
2690	superclass = rel_model._default_manager.__class__
2691	RelatedManager = create_generic_related_manager(superclass)
2692
2693	- qn = connection.ops.quote_name
2694	+ qn = rel_model._default_manager.db.connection.ops.quote_name
2695
2696	manager = RelatedManager(
2697	model = rel_model,
2698	=== django/contrib/auth/backends.py
2699	==================================================================
2700	--- django/contrib/auth/backends.py (/mirror/django/trunk) (revision 5420)
2701
2702	+++ django/contrib/auth/backends.py (/local/django/mymultidb) (revision 5420)
2703
2704	@@ -1,4 +1,3 @@
2705
2706	-from django.db import connection
2707	from django.contrib.auth.models import User
2708
2709	try:
2710	@@ -23,6 +22,7 @@
2711
2712	def get_group_permissions(self, user_obj):
2713	"Returns a list of permission strings that this user has through his/her groups."
2714	if not hasattr(user_obj, '_group_perm_cache'):
2715	+ connection = User._default_manager.db.connection
2716	cursor = connection.cursor()
2717	# The SQL below works out to the following, after DB quoting:
2718	# cursor.execute("""
2719	=== tests/modeltests/multiple_databases (new directory)
2720	==================================================================
2721	=== tests/modeltests/multiple_databases/__init__.py
2722	==================================================================
2723	--- tests/modeltests/multiple_databases/__init__.py (/mirror/django/trunk) (revision 5420)
2724
2725	+++ tests/modeltests/multiple_databases/__init__.py (/local/django/mymultidb) (revision 5420)
2726
2727	@@ -0,0 +1 @@
2728
2729	+pass
2730
2731	=== tests/modeltests/multiple_databases/models.py
2732	==================================================================
2733	--- tests/modeltests/multiple_databases/models.py (/mirror/django/trunk) (revision 5420)
2734
2735	+++ tests/modeltests/multiple_databases/models.py (/local/django/mymultidb) (revision 5420)
2736
2737	@@ -0,0 +1,221 @@
2738
2739	+"""
2740	+XXX. Using multiple database connections
2741	+
2742	+Django normally uses only a single database connection. However,
2743	+support is available for using any number of different, named
2744	+connections. Multiple database support is entirely optional and has
2745	+no impact on your application if you don't use it.
2746	+
2747	+Named connections are defined in your settings module. Create a
2748	+`OTHER_DATABASES` variable that is a dict, mapping connection names to their
2749	+particulars. The particulars are defined in a dict with the same keys
2750	+as the variable names as are used to define the default connection, with one
2751	+addition: MODELS.
2752	+
2753	+The MODELS item in an OTHER_DATABASES entry is a list of the apps and models
2754	+that will use that connection.
2755	+
2756	+Access to named connections is through `django.db.connections`, which
2757	+behaves like a dict: you access connections by name. Connections are
2758	+established lazily, when accessed. `django.db.connections[database]`
2759	+holds a `ConnectionInfo` instance, with the attributes:
2760	+`DatabaseError`, `backend`, `get_introspection_module`,
2761	+`get_creation_module`, and `runshell`.
2762	+
2763	+To access a model's connection, use its manager. The connection is available
2764	+at `model._default_manager.db.connection`. To find the backend or other
2765	+connection metadata, use `model._meta.db` to access the full ConnectionInfo
2766	+with connection metadata.
2767	+"""
2768	+
2769	+from django.db import models
2770	+
2771	+class Artist(models.Model):
2772	+ name = models.CharField(max_length=100)
2773	+ alive = models.BooleanField(default=True)
2774	+
2775	+ def __str__(self):
2776	+ return self.name
2777	+
2778	+
2779	+class Opus(models.Model):
2780	+ artist = models.ForeignKey(Artist)
2781	+ name = models.CharField(max_length=100)
2782	+ year = models.IntegerField()
2783	+
2784	+ def __str__(self):
2785	+ return "%s (%s)" % (self.name, self.year)
2786	+
2787	+
2788	+class Widget(models.Model):
2789	+ code = models.CharField(max_length=10, unique=True)
2790	+ weight = models.IntegerField()
2791	+
2792	+ def __str__(self):
2793	+ return self.code
2794	+
2795	+
2796	+class DooHickey(models.Model):
2797	+ name = models.CharField(max_length=50)
2798	+ widgets = models.ManyToManyField(Widget, related_name='doohickeys')
2799	+
2800	+ def __str__(self):
2801	+ return self.name
2802	+
2803	+
2804	+class Vehicle(models.Model):
2805	+ make = models.CharField(max_length=20)
2806	+ model = models.CharField(max_length=20)
2807	+ year = models.IntegerField()
2808	+
2809	+ def __str__(self):
2810	+ return "%d %s %s" % (self.year, self.make, self.model)
2811	+
2812	+
2813	+__test__ = {'API_TESTS': """
2814	+
2815	+# See what connections are defined. django.db.connections acts like a dict.
2816	+>>> from django.db import connection, connections, _default, model_connection_name
2817	+>>> from django.conf import settings
2818	+
2819	+# Connections are referenced by name
2820	+>>> connections['_a']
2821	+Connection: ...
2822	+>>> connections['_b']
2823	+Connection: ...
2824	+
2825	+# Let's see what connections are available. The default connection is always
2826	+# included in connections as well, and may be accessed as connections[_default].
2827	+
2828	+>>> connection_names = connections.keys()
2829	+>>> connection_names.sort()
2830	+>>> connection_names
2831	+[<default>, '_a', '_b']
2832	+
2833	+# Invalid connection names raise ImproperlyConfigured
2834	+
2835	+>>> connections['bad']
2836	+Traceback (most recent call last):
2837	+ ...
2838	+ImproperlyConfigured: No database connection 'bad' has been configured
2839	+
2840	+# The model_connection_name() function will tell you the name of the
2841	+# connection that a model is configured to use.
2842	+
2843	+>>> model_connection_name(Artist)
2844	+'_a'
2845	+>>> model_connection_name(Widget)
2846	+'_b'
2847	+>>> model_connection_name(Vehicle) is _default
2848	+True
2849	+>>> a = Artist(name="Paul Klee", alive=False)
2850	+>>> a.save()
2851	+>>> w = Widget(code='100x2r', weight=1000)
2852	+>>> w.save()
2853	+>>> v = Vehicle(make='Chevy', model='Camaro', year='1966')
2854	+>>> v.save()
2855	+>>> artists = Artist.objects.all()
2856	+>>> list(artists)
2857	+[<Artist: Paul Klee>]
2858	+
2859	+# Models can access their connections through the db property of their
2860	+# default manager.
2861	+
2862	+>>> paul = _[0]
2863	+>>> Artist.objects.db
2864	+Connection: ... (ENGINE=... NAME=...)
2865	+>>> paul._default_manager.db
2866	+Connection: ... (ENGINE=... NAME=...)
2867	+
2868	+# When transactions are not managed, model save will commit only
2869	+# for the model's connection.
2870	+
2871	+>>> from django.db import transaction
2872	+>>> transaction.enter_transaction_management()
2873	+>>> transaction.managed(False)
2874	+>>> a = Artist(name="Joan Miro", alive=False)
2875	+>>> w = Widget(code="99rbln", weight=1)
2876	+>>> a.save()
2877	+
2878	+# Only connection '_a' is committed, so if we rollback
2879	+# all connections we'll forget the new Widget.
2880	+
2881	+>>> transaction.rollback()
2882	+>>> list(Artist.objects.all())
2883	+[<Artist: Paul Klee>, <Artist: Joan Miro>]
2884	+>>> list(Widget.objects.all())
2885	+[<Widget: 100x2r>]
2886	+
2887	+# Managed transaction state applies across all connections.
2888	+
2889	+>>> transaction.managed(True)
2890	+
2891	+# When managed, just as when using a single connection, updates are
2892	+# not committed until a commit is issued.
2893	+
2894	+>>> a = Artist(name="Pablo Picasso", alive=False)
2895	+>>> a.save()
2896	+>>> w = Widget(code="99rbln", weight=1)
2897	+>>> w.save()
2898	+>>> v = Vehicle(make='Pontiac', model='Fiero', year='1987')
2899	+>>> v.save()
2900	+
2901	+# The connections argument may be passed to commit, rollback, and the
2902	+# commit_on_success decorator as a keyword argument, as the first (for
2903	+# commit and rollback) or second (for the decorator) positional
2904	+# argument. It may be passed as a ConnectionInfo object, a connection
2905	+# (DatabaseWrapper) object, a connection name, or a list or dict of
2906	+# ConnectionInfo objects, connection objects, or connection names. If a
2907	+# dict is passed, the keys are ignored and the values used as the list
2908	+# of connections to commit, rollback, etc.
2909	+
2910	+>>> transaction.commit(connections['_b'])
2911	+>>> transaction.commit('_b')
2912	+>>> transaction.commit(connections='_b')
2913	+>>> transaction.commit(connections=['_b'])
2914	+>>> transaction.commit(['_a', '_b'])
2915	+>>> transaction.commit(connections)
2916	+
2917	+# When the connections argument is omitted entirely, the transaction
2918	+# command applies to all connections. Here we have committed
2919	+# connections 'django_test_db_a' and 'django_test_db_b', but not the
2920	+# default connection, so the new vehicle is lost on rollback.
2921	+
2922	+>>> transaction.rollback()
2923	+>>> list(Artist.objects.all())
2924	+[<Artist: Paul Klee>, <Artist: Joan Miro>, <Artist: Pablo Picasso>]
2925	+>>> list(Widget.objects.all())
2926	+[<Widget: 100x2r>, <Widget: 99rbln>]
2927	+>>> list(Vehicle.objects.all())
2928	+[<Vehicle: 1966 Chevy Camaro>]
2929	+>>> transaction.rollback()
2930	+>>> transaction.managed(False)
2931	+>>> transaction.leave_transaction_management()
2932	+
2933	+# Of course, relations and all other normal database operations work
2934	+# with models that use named connections just the same as with models
2935	+# that use the default connection. The only caveat is that you can't
2936	+# use a relation between two models that are stored in different
2937	+# databases. Note that that doesn't mean that two models using
2938	+# different connection names can't be related; only that in the the
2939	+# context in which they are used, if you use the relation, the
2940	+# connections named by the two models must resolve to the same
2941	+# database.
2942	+
2943	+>>> a = Artist.objects.get(name="Paul Klee")
2944	+>>> list(a.opus_set.all())
2945	+[]
2946	+>>> a.opus_set.create(name="Magic Garden", year="1926")
2947	+<Opus: Magic Garden (1926)>
2948	+>>> list(a.opus_set.all())
2949	+[<Opus: Magic Garden (1926)>]
2950	+>>> d = DooHickey(name='Thing')
2951	+>>> d.save()
2952	+>>> d.widgets.create(code='d101', weight=92)
2953	+<Widget: d101>
2954	+>>> list(d.widgets.all())
2955	+[<Widget: d101>]
2956	+>>> w = Widget.objects.get(code='d101')
2957	+>>> list(w.doohickeys.all())
2958	+[<DooHickey: Thing>]
2959	+"""}
2960
2961	Property changes on: tests/modeltests/multiple_databases
2962	___________________________________________________________________
2963	Name: svn:ignore
2964	+*.pyc
2965	+
2966
2967	=== tests/regressiontests/manager_db (new directory)
2968	==================================================================
2969	=== tests/regressiontests/manager_db/__init__.py
2970	==================================================================
2971	=== tests/regressiontests/manager_db/tests.py
2972	==================================================================
2973	--- tests/regressiontests/manager_db/tests.py (/mirror/django/trunk) (revision 5420)
2974
2975	+++ tests/regressiontests/manager_db/tests.py (/local/django/mymultidb) (revision 5420)
2976
2977	@@ -0,0 +1,17 @@
2978
2979	+import unittest
2980	+from regressiontests.manager_db.models import Insect
2981	+
2982	+class TestManagerDBAccess(unittest.TestCase):
2983	+
2984	+ def test_db_property(self):
2985	+ m = Insect.objects
2986	+ db = Insect.objects.db
2987	+ assert db
2988	+ assert db.connection
2989	+ assert db.connection.cursor
2990	+ assert db.backend
2991	+ assert db.connection.ops.quote_name
2992	+ assert db.get_creation_module
2993	+
2994	+if __name__ == '__main__':
2995	+ unittest.main()
2996	=== tests/regressiontests/manager_db/models.py
2997	==================================================================
2998	--- tests/regressiontests/manager_db/models.py (/mirror/django/trunk) (revision 5420)
2999
3000	+++ tests/regressiontests/manager_db/models.py (/local/django/mymultidb) (revision 5420)
3001
3002	@@ -0,0 +1,5 @@
3003
3004	+from django.db import models
3005	+
3006	+class Insect(models.Model):
3007	+ common_name = models.CharField(max_length=64)
3008	+ latin_name = models.CharField(max_length=128)
3009
3010	Property changes on: tests/regressiontests/manager_db
3011	___________________________________________________________________
3012	Name: svn:ignore
3013	+*.pyc
3014	+
3015
3016	=== tests/regressiontests/thread_isolation (new directory)
3017	==================================================================
3018	=== tests/regressiontests/thread_isolation/__init__.py
3019	==================================================================
3020	=== tests/regressiontests/thread_isolation/tests.py
3021	==================================================================
3022	--- tests/regressiontests/thread_isolation/tests.py (/mirror/django/trunk) (revision 5420)
3023
3024	+++ tests/regressiontests/thread_isolation/tests.py (/local/django/mymultidb) (revision 5420)
3025
3026	@@ -0,0 +1,251 @@
3027
3028	+# tests that db settings can be different in different threads
3029	+#
3030	+#
3031	+# What's going on here:
3032	+#
3033	+# Simulating multiple web requests in a threaded environment, one in
3034	+# which settings are different for each request. So we replace
3035	+# django.conf.settings with a thread local, with different
3036	+# configurations in each thread, and then fire off three
3037	+# simultaneous requests (using a condition to sync them up), and
3038	+# test that each thread sees its own settings and the models in each
3039	+# thread attempt to connect to the correct database as per their
3040	+# settings.
3041	+#
3042	+
3043	+
3044	+import copy
3045	+import os
3046	+import sys
3047	+import threading
3048	+import unittest
3049	+from thread import get_ident
3050	+
3051	+from django.conf import settings, UserSettingsHolder
3052	+from django.core.handlers.wsgi import WSGIHandler
3053	+from django.db import model_connection_name, _default, connection, connections
3054	+from regressiontests.request_isolation.tests import MockHandler
3055	+from regressiontests.thread_isolation.models import *
3056	+
3057	+try:
3058	+ # Only exists in Python 2.4+
3059	+ from threading import local
3060	+except ImportError:
3061	+ # Import copy of _thread_local.py from Python 2.4
3062	+ from django.utils._threading_local import local
3063	+
3064	+# helpers
3065	+EV = threading.Event()
3066	+
3067	+class LocalSettings:
3068	+ """Settings holder that allows thread-local overrides of defaults.
3069	+ """
3070	+ def __init__(self, defaults):
3071	+ self._defaults = defaults
3072	+ self._local = local()
3073	+
3074	+ def __getattr__(self, attr):
3075	+ if attr in ('_defaults', '_local'):
3076	+ return self.__dict__[attr]
3077	+ _local = self.__dict__['_local']
3078	+ _defaults = self.__dict__['_defaults']
3079	+ debug("LS get %s (%s)", attr, hasattr(_local, attr))
3080	+ if not hasattr(_local, attr):
3081	+ # Make sure everything we return is the local version; this
3082	+ # avoids sets to deep datastructures overwriting the defaults
3083	+ setattr(_local, attr, copy.deepcopy(getattr(_defaults, attr)))
3084	+ return getattr(_local, attr)
3085	+
3086	+ def __setattr__(self, attr, val):
3087	+ if attr in ('_defaults', '_local'):
3088	+ self.__dict__[attr] = val
3089	+ else:
3090	+ debug("LS set local %s = %s", attr, val)
3091	+ setattr(self.__dict__['_local'], attr, val)
3092	+
3093	+def thread_two(func, *arg):
3094	+ def start():
3095	+ # from django.conf import settings
3096	+ settings.OTHER_DATABASES['_b']['MODELS'] = []
3097	+
3098	+ debug("t2 ODB: %s", settings.OTHER_DATABASES)
3099	+ debug("t2 waiting")
3100	+ EV.wait(2.0)
3101	+ func(*arg)
3102	+ debug("t2 complete")
3103	+ t2 = threading.Thread(target=start)
3104	+ t2.start()
3105	+ return t2
3106	+
3107	+def thread_three(func, *arg):
3108	+ def start():
3109	+ # from django.conf import settings
3110	+ settings.OTHER_DATABASES['_b']['MODELS'] = ['ti.MY']
3111	+ settings.OTHER_DATABASES['_b'], \
3112	+ settings.OTHER_DATABASES['_a'] = \
3113	+ settings.OTHER_DATABASES['_a'], \
3114	+ settings.OTHER_DATABASES['_b']
3115	+
3116	+ settings.DATABASE_NAME = \
3117	+ settings.OTHER_DATABASES['_a']['DATABASE_NAME']
3118	+
3119	+ debug("t3 ODB: %s", settings.OTHER_DATABASES)
3120	+ debug("3 %s: start: default: %s", get_ident(), settings.DATABASE_NAME)
3121	+ debug("3 %s: start: conn: %s", get_ident(),
3122	+ connection.settings.DATABASE_NAME)
3123	+
3124	+ debug("t3 waiting")
3125	+ EV.wait(2.0)
3126	+ func(*arg)
3127	+ debug("t3 complete")
3128	+ t3 = threading.Thread(target=start)
3129	+ t3.start()
3130	+ return t3
3131	+
3132	+def debug(*arg):
3133	+ pass
3134	+## msg, arg = arg[0], arg[1:]
3135	+## print msg % arg
3136	+
3137	+def start_response(code, headers):
3138	+ debug("start response: %s %s", code, headers)
3139	+ pass
3140	+
3141	+class TestThreadIsolation(unittest.TestCase):
3142	+ # event used to synchronize threads so we can be sure they are running
3143	+ # together
3144	+ lock = threading.RLock()
3145	+ errors = []
3146	+
3147	+ def setUp(self):
3148	+ debug("setup")
3149	+ self.settings = settings._target
3150	+ settings._target = UserSettingsHolder(copy.deepcopy(settings._target))
3151	+ settings.OTHER_DATABASES['_a']['MODELS'] = ['ti.MX']
3152	+ settings.OTHER_DATABASES['_b']['MODELS'] = ['ti.MY']
3153	+
3154	+ # normal settings holders aren't thread-safe, so we need to substitute
3155	+ # one that is (and so allows per-thread settings)
3156	+ holder = settings._target
3157	+ settings._target = LocalSettings(holder)
3158	+
3159	+ def teardown(self):
3160	+ debug("teardown")
3161	+ settings._target = self.settings
3162	+
3163	+ def add_thread_error(self, err):
3164	+ self.lock.acquire()
3165	+ try:
3166	+ self.errors.append(err)
3167	+ finally:
3168	+ self.lock.release()
3169	+
3170	+ def thread_errors(self):
3171	+ self.lock.acquire()
3172	+ try:
3173	+ return self.errors[:]
3174	+ finally:
3175	+ self.lock.release()
3176	+
3177	+ def request_one(self, request):
3178	+ """Start out with settings as originally configured"""
3179	+ from django.conf import settings
3180	+ debug("request_one: %s", settings.OTHER_DATABASES)
3181	+
3182	+ self.assertEqual(model_connection_name(MQ), _default)
3183	+ self.assertEqual(model_connection_name(MX), '_a')
3184	+ self.assertEqual(
3185	+ MX._default_manager.db.connection.settings.DATABASE_NAME,
3186	+ settings.OTHER_DATABASES['_a']['DATABASE_NAME'])
3187	+ self.assertEqual(model_connection_name(MY), '_b')
3188	+ self.assertEqual(
3189	+ MY._default_manager.db.connection.settings.DATABASE_NAME,
3190	+ settings.OTHER_DATABASES['_b']['DATABASE_NAME'])
3191	+ self.assert_(MQ._default_manager.db.connection is
3192	+ connections[_default].connection)
3193	+ self.assertEqual(
3194	+ MQ._default_manager.db.connection.settings.DATABASE_NAME,
3195	+ settings.DATABASE_NAME)
3196	+ self.assertEqual(connection.settings.DATABASE_NAME,
3197	+ settings.DATABASE_NAME)
3198	+
3199	+ def request_two(self, request):
3200	+ """Between the first and second requests, settings change to assign
3201	+ model MY to a different connection
3202	+ """
3203	+ # from django.conf import settings
3204	+ debug("request_two: %s", settings.OTHER_DATABASES)
3205	+
3206	+ try:
3207	+ self.assertEqual(model_connection_name(MQ), _default)
3208	+ self.assertEqual(model_connection_name(MX), '_a')
3209	+ self.assertEqual(
3210	+ MX._default_manager.db.connection.settings.DATABASE_NAME,
3211	+ settings.OTHER_DATABASES['_a']['DATABASE_NAME'])
3212	+ self.assertEqual(model_connection_name(MY), _default)
3213	+ self.assertEqual(
3214	+ MY._default_manager.db.connection.settings.DATABASE_NAME,
3215	+ settings.DATABASE_NAME)
3216	+ self.assert_(MQ._default_manager.db.connection is
3217	+ connections[_default].connection)
3218	+ self.assertEqual(
3219	+ MQ._default_manager.db.connection.settings.DATABASE_NAME,
3220	+ settings.DATABASE_NAME)
3221	+ self.assertEqual(connection.settings.DATABASE_NAME,
3222	+ settings.DATABASE_NAME)
3223	+ except:
3224	+ self.add_thread_error(sys.exc_info())
3225	+
3226	+ def request_three(self, request):
3227	+ """Between the 2nd and 3rd requests, the settings at the names in
3228	+ OTHER_DATABASES have changed.
3229	+ """
3230	+ # from django.conf import settings
3231	+ debug("3 %s: %s", get_ident(), settings.OTHER_DATABASES)
3232	+ debug("3 %s: default: %s", get_ident(), settings.DATABASE_NAME)
3233	+ debug("3 %s: conn: %s", get_ident(),
3234	+ connection.settings.DATABASE_NAME)
3235	+ try:
3236	+ self.assertEqual(model_connection_name(MQ), _default)
3237	+ self.assertEqual(model_connection_name(MX), '_b')
3238	+ self.assertEqual(
3239	+ MX._default_manager.db.connection.settings.DATABASE_NAME,
3240	+ settings.OTHER_DATABASES['_b']['DATABASE_NAME'])
3241	+ self.assertEqual(model_connection_name(MY), '_a')
3242	+ self.assertEqual(
3243	+ MY._default_manager.db.connection.settings.DATABASE_NAME,
3244	+ settings.OTHER_DATABASES['_a']['DATABASE_NAME'])
3245	+ self.assert_(MQ._default_manager.db.connection is
3246	+ connections[_default].connection)
3247	+ self.assertEqual(
3248	+ connection.settings.DATABASE_NAME,
3249	+ settings.OTHER_DATABASES['_a']['DATABASE_NAME'])
3250	+ except:
3251	+ self.add_thread_error(sys.exc_info())
3252	+
3253	+ def test_thread_isolation(self):
3254	+
3255	+ debug("running tests")
3256	+
3257	+ env = os.environ.copy()
3258	+ env['PATH_INFO'] = '/'
3259	+ env['REQUEST_METHOD'] = 'GET'
3260	+
3261	+ t2 = thread_two(MockHandler(self.request_two), env, start_response)
3262	+ t3 = thread_three(MockHandler(self.request_three), env, start_response)
3263	+
3264	+ try:
3265	+ EV.set()
3266	+ MockHandler(self.request_one)(env, start_response)
3267	+ finally:
3268	+ t2.join()
3269	+ t3.join()
3270	+ err = self.thread_errors()
3271	+ if err:
3272	+ import traceback
3273	+ for e in err:
3274	+ traceback.print_exception(*e)
3275	+ raise AssertionError("%s thread%s failed" %
3276	+ (len(err), len(err) > 1 and 's' or
3277	+ ''))
3278	+
3279	=== tests/regressiontests/thread_isolation/models.py
3280	==================================================================
3281	--- tests/regressiontests/thread_isolation/models.py (/mirror/django/trunk) (revision 5420)
3282
3283	+++ tests/regressiontests/thread_isolation/models.py (/local/django/mymultidb) (revision 5420)
3284
3285	@@ -0,0 +1,19 @@
3286
3287	+from django.db import models
3288	+
3289	+# models
3290	+class MQ(models.Model):
3291	+ val = models.CharField(max_length=10)
3292	+ class Meta:
3293	+ app_label = 'ti'
3294	+
3295	+
3296	+class MX(models.Model):
3297	+ val = models.CharField(max_length=10)
3298	+ class Meta:
3299	+ app_label = 'ti'
3300	+
3301	+
3302	+class MY(models.Model):
3303	+ val = models.CharField(max_length=10)
3304	+ class Meta:
3305	+ app_label = 'ti'
3306
3307	Property changes on: tests/regressiontests/thread_isolation
3308	___________________________________________________________________
3309	Name: svn:ignore
3310	+*.pyc
3311	+
3312
3313	=== tests/regressiontests/request_isolation (new directory)
3314	==================================================================
3315	=== tests/regressiontests/request_isolation/__init__.py
3316	==================================================================
3317	=== tests/regressiontests/request_isolation/tests.py
3318	==================================================================
3319	--- tests/regressiontests/request_isolation/tests.py (/mirror/django/trunk) (revision 5420)
3320
3321	+++ tests/regressiontests/request_isolation/tests.py (/local/django/mymultidb) (revision 5420)
3322
3323	@@ -0,0 +1,100 @@
3324
3325	+# tests that db settings can change between requests
3326	+import copy
3327	+import os
3328	+import unittest
3329	+from django.conf import settings, UserSettingsHolder
3330	+from django.core.handlers.wsgi import WSGIHandler
3331	+from django.db import models, model_connection_name, _default, connection
3332	+from django.http import HttpResponse
3333	+from regressiontests.request_isolation.models import *
3334	+
3335	+
3336	+# helpers
3337	+class MockHandler(WSGIHandler):
3338	+
3339	+ def __init__(self, test):
3340	+ self.test = test
3341	+ super(MockHandler, self).__init__()
3342	+
3343	+ def get_response(self, request):
3344	+ # debug("mock handler answering %s, %s", path, request)
3345	+ return HttpResponse(self.test(request))
3346	+
3347	+
3348	+def debug(*arg):
3349	+ pass
3350	+ # msg, arg = arg[0], arg[1:]
3351	+ # print msg % arg
3352	+
3353	+
3354	+def start_response(code, headers):
3355	+ debug("start response: %s %s", code, headers)
3356	+ pass
3357	+
3358	+# tests
3359	+class TestRequestIsolation(unittest.TestCase):
3360	+
3361	+ def setUp(self):
3362	+ debug("setup")
3363	+ self.settings = settings._target
3364	+ settings._target = UserSettingsHolder(copy.deepcopy(settings._target))
3365	+ settings.OTHER_DATABASES['_a']['MODELS'] = ['ri.MX']
3366	+ settings.OTHER_DATABASES['_b']['MODELS'] = ['ri.MY']
3367	+
3368	+ def tearDown(self):
3369	+ debug("teardown")
3370	+ settings._target = self.settings
3371	+
3372	+ def testRequestIsolation(self):
3373	+ env = os.environ.copy()
3374	+ env['PATH_INFO'] = '/'
3375	+ env['REQUEST_METHOD'] = 'GET'
3376	+
3377	+ def request_one(request):
3378	+ """Start out with settings as originally configured"""
3379	+ self.assertEqual(model_connection_name(MX), '_a')
3380	+ self.assertEqual(
3381	+ MX._default_manager.db.connection.settings.DATABASE_NAME,
3382	+ settings.OTHER_DATABASES['_a']['DATABASE_NAME'])
3383	+ self.assertEqual(model_connection_name(MY), '_b')
3384	+ self.assertEqual(
3385	+ MY._default_manager.db.connection.settings.DATABASE_NAME,
3386	+ settings.OTHER_DATABASES['_b']['DATABASE_NAME'])
3387	+
3388	+ def request_two(request):
3389	+ """Between the first and second requests, settings change to assign
3390	+ model MY to a different connection
3391	+ """
3392	+ self.assertEqual(model_connection_name(MX), '_a')
3393	+ self.assertEqual(
3394	+ MX._default_manager.db.connection.settings.DATABASE_NAME,
3395	+ settings.OTHER_DATABASES['_a']['DATABASE_NAME'])
3396	+ self.assertEqual(model_connection_name(MY), _default)
3397	+ self.assertEqual(
3398	+ MY._default_manager.db.connection.settings.DATABASE_NAME,
3399	+ settings.DATABASE_NAME)
3400	+
3401	+ def request_three(request):
3402	+ """Between the 2nd and 3rd requests, the settings at the names in
3403	+ OTHER_DATABASES have changed.
3404	+ """
3405	+ self.assertEqual(model_connection_name(MX), '_b')
3406	+ self.assertEqual(
3407	+ MX._default_manager.db.connection.settings.DATABASE_NAME,
3408	+ settings.OTHER_DATABASES['_b']['DATABASE_NAME'])
3409	+ self.assertEqual(model_connection_name(MY), '_a')
3410	+ self.assertEqual(
3411	+ MY._default_manager.db.connection.settings.DATABASE_NAME,
3412	+ settings.OTHER_DATABASES['_a']['DATABASE_NAME'])
3413	+
3414	+ MockHandler(request_one)(env, start_response)
3415	+
3416	+ settings.OTHER_DATABASES['_b']['MODELS'] = []
3417	+ MockHandler(request_two)(env, start_response)
3418	+
3419	+ settings.OTHER_DATABASES['_b']['MODELS'] = ['ri.MY']
3420	+ settings.OTHER_DATABASES['_b'], \
3421	+ settings.OTHER_DATABASES['_a'] = \
3422	+ settings.OTHER_DATABASES['_a'], \
3423	+ settings.OTHER_DATABASES['_b']
3424	+ MockHandler(request_three)(env, start_response)
3425	=== tests/regressiontests/request_isolation/models.py
3426	==================================================================
3427	--- tests/regressiontests/request_isolation/models.py (/mirror/django/trunk) (revision 5420)
3428
3429	+++ tests/regressiontests/request_isolation/models.py (/local/django/mymultidb) (revision 5420)
3430
3431	@@ -0,0 +1,13 @@
3432
3433	+from django.db import models
3434	+
3435	+# models
3436	+class MX(models.Model):
3437	+ val = models.CharField(max_length=10)
3438	+ class Meta:
3439	+ app_label = 'ri'
3440	+
3441	+
3442	+class MY(models.Model):
3443	+ val = models.CharField(max_length=10)
3444	+ class Meta:
3445	+ app_label = 'ri'
3446
3447	Property changes on: tests/regressiontests/request_isolation
3448	___________________________________________________________________
3449	Name: svn:ignore
3450	+*.pyc
3451	+
3452
3453	=== tests/runtests.py
3454	==================================================================
3455	--- tests/runtests.py (/mirror/django/trunk) (revision 5420)
3456
3457	+++ tests/runtests.py (/local/django/mymultidb) (revision 5420)
3458
3459	@@ -12,6 +12,14 @@
3460
3461
3462
3463	CONTRIB_DIR_NAME = 'django.contrib'
3464	+TEST_OTHER_DATABASES = {
3465	+ '_a': { 'DATABASE_NAME': 'django_test_a.db',
3466	+ 'MODELS': [ 'multiple_databases.Artist',
3467	+ 'multiple_databases.Opus' ]},
3468	+ '_b': { 'DATABASE_NAME': 'django_test_b.db',
3469	+ 'MODELS': [ 'multiple_databases.Widget',
3470	+ 'multiple_databases.DooHickey' ]}
3471	+}
3472	MODEL_TESTS_DIR_NAME = 'modeltests'
3473	REGRESSION_TESTS_DIR_NAME = 'regressiontests'
3474
3475	@@ -99,6 +107,7 @@
3476
3477
3478	# Redirect some settings for the duration of these tests.
3479	settings.INSTALLED_APPS = ALWAYS_INSTALLED_APPS
3480	+ settings.TEST_OTHER_DATABASES = TEST_OTHER_DATABASES
3481	settings.ROOT_URLCONF = 'urls'
3482	settings.TEMPLATE_DIRS = (os.path.join(os.path.dirname(__file__), TEST_TEMPLATE_DIR),)
3483	settings.USE_I18N = True
3484	=== docs/settings.txt
3485	==================================================================
3486	--- docs/settings.txt (/mirror/django/trunk) (revision 5420)
3487
3488	+++ docs/settings.txt (/local/django/mymultidb) (revision 5420)
3489
3490	@@ -733,6 +733,13 @@
3491
3492	See `allowed date format strings`_. See also ``DATE_FORMAT``,
3493	``DATETIME_FORMAT``, ``TIME_FORMAT`` and ``YEAR_MONTH_FORMAT``.
3494
3495	+OTHER_DATABASES
3496	+---------------
3497	+
3498	+Default: ``{}``
3499	+
3500	+Other database connections to use in addition to the default connection. See the `multiple database support docs`_.
3501	+
3502	PREPEND_WWW
3503	-----------
3504
3505	=== docs/multiple_database_support.txt
3506	==================================================================
3507	--- docs/multiple_database_support.txt (/mirror/django/trunk) (revision 5420)
3508
3509	+++ docs/multiple_database_support.txt (/local/django/mymultidb) (revision 5420)
3510
3511	@@ -0,0 +1,163 @@
3512
3513	+========================
3514	+Using Multiple Databases
3515	+========================
3516	+
3517	+Standard Django practice is to use a single database connection for
3518	+all models in all applications. However, Django supports configuring
3519	+and using multiple database connections on a per-application, per-model
3520	+or an ad-hoc basis. Using multiple database connections is optional.
3521	+
3522	+Configuring other database connections
3523	+======================================
3524	+
3525	+Django's default database connection is configured via the settings
3526	+DATABASE_ENGINE, DATABASE_NAME, DATABASE_USER, DATABASE_PASSWORD,
3527	+DATABASE_HOST, and DATABASE_PORT. Other connections are configured via
3528	+the OTHER_DATABASES setting. Define OTHER_DATABASES as a dict, with a
3529	+name for each connection as the key and a dict of settings as the
3530	+value. In each OTHER_DATABASES entry (called a "named connection"),
3531	+the keys are the same as the DATABASE_ENGINE, etc, settings used to
3532	+configure the default connection. All keys are optional; any that are
3533	+missing in a named connection's settings will inherit their values
3534	+from the default connection.
3535	+
3536	+Here's an example::
3537	+
3538	+ DATABASE_ENGINE = 'postgresql'
3539	+ DATABASE_NAME = 'django_apps'
3540	+ DATABASE_USER = 'default_user'
3541	+ DATABASE_PASSWORD = 'xxx'
3542	+
3543	+ OTHER_DATABASES = {
3544	+ 'local': { 'DATABASE_ENGINE': 'sqlite3',
3545	+ 'DATABASE_NAME': '/tmp/cache.db' },
3546	+ 'public': { 'DATABASE_HOST': 'public',
3547	+ 'DATABASE_USER': 'public_user',
3548	+ 'DATABASE_PASSWORD': 'xxx' }
3549	+ 'private': { 'DATABASE_HOST': 'private',
3550	+ 'DATABASE_USER': 'private_user',
3551	+ 'DATABASE_PASSWORD': 'xxx' }
3552	+ }
3553	+
3554	+In addition to the DATABASE_* settings, each named connection in
3555	+OTHER_DATABASES may optionally include a MODELS setting. This should
3556	+be a list of app or app.model names, and is used to configure which
3557	+models should use this connection instead of the default connection.
3558	+
3559	+Here's the example above, with ``MODELS``::
3560	+
3561	+ OTHER_DATABASES = {
3562	+ 'local': { 'DATABASE_ENGINE': 'sqlite3',
3563	+ 'DATABASE_NAME': '/tmp/cache.db',
3564	+ # A model name: only the model ContentItem
3565	+ # with the app_label myapp will use this connection
3566	+ 'MODELS': ['myapp.ContentItem'] },
3567	+ 'public': { 'DATABASE_HOST': 'public',
3568	+ 'DATABASE_USER': 'public_user',
3569	+ 'DATABASE_PASSWORD': 'xxx',
3570	+ # Two models in myapp will use the connection
3571	+ # named 'public', as will ALL models in
3572	+ # django.contribe.comments
3573	+ 'MODELS': ['myapp.Blog','myapp.Article',
3574	+ 'django.contrib.comments' ] }
3575	+ # No models or apps are configured to use the private db
3576	+ 'private': { 'DATABASE_HOST': 'private',
3577	+ 'DATABASE_USER': 'private_user',
3578	+ 'DATABASE_PASSWORD': 'xxx' }
3579	+ }
3580	+
3581	+Accessing a model's connection
3582	+==============================
3583	+
3584	+Each manager has a ``db`` attribute that can be used to access the model's
3585	+connection. Access the ``db`` attribute of a model's manager to obtain the
3586	+model's currently configured connection.
3587	+
3588	+Example::
3589	+
3590	+ from django.db import models
3591	+
3592	+ class Blog(models.Model)
3593	+ name = models.CharField(maxlength=50)
3594	+
3595	+ class Article(models.Model)
3596	+ blog = models.ForeignKey(Blog)
3597	+ title = models.CharField(maxlength=100)
3598	+ slug = models.SlugField()
3599	+ summary = models.CharField(maxlength=500)
3600	+ body = models.TextField()
3601	+
3602	+ class ContentItem(models.Model)
3603	+ slug = models.SlugField()
3604	+ mimetype = models.CharField(maxlength=50)
3605	+ file = models.FileField()
3606	+
3607	+ # Get a ConnectionInfo instance that describes the connection
3608	+ article_db = Article.objects.db
3609	+
3610	+ # Get a connection and a cursor
3611	+ connection = article_db.connection
3612	+ cursor = connection.cursor()
3613	+
3614	+ # Get the ``quote_name`` function from the backend
3615	+ qn = article_db.backend.quote_name
3616	+
3617	+Ordinarily you won't have to access a model's connection directly;
3618	+just use the model and manager normally and they will use the
3619	+connection configured for the model.
3620	+
3621	+ConnectionInfo objects
3622	+======================
3623	+
3624	+FIXME Describe the ConnectionInfo object and each of its attributes.
3625	+
3626	+
3627	+Accessing connections by name
3628	+=============================
3629	+
3630	+Access named connections directly through
3631	+``django.db.connections``. Each entry in ``django.db.connections`` is
3632	+a ``ConnectionInfo`` instance bound to the settings configured in the
3633	+OTHER_DATABASES entry under the same key.
3634	+
3635	+Example::
3636	+
3637	+ from django.db import connections
3638	+
3639	+ private_db = connections['private']
3640	+ cursor = private_db.connection.cursor()
3641	+
3642	+
3643	+Using transactions with other database connections
3644	+==================================================
3645	+
3646	+Transaction managed state applies across all connections
3647	+commit/rollback apply to all connections by default
3648	+but you can specify individual connections or lists or dicts of connections
3649	+
3650	+
3651	+Changing model connections on the fly
3652	+=====================================
3653	+
3654	+Here's an example of primitive mirroring::
3655	+
3656	+ # Read all articles from the private db
3657	+ # Note that we pull the articles into a list; this is necessary
3658	+ # because query sets are lazy. If we were to change the model's
3659	+ # connection without copying the articles into a local list, we'd
3660	+ # wind up reading from public instead of private.
3661	+
3662	+ Article.objects.db = connections['private']
3663	+ all_articles = list(Article.objects.all())
3664	+
3665	+ # Save each article in the public db
3666	+ Article.objects.db = connections['public']
3667	+ for article in all_articles:
3668	+ article.save()
3669	+
3670	+Thread and request isolation
3671	+============================
3672	+
3673	+connections close after each request
3674	+connection settings are thread-local
3675	+

Download in other formats:

Original Format

Code

Context Navigation

Ticket #4747: mymultidb_trunk7534_20080520.2.diff

Download in other formats:

Django Links

Learn More

Get Involved

Follow Us