1 | === django/test/utils.py |
---|
2 | ================================================================== |
---|
3 | --- django/test/utils.py (/mirror/django/trunk) (revision 4246) |
---|
4 | |
---|
5 | +++ django/test/utils.py (/local/django/multidb) (revision 4246) |
---|
6 | |
---|
7 | @@ -1,6 +1,6 @@ |
---|
8 | |
---|
9 | import sys, time |
---|
10 | from django.conf import settings |
---|
11 | -from django.db import connection, get_creation_module |
---|
12 | +from django.db import connection, connections, get_creation_module |
---|
13 | from django.core import mail |
---|
14 | from django.core.management import call_command |
---|
15 | from django.dispatch import dispatcher |
---|
16 | @@ -106,6 +106,7 @@ |
---|
17 | |
---|
18 | # in-memory database. |
---|
19 | if settings.DATABASE_ENGINE == "sqlite3": |
---|
20 | TEST_DATABASE_NAME = ":memory:" |
---|
21 | +## TEST_DATABASE_NAME = settings.TEST_DATABASE_NAME |
---|
22 | else: |
---|
23 | suffix = { |
---|
24 | 'postgresql': get_postgresql_create_suffix, |
---|
25 | @@ -148,6 +149,7 @@ |
---|
26 | |
---|
27 | |
---|
28 | connection.close() |
---|
29 | settings.DATABASE_NAME = TEST_DATABASE_NAME |
---|
30 | + settings.OTHER_DATABASES = settings.TEST_OTHER_DATABASES |
---|
31 | |
---|
32 | call_command('syncdb', verbosity=verbosity, interactive=False) |
---|
33 | |
---|
34 | @@ -161,7 +163,8 @@ |
---|
35 | |
---|
36 | |
---|
37 | return TEST_DATABASE_NAME |
---|
38 | |
---|
39 | -def destroy_test_db(old_database_name, verbosity=1): |
---|
40 | +def destroy_test_db(old_database_name, old_databases, verbosity=1): |
---|
41 | + |
---|
42 | # If the database wants to drop the test DB itself, let it |
---|
43 | creation_module = get_creation_module() |
---|
44 | if hasattr(creation_module, "destroy_test_db"): |
---|
45 | @@ -175,7 +178,12 @@ |
---|
46 | |
---|
47 | if verbosity >= 1: |
---|
48 | print "Destroying test database..." |
---|
49 | connection.close() |
---|
50 | +## for cnx in connections.keys(): |
---|
51 | +## connections[cnx].close() |
---|
52 | +## connections.reset() |
---|
53 | TEST_DATABASE_NAME = settings.DATABASE_NAME |
---|
54 | + if verbosity >= 2: |
---|
55 | + print "Closed connections to %s" % TEST_DATABASE_NAME |
---|
56 | settings.DATABASE_NAME = old_database_name |
---|
57 | |
---|
58 | if settings.DATABASE_ENGINE != "sqlite3": |
---|
59 | @@ -184,3 +192,11 @@ |
---|
60 | |
---|
61 | time.sleep(1) # To avoid "database is being accessed by other users" errors. |
---|
62 | cursor.execute("DROP DATABASE %s" % connection.ops.quote_name(TEST_DATABASE_NAME)) |
---|
63 | connection.close() |
---|
64 | +## settings.OTHER_DATABASES = old_databases |
---|
65 | +## for cnx in connections.keys(): |
---|
66 | +## try: |
---|
67 | +## cursor = connections[cnx].connection.cursor() |
---|
68 | +## except (KeyboardInterrupt, SystemExit): |
---|
69 | +## raise |
---|
70 | +## except: |
---|
71 | +## pass |
---|
72 | === django/db/models/base.py |
---|
73 | ================================================================== |
---|
74 | --- django/db/models/base.py (/mirror/django/trunk) (revision 4246) |
---|
75 | |
---|
76 | +++ django/db/models/base.py (/local/django/multidb) (revision 4246) |
---|
77 | |
---|
78 | @@ -6,7 +6,7 @@ |
---|
79 | |
---|
80 | from django.db.models.fields.related import OneToOneRel, ManyToOneRel |
---|
81 | from django.db.models.query import delete_objects |
---|
82 | from django.db.models.options import Options, AdminOptions |
---|
83 | -from django.db import connection, transaction |
---|
84 | +from django.db import transaction |
---|
85 | from django.db.models import signals |
---|
86 | from django.db.models.loading import register_models, get_model |
---|
87 | from django.dispatch import dispatcher |
---|
88 | @@ -209,6 +209,8 @@ |
---|
89 | |
---|
90 | def save(self, raw=False): |
---|
91 | dispatcher.send(signal=signals.pre_save, sender=self.__class__, instance=self) |
---|
92 | |
---|
93 | + db = self.__class__._default_manager.db |
---|
94 | + connection = db.connection |
---|
95 | non_pks = [f for f in self._meta.fields if not f.primary_key] |
---|
96 | cursor = connection.cursor() |
---|
97 | |
---|
98 | @@ -227,7 +229,7 @@ |
---|
99 | |
---|
100 | self._meta.pk.get_db_prep_lookup('exact', pk_val)) |
---|
101 | # If it does already exist, do an UPDATE. |
---|
102 | if cursor.fetchone(): |
---|
103 | - db_values = [f.get_db_prep_save(raw and getattr(self, f.attname) or f.pre_save(self, False)) for f in non_pks] |
---|
104 | + db_values = [f.get_db_prep_save(self, raw and getattr(self, f.attname) or f.pre_save(self, False)) for f in non_pks] |
---|
105 | if db_values: |
---|
106 | cursor.execute("UPDATE %s SET %s WHERE %s=%%s" % \ |
---|
107 | (qn(self._meta.db_table), |
---|
108 | @@ -238,11 +240,11 @@ |
---|
109 | |
---|
110 | record_exists = False |
---|
111 | if not pk_set or not record_exists: |
---|
112 | field_names = [qn(f.column) for f in self._meta.fields if not isinstance(f, AutoField)] |
---|
113 | - db_values = [f.get_db_prep_save(raw and getattr(self, f.attname) or f.pre_save(self, True)) for f in self._meta.fields if not isinstance(f, AutoField)] |
---|
114 | + db_values = [f.get_db_prep_save(self, raw and getattr(self, f.attname) or f.pre_save(self, True)) for f in self._meta.fields if not isinstance(f, AutoField)] |
---|
115 | # If the PK has been manually set, respect that. |
---|
116 | if pk_set: |
---|
117 | field_names += [f.column for f in self._meta.fields if isinstance(f, AutoField)] |
---|
118 | - db_values += [f.get_db_prep_save(raw and getattr(self, f.attname) or f.pre_save(self, True)) for f in self._meta.fields if isinstance(f, AutoField)] |
---|
119 | + db_values += [f.get_db_prep_save(self, raw and getattr(self, f.attname) or f.pre_save(self, True)) for f in self._meta.fields if isinstance(f, AutoField)] |
---|
120 | placeholders = ['%s'] * len(field_names) |
---|
121 | if self._meta.order_with_respect_to: |
---|
122 | field_names.append(qn('_order')) |
---|
123 | @@ -264,7 +266,7 @@ |
---|
124 | |
---|
125 | connection.ops.pk_default_value())) |
---|
126 | if self._meta.has_auto_field and not pk_set: |
---|
127 | setattr(self, self._meta.pk.attname, connection.ops.last_insert_id(cursor, self._meta.db_table, self._meta.pk.column)) |
---|
128 | - transaction.commit_unless_managed() |
---|
129 | + transaction.commit_unless_managed([connection]) |
---|
130 | |
---|
131 | # Run any post-save hooks. |
---|
132 | dispatcher.send(signal=signals.post_save, sender=self.__class__, |
---|
133 | @@ -336,6 +338,8 @@ |
---|
134 | |
---|
135 | return force_unicode(dict(field.choices).get(value, value), strings_only=True) |
---|
136 | |
---|
137 | def _get_next_or_previous_by_FIELD(self, field, is_next, **kwargs): |
---|
138 | + db = self.__class__._default_manager.db |
---|
139 | + connection = db.connection |
---|
140 | qn = connection.ops.quote_name |
---|
141 | op = is_next and '>' or '<' |
---|
142 | where = '(%s %s %%s OR (%s = %%s AND %s.%s %s %%s))' % \ |
---|
143 | @@ -351,6 +355,8 @@ |
---|
144 | |
---|
145 | raise self.DoesNotExist, "%s matching query does not exist." % self.__class__._meta.object_name |
---|
146 | |
---|
147 | def _get_next_or_previous_in_order(self, is_next): |
---|
148 | + db = self.__class__._default_manager.db |
---|
149 | + connection = db.connection |
---|
150 | qn = connection.ops.quote_name |
---|
151 | cachename = "__%s_order_cache" % is_next |
---|
152 | if not hasattr(self, cachename): |
---|
153 | @@ -441,6 +447,8 @@ |
---|
154 | |
---|
155 | # ORDERING METHODS ######################### |
---|
156 | |
---|
157 | def method_set_order(ordered_obj, self, id_list): |
---|
158 | + db = ordered_obj._default_manager.db |
---|
159 | + connection = db.connection |
---|
160 | qn = connection.ops.quote_name |
---|
161 | cursor = connection.cursor() |
---|
162 | # Example: "UPDATE poll_choices SET _order = %s WHERE poll_id = %s AND id = %s" |
---|
163 | @@ -450,9 +458,11 @@ |
---|
164 | |
---|
165 | qn(ordered_obj._meta.pk.column)) |
---|
166 | rel_val = getattr(self, ordered_obj._meta.order_with_respect_to.rel.field_name) |
---|
167 | cursor.executemany(sql, [(i, rel_val, j) for i, j in enumerate(id_list)]) |
---|
168 | - transaction.commit_unless_managed() |
---|
169 | + transaction.commit_unless_managed([connection]) |
---|
170 | |
---|
171 | def method_get_order(ordered_obj, self): |
---|
172 | + db = ordered_obj._default_manager.db |
---|
173 | + connection = db.connection |
---|
174 | qn = connection.ops.quote_name |
---|
175 | cursor = connection.cursor() |
---|
176 | # Example: "SELECT id FROM poll_choices WHERE poll_id = %s ORDER BY _order" |
---|
177 | === django/db/models/manager.py |
---|
178 | ================================================================== |
---|
179 | --- django/db/models/manager.py (/mirror/django/trunk) (revision 4246) |
---|
180 | |
---|
181 | +++ django/db/models/manager.py (/local/django/multidb) (revision 4246) |
---|
182 | |
---|
183 | @@ -1,6 +1,7 @@ |
---|
184 | |
---|
185 | -from django.db.models.query import QuerySet, EmptyQuerySet |
---|
186 | +from django.db import ConnectionInfoDescriptor |
---|
187 | +from django.db.models.query import _QuerySet, EmptyQuerySet |
---|
188 | from django.dispatch import dispatcher |
---|
189 | -from django.db.models import signals |
---|
190 | +from django.db.models import signals, get_apps, get_models |
---|
191 | from django.db.models.fields import FieldDoesNotExist |
---|
192 | |
---|
193 | def ensure_default_manager(sender): |
---|
194 | @@ -13,13 +14,17 @@ |
---|
195 | |
---|
196 | except FieldDoesNotExist: |
---|
197 | pass |
---|
198 | cls.add_to_class('objects', Manager()) |
---|
199 | + elif cls._default_manager.model != cls: |
---|
200 | + # cls is an inherited model; don't want the parent manager |
---|
201 | + cls.add_to_class('objects', Manager()) |
---|
202 | |
---|
203 | dispatcher.connect(ensure_default_manager, signal=signals.class_prepared) |
---|
204 | |
---|
205 | class Manager(object): |
---|
206 | # Tracks each time a Manager instance is created. Used to retain order. |
---|
207 | creation_counter = 0 |
---|
208 | - |
---|
209 | + db = ConnectionInfoDescriptor() |
---|
210 | + |
---|
211 | def __init__(self): |
---|
212 | super(Manager, self).__init__() |
---|
213 | # Increase the creation counter, and save our local copy. |
---|
214 | @@ -31,9 +36,11 @@ |
---|
215 | |
---|
216 | # TODO: Use weakref because of possible memory leak / circular reference. |
---|
217 | self.model = model |
---|
218 | setattr(model, name, ManagerDescriptor(self)) |
---|
219 | - if not hasattr(model, '_default_manager') or self.creation_counter < model._default_manager.creation_counter: |
---|
220 | + if not hasattr(model, '_default_manager') \ |
---|
221 | + or self.creation_counter < model._default_manager.creation_counter \ |
---|
222 | + or model._default_manager.model != model: |
---|
223 | model._default_manager = self |
---|
224 | - |
---|
225 | + |
---|
226 | ####################### |
---|
227 | # PROXIES TO QUERYSET # |
---|
228 | ####################### |
---|
229 | @@ -45,7 +52,11 @@ |
---|
230 | |
---|
231 | """Returns a new QuerySet object. Subclasses can override this method |
---|
232 | to easily customize the behavior of the Manager. |
---|
233 | """ |
---|
234 | - return QuerySet(self.model) |
---|
235 | + if self.db.connection.features.uses_custom_queryset: |
---|
236 | + QS = self.db.connection.ops.query_set_class(_QuerySet) |
---|
237 | + return QS(self.model) |
---|
238 | + else: |
---|
239 | + return _QuerySet(self.model) |
---|
240 | |
---|
241 | def none(self): |
---|
242 | return self.get_empty_query_set() |
---|
243 | === django/db/models/options.py |
---|
244 | ================================================================== |
---|
245 | --- django/db/models/options.py (/mirror/django/trunk) (revision 4246) |
---|
246 | |
---|
247 | +++ django/db/models/options.py (/local/django/multidb) (revision 4246) |
---|
248 | |
---|
249 | @@ -1,4 +1,5 @@ |
---|
250 | |
---|
251 | from django.conf import settings |
---|
252 | +from django.db import connection_info, connections |
---|
253 | from django.db.models.related import RelatedObject |
---|
254 | from django.db.models.fields.related import ManyToManyRel |
---|
255 | from django.db.models.fields import AutoField, FieldDoesNotExist |
---|
256 | @@ -9,6 +10,7 @@ |
---|
257 | |
---|
258 | from django.utils.encoding import force_unicode, smart_str |
---|
259 | from bisect import bisect |
---|
260 | import re |
---|
261 | +import weakref |
---|
262 | |
---|
263 | # Calculate the verbose_name by converting from InitialCaps to "lowercase with spaces". |
---|
264 | get_verbose_name = lambda class_name: re.sub('(((?<=[a-z])[A-Z])|([A-Z](?![A-Z]|$)))', ' \\1', class_name).lower().strip() |
---|
265 | @@ -91,6 +93,9 @@ |
---|
266 | |
---|
267 | self.db_table = "%s_%s" % (self.app_label, self.module_name) |
---|
268 | self.db_table = truncate_name(self.db_table, connection.ops.max_name_length()) |
---|
269 | |
---|
270 | + # Keep a weakref to my model, for access to managers and such |
---|
271 | + self._model = weakref.ref(model) |
---|
272 | + |
---|
273 | def add_field(self, field): |
---|
274 | # Insert the given field in the order in which it was created, using |
---|
275 | # the "creation_counter" attribute of the field. |
---|
276 | @@ -130,6 +135,12 @@ |
---|
277 | |
---|
278 | return f |
---|
279 | raise FieldDoesNotExist, '%s has no field named %r' % (self.object_name, name) |
---|
280 | |
---|
281 | + def get_default_manager(self): |
---|
282 | + model = self._model() |
---|
283 | + if model is None: |
---|
284 | + raise ReferenceError("Model no longer available in %s" % self) |
---|
285 | + return model._default_manager |
---|
286 | + |
---|
287 | def get_order_sql(self, table_prefix=''): |
---|
288 | "Returns the full 'ORDER BY' clause for this object, according to self.ordering." |
---|
289 | if not self.ordering: return '' |
---|
290 | === django/db/models/fields/__init__.py |
---|
291 | ================================================================== |
---|
292 | --- django/db/models/fields/__init__.py (/mirror/django/trunk) (revision 4246) |
---|
293 | |
---|
294 | +++ django/db/models/fields/__init__.py (/local/django/multidb) (revision 4246) |
---|
295 | |
---|
296 | @@ -201,7 +201,7 @@ |
---|
297 | |
---|
298 | "Returns field's value just before saving." |
---|
299 | return getattr(model_instance, self.attname) |
---|
300 | |
---|
301 | - def get_db_prep_save(self, value): |
---|
302 | + def get_db_prep_save(self, model_instance, value): |
---|
303 | "Returns field's value prepared for saving into a database." |
---|
304 | return value |
---|
305 | |
---|
306 | @@ -536,7 +536,7 @@ |
---|
307 | |
---|
308 | else: |
---|
309 | return self.editable or self.auto_now or self.auto_now_add |
---|
310 | |
---|
311 | - def get_db_prep_save(self, value): |
---|
312 | + def get_db_prep_save(self, model_instance, value): |
---|
313 | # Casts dates into string format for entry into database. |
---|
314 | if value is not None: |
---|
315 | try: |
---|
316 | @@ -545,7 +545,7 @@ |
---|
317 | |
---|
318 | # If value is already a string it won't have a strftime method, |
---|
319 | # so we'll just let it pass through. |
---|
320 | pass |
---|
321 | - return Field.get_db_prep_save(self, value) |
---|
322 | + return Field.get_db_prep_save(self, model_instance, value) |
---|
323 | |
---|
324 | def get_manipulator_field_objs(self): |
---|
325 | return [oldforms.DateField] |
---|
326 | @@ -578,7 +578,17 @@ |
---|
327 | |
---|
328 | except ValueError: |
---|
329 | raise validators.ValidationError, _('Enter a valid date/time in YYYY-MM-DD HH:MM format.') |
---|
330 | |
---|
331 | - def get_db_prep_save(self, value): |
---|
332 | + def pre_save(self, model_instance, add): |
---|
333 | + value = super(DateTimeField, self).pre_save(model_instance, add) |
---|
334 | + if value is not None: |
---|
335 | + # MySQL will throw a warning if microseconds are given, because it |
---|
336 | + # doesn't support microseconds. |
---|
337 | + settings = model_instance._default_manager.db.connection.settings |
---|
338 | + if settings.DATABASE_ENGINE == 'mysql' and hasattr(value, 'microsecond'): |
---|
339 | + value = value.replace(microsecond=0) |
---|
340 | + return value |
---|
341 | + |
---|
342 | + def get_db_prep_save(self, model_instance, value): |
---|
343 | # Casts dates into string format for entry into database. |
---|
344 | if value is not None: |
---|
345 | # MySQL will throw a warning if microseconds are given, because it |
---|
346 | @@ -586,7 +596,7 @@ |
---|
347 | |
---|
348 | if settings.DATABASE_ENGINE == 'mysql' and hasattr(value, 'microsecond'): |
---|
349 | value = value.replace(microsecond=0) |
---|
350 | value = smart_unicode(value) |
---|
351 | - return Field.get_db_prep_save(self, value) |
---|
352 | + return Field.get_db_prep_save(self, model_instance, value) |
---|
353 | |
---|
354 | def get_db_prep_lookup(self, lookup_type, value): |
---|
355 | if lookup_type == 'range': |
---|
356 | @@ -660,10 +670,10 @@ |
---|
357 | |
---|
358 | |
---|
359 | return u"%.*f" % (self.decimal_places, value) |
---|
360 | |
---|
361 | - def get_db_prep_save(self, value): |
---|
362 | + def get_db_prep_save(self, model_instance, value): |
---|
363 | if value is not None: |
---|
364 | value = self._format(value) |
---|
365 | - return super(DecimalField, self).get_db_prep_save(value) |
---|
366 | + return super(DecimalField, self).get_db_prep_save(model_instance, value) |
---|
367 | |
---|
368 | def get_db_prep_lookup(self, lookup_type, value): |
---|
369 | if lookup_type == 'range': |
---|
370 | @@ -986,11 +996,12 @@ |
---|
371 | |
---|
372 | else: |
---|
373 | return super(TimeField, self).pre_save(model_instance, add) |
---|
374 | |
---|
375 | - def get_db_prep_save(self, value): |
---|
376 | + def get_db_prep_save(self, model_instance, value): |
---|
377 | # Casts dates into string format for entry into database. |
---|
378 | if value is not None: |
---|
379 | # MySQL will throw a warning if microseconds are given, because it |
---|
380 | # doesn't support microseconds. |
---|
381 | + settings = model_instance._default_manager.db.connection.settings |
---|
382 | if settings.DATABASE_ENGINE == 'mysql' and hasattr(value, 'microsecond'): |
---|
383 | value = value.replace(microsecond=0) |
---|
384 | if settings.DATABASE_ENGINE == 'oracle': |
---|
385 | @@ -1002,7 +1013,7 @@ |
---|
386 | |
---|
387 | value = datetime.datetime(*(time.strptime(value, '%H:%M:%S')[:6])) |
---|
388 | else: |
---|
389 | value = smart_unicode(value) |
---|
390 | - return Field.get_db_prep_save(self, value) |
---|
391 | + return Field.get_db_prep_save(self, model_instance, value) |
---|
392 | |
---|
393 | def get_manipulator_field_objs(self): |
---|
394 | return [oldforms.TimeField] |
---|
395 | === django/db/models/fields/related.py |
---|
396 | ================================================================== |
---|
397 | --- django/db/models/fields/related.py (/mirror/django/trunk) (revision 4246) |
---|
398 | |
---|
399 | +++ django/db/models/fields/related.py (/local/django/multidb) (revision 4246) |
---|
400 | |
---|
401 | @@ -1,4 +1,4 @@ |
---|
402 | |
---|
403 | -from django.db import connection, transaction |
---|
404 | +from django.db import transaction |
---|
405 | from django.db.models import signals, get_model |
---|
406 | from django.db.models.fields import AutoField, Field, IntegerField, PositiveIntegerField, PositiveSmallIntegerField, get_ul_class |
---|
407 | from django.db.models.related import RelatedObject |
---|
408 | @@ -319,6 +319,7 @@ |
---|
409 | |
---|
410 | # source_col_name: the PK colname in join_table for the source object |
---|
411 | # target_col_name: the PK colname in join_table for the target object |
---|
412 | # *objs - objects to add. Either object instances, or primary keys of object instances. |
---|
413 | + connection = self.model._default_manager.db.connection |
---|
414 | |
---|
415 | # If there aren't any objects, there is nothing to do. |
---|
416 | if objs: |
---|
417 | @@ -343,12 +344,13 @@ |
---|
418 | |
---|
419 | cursor.execute("INSERT INTO %s (%s, %s) VALUES (%%s, %%s)" % \ |
---|
420 | (self.join_table, source_col_name, target_col_name), |
---|
421 | [self._pk_val, obj_id]) |
---|
422 | - transaction.commit_unless_managed() |
---|
423 | + transaction.commit_unless_managed(connection) |
---|
424 | |
---|
425 | def _remove_items(self, source_col_name, target_col_name, *objs): |
---|
426 | # source_col_name: the PK colname in join_table for the source object |
---|
427 | # target_col_name: the PK colname in join_table for the target object |
---|
428 | # *objs - objects to remove |
---|
429 | + connection = self.model._default_manager.db.connection |
---|
430 | |
---|
431 | # If there aren't any objects, there is nothing to do. |
---|
432 | if objs: |
---|
433 | @@ -365,15 +367,16 @@ |
---|
434 | |
---|
435 | (self.join_table, source_col_name, |
---|
436 | target_col_name, ",".join(['%s'] * len(old_ids))), |
---|
437 | [self._pk_val] + list(old_ids)) |
---|
438 | - transaction.commit_unless_managed() |
---|
439 | + transaction.commit_unless_managed(connection) |
---|
440 | |
---|
441 | def _clear_items(self, source_col_name): |
---|
442 | # source_col_name: the PK colname in join_table for the source object |
---|
443 | + connection = self.model._default_manager.db.connection |
---|
444 | cursor = connection.cursor() |
---|
445 | cursor.execute("DELETE FROM %s WHERE %s = %%s" % \ |
---|
446 | (self.join_table, source_col_name), |
---|
447 | [self._pk_val]) |
---|
448 | - transaction.commit_unless_managed() |
---|
449 | + transaction.commit_unless_managed(connection) |
---|
450 | |
---|
451 | return ManyRelatedManager |
---|
452 | |
---|
453 | @@ -397,7 +400,7 @@ |
---|
454 | |
---|
455 | superclass = rel_model._default_manager.__class__ |
---|
456 | RelatedManager = create_many_related_manager(superclass) |
---|
457 | |
---|
458 | - qn = connection.ops.quote_name |
---|
459 | + qn = rel_model._default_manager.db.connection.ops.quote_name |
---|
460 | manager = RelatedManager( |
---|
461 | model=rel_model, |
---|
462 | core_filters={'%s__pk' % self.related.field.name: instance._get_pk_val()}, |
---|
463 | @@ -438,7 +441,7 @@ |
---|
464 | |
---|
465 | superclass = rel_model._default_manager.__class__ |
---|
466 | RelatedManager = create_many_related_manager(superclass) |
---|
467 | |
---|
468 | - qn = connection.ops.quote_name |
---|
469 | + qn = rel_model._default_manager.db.connection.ops.quote_name |
---|
470 | manager = RelatedManager( |
---|
471 | model=rel_model, |
---|
472 | core_filters={'%s__pk' % self.field.related_query_name(): instance._get_pk_val()}, |
---|
473 | @@ -519,11 +522,11 @@ |
---|
474 | |
---|
475 | else: |
---|
476 | return [oldforms.IntegerField] |
---|
477 | |
---|
478 | - def get_db_prep_save(self, value): |
---|
479 | + def get_db_prep_save(self, model_instance, value): |
---|
480 | if value == '' or value == None: |
---|
481 | return None |
---|
482 | else: |
---|
483 | - return self.rel.get_related_field().get_db_prep_save(value) |
---|
484 | + return self.rel.get_related_field().get_db_prep_save(model_instance, value) |
---|
485 | |
---|
486 | def flatten_data(self, follow, obj=None): |
---|
487 | if not obj: |
---|
488 | === django/db/models/query.py |
---|
489 | ================================================================== |
---|
490 | --- django/db/models/query.py (/mirror/django/trunk) (revision 4246) |
---|
491 | |
---|
492 | +++ django/db/models/query.py (/local/django/multidb) (revision 4246) |
---|
493 | |
---|
494 | @@ -77,11 +77,11 @@ |
---|
495 | |
---|
496 | output.append('%s%s ASC' % (prefix, qn(orderfield2column(f, opts)))) |
---|
497 | return ', '.join(output) |
---|
498 | |
---|
499 | -def quote_only_if_word(word): |
---|
500 | +def quote_only_if_word(word, qn): |
---|
501 | if re.search('\W', word): # Don't quote if there are spaces or non-word chars. |
---|
502 | return word |
---|
503 | else: |
---|
504 | - return connection.ops.quote_name(word) |
---|
505 | + return qn(word) |
---|
506 | |
---|
507 | class _QuerySet(object): |
---|
508 | "Represents a lazy database lookup for a set of objects" |
---|
509 | @@ -184,8 +184,7 @@ |
---|
510 | |
---|
511 | # self._select is a dictionary, and dictionaries' key order is |
---|
512 | # undefined, so we convert it to a list of tuples. |
---|
513 | extra_select = self._select.items() |
---|
514 | - |
---|
515 | - cursor = connection.cursor() |
---|
516 | + cursor = self.model._default_manager.db.connection.cursor() |
---|
517 | cursor.execute("SELECT " + (self._distinct and "DISTINCT " or "") + ",".join(select) + sql, params) |
---|
518 | |
---|
519 | fill_cache = self._select_related |
---|
520 | @@ -219,7 +218,9 @@ |
---|
521 | |
---|
522 | """ |
---|
523 | if self._result_cache is not None: |
---|
524 | return len(self._result_cache) |
---|
525 | - |
---|
526 | + #from multi-db |
---|
527 | + connection = self.model._default_manager.db.connection |
---|
528 | + |
---|
529 | counter = self._clone() |
---|
530 | counter._order_by = () |
---|
531 | counter._select_related = False |
---|
532 | @@ -306,6 +307,7 @@ |
---|
533 | |
---|
534 | Returns a dictionary mapping each of the given IDs to the object with |
---|
535 | that ID. |
---|
536 | """ |
---|
537 | + connection = self.model._default_manager.db.connection |
---|
538 | assert self._limit is None and self._offset is None, \ |
---|
539 | "Cannot use 'limit' or 'offset' with in_bulk" |
---|
540 | assert isinstance(id_list, (tuple, list)), "in_bulk() must be provided with a list of IDs." |
---|
541 | @@ -483,12 +485,12 @@ |
---|
542 | |
---|
543 | return self._result_cache |
---|
544 | |
---|
545 | def _get_sql_clause(self): |
---|
546 | + connection = self.model._default_manager.db.connection |
---|
547 | qn = connection.ops.quote_name |
---|
548 | opts = self.model._meta |
---|
549 | - |
---|
550 | # Construct the fundamental parts of the query: SELECT X FROM Y WHERE Z. |
---|
551 | select = ["%s.%s" % (qn(opts.db_table), qn(f.column)) for f in opts.fields] |
---|
552 | - tables = [quote_only_if_word(t) for t in self._tables] |
---|
553 | + tables = [quote_only_if_word(t, qn) for t in self._tables] |
---|
554 | joins = SortedDict() |
---|
555 | where = self._where[:] |
---|
556 | params = self._params[:] |
---|
557 | @@ -508,7 +510,7 @@ |
---|
558 | |
---|
559 | |
---|
560 | # Add any additional SELECTs. |
---|
561 | if self._select: |
---|
562 | - select.extend(['(%s) AS %s' % (quote_only_if_word(s[1]), qn(s[0])) for s in self._select.items()]) |
---|
563 | + select.extend(['(%s) AS %s' % (quote_only_if_word(s[1], qn), qn(s[0])) for s in self._select.items()]) |
---|
564 | |
---|
565 | # Start composing the body of the SQL statement. |
---|
566 | sql = [" FROM", qn(opts.db_table)] |
---|
567 | @@ -565,6 +567,7 @@ |
---|
568 | |
---|
569 | return select, " ".join(sql), params |
---|
570 | |
---|
571 | # Use the backend's QuerySet class if it defines one. Otherwise, use _QuerySet. |
---|
572 | +# This is now in manager.py |
---|
573 | if connection.features.uses_custom_queryset: |
---|
574 | QuerySet = connection.ops.query_set_class(_QuerySet) |
---|
575 | else: |
---|
576 | @@ -582,6 +585,9 @@ |
---|
577 | |
---|
578 | except EmptyResultSet: |
---|
579 | raise StopIteration |
---|
580 | |
---|
581 | + #from multi-db |
---|
582 | + db = self.model._default_manager.db |
---|
583 | + connection = db.connection |
---|
584 | qn = connection.ops.quote_name |
---|
585 | |
---|
586 | # self._select is a dictionary, and dictionaries' key order is |
---|
587 | @@ -612,7 +618,7 @@ |
---|
588 | |
---|
589 | columns = [f.column for f in fields] |
---|
590 | select = ['%s.%s' % (qn(self.model._meta.db_table), qn(c)) for c in columns] |
---|
591 | if extra_select: |
---|
592 | - select.extend(['(%s) AS %s' % (quote_only_if_word(s[1]), qn(s[0])) for s in extra_select]) |
---|
593 | + select.extend(['(%s) AS %s' % (quote_only_if_word(s[1], qn), qn(s[0])) for s in extra_select]) |
---|
594 | field_names.extend([f[0] for f in extra_select]) |
---|
595 | |
---|
596 | cursor = connection.cursor() |
---|
597 | @@ -638,6 +644,8 @@ |
---|
598 | |
---|
599 | from django.db.backends.util import typecast_timestamp |
---|
600 | from django.db.models.fields import DateTimeField |
---|
601 | |
---|
602 | + db = self.model._default_manager.db |
---|
603 | + connection = db.connection |
---|
604 | qn = connection.ops.quote_name |
---|
605 | self._order_by = () # Clear this because it'll mess things up otherwise. |
---|
606 | if self._field.null: |
---|
607 | @@ -783,7 +791,8 @@ |
---|
608 | |
---|
609 | return SortedDict(), [], [] |
---|
610 | return joins, where2, params |
---|
611 | |
---|
612 | -def get_where_clause(lookup_type, table_prefix, field_name, value, db_type): |
---|
613 | +def get_where_clause(opts, lookup_type, table_prefix, field_name, value, db_type): |
---|
614 | + connection = opts.get_default_manager().db.connection |
---|
615 | if table_prefix.endswith('.'): |
---|
616 | table_prefix = connection.ops.quote_name(table_prefix[:-1])+'.' |
---|
617 | field_name = connection.ops.quote_name(field_name) |
---|
618 | @@ -850,6 +859,7 @@ |
---|
619 | |
---|
620 | Helper function that recursively populates the select, tables and where (in |
---|
621 | place) for select_related queries. |
---|
622 | """ |
---|
623 | + connection = opts.get_default_manager().db.connection |
---|
624 | |
---|
625 | # If we've got a max_depth set and we've exceeded that depth, bail now. |
---|
626 | if max_depth and cur_depth > max_depth: |
---|
627 | @@ -953,13 +963,20 @@ |
---|
628 | |
---|
629 | return choices |
---|
630 | |
---|
631 | def lookup_inner(path, lookup_type, value, opts, table, column): |
---|
632 | - qn = connection.ops.quote_name |
---|
633 | joins, where, params = SortedDict(), [], [] |
---|
634 | current_opts = opts |
---|
635 | current_table = table |
---|
636 | current_column = column |
---|
637 | intermediate_table = None |
---|
638 | join_required = False |
---|
639 | + db = current_opts.get_default_manager().db |
---|
640 | + backend = db.backend |
---|
641 | + connection = db.connection |
---|
642 | + qn = connection.ops.quote_name |
---|
643 | + if hasattr(connection.ops, 'alias'): |
---|
644 | + al = connection.ops.alias |
---|
645 | + else: |
---|
646 | + al = lambda x,y: "%s__%s" % (x,y) |
---|
647 | |
---|
648 | name = path.pop(0) |
---|
649 | # Has the primary key been requested? If so, expand it out |
---|
650 | @@ -972,7 +989,7 @@ |
---|
651 | |
---|
652 | # Does the name belong to a defined many-to-many field? |
---|
653 | field = find_field(name, current_opts.many_to_many, False) |
---|
654 | if field: |
---|
655 | - new_table = current_table + '__' + name |
---|
656 | + new_table = al(current_table, name) |
---|
657 | new_opts = field.rel.to._meta |
---|
658 | new_column = new_opts.pk.column |
---|
659 | |
---|
660 | @@ -989,7 +1006,7 @@ |
---|
661 | |
---|
662 | # Does the name belong to a reverse defined many-to-many field? |
---|
663 | field = find_field(name, current_opts.get_all_related_many_to_many_objects(), True) |
---|
664 | if field: |
---|
665 | - new_table = current_table + '__' + name |
---|
666 | + new_table = al(current_table, name) |
---|
667 | new_opts = field.opts |
---|
668 | new_column = new_opts.pk.column |
---|
669 | |
---|
670 | @@ -1006,7 +1023,7 @@ |
---|
671 | |
---|
672 | # Does the name belong to a one-to-many field? |
---|
673 | field = find_field(name, current_opts.get_all_related_objects(), True) |
---|
674 | if field: |
---|
675 | - new_table = table + '__' + name |
---|
676 | + new_table = al(current_table, name) |
---|
677 | new_opts = field.opts |
---|
678 | new_column = field.field.column |
---|
679 | join_column = opts.pk.column |
---|
680 | @@ -1020,7 +1037,7 @@ |
---|
681 | |
---|
682 | field = find_field(name, current_opts.fields, False) |
---|
683 | if field: |
---|
684 | if field.rel: # One-to-One/Many-to-one field |
---|
685 | - new_table = current_table + '__' + name |
---|
686 | + new_table = al(current_table, name) |
---|
687 | new_opts = field.rel.to._meta |
---|
688 | new_column = new_opts.pk.column |
---|
689 | join_column = field.column |
---|
690 | @@ -1112,20 +1129,23 @@ |
---|
691 | |
---|
692 | column = field.column |
---|
693 | db_type = field.db_type() |
---|
694 | |
---|
695 | - where.append(get_where_clause(lookup_type, current_table + '.', column, value, db_type)) |
---|
696 | + where.append(get_where_clause(current_opts, lookup_type, current_table + '.', column, value, db_type)) |
---|
697 | params.extend(field.get_db_prep_lookup(lookup_type, value)) |
---|
698 | |
---|
699 | return joins, where, params |
---|
700 | |
---|
701 | def delete_objects(seen_objs): |
---|
702 | "Iterate through a list of seen classes, and remove any instances that are referred to" |
---|
703 | - qn = connection.ops.quote_name |
---|
704 | ordered_classes = seen_objs.keys() |
---|
705 | ordered_classes.reverse() |
---|
706 | |
---|
707 | - cursor = connection.cursor() |
---|
708 | - |
---|
709 | for cls in ordered_classes: |
---|
710 | + db = cls._default_manager.db |
---|
711 | + backend = db.backend |
---|
712 | + connection = db.connection |
---|
713 | + cursor = connection.cursor() |
---|
714 | + qn = connection.ops.quote_name |
---|
715 | + |
---|
716 | seen_objs[cls] = seen_objs[cls].items() |
---|
717 | seen_objs[cls].sort() |
---|
718 | |
---|
719 | @@ -1164,7 +1184,17 @@ |
---|
720 | |
---|
721 | pk_list[offset:offset+GET_ITERATOR_CHUNK_SIZE]) |
---|
722 | |
---|
723 | # Now delete the actual data |
---|
724 | + dirty_conns = [] |
---|
725 | for cls in ordered_classes: |
---|
726 | + |
---|
727 | + db = cls._default_manager.db |
---|
728 | + backend = db.backend |
---|
729 | + connection = db.connection |
---|
730 | + qn = connection.ops.quote_name |
---|
731 | + cursor = connection.cursor() |
---|
732 | + if connection not in dirty_conns: |
---|
733 | + dirty_conns.append(connection) |
---|
734 | + |
---|
735 | seen_objs[cls].reverse() |
---|
736 | pk_list = [pk for pk,instance in seen_objs[cls]] |
---|
737 | for offset in range(0, len(pk_list), GET_ITERATOR_CHUNK_SIZE): |
---|
738 | @@ -1183,4 +1213,4 @@ |
---|
739 | |
---|
740 | dispatcher.send(signal=signals.post_delete, sender=cls, instance=instance) |
---|
741 | setattr(instance, cls._meta.pk.attname, None) |
---|
742 | |
---|
743 | - transaction.commit_unless_managed() |
---|
744 | + transaction.commit_unless_managed(dirty_conns) |
---|
745 | === django/db/__init__.py |
---|
746 | ================================================================== |
---|
747 | --- django/db/__init__.py (/mirror/django/trunk) (revision 4246) |
---|
748 | |
---|
749 | +++ django/db/__init__.py (/local/django/multidb) (revision 4246) |
---|
750 | |
---|
751 | @@ -1,70 +1,380 @@ |
---|
752 | |
---|
753 | import os |
---|
754 | -from django.conf import settings |
---|
755 | +from django.conf import settings, UserSettingsHolder |
---|
756 | from django.core import signals |
---|
757 | from django.core.exceptions import ImproperlyConfigured |
---|
758 | from django.dispatch import dispatcher |
---|
759 | from django.utils.functional import curry |
---|
760 | |
---|
761 | +try: |
---|
762 | + # Only exists in Python 2.4+ |
---|
763 | + from threading import local |
---|
764 | +except ImportError: |
---|
765 | + # Import copy of _thread_local.py from Python 2.4 |
---|
766 | + from django.utils._threading_local import local |
---|
767 | + |
---|
768 | __all__ = ('backend', 'connection', 'DatabaseError', 'IntegrityError') |
---|
769 | |
---|
770 | + |
---|
771 | +# singleton to represent the default connection in connections |
---|
772 | +class dummy(object): |
---|
773 | + def __repr__(self): |
---|
774 | + return self.__str__() |
---|
775 | + def __str__(self): |
---|
776 | + return '<default>' |
---|
777 | +_default = dummy() |
---|
778 | +del dummy |
---|
779 | + |
---|
780 | + |
---|
781 | +# storage for local default connection |
---|
782 | +_local = local() |
---|
783 | + |
---|
784 | if not settings.DATABASE_ENGINE: |
---|
785 | settings.DATABASE_ENGINE = 'dummy' |
---|
786 | + |
---|
787 | |
---|
788 | -try: |
---|
789 | - # Most of the time, the database backend will be one of the official |
---|
790 | - # backends that ships with Django, so look there first. |
---|
791 | - _import_path = 'django.db.backends.' |
---|
792 | - backend = __import__('%s%s.base' % (_import_path, settings.DATABASE_ENGINE), {}, {}, ['']) |
---|
793 | -except ImportError, e: |
---|
794 | - # If the import failed, we might be looking for a database backend |
---|
795 | - # distributed external to Django. So we'll try that next. |
---|
796 | - try: |
---|
797 | - _import_path = '' |
---|
798 | - backend = __import__('%s.base' % settings.DATABASE_ENGINE, {}, {}, ['']) |
---|
799 | - except ImportError, e_user: |
---|
800 | - # The database backend wasn't found. Display a helpful error message |
---|
801 | - # listing all possible (built-in) database backends. |
---|
802 | - backend_dir = os.path.join(__path__[0], 'backends') |
---|
803 | - 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')] |
---|
804 | - available_backends.sort() |
---|
805 | - if settings.DATABASE_ENGINE not in available_backends: |
---|
806 | - raise ImproperlyConfigured, "%r isn't an available database backend. Available options are: %s" % \ |
---|
807 | - (settings.DATABASE_ENGINE, ", ".join(map(repr, available_backends))) |
---|
808 | - else: |
---|
809 | - raise # If there's some other error, this must be an error in Django itself. |
---|
810 | +def connect(settings, **kw): |
---|
811 | + """Connect to the database specified in settings. Returns a |
---|
812 | + ConnectionInfo on success, raises ImproperlyConfigured if the |
---|
813 | + settings don't specify a valid database connection. |
---|
814 | + """ |
---|
815 | + return ConnectionInfo(settings, **kw) |
---|
816 | |
---|
817 | -def _import_database_module(import_path='', module_name=''): |
---|
818 | - """Lazyily import a database module when requested.""" |
---|
819 | - return __import__('%s%s.%s' % (_import_path, settings.DATABASE_ENGINE, module_name), {}, {}, ['']) |
---|
820 | + |
---|
821 | +class ConnectionInfo(object): |
---|
822 | + """Encapsulates all information about a connection and the backend |
---|
823 | + to which it belongs. Provides methods for loading backend |
---|
824 | + creation, introspection, and shell modules, closing the |
---|
825 | + connection, and resetting the connection's query log. |
---|
826 | + """ |
---|
827 | + def __init__(self, settings=None, **kw): |
---|
828 | + super(ConnectionInfo, self).__init__(**kw) |
---|
829 | + if settings is None: |
---|
830 | + from django.conf import settings |
---|
831 | + if not settings.DATABASE_OPTIONS: |
---|
832 | + settings.DATABASE_OPTIONS = {} |
---|
833 | + self.settings = settings |
---|
834 | + self.backend = self.load_backend() |
---|
835 | + self.connection = self.backend.DatabaseWrapper(settings) |
---|
836 | + self.DatabaseError = self.backend.DatabaseError |
---|
837 | |
---|
838 | -# We don't want to import the introspect/creation modules unless |
---|
839 | -# someone asks for 'em, so lazily load them on demmand. |
---|
840 | -get_introspection_module = curry(_import_database_module, _import_path, 'introspection') |
---|
841 | -get_creation_module = curry(_import_database_module, _import_path, 'creation') |
---|
842 | + # Register an event that closes the database connection |
---|
843 | + # when a Django request is finished. |
---|
844 | + dispatcher.connect(self.close, signal=signals.request_finished) |
---|
845 | + |
---|
846 | + # Register an event that resets connection.queries |
---|
847 | + # when a Django request is started. |
---|
848 | + dispatcher.connect(self.reset_queries, signal=signals.request_started) |
---|
849 | |
---|
850 | -# We want runshell() to work the same way, but we have to treat it a |
---|
851 | -# little differently (since it just runs instead of returning a module like |
---|
852 | -# the above) and wrap the lazily-loaded runshell() method. |
---|
853 | -runshell = lambda: _import_database_module(_import_path, "client").runshell() |
---|
854 | + def __repr__(self): |
---|
855 | + return "Connection: %r (ENGINE=%s NAME=%s)" \ |
---|
856 | + % (self.connection, |
---|
857 | + self.settings.DATABASE_ENGINE, |
---|
858 | + self.settings.DATABASE_NAME) |
---|
859 | |
---|
860 | -# Convenient aliases for backend bits. |
---|
861 | -connection = backend.DatabaseWrapper(**settings.DATABASE_OPTIONS) |
---|
862 | -DatabaseError = backend.DatabaseError |
---|
863 | + def close(self): |
---|
864 | + """Close connection""" |
---|
865 | + self.connection.close() |
---|
866 | + |
---|
867 | + # We don't want to import the introspect/creation modules unless |
---|
868 | + # someone asks for 'em, so lazily load them on demmand. |
---|
869 | + def get_introspection_module(self): |
---|
870 | + return __import__('%s%s.%s' % (self._import_path, self.settings.DATABASE_ENGINE, 'introspection'), {}, {}, ['']) |
---|
871 | + |
---|
872 | + def get_creation_module(self): |
---|
873 | + return __import__('%s%s.%s' % (self._import_path, self.settings.DATABASE_ENGINE, 'creation'), {}, {}, ['']) |
---|
874 | + |
---|
875 | + def load_backend(self): |
---|
876 | + try: |
---|
877 | + # Most of the time, the database backend will be one of the official |
---|
878 | + # backends that ships with Django, so look there first. |
---|
879 | + self._import_path = 'django.db.backends.' |
---|
880 | + backend = __import__('%s%s.base' % (self._import_path, |
---|
881 | + self.settings.DATABASE_ENGINE), {}, {}, ['']) |
---|
882 | + except ImportError, e: |
---|
883 | + # If the import failed, we might be looking for a database backend |
---|
884 | + # distributed external to Django. So we'll try that next. |
---|
885 | + try: |
---|
886 | + self._import_path = '' |
---|
887 | + backend = __import__('%s.base' % self.settings.DATABASE_ENGINE, {}, {}, ['']) |
---|
888 | + except ImportError, e_user: |
---|
889 | + # The database backend wasn't found. Display a helpful error message |
---|
890 | + # listing all possible (built-in) database backends. |
---|
891 | + backend_dir = os.path.join(__path__[0], 'backends') |
---|
892 | + 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')] |
---|
893 | + available_backends.sort() |
---|
894 | + if self.settings.DATABASE_ENGINE not in available_backends: |
---|
895 | + raise ImproperlyConfigured, "%r isn't an available database backend. Available options are: %s" % \ |
---|
896 | + (self.settings.DATABASE_ENGINE, ", ".join(map(repr, available_backends))) |
---|
897 | + else: |
---|
898 | + raise # If there's some other error, this must be an error in Django itself. |
---|
899 | + return backend |
---|
900 | + |
---|
901 | + # We want runshell() to work the same way, but we have to treat it a |
---|
902 | + # little differently (since it just runs instead of returning a module like |
---|
903 | + # the above) and wrap the lazily-loaded runshell() method. |
---|
904 | + def runshell(self): |
---|
905 | + return lambda: __import__('%s%s.%s' % (self._import_path, self.settings.DATABASE_ENGINE, 'client'), {}, {}, ['']).runshell() |
---|
906 | + |
---|
907 | + def reset_queries(self): |
---|
908 | + """Reset log of queries executed by connection""" |
---|
909 | + self.connection.queries = [] |
---|
910 | + |
---|
911 | +class LazyConnectionManager(object): |
---|
912 | + """Manages named connections lazily, instantiating them as |
---|
913 | + they are requested. |
---|
914 | + """ |
---|
915 | + def __init__(self): |
---|
916 | + self.local = local() |
---|
917 | + self.local.connections = {} |
---|
918 | + |
---|
919 | + # Reset connections on request finish, to make sure each request can |
---|
920 | + # load the correct connections for its settings |
---|
921 | + dispatcher.connect(self.reset, signal=signals.request_finished) |
---|
922 | + |
---|
923 | + def __iter__(self): |
---|
924 | + # Iterates only over *active* connections, not all possible |
---|
925 | + # connections |
---|
926 | + return iter(self.local.connections.keys()) |
---|
927 | + |
---|
928 | + def __getattr__(self, attr): |
---|
929 | + return getattr(self.local.connections, attr) |
---|
930 | + |
---|
931 | + def __getitem__(self, k): |
---|
932 | + try: |
---|
933 | + return self.local.connections[k] |
---|
934 | + except (AttributeError, KeyError): |
---|
935 | + return self.connect(k) |
---|
936 | + |
---|
937 | + def __setitem__(self, k, v): |
---|
938 | + try: |
---|
939 | + self.local.connections[k] = v |
---|
940 | + except AttributeError: |
---|
941 | + # First access in thread |
---|
942 | + self.local.connections = {k: v} |
---|
943 | + |
---|
944 | + def connect(self, name): |
---|
945 | + """Return the connection with this name in |
---|
946 | + settings.OTHER_DATABASES. Creates the connection if it doesn't yet |
---|
947 | + exist. Reconnects if it does. If the name requested is the default |
---|
948 | + connection (a singleton defined in django.db), then the default |
---|
949 | + connection is returned. |
---|
950 | + """ |
---|
951 | + try: |
---|
952 | + cnx = self.local.connections |
---|
953 | + except AttributeError: |
---|
954 | + cnx = self.local.connections = {} |
---|
955 | + if name in cnx: |
---|
956 | + cnx[name].close() |
---|
957 | + if name is _default: |
---|
958 | + cnx[name] = connect(settings) |
---|
959 | + return cnx[name] |
---|
960 | + try: |
---|
961 | + info = settings.OTHER_DATABASES[name] |
---|
962 | + except KeyError: |
---|
963 | + raise ImproperlyConfigured, \ |
---|
964 | + "No database connection '%s' has been configured" % name |
---|
965 | + except AttributeError: |
---|
966 | + raise ImproperlyConfigured, \ |
---|
967 | + "No OTHER_DATABASES in settings." |
---|
968 | + |
---|
969 | + # In settings it's a dict, but connect() needs an object: |
---|
970 | + # pass global settings so that the default connection settings |
---|
971 | + # can be defaults for the named connections. |
---|
972 | + database = UserSettingsHolder(settings) |
---|
973 | + for k, v in info.items(): |
---|
974 | + setattr(database, k, v) |
---|
975 | + cnx[name] = connect(database) |
---|
976 | + return cnx[name] |
---|
977 | + |
---|
978 | + def items(self): |
---|
979 | + # Iterates over *all possible* connections |
---|
980 | + items = [] |
---|
981 | + for key in self.keys(): |
---|
982 | + items.append((key, self[key])) |
---|
983 | + return items |
---|
984 | + |
---|
985 | + def keys(self): |
---|
986 | + # Iterates over *all possible* connections |
---|
987 | + keys = [_default] |
---|
988 | + try: |
---|
989 | + keys.extend(settings.OTHER_DATABASES.keys()) |
---|
990 | + except AttributeError: |
---|
991 | + pass |
---|
992 | + return keys |
---|
993 | + |
---|
994 | + def reset(self): |
---|
995 | + if not hasattr(self.local, 'connections'): |
---|
996 | + return |
---|
997 | + self.local.connections = {} |
---|
998 | + |
---|
999 | +def model_connection_name(klass): |
---|
1000 | + """Get the connection name that a model is configured to use, with the |
---|
1001 | + current settings. |
---|
1002 | + """ |
---|
1003 | + app = klass._meta.app_label |
---|
1004 | + model = klass.__name__ |
---|
1005 | + app_model = "%s.%s" % (app, model) |
---|
1006 | + |
---|
1007 | + # Quick exit if no OTHER_DATABASES defined |
---|
1008 | + if (not hasattr(settings, 'OTHER_DATABASES') |
---|
1009 | + or not settings.OTHER_DATABASES): |
---|
1010 | + return _default |
---|
1011 | + # Look in MODELS for the best match: app_label.Model. If that isn't |
---|
1012 | + # found, take just app_label. If nothing is found, use the default |
---|
1013 | + maybe = None |
---|
1014 | + for name, db_def in settings.OTHER_DATABASES.items(): |
---|
1015 | + if not 'MODELS' in db_def: |
---|
1016 | + continue |
---|
1017 | + mods = db_def['MODELS'] |
---|
1018 | + # Can't get a better match than this |
---|
1019 | + if app_model in mods: |
---|
1020 | + return name |
---|
1021 | + elif app in mods: |
---|
1022 | + if maybe is not None: |
---|
1023 | + raise ImproperlyConfigured, \ |
---|
1024 | + "App %s appears in more than one OTHER_DATABASES " \ |
---|
1025 | + "setting (%s and %s)" % (maybe, name) |
---|
1026 | + maybe = name |
---|
1027 | + if maybe: |
---|
1028 | + return maybe |
---|
1029 | + # No named connection for this model; use the default |
---|
1030 | + return _default |
---|
1031 | + |
---|
1032 | + |
---|
1033 | +class ConnectionInfoDescriptor(object): |
---|
1034 | + """Descriptor used to access database connection information from a |
---|
1035 | + manager or other connection holder. Keeps a thread-local cache of |
---|
1036 | + connections per instance, and always returns the same connection for an |
---|
1037 | + instance in particular thread during a particular request. |
---|
1038 | + |
---|
1039 | + Any object that includes a ``model`` attribute that holds a model class |
---|
1040 | + can use this descriptor to manage connections. |
---|
1041 | + """ |
---|
1042 | + |
---|
1043 | + def __init__(self): |
---|
1044 | + self.local = local() |
---|
1045 | + self.local.cnx = {} |
---|
1046 | + dispatcher.connect(self.reset, signal=signals.request_finished) |
---|
1047 | + |
---|
1048 | + def __get__(self, instance, type=None): |
---|
1049 | + if instance is None: |
---|
1050 | + raise AttributeError, \ |
---|
1051 | + "ConnectionInfo is accessible only through an instance" |
---|
1052 | + try: |
---|
1053 | + instance_connection = self.local.cnx.get(instance, None) |
---|
1054 | + except AttributeError: |
---|
1055 | + # First access in this thread |
---|
1056 | + self.local.cnx = {} |
---|
1057 | + instance_connection = None |
---|
1058 | + if instance_connection is None: |
---|
1059 | + instance_connection = self.get_connection(instance) |
---|
1060 | + self.local.cnx[instance] = instance_connection |
---|
1061 | + return instance_connection |
---|
1062 | + |
---|
1063 | + def __set__(self, instance, value): |
---|
1064 | + try: |
---|
1065 | + self.local.cnx[instance] = value |
---|
1066 | + except AttributeError: |
---|
1067 | + # First access in thread |
---|
1068 | + self.local.cnx = {instance: value} |
---|
1069 | + |
---|
1070 | + def __delete__(self, instance): |
---|
1071 | + try: |
---|
1072 | + del self.local.cnx[instance] |
---|
1073 | + except (AttributeError, KeyError): |
---|
1074 | + # Not stored, no need to reset |
---|
1075 | + pass |
---|
1076 | + |
---|
1077 | + def get_connection(self, instance): |
---|
1078 | + return connections[model_connection_name(instance.model)] |
---|
1079 | + |
---|
1080 | + def reset(self): |
---|
1081 | + if not hasattr(self.local, 'cnx'): |
---|
1082 | + return |
---|
1083 | + self.local.cnx = {} |
---|
1084 | + |
---|
1085 | +class LocalizingProxy: |
---|
1086 | + """A lazy-initializing proxy. The proxied object is not |
---|
1087 | + initialized until the first attempt to access it. This is used to |
---|
1088 | + attach module-level properties to local storage. |
---|
1089 | + """ |
---|
1090 | + def __init__(self, name, storage, func, *arg, **kw): |
---|
1091 | + self.__name = name |
---|
1092 | + self.__storage = storage |
---|
1093 | + self.__func = func |
---|
1094 | + self.__arg = arg |
---|
1095 | + self.__kw = kw |
---|
1096 | + |
---|
1097 | + # We need to clear out this thread's storage at the end of each |
---|
1098 | + # request, in case new settings are loaded with the next |
---|
1099 | + def reset(stor=storage, name=name): |
---|
1100 | + if hasattr(stor, name): |
---|
1101 | + delattr(stor, name) |
---|
1102 | + dispatcher.connect(reset, signal=signals.request_finished) |
---|
1103 | + |
---|
1104 | + def __getattr__(self, attr): |
---|
1105 | + # Private (__*) attributes are munged |
---|
1106 | + if attr.startswith('_LocalizingProxy'): |
---|
1107 | + return self.__dict__[attr] |
---|
1108 | + try: |
---|
1109 | + return getattr(getattr(self.__storage, self.__name), attr) |
---|
1110 | + except AttributeError: |
---|
1111 | + setattr(self.__storage, self.__name, self.__func(*self.__arg, |
---|
1112 | + **self.__kw)) |
---|
1113 | + return getattr(getattr(self.__storage, self.__name), attr) |
---|
1114 | + |
---|
1115 | + def __setattr__(self, attr, val): |
---|
1116 | + # Private (__*) attributes are munged |
---|
1117 | + if attr.startswith('_LocalizingProxy'): |
---|
1118 | + self.__dict__[attr] = val |
---|
1119 | + return |
---|
1120 | + try: |
---|
1121 | + stor = getattr(self.__storage, self.__name) |
---|
1122 | + except AttributeError: |
---|
1123 | + stor = self.__func(*self.__arg) |
---|
1124 | + setattr(self.__storage, self.__name, stor) |
---|
1125 | + setattr(stor, attr, val) |
---|
1126 | + |
---|
1127 | + |
---|
1128 | +# Create a manager for named connections |
---|
1129 | +connections = LazyConnectionManager() |
---|
1130 | + |
---|
1131 | +# Backwards compatibility: establish the default connection and set the |
---|
1132 | +# default connection properties at module level, using the lazy proxy so that |
---|
1133 | +# each thread may have a different default connection, if so configured |
---|
1134 | +connection_info = LocalizingProxy('connection_info', _local, |
---|
1135 | + lambda: connections[_default]) |
---|
1136 | +connection = LocalizingProxy('connection', _local, |
---|
1137 | + lambda: connections[_default].connection) |
---|
1138 | +backend = LocalizingProxy('backend', _local, |
---|
1139 | + lambda: connections[_default].backend) |
---|
1140 | +DatabaseError = LocalizingProxy('DatabaseError', _local, |
---|
1141 | + lambda: connections[_default].DatabaseError) |
---|
1142 | +#================================BUG==Might need LocalizingProxy============== |
---|
1143 | IntegrityError = backend.IntegrityError |
---|
1144 | +get_introspection_module = LocalizingProxy( |
---|
1145 | + 'get_introspection_module', _local, |
---|
1146 | + lambda: connections[_default].get_introspection_module) |
---|
1147 | +get_creation_module = LocalizingProxy( |
---|
1148 | + 'get_creation_module', _local, |
---|
1149 | + lambda: connections[_default].get_creation_module) |
---|
1150 | +runshell = LocalizingProxy('runshell', _local, |
---|
1151 | + lambda: connections[_default].runshell) |
---|
1152 | |
---|
1153 | -# Register an event that closes the database connection |
---|
1154 | -# when a Django request is finished. |
---|
1155 | -dispatcher.connect(connection.close, signal=signals.request_finished) |
---|
1156 | |
---|
1157 | -# Register an event that resets connection.queries |
---|
1158 | -# when a Django request is started. |
---|
1159 | -def reset_queries(): |
---|
1160 | - connection.queries = [] |
---|
1161 | -dispatcher.connect(reset_queries, signal=signals.request_started) |
---|
1162 | - |
---|
1163 | -# Register an event that rolls back the connection |
---|
1164 | +# Register an event that rolls back all connections |
---|
1165 | # when a Django request has an exception. |
---|
1166 | def _rollback_on_exception(): |
---|
1167 | from django.db import transaction |
---|
1168 | transaction.rollback_unless_managed() |
---|
1169 | -dispatcher.connect(_rollback_on_exception, signal=signals.got_request_exception) |
---|
1170 | +dispatcher.connect(_rollback_on_exception, |
---|
1171 | + signal=signals.got_request_exception) |
---|
1172 | + |
---|
1173 | +def reset_queries(): |
---|
1174 | + connections[_default].reset_queries() |
---|
1175 | + for c in connections: |
---|
1176 | + try: |
---|
1177 | + c.reset_queries() |
---|
1178 | + except: |
---|
1179 | + pass |
---|
1180 | + |
---|
1181 | === django/db/backends/ado_mssql/client.py |
---|
1182 | ================================================================== |
---|
1183 | --- django/db/backends/ado_mssql/client.py (/mirror/django/trunk) (revision 4246) |
---|
1184 | |
---|
1185 | +++ django/db/backends/ado_mssql/client.py (/local/django/multidb) (revision 4246) |
---|
1186 | |
---|
1187 | @@ -1,2 +1,2 @@ |
---|
1188 | |
---|
1189 | -def runshell(): |
---|
1190 | +def runshell(settings): |
---|
1191 | raise NotImplementedError |
---|
1192 | === django/db/backends/mysql_old/base.py |
---|
1193 | ================================================================== |
---|
1194 | --- django/db/backends/mysql_old/base.py (/mirror/django/trunk) (revision 4246) |
---|
1195 | |
---|
1196 | +++ django/db/backends/mysql_old/base.py (/local/django/multidb) (revision 4246) |
---|
1197 | |
---|
1198 | @@ -148,8 +148,8 @@ |
---|
1199 | |
---|
1200 | 'iendswith': 'LIKE %s', |
---|
1201 | } |
---|
1202 | |
---|
1203 | - def __init__(self, **kwargs): |
---|
1204 | - super(DatabaseWrapper, self).__init__(**kwargs) |
---|
1205 | + def __init__(self, settings): |
---|
1206 | + super(DatabaseWrapper, self).__init__(settings) |
---|
1207 | self.server_version = None |
---|
1208 | |
---|
1209 | def _valid_connection(self): |
---|
1210 | === django/db/backends/postgresql/client.py |
---|
1211 | ================================================================== |
---|
1212 | --- django/db/backends/postgresql/client.py (/mirror/django/trunk) (revision 4246) |
---|
1213 | |
---|
1214 | +++ django/db/backends/postgresql/client.py (/local/django/multidb) (revision 4246) |
---|
1215 | |
---|
1216 | @@ -1,7 +1,6 @@ |
---|
1217 | |
---|
1218 | -from django.conf import settings |
---|
1219 | import os |
---|
1220 | |
---|
1221 | -def runshell(): |
---|
1222 | +def runshell(settings): |
---|
1223 | args = ['psql'] |
---|
1224 | if settings.DATABASE_USER: |
---|
1225 | args += ["-U", settings.DATABASE_USER] |
---|
1226 | === django/db/backends/sqlite3/base.py |
---|
1227 | ================================================================== |
---|
1228 | --- django/db/backends/sqlite3/base.py (/mirror/django/trunk) (revision 4246) |
---|
1229 | |
---|
1230 | +++ django/db/backends/sqlite3/base.py (/local/django/multidb) (revision 4246) |
---|
1231 | |
---|
1232 | @@ -115,7 +115,7 @@ |
---|
1233 | |
---|
1234 | return self.connection.cursor(factory=SQLiteCursorWrapper) |
---|
1235 | |
---|
1236 | def close(self): |
---|
1237 | - from django.conf import settings |
---|
1238 | + settings = self.settings |
---|
1239 | # If database is in memory, closing the connection destroys the |
---|
1240 | # database. To prevent accidental data loss, ignore close requests on |
---|
1241 | # an in-memory db. |
---|
1242 | === django/db/backends/sqlite3/client.py |
---|
1243 | ================================================================== |
---|
1244 | --- django/db/backends/sqlite3/client.py (/mirror/django/trunk) (revision 4246) |
---|
1245 | |
---|
1246 | +++ django/db/backends/sqlite3/client.py (/local/django/multidb) (revision 4246) |
---|
1247 | |
---|
1248 | @@ -1,6 +1,5 @@ |
---|
1249 | |
---|
1250 | -from django.conf import settings |
---|
1251 | import os |
---|
1252 | |
---|
1253 | -def runshell(): |
---|
1254 | +def runshell(settings): |
---|
1255 | args = ['', settings.DATABASE_NAME] |
---|
1256 | os.execvp('sqlite3', args) |
---|
1257 | === django/db/backends/mysql/base.py |
---|
1258 | ================================================================== |
---|
1259 | --- django/db/backends/mysql/base.py (/mirror/django/trunk) (revision 4246) |
---|
1260 | |
---|
1261 | +++ django/db/backends/mysql/base.py (/local/django/multidb) (revision 4246) |
---|
1262 | |
---|
1263 | @@ -144,8 +144,8 @@ |
---|
1264 | |
---|
1265 | 'iendswith': 'LIKE %s', |
---|
1266 | } |
---|
1267 | |
---|
1268 | - def __init__(self, **kwargs): |
---|
1269 | - super(DatabaseWrapper, self).__init__(**kwargs) |
---|
1270 | + def __init__(self, settings): |
---|
1271 | + super(DatabaseWrapper, self).__init__(settings) |
---|
1272 | self.server_version = None |
---|
1273 | |
---|
1274 | def _valid_connection(self): |
---|
1275 | === django/db/backends/mysql/client.py |
---|
1276 | ================================================================== |
---|
1277 | --- django/db/backends/mysql/client.py (/mirror/django/trunk) (revision 4246) |
---|
1278 | |
---|
1279 | +++ django/db/backends/mysql/client.py (/local/django/multidb) (revision 4246) |
---|
1280 | |
---|
1281 | @@ -1,7 +1,6 @@ |
---|
1282 | |
---|
1283 | -from django.conf import settings |
---|
1284 | import os |
---|
1285 | |
---|
1286 | -def runshell(): |
---|
1287 | +def runshell(settings): |
---|
1288 | args = [''] |
---|
1289 | db = settings.DATABASE_OPTIONS.get('db', settings.DATABASE_NAME) |
---|
1290 | user = settings.DATABASE_OPTIONS.get('user', settings.DATABASE_USER) |
---|
1291 | === django/db/backends/oracle/base.py |
---|
1292 | ================================================================== |
---|
1293 | --- django/db/backends/oracle/base.py (/mirror/django/trunk) (revision 4246) |
---|
1294 | |
---|
1295 | +++ django/db/backends/oracle/base.py (/local/django/multidb) (revision 4246) |
---|
1296 | |
---|
1297 | @@ -412,6 +412,7 @@ |
---|
1298 | |
---|
1299 | return self.connection is not None |
---|
1300 | |
---|
1301 | def _cursor(self, settings): |
---|
1302 | + settings = self.settings |
---|
1303 | if not self._valid_connection(): |
---|
1304 | if len(settings.DATABASE_HOST.strip()) == 0: |
---|
1305 | settings.DATABASE_HOST = 'localhost' |
---|
1306 | === django/db/backends/oracle/client.py |
---|
1307 | ================================================================== |
---|
1308 | --- django/db/backends/oracle/client.py (/mirror/django/trunk) (revision 4246) |
---|
1309 | |
---|
1310 | +++ django/db/backends/oracle/client.py (/local/django/multidb) (revision 4246) |
---|
1311 | |
---|
1312 | @@ -1,7 +1,6 @@ |
---|
1313 | |
---|
1314 | -from django.conf import settings |
---|
1315 | import os |
---|
1316 | |
---|
1317 | -def runshell(): |
---|
1318 | +def runshell(settings): |
---|
1319 | dsn = settings.DATABASE_USER |
---|
1320 | if settings.DATABASE_PASSWORD: |
---|
1321 | dsn += "/%s" % settings.DATABASE_PASSWORD |
---|
1322 | === django/db/backends/__init__.py |
---|
1323 | ================================================================== |
---|
1324 | --- django/db/backends/__init__.py (/mirror/django/trunk) (revision 4246) |
---|
1325 | |
---|
1326 | +++ django/db/backends/__init__.py (/local/django/multidb) (revision 4246) |
---|
1327 | |
---|
1328 | @@ -5,15 +5,16 @@ |
---|
1329 | |
---|
1330 | # Import copy of _thread_local.py from Python 2.4 |
---|
1331 | from django.utils._threading_local import local |
---|
1332 | |
---|
1333 | -class BaseDatabaseWrapper(local): |
---|
1334 | +class BaseDatabaseWrapper(object): |
---|
1335 | """ |
---|
1336 | Represents a database connection. |
---|
1337 | """ |
---|
1338 | ops = None |
---|
1339 | - def __init__(self, **kwargs): |
---|
1340 | + def __init__(self, settings): |
---|
1341 | + self.settings = settings |
---|
1342 | + self.options = settings.DATABASE_OPTIONS |
---|
1343 | self.connection = None |
---|
1344 | self.queries = [] |
---|
1345 | - self.options = kwargs |
---|
1346 | |
---|
1347 | def _commit(self): |
---|
1348 | if self.connection is not None: |
---|
1349 | @@ -29,7 +30,7 @@ |
---|
1350 | |
---|
1351 | self.connection = None |
---|
1352 | |
---|
1353 | def cursor(self): |
---|
1354 | - from django.conf import settings |
---|
1355 | + settings = self.settings |
---|
1356 | cursor = self._cursor(settings) |
---|
1357 | if settings.DEBUG: |
---|
1358 | return self.make_debug_cursor(cursor) |
---|
1359 | === django/db/backends/dummy/base.py |
---|
1360 | ================================================================== |
---|
1361 | --- django/db/backends/dummy/base.py (/mirror/django/trunk) (revision 4246) |
---|
1362 | |
---|
1363 | +++ django/db/backends/dummy/base.py (/local/django/multidb) (revision 4246) |
---|
1364 | |
---|
1365 | @@ -33,8 +33,5 @@ |
---|
1366 | |
---|
1367 | _commit = complain |
---|
1368 | _rollback = ignore |
---|
1369 | |
---|
1370 | - def __init__(self, **kwargs): |
---|
1371 | - pass |
---|
1372 | - |
---|
1373 | def close(self): |
---|
1374 | pass |
---|
1375 | === django/db/transaction.py |
---|
1376 | ================================================================== |
---|
1377 | --- django/db/transaction.py (/mirror/django/trunk) (revision 4246) |
---|
1378 | |
---|
1379 | +++ django/db/transaction.py (/local/django/multidb) (revision 4246) |
---|
1380 | |
---|
1381 | @@ -16,7 +16,6 @@ |
---|
1382 | |
---|
1383 | import thread |
---|
1384 | except ImportError: |
---|
1385 | import dummy_thread as thread |
---|
1386 | -from django.db import connection |
---|
1387 | from django.conf import settings |
---|
1388 | |
---|
1389 | class TransactionManagementError(Exception): |
---|
1390 | @@ -116,48 +115,67 @@ |
---|
1391 | |
---|
1392 | Puts the transaction manager into a manual state: managed transactions have |
---|
1393 | to be committed explicitly by the user. If you switch off transaction |
---|
1394 | management and there is a pending commit/rollback, the data will be |
---|
1395 | - commited. |
---|
1396 | + commited. Note that managed state applies across all connections. |
---|
1397 | """ |
---|
1398 | thread_ident = thread.get_ident() |
---|
1399 | top = state.get(thread_ident, None) |
---|
1400 | if top: |
---|
1401 | top[-1] = flag |
---|
1402 | if not flag and is_dirty(): |
---|
1403 | - connection._commit() |
---|
1404 | + for cx in all_connections(): |
---|
1405 | + cx._commit() |
---|
1406 | set_clean() |
---|
1407 | else: |
---|
1408 | raise TransactionManagementError("This code isn't under transaction management") |
---|
1409 | |
---|
1410 | -def commit_unless_managed(): |
---|
1411 | +def commit_unless_managed(connections=None): |
---|
1412 | """ |
---|
1413 | Commits changes if the system is not in managed transaction mode. |
---|
1414 | """ |
---|
1415 | if not is_managed(): |
---|
1416 | - connection._commit() |
---|
1417 | + if connections is None: |
---|
1418 | + connections = all_connections() |
---|
1419 | + else: |
---|
1420 | + connections = ensure_connections(connections) |
---|
1421 | + for cx in connections: |
---|
1422 | + cx._commit() |
---|
1423 | else: |
---|
1424 | set_dirty() |
---|
1425 | |
---|
1426 | -def rollback_unless_managed(): |
---|
1427 | +def rollback_unless_managed(connections=None): |
---|
1428 | """ |
---|
1429 | Rolls back changes if the system is not in managed transaction mode. |
---|
1430 | """ |
---|
1431 | if not is_managed(): |
---|
1432 | - connection._rollback() |
---|
1433 | + if connections is None: |
---|
1434 | + connections = all_connections() |
---|
1435 | + for cx in connections: |
---|
1436 | + cx._rollback() |
---|
1437 | else: |
---|
1438 | set_dirty() |
---|
1439 | |
---|
1440 | -def commit(): |
---|
1441 | +def commit(connections=None): |
---|
1442 | """ |
---|
1443 | Does the commit itself and resets the dirty flag. |
---|
1444 | """ |
---|
1445 | - connection._commit() |
---|
1446 | + if connections is None: |
---|
1447 | + connections = all_connections() |
---|
1448 | + else: |
---|
1449 | + connections = ensure_connections(connections) |
---|
1450 | + for cx in connections: |
---|
1451 | + cx._commit() |
---|
1452 | set_clean() |
---|
1453 | |
---|
1454 | -def rollback(): |
---|
1455 | +def rollback(connections=None): |
---|
1456 | """ |
---|
1457 | This function does the rollback itself and resets the dirty flag. |
---|
1458 | """ |
---|
1459 | - connection._rollback() |
---|
1460 | + if connections is None: |
---|
1461 | + connections = all_connections() |
---|
1462 | + else: |
---|
1463 | + connections = ensure_connections(connections) |
---|
1464 | + for cx in connections: |
---|
1465 | + cx._rollback() |
---|
1466 | set_clean() |
---|
1467 | |
---|
1468 | ############## |
---|
1469 | @@ -179,7 +197,7 @@ |
---|
1470 | |
---|
1471 | leave_transaction_management() |
---|
1472 | return _autocommit |
---|
1473 | |
---|
1474 | -def commit_on_success(func): |
---|
1475 | +def commit_on_success(func, connections=None): |
---|
1476 | """ |
---|
1477 | This decorator activates commit on response. This way, if the view function |
---|
1478 | runs successfully, a commit is made; if the viewfunc produces an exception, |
---|
1479 | @@ -198,7 +216,7 @@ |
---|
1480 | |
---|
1481 | raise |
---|
1482 | else: |
---|
1483 | if is_dirty(): |
---|
1484 | - commit() |
---|
1485 | + commit(connections) |
---|
1486 | return res |
---|
1487 | finally: |
---|
1488 | leave_transaction_management() |
---|
1489 | @@ -220,3 +238,31 @@ |
---|
1490 | |
---|
1491 | leave_transaction_management() |
---|
1492 | |
---|
1493 | return _commit_manually |
---|
1494 | + |
---|
1495 | +########### |
---|
1496 | +# HELPERS # |
---|
1497 | +########### |
---|
1498 | + |
---|
1499 | +def all_connections(): |
---|
1500 | + from django.db import connection, connections |
---|
1501 | + return [connection] + [ c.connection |
---|
1502 | + for c in connections.values() ] |
---|
1503 | + |
---|
1504 | +def ensure_connections(val): |
---|
1505 | + from django.db import connections |
---|
1506 | + conns = [] |
---|
1507 | + if isinstance(val, basestring): |
---|
1508 | + val = [val] |
---|
1509 | + try: |
---|
1510 | + iter(val) |
---|
1511 | + except: |
---|
1512 | + val = [val] |
---|
1513 | + for cx in val: |
---|
1514 | + if hasattr(cx, 'cursor'): |
---|
1515 | + conns.append(cx) |
---|
1516 | + elif hasattr(cx, 'connection'): |
---|
1517 | + conns.append(cx.connection) |
---|
1518 | + elif isinstance(cx, basestring): |
---|
1519 | + conns.append(connections[cx].connection) |
---|
1520 | + return conns |
---|
1521 | + |
---|
1522 | === django/conf/global_settings.py |
---|
1523 | ================================================================== |
---|
1524 | --- django/conf/global_settings.py (/mirror/django/trunk) (revision 4246) |
---|
1525 | |
---|
1526 | +++ django/conf/global_settings.py (/local/django/multidb) (revision 4246) |
---|
1527 | |
---|
1528 | @@ -118,6 +118,9 @@ |
---|
1529 | |
---|
1530 | DATABASE_PORT = '' # Set to empty string for default. Not used with sqlite3. |
---|
1531 | DATABASE_OPTIONS = {} # Set to empty dictionary for default. |
---|
1532 | |
---|
1533 | +# Optional named database connections in addition to the default. |
---|
1534 | +OTHER_DATABASES = {} |
---|
1535 | + |
---|
1536 | # Host for sending e-mail. |
---|
1537 | EMAIL_HOST = 'localhost' |
---|
1538 | |
---|
1539 | @@ -343,6 +346,16 @@ |
---|
1540 | |
---|
1541 | # If None, a name of 'test_' + DATABASE_NAME will be assumed |
---|
1542 | TEST_DATABASE_NAME = None |
---|
1543 | |
---|
1544 | +# Tuple of other test databases to create. Names in this tuple |
---|
1545 | +# are suffixes that will be appended to TEST_DATABASE_NAME |
---|
1546 | +TEST_DATABASES = [] |
---|
1547 | + |
---|
1548 | +# Models to assign to each test database. This must be a list of |
---|
1549 | +# dicts, with each dict key being a name from TEST_DATABASES and value |
---|
1550 | +# a list of models or app_labels that will use that database. |
---|
1551 | +TEST_DATABASE_MODELS = [] |
---|
1552 | + |
---|
1553 | +############### FROM TRUNK ############################# |
---|
1554 | # Strings used to set the character set and collation order for the test |
---|
1555 | # database. These values are passed literally to the server, so they are |
---|
1556 | # backend-dependent. If None, no special settings are sent (system defaults are |
---|
1557 | === django/core/management/commands/sqlsequencereset.py |
---|
1558 | ================================================================== |
---|
1559 | --- django/core/management/commands/sqlsequencereset.py (/mirror/django/trunk) (revision 4246) |
---|
1560 | |
---|
1561 | +++ django/core/management/commands/sqlsequencereset.py (/local/django/multidb) (revision 4246) |
---|
1562 | |
---|
1563 | @@ -5,5 +5,8 @@ |
---|
1564 | |
---|
1565 | output_transaction = True |
---|
1566 | |
---|
1567 | def handle_app(self, app, **options): |
---|
1568 | - from django.db import connection, models |
---|
1569 | - return '\n'.join(connection.ops.sequence_reset_sql(self.style, models.get_models(app))) |
---|
1570 | + from django.db import connection, models, model_connection_name |
---|
1571 | + connection_output = [] |
---|
1572 | + for model in models.get_models(app): |
---|
1573 | + connection_output.extend(model._default_manager.db.connection.ops.sequence_reset_sql(self.style,[model])) |
---|
1574 | + return '\n'.join(connection_output) |
---|
1575 | === django/core/management/commands/flush.py |
---|
1576 | ================================================================== |
---|
1577 | --- django/core/management/commands/flush.py (/mirror/django/trunk) (revision 4246) |
---|
1578 | |
---|
1579 | +++ django/core/management/commands/flush.py (/local/django/multidb) (revision 4246) |
---|
1580 | |
---|
1581 | @@ -14,7 +14,7 @@ |
---|
1582 | |
---|
1583 | |
---|
1584 | def handle_noargs(self, **options): |
---|
1585 | from django.conf import settings |
---|
1586 | - from django.db import connection, transaction, models |
---|
1587 | + from django.db import connections, connection, transaction, models |
---|
1588 | from django.dispatch import dispatcher |
---|
1589 | from django.core.management.sql import sql_flush, emit_post_sync_signal |
---|
1590 | |
---|
1591 | @@ -32,7 +32,6 @@ |
---|
1592 | |
---|
1593 | pass |
---|
1594 | |
---|
1595 | sql_list = sql_flush(self.style, only_django=True) |
---|
1596 | - |
---|
1597 | if interactive: |
---|
1598 | confirm = raw_input("""You have requested a flush of the database. |
---|
1599 | This will IRREVERSIBLY DESTROY all data currently in the %r database, |
---|
1600 | @@ -45,8 +44,8 @@ |
---|
1601 | |
---|
1602 | |
---|
1603 | if confirm == 'yes': |
---|
1604 | try: |
---|
1605 | - cursor = connection.cursor() |
---|
1606 | - for sql in sql_list: |
---|
1607 | + for conn, sql in sql_list: |
---|
1608 | + cursor = connections[conn].connection.cursor() |
---|
1609 | cursor.execute(sql) |
---|
1610 | except Exception, e: |
---|
1611 | transaction.rollback_unless_managed() |
---|
1612 | === django/core/management/commands/syncdb.py |
---|
1613 | ================================================================== |
---|
1614 | --- django/core/management/commands/syncdb.py (/mirror/django/trunk) (revision 4246) |
---|
1615 | |
---|
1616 | +++ django/core/management/commands/syncdb.py (/local/django/multidb) (revision 4246) |
---|
1617 | |
---|
1618 | @@ -19,7 +19,8 @@ |
---|
1619 | |
---|
1620 | help = "Create the database tables for all apps in INSTALLED_APPS whose tables haven't already been created." |
---|
1621 | |
---|
1622 | def handle_noargs(self, **options): |
---|
1623 | - from django.db import connection, transaction, models |
---|
1624 | + from django.db import model_connection_name |
---|
1625 | + from django.db import transaction, models |
---|
1626 | from django.conf import settings |
---|
1627 | 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 |
---|
1628 | |
---|
1629 | @@ -36,15 +37,9 @@ |
---|
1630 | |
---|
1631 | except ImportError: |
---|
1632 | pass |
---|
1633 | |
---|
1634 | - cursor = connection.cursor() |
---|
1635 | - |
---|
1636 | - if connection.features.uses_case_insensitive_names: |
---|
1637 | - table_name_converter = lambda x: x.upper() |
---|
1638 | - else: |
---|
1639 | - table_name_converter = lambda x: x |
---|
1640 | # Get a list of all existing database tables, so we know what needs to |
---|
1641 | # be added. |
---|
1642 | - tables = [table_name_converter(name) for name in table_list()] |
---|
1643 | + tables = table_list() |
---|
1644 | |
---|
1645 | # Get a list of already installed *models* so that references work right. |
---|
1646 | seen_models = installed_models(tables) |
---|
1647 | @@ -58,8 +53,15 @@ |
---|
1648 | |
---|
1649 | for model in model_list: |
---|
1650 | # Create the model's database table, if it doesn't already exist. |
---|
1651 | if verbosity >= 2: |
---|
1652 | - print "Processing %s.%s model" % (app_name, model._meta.object_name) |
---|
1653 | - if table_name_converter(model._meta.db_table) in tables: |
---|
1654 | + print "Processing %s.%s model (%s))" % (app_name, model._meta.object_name, model_connection_name(model)) |
---|
1655 | + connection = model._default_manager.db.connection |
---|
1656 | + cursor = connection.cursor() |
---|
1657 | + if connection.features.uses_case_insensitive_names: |
---|
1658 | + table_name_converter = lambda x: x.upper() |
---|
1659 | + else: |
---|
1660 | + table_name_converter = lambda x: x |
---|
1661 | + ctables = [table_name_converter(name) for name in tables] |
---|
1662 | + if table_name_converter(model._meta.db_table) in ctables: |
---|
1663 | continue |
---|
1664 | sql, references = sql_model_create(model, self.style, seen_models) |
---|
1665 | seen_models.add(model) |
---|
1666 | @@ -80,6 +82,8 @@ |
---|
1667 | |
---|
1668 | model_list = models.get_models(app) |
---|
1669 | for model in model_list: |
---|
1670 | if model in created_models: |
---|
1671 | + connection = model._default_manager.db.connection |
---|
1672 | + cursor = connection.cursor() |
---|
1673 | sql = many_to_many_sql_for_model(model, self.style) |
---|
1674 | if sql: |
---|
1675 | if verbosity >= 2: |
---|
1676 | @@ -99,6 +103,8 @@ |
---|
1677 | |
---|
1678 | app_name = app.__name__.split('.')[-2] |
---|
1679 | for model in models.get_models(app): |
---|
1680 | if model in created_models: |
---|
1681 | + connection = model._default_manager.db.connection |
---|
1682 | + cursor = connection.cursor() |
---|
1683 | custom_sql = custom_sql_for_model(model) |
---|
1684 | if custom_sql: |
---|
1685 | if verbosity >= 1: |
---|
1686 | @@ -118,6 +124,8 @@ |
---|
1687 | |
---|
1688 | app_name = app.__name__.split('.')[-2] |
---|
1689 | for model in models.get_models(app): |
---|
1690 | if model in created_models: |
---|
1691 | + connection = model._default_manager.db.connection |
---|
1692 | + cursor = connection.cursor() |
---|
1693 | index_sql = sql_indexes_for_model(model, self.style) |
---|
1694 | if index_sql: |
---|
1695 | if verbosity >= 1: |
---|
1696 | @@ -135,3 +143,4 @@ |
---|
1697 | |
---|
1698 | # Install the 'initial_data' fixture, using format discovery |
---|
1699 | from django.core.management import call_command |
---|
1700 | call_command('loaddata', 'initial_data', verbosity=verbosity) |
---|
1701 | + |
---|
1702 | === django/core/management/validation.py |
---|
1703 | ================================================================== |
---|
1704 | --- django/core/management/validation.py (/mirror/django/trunk) (revision 4246) |
---|
1705 | |
---|
1706 | +++ django/core/management/validation.py (/local/django/multidb) (revision 4246) |
---|
1707 | |
---|
1708 | @@ -19,7 +19,7 @@ |
---|
1709 | |
---|
1710 | Returns number of errors. |
---|
1711 | """ |
---|
1712 | from django.conf import settings |
---|
1713 | - from django.db import models, connection |
---|
1714 | + from django.db import models, connections, model_connection_name |
---|
1715 | from django.db.models.loading import get_app_errors |
---|
1716 | from django.db.models.fields.related import RelatedObject |
---|
1717 | |
---|
1718 | @@ -30,6 +30,8 @@ |
---|
1719 | |
---|
1720 | |
---|
1721 | for cls in models.get_models(app): |
---|
1722 | opts = cls._meta |
---|
1723 | + connection_name = model_connection_name(cls) |
---|
1724 | + connection = connections[connection_name] |
---|
1725 | |
---|
1726 | # Do field-specific validation. |
---|
1727 | for f in opts.fields: |
---|
1728 | @@ -63,7 +65,7 @@ |
---|
1729 | |
---|
1730 | |
---|
1731 | # Check that max_length <= 255 if using older MySQL versions. |
---|
1732 | if settings.DATABASE_ENGINE == 'mysql': |
---|
1733 | - db_version = connection.get_server_version() |
---|
1734 | + db_version = connection.connection.get_server_version() |
---|
1735 | if db_version < (5, 0, 3) and isinstance(f, (models.CharField, models.CommaSeparatedIntegerField, models.SlugField)) and f.max_length > 255: |
---|
1736 | e.add(opts, '"%s": %s cannot have a "max_length" greater than 255 when you are using a version of MySQL prior to 5.0.3 (you are using %s).' % (f.name, f.__class__.__name__, '.'.join([str(n) for n in db_version[:3]]))) |
---|
1737 | |
---|
1738 | @@ -74,6 +76,11 @@ |
---|
1739 | |
---|
1740 | if f.rel.to not in models.get_models(): |
---|
1741 | e.add(opts, "'%s' has relation with model %s, which has not been installed" % (f.name, rel_opts.object_name)) |
---|
1742 | |
---|
1743 | + #TODO: Fix this to allow relations that span databases by splitting querys up |
---|
1744 | + rel_connection = model_connection_name(f.rel.to) |
---|
1745 | + if rel_connection != connection_name: |
---|
1746 | + 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)) |
---|
1747 | + |
---|
1748 | rel_name = RelatedObject(f.rel.to, cls, f).get_accessor_name() |
---|
1749 | rel_query_name = f.related_query_name() |
---|
1750 | for r in rel_opts.fields: |
---|
1751 | === django/core/management/sql.py |
---|
1752 | ================================================================== |
---|
1753 | --- django/core/management/sql.py (/mirror/django/trunk) (revision 4246) |
---|
1754 | |
---|
1755 | +++ django/core/management/sql.py (/local/django/multidb) (revision 4246) |
---|
1756 | |
---|
1757 | @@ -8,11 +8,21 @@ |
---|
1758 | |
---|
1759 | from sets import Set as set # Python 2.3 fallback |
---|
1760 | |
---|
1761 | def table_list(): |
---|
1762 | - "Returns a list of all table names that exist in the database." |
---|
1763 | - from django.db import connection, get_introspection_module |
---|
1764 | - cursor = connection.cursor() |
---|
1765 | - return get_introspection_module().get_table_list(cursor) |
---|
1766 | + """Returns a list of all table names that exist in the database.""" |
---|
1767 | + from django.db import connections |
---|
1768 | + table_list = [] |
---|
1769 | + for conn in connections: |
---|
1770 | + table_list.extend(table_list_conn(conn)) |
---|
1771 | + return table_list |
---|
1772 | |
---|
1773 | +def table_list_conn(conn): |
---|
1774 | + from django.db import connections |
---|
1775 | + try: |
---|
1776 | + cursor = connections[conn].connection.cursor() |
---|
1777 | + return connections[conn].get_introspection_module().get_table_list(cursor) |
---|
1778 | + except: |
---|
1779 | + return [] |
---|
1780 | + |
---|
1781 | def django_table_list(only_existing=False): |
---|
1782 | """ |
---|
1783 | Returns a list of all table names that have associated Django models and |
---|
1784 | @@ -32,18 +42,34 @@ |
---|
1785 | |
---|
1786 | tables = [t for t in tables if t in existing] |
---|
1787 | return tables |
---|
1788 | |
---|
1789 | +def django_table_list_conn(conn, only_existing=False): |
---|
1790 | + from django.db import models |
---|
1791 | + from django.db import model_connection_name |
---|
1792 | + tables = [] |
---|
1793 | + for app in models.get_apps(): |
---|
1794 | + for model in models.get_models(app): |
---|
1795 | + if model_connection_name(model)==conn: |
---|
1796 | + tables.append(model._meta.db_table) |
---|
1797 | + tables.extend([f.m2m_db_table() for f in model._meta.many_to_many]) |
---|
1798 | + if only_existing: |
---|
1799 | + existing = table_list_conn(conn) |
---|
1800 | + tables = [t for t in tables if t in existing] |
---|
1801 | + return tables |
---|
1802 | + |
---|
1803 | def installed_models(table_list): |
---|
1804 | "Returns a set of all models that are installed, given a list of existing table names." |
---|
1805 | from django.db import connection, models |
---|
1806 | all_models = [] |
---|
1807 | for app in models.get_apps(): |
---|
1808 | for model in models.get_models(app): |
---|
1809 | - all_models.append(model) |
---|
1810 | - if connection.features.uses_case_insensitive_names: |
---|
1811 | - converter = lambda x: x.upper() |
---|
1812 | - else: |
---|
1813 | - converter = lambda x: x |
---|
1814 | - return set([m for m in all_models if converter(m._meta.db_table) in map(converter, table_list)]) |
---|
1815 | + connection = model._default_manager.db.connection |
---|
1816 | + if connection.features.uses_case_insensitive_names: |
---|
1817 | + converter = lambda x: x.upper() |
---|
1818 | + else: |
---|
1819 | + converter = lambda x: x |
---|
1820 | + if converter(model._meta.db_table) in map(converter, table_list): |
---|
1821 | + all_models.append(converter(model)) |
---|
1822 | + return set(all_models) |
---|
1823 | |
---|
1824 | def sequence_list(): |
---|
1825 | "Returns a list of information about all DB sequences for all models in all apps." |
---|
1826 | @@ -66,7 +92,7 @@ |
---|
1827 | |
---|
1828 | |
---|
1829 | def sql_create(app, style): |
---|
1830 | "Returns a list of the CREATE TABLE SQL statements for the given app." |
---|
1831 | - from django.db import models |
---|
1832 | + from django.db import models, model_connection_name |
---|
1833 | from django.conf import settings |
---|
1834 | |
---|
1835 | if settings.DATABASE_ENGINE == 'dummy': |
---|
1836 | @@ -81,22 +107,30 @@ |
---|
1837 | |
---|
1838 | # generate invalid SQL (leaving models out of known_models is harmless, so |
---|
1839 | # we can be conservative). |
---|
1840 | app_models = models.get_models(app) |
---|
1841 | - final_output = [] |
---|
1842 | + # final_output = [] |
---|
1843 | known_models = set([model for model in installed_models(table_list()) if model not in app_models]) |
---|
1844 | pending_references = {} |
---|
1845 | |
---|
1846 | + connection_output = {} |
---|
1847 | + |
---|
1848 | for model in app_models: |
---|
1849 | + connection_name = model_connection_name(model) |
---|
1850 | + f_output = connection_output.setdefault(connection_name, []) |
---|
1851 | output, references = sql_model_create(model, style, known_models) |
---|
1852 | - final_output.extend(output) |
---|
1853 | + f_output.extend(output) |
---|
1854 | for refto, refs in references.items(): |
---|
1855 | pending_references.setdefault(refto, []).extend(refs) |
---|
1856 | - final_output.extend(sql_for_pending_references(model, style, pending_references)) |
---|
1857 | + f_output.extend(sql_for_pending_references(model, style, pending_references)) |
---|
1858 | # Keep track of the fact that we've created the table for this model. |
---|
1859 | known_models.add(model) |
---|
1860 | |
---|
1861 | + final_output = _collate(connection_output) |
---|
1862 | + |
---|
1863 | # Create the many-to-many join tables. |
---|
1864 | for model in app_models: |
---|
1865 | - final_output.extend(many_to_many_sql_for_model(model, style)) |
---|
1866 | + connection_name = model_connection_name(model) |
---|
1867 | + f_output = connection_output.setdefault(connection_name, []) |
---|
1868 | + f_output.extend(many_to_many_sql_for_model(model,style)) |
---|
1869 | |
---|
1870 | # Handle references to tables that are from other apps |
---|
1871 | # but don't exist physically. |
---|
1872 | @@ -110,39 +144,45 @@ |
---|
1873 | |
---|
1874 | final_output.append('-- The following references should be added but depend on non-existent tables:') |
---|
1875 | final_output.extend(alter_sql) |
---|
1876 | |
---|
1877 | + # convert Boundstatements into strings |
---|
1878 | + final_output = map(str, final_output) |
---|
1879 | + |
---|
1880 | return final_output |
---|
1881 | |
---|
1882 | def sql_delete(app, style): |
---|
1883 | "Returns a list of the DROP TABLE SQL statements for the given app." |
---|
1884 | + from django.db import model_connection_name |
---|
1885 | from django.db import connection, models, get_introspection_module |
---|
1886 | from django.db.backends.util import truncate_name |
---|
1887 | - introspection = get_introspection_module() |
---|
1888 | |
---|
1889 | - # This should work even if a connection isn't available |
---|
1890 | - try: |
---|
1891 | - cursor = connection.cursor() |
---|
1892 | - except: |
---|
1893 | - cursor = None |
---|
1894 | - |
---|
1895 | - # Figure out which tables already exist |
---|
1896 | - if cursor: |
---|
1897 | - table_names = introspection.get_table_list(cursor) |
---|
1898 | - else: |
---|
1899 | - table_names = [] |
---|
1900 | - if connection.features.uses_case_insensitive_names: |
---|
1901 | - table_name_converter = lambda x: x.upper() |
---|
1902 | - else: |
---|
1903 | - table_name_converter = lambda x: x |
---|
1904 | - |
---|
1905 | output = [] |
---|
1906 | - qn = connection.ops.quote_name |
---|
1907 | - |
---|
1908 | + |
---|
1909 | # Output DROP TABLE statements for standard application tables. |
---|
1910 | to_delete = set() |
---|
1911 | |
---|
1912 | references_to_delete = {} |
---|
1913 | + |
---|
1914 | app_models = models.get_models(app) |
---|
1915 | for model in app_models: |
---|
1916 | + connection = model._default_manager.db.connection |
---|
1917 | + introspection = model._default_manager.db.get_introspection_module() |
---|
1918 | + # This should work even if a connection isn't available |
---|
1919 | + try: |
---|
1920 | + cursor = connection.cursor() |
---|
1921 | + except: |
---|
1922 | + cursor = None |
---|
1923 | + # Figure out which tables already exist |
---|
1924 | + if cursor: |
---|
1925 | + table_names = introspection.get_table_list(cursor) |
---|
1926 | + else: |
---|
1927 | + table_names = [] |
---|
1928 | + if connection.features.uses_case_insensitive_names: |
---|
1929 | + table_name_converter = lambda x: x.upper() |
---|
1930 | + else: |
---|
1931 | + table_name_converter = lambda x: x |
---|
1932 | + |
---|
1933 | + qn = connection.ops.quote_name |
---|
1934 | + |
---|
1935 | if cursor and table_name_converter(model._meta.db_table) in table_names: |
---|
1936 | # The table exists, so it needs to be dropped |
---|
1937 | opts = model._meta |
---|
1938 | @@ -153,6 +193,25 @@ |
---|
1939 | |
---|
1940 | to_delete.add(model) |
---|
1941 | |
---|
1942 | for model in app_models: |
---|
1943 | + connection = model._default_manager.db.connection |
---|
1944 | + introspection = model._default_manager.db.get_introspection_module() |
---|
1945 | + # This should work even if a connection isn't available |
---|
1946 | + try: |
---|
1947 | + cursor = connection.cursor() |
---|
1948 | + except: |
---|
1949 | + cursor = None |
---|
1950 | + # Figure out which tables already exist |
---|
1951 | + if cursor: |
---|
1952 | + table_names = introspection.get_table_list(cursor) |
---|
1953 | + else: |
---|
1954 | + table_names = [] |
---|
1955 | + if connection.features.uses_case_insensitive_names: |
---|
1956 | + table_name_converter = str.upper |
---|
1957 | + else: |
---|
1958 | + table_name_converter = lambda x: x |
---|
1959 | + |
---|
1960 | + qn = connection.ops.quote_name |
---|
1961 | + |
---|
1962 | if cursor and table_name_converter(model._meta.db_table) in table_names: |
---|
1963 | # Drop the table now |
---|
1964 | output.append('%s %s;' % (style.SQL_KEYWORD('DROP TABLE'), |
---|
1965 | @@ -177,6 +236,25 @@ |
---|
1966 | |
---|
1967 | |
---|
1968 | # Output DROP TABLE statements for many-to-many tables. |
---|
1969 | for model in app_models: |
---|
1970 | + connection = model._default_manager.db.connection |
---|
1971 | + introspection = model._default_manager.db.get_introspection_module() |
---|
1972 | + # This should work even if a connection isn't available |
---|
1973 | + try: |
---|
1974 | + cursor = connection.cursor() |
---|
1975 | + except: |
---|
1976 | + cursor = None |
---|
1977 | + # Figure out which tables already exist |
---|
1978 | + if cursor: |
---|
1979 | + table_names = introspection.get_table_list(cursor) |
---|
1980 | + else: |
---|
1981 | + table_names = [] |
---|
1982 | + if connection.features.uses_case_insensitive_names: |
---|
1983 | + table_name_converter = str.upper |
---|
1984 | + else: |
---|
1985 | + table_name_converter = lambda x: x |
---|
1986 | + |
---|
1987 | + qn = connection.ops.quote_name |
---|
1988 | + |
---|
1989 | opts = model._meta |
---|
1990 | for f in opts.many_to_many: |
---|
1991 | if cursor and table_name_converter(f.m2m_db_table()) in table_names: |
---|
1992 | @@ -190,9 +268,15 @@ |
---|
1993 | |
---|
1994 | |
---|
1995 | # Close database connection explicitly, in case this output is being piped |
---|
1996 | # directly into a database client, to avoid locking issues. |
---|
1997 | - if cursor: |
---|
1998 | - cursor.close() |
---|
1999 | - connection.close() |
---|
2000 | + for model in app_models: |
---|
2001 | + connection = model._default_manager.db.connection |
---|
2002 | + try: |
---|
2003 | + cursor = connection.cursor() |
---|
2004 | + except: |
---|
2005 | + cursor = None |
---|
2006 | + if cursor: |
---|
2007 | + cursor.close() |
---|
2008 | + connection.close() |
---|
2009 | |
---|
2010 | return output[::-1] # Reverse it, to deal with table dependencies. |
---|
2011 | |
---|
2012 | @@ -207,34 +291,42 @@ |
---|
2013 | |
---|
2014 | If only_django is True, then only table names that have associated Django |
---|
2015 | models and are in INSTALLED_APPS will be included. |
---|
2016 | """ |
---|
2017 | - from django.db import connection |
---|
2018 | - if only_django: |
---|
2019 | - tables = django_table_list() |
---|
2020 | - else: |
---|
2021 | - tables = table_list() |
---|
2022 | - statements = connection.ops.sql_flush(style, tables, sequence_list()) |
---|
2023 | + from django.db import connections |
---|
2024 | + statements = [] |
---|
2025 | + for conn in connections: |
---|
2026 | + if only_django: |
---|
2027 | + tables = django_table_list_conn(conn) |
---|
2028 | + else: |
---|
2029 | + tables = table_list_conn(conn) |
---|
2030 | + statements.extend((conn,f) for f in connections[conn].connection.ops.sql_flush(style, tables, sequence_list())) |
---|
2031 | return statements |
---|
2032 | |
---|
2033 | def sql_custom(app): |
---|
2034 | "Returns a list of the custom table modifying SQL statements for the given app." |
---|
2035 | from django.db.models import get_models |
---|
2036 | - output = [] |
---|
2037 | + from django.db import model_connection_name |
---|
2038 | + connection_output = {} |
---|
2039 | |
---|
2040 | app_models = get_models(app) |
---|
2041 | app_dir = os.path.normpath(os.path.join(os.path.dirname(app.__file__), 'sql')) |
---|
2042 | |
---|
2043 | for model in app_models: |
---|
2044 | - output.extend(custom_sql_for_model(model)) |
---|
2045 | + connection_name = model_connection_name(model) |
---|
2046 | + output = connection_output.setdefault(connection_name, []) |
---|
2047 | + output.extend(map(str, custom_sql_for_model(model))) |
---|
2048 | + return _collate(connection_output) |
---|
2049 | |
---|
2050 | - return output |
---|
2051 | - |
---|
2052 | def sql_indexes(app, style): |
---|
2053 | "Returns a list of the CREATE INDEX SQL statements for all models in the given app." |
---|
2054 | - from django.db import models |
---|
2055 | - output = [] |
---|
2056 | - for model in models.get_models(app): |
---|
2057 | - output.extend(sql_indexes_for_model(model, style)) |
---|
2058 | - return output |
---|
2059 | + from django.db import model_connection_name |
---|
2060 | + from django.db.models import get_models |
---|
2061 | + connection_output = {} |
---|
2062 | + for model in get_models(app): |
---|
2063 | + opts = model._meta |
---|
2064 | + connection_name = model_connection_name(model) |
---|
2065 | + output = connection_output.setdefault(connection_name, []) |
---|
2066 | + output.extend(map(str, sql_indexes_for_model(model, style))) |
---|
2067 | + return _collate(connection_output) |
---|
2068 | |
---|
2069 | def sql_all(app, style): |
---|
2070 | "Returns a list of CREATE TABLE SQL, initial-data inserts, and CREATE INDEX SQL for the given module." |
---|
2071 | @@ -245,12 +337,13 @@ |
---|
2072 | |
---|
2073 | Returns the SQL required to create a single model, as a tuple of: |
---|
2074 | (list_of_sql, pending_references_dict) |
---|
2075 | """ |
---|
2076 | - from django.db import connection, models |
---|
2077 | + from django.db import models |
---|
2078 | |
---|
2079 | opts = model._meta |
---|
2080 | final_output = [] |
---|
2081 | table_output = [] |
---|
2082 | pending_references = {} |
---|
2083 | + connection = model._default_manager.db.connection |
---|
2084 | qn = connection.ops.quote_name |
---|
2085 | for f in opts.fields: |
---|
2086 | col_type = f.db_type() |
---|
2087 | @@ -314,10 +407,14 @@ |
---|
2088 | |
---|
2089 | """ |
---|
2090 | Returns any ALTER TABLE statements to add constraints after the fact. |
---|
2091 | """ |
---|
2092 | - from django.db import connection |
---|
2093 | from django.db.backends.util import truncate_name |
---|
2094 | |
---|
2095 | + connection = model._default_manager.db.connection |
---|
2096 | qn = connection.ops.quote_name |
---|
2097 | + if hasattr(connection.ops, 'max_constraint_length'): |
---|
2098 | + mnl = connection.ops.max_constraint_length |
---|
2099 | + else: |
---|
2100 | + mnl = connection.ops.max_name_length |
---|
2101 | final_output = [] |
---|
2102 | if connection.features.supports_constraints: |
---|
2103 | opts = model._meta |
---|
2104 | @@ -332,18 +429,19 @@ |
---|
2105 | |
---|
2106 | # So we are careful with character usage here. |
---|
2107 | r_name = '%s_refs_%s_%x' % (r_col, col, abs(hash((r_table, table)))) |
---|
2108 | final_output.append(style.SQL_KEYWORD('ALTER TABLE') + ' %s ADD CONSTRAINT %s FOREIGN KEY (%s) REFERENCES %s (%s)%s;' % \ |
---|
2109 | - (qn(r_table), truncate_name(r_name, connection.ops.max_name_length()), |
---|
2110 | + (qn(r_table), truncate_name(r_name, mnl()), |
---|
2111 | qn(r_col), qn(table), qn(col), |
---|
2112 | connection.ops.deferrable_sql())) |
---|
2113 | del pending_references[model] |
---|
2114 | return final_output |
---|
2115 | |
---|
2116 | def many_to_many_sql_for_model(model, style): |
---|
2117 | - from django.db import connection, models |
---|
2118 | + from django.db import models |
---|
2119 | from django.contrib.contenttypes import generic |
---|
2120 | |
---|
2121 | opts = model._meta |
---|
2122 | final_output = [] |
---|
2123 | + connection = model._default_manager.db.connection |
---|
2124 | qn = connection.ops.quote_name |
---|
2125 | for f in opts.many_to_many: |
---|
2126 | if not isinstance(f.rel, generic.GenericRel): |
---|
2127 | @@ -455,3 +553,25 @@ |
---|
2128 | |
---|
2129 | dispatcher.send(signal=models.signals.post_syncdb, sender=app, |
---|
2130 | app=app, created_models=created_models, |
---|
2131 | verbosity=verbosity, interactive=interactive) |
---|
2132 | + |
---|
2133 | +def _collate(connection_output, reverse=False): |
---|
2134 | + from django.db import _default |
---|
2135 | + final_output = [] |
---|
2136 | + if len(connection_output.keys()) == 1: |
---|
2137 | + # all for the default connection |
---|
2138 | + for statements in connection_output.values(): |
---|
2139 | + final_output.extend(statements) |
---|
2140 | + if reverse: |
---|
2141 | + final_output.reverse() |
---|
2142 | + else: |
---|
2143 | + for connection_name, statements in connection_output.items(): |
---|
2144 | + if not statements: |
---|
2145 | + continue |
---|
2146 | + final_output.append(' -- The following statements are for connection: %s' % connection_name) |
---|
2147 | + if reverse: |
---|
2148 | + statements.reverse() |
---|
2149 | + final_output.extend(statements) |
---|
2150 | + final_output.append(' -- END statements for %s\n' % |
---|
2151 | + connection_name) |
---|
2152 | + return map(str, final_output) |
---|
2153 | + |
---|
2154 | === django/core/context_processors.py |
---|
2155 | ================================================================== |
---|
2156 | --- django/core/context_processors.py (/mirror/django/trunk) (revision 4246) |
---|
2157 | |
---|
2158 | +++ django/core/context_processors.py (/local/django/multidb) (revision 4246) |
---|
2159 | |
---|
2160 | @@ -33,8 +33,11 @@ |
---|
2161 | |
---|
2162 | context_extras = {} |
---|
2163 | if settings.DEBUG and request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS: |
---|
2164 | context_extras['debug'] = True |
---|
2165 | - from django.db import connection |
---|
2166 | - context_extras['sql_queries'] = connection.queries |
---|
2167 | + from django.db import connections |
---|
2168 | + sqlq = [] |
---|
2169 | + for c in connections: |
---|
2170 | + sqlq.extend(connections[c].connection.queries) |
---|
2171 | + context_extras['sql_queries'] = sqlq |
---|
2172 | return context_extras |
---|
2173 | |
---|
2174 | def i18n(request): |
---|
2175 | === tests/modeltests/invalid_models/__init__.py |
---|
2176 | ================================================================== |
---|
2177 | --- tests/modeltests/invalid_models/__init__.py (/mirror/django/trunk) (revision 4246) |
---|
2178 | |
---|
2179 | +++ tests/modeltests/invalid_models/__init__.py (/local/django/multidb) (revision 4246) |
---|
2180 | |
---|
2181 | @@ -1 +0,0 @@ |
---|
2182 | |
---|
2183 | - |
---|
2184 | === tests/modeltests/multiple_databases (new directory) |
---|
2185 | ================================================================== |
---|
2186 | === tests/modeltests/multiple_databases/__init__.py |
---|
2187 | ================================================================== |
---|
2188 | --- tests/modeltests/multiple_databases/__init__.py (/mirror/django/trunk) (revision 4246) |
---|
2189 | |
---|
2190 | +++ tests/modeltests/multiple_databases/__init__.py (/local/django/multidb) (revision 4246) |
---|
2191 | |
---|
2192 | @@ -0,0 +1 @@ |
---|
2193 | |
---|
2194 | +pass |
---|
2195 | |
---|
2196 | === tests/modeltests/multiple_databases/models.py |
---|
2197 | ================================================================== |
---|
2198 | --- tests/modeltests/multiple_databases/models.py (/mirror/django/trunk) (revision 4246) |
---|
2199 | |
---|
2200 | +++ tests/modeltests/multiple_databases/models.py (/local/django/multidb) (revision 4246) |
---|
2201 | |
---|
2202 | @@ -0,0 +1,221 @@ |
---|
2203 | |
---|
2204 | +""" |
---|
2205 | +XXX. Using multiple database connections |
---|
2206 | + |
---|
2207 | +Django normally uses only a single database connection. However, |
---|
2208 | +support is available for using any number of different, named |
---|
2209 | +connections. Multiple database support is entirely optional and has |
---|
2210 | +no impact on your application if you don't use it. |
---|
2211 | + |
---|
2212 | +Named connections are defined in your settings module. Create a |
---|
2213 | +`OTHER_DATABASES` variable that is a dict, mapping connection names to their |
---|
2214 | +particulars. The particulars are defined in a dict with the same keys |
---|
2215 | +as the variable names as are used to define the default connection, with one |
---|
2216 | +addition: MODELS. |
---|
2217 | + |
---|
2218 | +The MODELS item in an OTHER_DATABASES entry is a list of the apps and models |
---|
2219 | +that will use that connection. |
---|
2220 | + |
---|
2221 | +Access to named connections is through `django.db.connections`, which |
---|
2222 | +behaves like a dict: you access connections by name. Connections are |
---|
2223 | +established lazily, when accessed. `django.db.connections[database]` |
---|
2224 | +holds a `ConnectionInfo` instance, with the attributes: |
---|
2225 | +`DatabaseError`, `backend`, `get_introspection_module`, |
---|
2226 | +`get_creation_module`, and `runshell`. |
---|
2227 | + |
---|
2228 | +To access a model's connection, use its manager. The connection is available |
---|
2229 | +at `model._default_manager.db.connection`. To find the backend or other |
---|
2230 | +connection metadata, use `model._meta.db` to access the full ConnectionInfo |
---|
2231 | +with connection metadata. |
---|
2232 | +""" |
---|
2233 | + |
---|
2234 | +from django.db import models |
---|
2235 | + |
---|
2236 | +class Artist(models.Model): |
---|
2237 | + name = models.CharField(maxlength=100) |
---|
2238 | + alive = models.BooleanField(default=True) |
---|
2239 | + |
---|
2240 | + def __str__(self): |
---|
2241 | + return self.name |
---|
2242 | + |
---|
2243 | + |
---|
2244 | +class Opus(models.Model): |
---|
2245 | + artist = models.ForeignKey(Artist) |
---|
2246 | + name = models.CharField(maxlength=100) |
---|
2247 | + year = models.IntegerField() |
---|
2248 | + |
---|
2249 | + def __str__(self): |
---|
2250 | + return "%s (%s)" % (self.name, self.year) |
---|
2251 | + |
---|
2252 | + |
---|
2253 | +class Widget(models.Model): |
---|
2254 | + code = models.CharField(maxlength=10, unique=True) |
---|
2255 | + weight = models.IntegerField() |
---|
2256 | + |
---|
2257 | + def __str__(self): |
---|
2258 | + return self.code |
---|
2259 | + |
---|
2260 | + |
---|
2261 | +class DooHickey(models.Model): |
---|
2262 | + name = models.CharField(maxlength=50) |
---|
2263 | + widgets = models.ManyToManyField(Widget, related_name='doohickeys') |
---|
2264 | + |
---|
2265 | + def __str__(self): |
---|
2266 | + return self.name |
---|
2267 | + |
---|
2268 | + |
---|
2269 | +class Vehicle(models.Model): |
---|
2270 | + make = models.CharField(maxlength=20) |
---|
2271 | + model = models.CharField(maxlength=20) |
---|
2272 | + year = models.IntegerField() |
---|
2273 | + |
---|
2274 | + def __str__(self): |
---|
2275 | + return "%d %s %s" % (self.year, self.make, self.model) |
---|
2276 | + |
---|
2277 | + |
---|
2278 | +__test__ = {'API_TESTS': """ |
---|
2279 | + |
---|
2280 | +# See what connections are defined. django.db.connections acts like a dict. |
---|
2281 | +>>> from django.db import connection, connections, _default, model_connection_name |
---|
2282 | +>>> from django.conf import settings |
---|
2283 | + |
---|
2284 | +# Connections are referenced by name |
---|
2285 | +>>> connections['_a'] |
---|
2286 | +Connection: ... |
---|
2287 | +>>> connections['_b'] |
---|
2288 | +Connection: ... |
---|
2289 | + |
---|
2290 | +# Let's see what connections are available. The default connection is always |
---|
2291 | +# included in connections as well, and may be accessed as connections[_default]. |
---|
2292 | + |
---|
2293 | +>>> connection_names = connections.keys() |
---|
2294 | +>>> connection_names.sort() |
---|
2295 | +>>> connection_names |
---|
2296 | +[<default>, '_a', '_b'] |
---|
2297 | + |
---|
2298 | +# Invalid connection names raise ImproperlyConfigured |
---|
2299 | + |
---|
2300 | +>>> connections['bad'] |
---|
2301 | +Traceback (most recent call last): |
---|
2302 | + ... |
---|
2303 | +ImproperlyConfigured: No database connection 'bad' has been configured |
---|
2304 | + |
---|
2305 | +# The model_connection_name() function will tell you the name of the |
---|
2306 | +# connection that a model is configured to use. |
---|
2307 | + |
---|
2308 | +>>> model_connection_name(Artist) |
---|
2309 | +'_a' |
---|
2310 | +>>> model_connection_name(Widget) |
---|
2311 | +'_b' |
---|
2312 | +>>> model_connection_name(Vehicle) is _default |
---|
2313 | +True |
---|
2314 | +>>> a = Artist(name="Paul Klee", alive=False) |
---|
2315 | +>>> a.save() |
---|
2316 | +>>> w = Widget(code='100x2r', weight=1000) |
---|
2317 | +>>> w.save() |
---|
2318 | +>>> v = Vehicle(make='Chevy', model='Camaro', year='1966') |
---|
2319 | +>>> v.save() |
---|
2320 | +>>> artists = Artist.objects.all() |
---|
2321 | +>>> list(artists) |
---|
2322 | +[<Artist: Paul Klee>] |
---|
2323 | + |
---|
2324 | +# Models can access their connections through the db property of their |
---|
2325 | +# default manager. |
---|
2326 | + |
---|
2327 | +>>> paul = _[0] |
---|
2328 | +>>> Artist.objects.db |
---|
2329 | +Connection: ... (ENGINE=... NAME=...) |
---|
2330 | +>>> paul._default_manager.db |
---|
2331 | +Connection: ... (ENGINE=... NAME=...) |
---|
2332 | + |
---|
2333 | +# When transactions are not managed, model save will commit only |
---|
2334 | +# for the model's connection. |
---|
2335 | + |
---|
2336 | +>>> from django.db import transaction |
---|
2337 | +>>> transaction.enter_transaction_management() |
---|
2338 | +>>> transaction.managed(False) |
---|
2339 | +>>> a = Artist(name="Joan Miro", alive=False) |
---|
2340 | +>>> w = Widget(code="99rbln", weight=1) |
---|
2341 | +>>> a.save() |
---|
2342 | + |
---|
2343 | +# Only connection '_a' is committed, so if we rollback |
---|
2344 | +# all connections we'll forget the new Widget. |
---|
2345 | + |
---|
2346 | +>>> transaction.rollback() |
---|
2347 | +>>> list(Artist.objects.all()) |
---|
2348 | +[<Artist: Paul Klee>, <Artist: Joan Miro>] |
---|
2349 | +>>> list(Widget.objects.all()) |
---|
2350 | +[<Widget: 100x2r>] |
---|
2351 | + |
---|
2352 | +# Managed transaction state applies across all connections. |
---|
2353 | + |
---|
2354 | +>>> transaction.managed(True) |
---|
2355 | + |
---|
2356 | +# When managed, just as when using a single connection, updates are |
---|
2357 | +# not committed until a commit is issued. |
---|
2358 | + |
---|
2359 | +>>> a = Artist(name="Pablo Picasso", alive=False) |
---|
2360 | +>>> a.save() |
---|
2361 | +>>> w = Widget(code="99rbln", weight=1) |
---|
2362 | +>>> w.save() |
---|
2363 | +>>> v = Vehicle(make='Pontiac', model='Fiero', year='1987') |
---|
2364 | +>>> v.save() |
---|
2365 | + |
---|
2366 | +# The connections argument may be passed to commit, rollback, and the |
---|
2367 | +# commit_on_success decorator as a keyword argument, as the first (for |
---|
2368 | +# commit and rollback) or second (for the decorator) positional |
---|
2369 | +# argument. It may be passed as a ConnectionInfo object, a connection |
---|
2370 | +# (DatabaseWrapper) object, a connection name, or a list or dict of |
---|
2371 | +# ConnectionInfo objects, connection objects, or connection names. If a |
---|
2372 | +# dict is passed, the keys are ignored and the values used as the list |
---|
2373 | +# of connections to commit, rollback, etc. |
---|
2374 | + |
---|
2375 | +>>> transaction.commit(connections['_b']) |
---|
2376 | +>>> transaction.commit('_b') |
---|
2377 | +>>> transaction.commit(connections='_b') |
---|
2378 | +>>> transaction.commit(connections=['_b']) |
---|
2379 | +>>> transaction.commit(['_a', '_b']) |
---|
2380 | +>>> transaction.commit(connections) |
---|
2381 | + |
---|
2382 | +# When the connections argument is omitted entirely, the transaction |
---|
2383 | +# command applies to all connections. Here we have committed |
---|
2384 | +# connections 'django_test_db_a' and 'django_test_db_b', but not the |
---|
2385 | +# default connection, so the new vehicle is lost on rollback. |
---|
2386 | + |
---|
2387 | +>>> transaction.rollback() |
---|
2388 | +>>> list(Artist.objects.all()) |
---|
2389 | +[<Artist: Paul Klee>, <Artist: Joan Miro>, <Artist: Pablo Picasso>] |
---|
2390 | +>>> list(Widget.objects.all()) |
---|
2391 | +[<Widget: 100x2r>, <Widget: 99rbln>] |
---|
2392 | +>>> list(Vehicle.objects.all()) |
---|
2393 | +[<Vehicle: 1966 Chevy Camaro>] |
---|
2394 | +>>> transaction.rollback() |
---|
2395 | +>>> transaction.managed(False) |
---|
2396 | +>>> transaction.leave_transaction_management() |
---|
2397 | + |
---|
2398 | +# Of course, relations and all other normal database operations work |
---|
2399 | +# with models that use named connections just the same as with models |
---|
2400 | +# that use the default connection. The only caveat is that you can't |
---|
2401 | +# use a relation between two models that are stored in different |
---|
2402 | +# databases. Note that that doesn't mean that two models using |
---|
2403 | +# different connection *names* can't be related; only that in the the |
---|
2404 | +# context in which they are used, if you use the relation, the |
---|
2405 | +# connections named by the two models must resolve to the same |
---|
2406 | +# database. |
---|
2407 | + |
---|
2408 | +>>> a = Artist.objects.get(name="Paul Klee") |
---|
2409 | +>>> list(a.opus_set.all()) |
---|
2410 | +[] |
---|
2411 | +>>> a.opus_set.create(name="Magic Garden", year="1926") |
---|
2412 | +<Opus: Magic Garden (1926)> |
---|
2413 | +>>> list(a.opus_set.all()) |
---|
2414 | +[<Opus: Magic Garden (1926)>] |
---|
2415 | +>>> d = DooHickey(name='Thing') |
---|
2416 | +>>> d.save() |
---|
2417 | +>>> d.widgets.create(code='d101', weight=92) |
---|
2418 | +<Widget: d101> |
---|
2419 | +>>> list(d.widgets.all()) |
---|
2420 | +[<Widget: d101>] |
---|
2421 | +>>> w = Widget.objects.get(code='d101') |
---|
2422 | +>>> list(w.doohickeys.all()) |
---|
2423 | +[<DooHickey: Thing>] |
---|
2424 | +"""} |
---|
2425 | |
---|
2426 | Property changes on: tests/modeltests/multiple_databases |
---|
2427 | ___________________________________________________________________ |
---|
2428 | Name: svn:ignore |
---|
2429 | +*.pyc |
---|
2430 | + |
---|
2431 | |
---|
2432 | === tests/regressiontests/manager_db (new directory) |
---|
2433 | ================================================================== |
---|
2434 | === tests/regressiontests/manager_db/__init__.py |
---|
2435 | ================================================================== |
---|
2436 | === tests/regressiontests/manager_db/tests.py |
---|
2437 | ================================================================== |
---|
2438 | --- tests/regressiontests/manager_db/tests.py (/mirror/django/trunk) (revision 4246) |
---|
2439 | |
---|
2440 | +++ tests/regressiontests/manager_db/tests.py (/local/django/multidb) (revision 4246) |
---|
2441 | |
---|
2442 | @@ -0,0 +1,17 @@ |
---|
2443 | |
---|
2444 | +import unittest |
---|
2445 | +from regressiontests.manager_db.models import Insect |
---|
2446 | + |
---|
2447 | +class TestManagerDBAccess(unittest.TestCase): |
---|
2448 | + |
---|
2449 | + def test_db_property(self): |
---|
2450 | + m = Insect.objects |
---|
2451 | + db = Insect.objects.db |
---|
2452 | + assert db |
---|
2453 | + assert db.connection |
---|
2454 | + assert db.connection.cursor |
---|
2455 | + assert db.backend |
---|
2456 | + assert db.connection.ops.quote_name |
---|
2457 | + assert db.get_creation_module |
---|
2458 | + |
---|
2459 | +if __name__ == '__main__': |
---|
2460 | + unittest.main() |
---|
2461 | === tests/regressiontests/manager_db/models.py |
---|
2462 | ================================================================== |
---|
2463 | --- tests/regressiontests/manager_db/models.py (/mirror/django/trunk) (revision 4246) |
---|
2464 | |
---|
2465 | +++ tests/regressiontests/manager_db/models.py (/local/django/multidb) (revision 4246) |
---|
2466 | |
---|
2467 | @@ -0,0 +1,5 @@ |
---|
2468 | |
---|
2469 | +from django.db import models |
---|
2470 | + |
---|
2471 | +class Insect(models.Model): |
---|
2472 | + common_name = models.CharField(maxlength=64) |
---|
2473 | + latin_name = models.CharField(maxlength=128) |
---|
2474 | |
---|
2475 | Property changes on: tests/regressiontests/manager_db |
---|
2476 | ___________________________________________________________________ |
---|
2477 | Name: svn:ignore |
---|
2478 | +*.pyc |
---|
2479 | + |
---|
2480 | |
---|
2481 | === tests/regressiontests/thread_isolation (new directory) |
---|
2482 | ================================================================== |
---|
2483 | === tests/regressiontests/thread_isolation/__init__.py |
---|
2484 | ================================================================== |
---|
2485 | === tests/regressiontests/thread_isolation/tests.py |
---|
2486 | ================================================================== |
---|
2487 | --- tests/regressiontests/thread_isolation/tests.py (/mirror/django/trunk) (revision 4246) |
---|
2488 | |
---|
2489 | +++ tests/regressiontests/thread_isolation/tests.py (/local/django/multidb) (revision 4246) |
---|
2490 | |
---|
2491 | @@ -0,0 +1,251 @@ |
---|
2492 | |
---|
2493 | +# tests that db settings can be different in different threads |
---|
2494 | +# |
---|
2495 | +# |
---|
2496 | +# What's going on here: |
---|
2497 | +# |
---|
2498 | +# Simulating multiple web requests in a threaded environment, one in |
---|
2499 | +# which settings are different for each request. So we replace |
---|
2500 | +# django.conf.settings with a thread local, with different |
---|
2501 | +# configurations in each thread, and then fire off three |
---|
2502 | +# simultaneous requests (using a condition to sync them up), and |
---|
2503 | +# test that each thread sees its own settings and the models in each |
---|
2504 | +# thread attempt to connect to the correct database as per their |
---|
2505 | +# settings. |
---|
2506 | +# |
---|
2507 | + |
---|
2508 | + |
---|
2509 | +import copy |
---|
2510 | +import os |
---|
2511 | +import sys |
---|
2512 | +import threading |
---|
2513 | +import unittest |
---|
2514 | +from thread import get_ident |
---|
2515 | + |
---|
2516 | +from django.conf import settings, UserSettingsHolder |
---|
2517 | +from django.core.handlers.wsgi import WSGIHandler |
---|
2518 | +from django.db import model_connection_name, _default, connection, connections |
---|
2519 | +from regressiontests.request_isolation.tests import MockHandler |
---|
2520 | +from regressiontests.thread_isolation.models import * |
---|
2521 | + |
---|
2522 | +try: |
---|
2523 | + # Only exists in Python 2.4+ |
---|
2524 | + from threading import local |
---|
2525 | +except ImportError: |
---|
2526 | + # Import copy of _thread_local.py from Python 2.4 |
---|
2527 | + from django.utils._threading_local import local |
---|
2528 | + |
---|
2529 | +# helpers |
---|
2530 | +EV = threading.Event() |
---|
2531 | + |
---|
2532 | +class LocalSettings: |
---|
2533 | + """Settings holder that allows thread-local overrides of defaults. |
---|
2534 | + """ |
---|
2535 | + def __init__(self, defaults): |
---|
2536 | + self._defaults = defaults |
---|
2537 | + self._local = local() |
---|
2538 | + |
---|
2539 | + def __getattr__(self, attr): |
---|
2540 | + if attr in ('_defaults', '_local'): |
---|
2541 | + return self.__dict__[attr] |
---|
2542 | + _local = self.__dict__['_local'] |
---|
2543 | + _defaults = self.__dict__['_defaults'] |
---|
2544 | + debug("LS get %s (%s)", attr, hasattr(_local, attr)) |
---|
2545 | + if not hasattr(_local, attr): |
---|
2546 | + # Make sure everything we return is the local version; this |
---|
2547 | + # avoids sets to deep datastructures overwriting the defaults |
---|
2548 | + setattr(_local, attr, copy.deepcopy(getattr(_defaults, attr))) |
---|
2549 | + return getattr(_local, attr) |
---|
2550 | + |
---|
2551 | + def __setattr__(self, attr, val): |
---|
2552 | + if attr in ('_defaults', '_local'): |
---|
2553 | + self.__dict__[attr] = val |
---|
2554 | + else: |
---|
2555 | + debug("LS set local %s = %s", attr, val) |
---|
2556 | + setattr(self.__dict__['_local'], attr, val) |
---|
2557 | + |
---|
2558 | +def thread_two(func, *arg): |
---|
2559 | + def start(): |
---|
2560 | + # from django.conf import settings |
---|
2561 | + settings.OTHER_DATABASES['_b']['MODELS'] = [] |
---|
2562 | + |
---|
2563 | + debug("t2 ODB: %s", settings.OTHER_DATABASES) |
---|
2564 | + debug("t2 waiting") |
---|
2565 | + EV.wait(2.0) |
---|
2566 | + func(*arg) |
---|
2567 | + debug("t2 complete") |
---|
2568 | + t2 = threading.Thread(target=start) |
---|
2569 | + t2.start() |
---|
2570 | + return t2 |
---|
2571 | + |
---|
2572 | +def thread_three(func, *arg): |
---|
2573 | + def start(): |
---|
2574 | + # from django.conf import settings |
---|
2575 | + settings.OTHER_DATABASES['_b']['MODELS'] = ['ti.MY'] |
---|
2576 | + settings.OTHER_DATABASES['_b'], \ |
---|
2577 | + settings.OTHER_DATABASES['_a'] = \ |
---|
2578 | + settings.OTHER_DATABASES['_a'], \ |
---|
2579 | + settings.OTHER_DATABASES['_b'] |
---|
2580 | + |
---|
2581 | + settings.DATABASE_NAME = \ |
---|
2582 | + settings.OTHER_DATABASES['_a']['DATABASE_NAME'] |
---|
2583 | + |
---|
2584 | + debug("t3 ODB: %s", settings.OTHER_DATABASES) |
---|
2585 | + debug("3 %s: start: default: %s", get_ident(), settings.DATABASE_NAME) |
---|
2586 | + debug("3 %s: start: conn: %s", get_ident(), |
---|
2587 | + connection.settings.DATABASE_NAME) |
---|
2588 | + |
---|
2589 | + debug("t3 waiting") |
---|
2590 | + EV.wait(2.0) |
---|
2591 | + func(*arg) |
---|
2592 | + debug("t3 complete") |
---|
2593 | + t3 = threading.Thread(target=start) |
---|
2594 | + t3.start() |
---|
2595 | + return t3 |
---|
2596 | + |
---|
2597 | +def debug(*arg): |
---|
2598 | + pass |
---|
2599 | +# msg, arg = arg[0], arg[1:] |
---|
2600 | +# print msg % arg |
---|
2601 | + |
---|
2602 | +def start_response(code, headers): |
---|
2603 | + debug("start response: %s %s", code, headers) |
---|
2604 | + pass |
---|
2605 | + |
---|
2606 | +class TestThreadIsolation(unittest.TestCase): |
---|
2607 | + # event used to synchronize threads so we can be sure they are running |
---|
2608 | + # together |
---|
2609 | + lock = threading.RLock() |
---|
2610 | + errors = [] |
---|
2611 | + |
---|
2612 | + def setUp(self): |
---|
2613 | + debug("setup") |
---|
2614 | + self.settings = settings._target |
---|
2615 | + settings._target = UserSettingsHolder(copy.deepcopy(settings._target)) |
---|
2616 | + settings.OTHER_DATABASES['_a']['MODELS'] = ['ti.MX'] |
---|
2617 | + settings.OTHER_DATABASES['_b']['MODELS'] = ['ti.MY'] |
---|
2618 | + |
---|
2619 | + # normal settings holders aren't thread-safe, so we need to substitute |
---|
2620 | + # one that is (and so allows per-thread settings) |
---|
2621 | + holder = settings._target |
---|
2622 | + settings._target = LocalSettings(holder) |
---|
2623 | + |
---|
2624 | + def teardown(self): |
---|
2625 | + debug("teardown") |
---|
2626 | + settings._target = self.settings |
---|
2627 | + |
---|
2628 | + def add_thread_error(self, err): |
---|
2629 | + self.lock.acquire() |
---|
2630 | + try: |
---|
2631 | + self.errors.append(err) |
---|
2632 | + finally: |
---|
2633 | + self.lock.release() |
---|
2634 | + |
---|
2635 | + def thread_errors(self): |
---|
2636 | + self.lock.acquire() |
---|
2637 | + try: |
---|
2638 | + return self.errors[:] |
---|
2639 | + finally: |
---|
2640 | + self.lock.release() |
---|
2641 | + |
---|
2642 | + def request_one(self, request): |
---|
2643 | + """Start out with settings as originally configured""" |
---|
2644 | + from django.conf import settings |
---|
2645 | + debug("request_one: %s", settings.OTHER_DATABASES) |
---|
2646 | + |
---|
2647 | + self.assertEqual(model_connection_name(MQ), _default) |
---|
2648 | + self.assertEqual(model_connection_name(MX), '_a') |
---|
2649 | + self.assertEqual( |
---|
2650 | + MX._default_manager.db.connection.settings.DATABASE_NAME, |
---|
2651 | + settings.OTHER_DATABASES['_a']['DATABASE_NAME']) |
---|
2652 | + self.assertEqual(model_connection_name(MY), '_b') |
---|
2653 | + self.assertEqual( |
---|
2654 | + MY._default_manager.db.connection.settings.DATABASE_NAME, |
---|
2655 | + settings.OTHER_DATABASES['_b']['DATABASE_NAME']) |
---|
2656 | + self.assert_(MQ._default_manager.db.connection is |
---|
2657 | + connections[_default].connection) |
---|
2658 | + self.assertEqual( |
---|
2659 | + MQ._default_manager.db.connection.settings.DATABASE_NAME, |
---|
2660 | + settings.DATABASE_NAME) |
---|
2661 | + self.assertEqual(connection.settings.DATABASE_NAME, |
---|
2662 | + settings.DATABASE_NAME) |
---|
2663 | + |
---|
2664 | + def request_two(self, request): |
---|
2665 | + """Between the first and second requests, settings change to assign |
---|
2666 | + model MY to a different connection |
---|
2667 | + """ |
---|
2668 | + # from django.conf import settings |
---|
2669 | + debug("request_two: %s", settings.OTHER_DATABASES) |
---|
2670 | + |
---|
2671 | + try: |
---|
2672 | + self.assertEqual(model_connection_name(MQ), _default) |
---|
2673 | + self.assertEqual(model_connection_name(MX), '_a') |
---|
2674 | + self.assertEqual( |
---|
2675 | + MX._default_manager.db.connection.settings.DATABASE_NAME, |
---|
2676 | + settings.OTHER_DATABASES['_a']['DATABASE_NAME']) |
---|
2677 | + self.assertEqual(model_connection_name(MY), _default) |
---|
2678 | + self.assertEqual( |
---|
2679 | + MY._default_manager.db.connection.settings.DATABASE_NAME, |
---|
2680 | + settings.DATABASE_NAME) |
---|
2681 | + self.assert_(MQ._default_manager.db.connection is |
---|
2682 | + connections[_default].connection) |
---|
2683 | + self.assertEqual( |
---|
2684 | + MQ._default_manager.db.connection.settings.DATABASE_NAME, |
---|
2685 | + settings.DATABASE_NAME) |
---|
2686 | + self.assertEqual(connection.settings.DATABASE_NAME, |
---|
2687 | + settings.DATABASE_NAME) |
---|
2688 | + except: |
---|
2689 | + self.add_thread_error(sys.exc_info()) |
---|
2690 | + |
---|
2691 | + def request_three(self, request): |
---|
2692 | + """Between the 2nd and 3rd requests, the settings at the names in |
---|
2693 | + OTHER_DATABASES have changed. |
---|
2694 | + """ |
---|
2695 | + # from django.conf import settings |
---|
2696 | + debug("3 %s: %s", get_ident(), settings.OTHER_DATABASES) |
---|
2697 | + debug("3 %s: default: %s", get_ident(), settings.DATABASE_NAME) |
---|
2698 | + debug("3 %s: conn: %s", get_ident(), |
---|
2699 | + connection.settings.DATABASE_NAME) |
---|
2700 | + try: |
---|
2701 | + self.assertEqual(model_connection_name(MQ), _default) |
---|
2702 | + self.assertEqual(model_connection_name(MX), '_b') |
---|
2703 | + self.assertEqual( |
---|
2704 | + MX._default_manager.db.connection.settings.DATABASE_NAME, |
---|
2705 | + settings.OTHER_DATABASES['_b']['DATABASE_NAME']) |
---|
2706 | + self.assertEqual(model_connection_name(MY), '_a') |
---|
2707 | + self.assertEqual( |
---|
2708 | + MY._default_manager.db.connection.settings.DATABASE_NAME, |
---|
2709 | + settings.OTHER_DATABASES['_a']['DATABASE_NAME']) |
---|
2710 | + self.assert_(MQ._default_manager.db.connection is |
---|
2711 | + connections[_default].connection) |
---|
2712 | + self.assertEqual( |
---|
2713 | + connection.settings.DATABASE_NAME, |
---|
2714 | + settings.OTHER_DATABASES['_a']['DATABASE_NAME']) |
---|
2715 | + except: |
---|
2716 | + self.add_thread_error(sys.exc_info()) |
---|
2717 | + |
---|
2718 | + def test_thread_isolation(self): |
---|
2719 | + |
---|
2720 | + debug("running tests") |
---|
2721 | + |
---|
2722 | + env = os.environ.copy() |
---|
2723 | + env['PATH_INFO'] = '/' |
---|
2724 | + env['REQUEST_METHOD'] = 'GET' |
---|
2725 | + |
---|
2726 | + t2 = thread_two(MockHandler(self.request_two), env, start_response) |
---|
2727 | + t3 = thread_three(MockHandler(self.request_three), env, start_response) |
---|
2728 | + |
---|
2729 | + try: |
---|
2730 | + EV.set() |
---|
2731 | + MockHandler(self.request_one)(env, start_response) |
---|
2732 | + finally: |
---|
2733 | + t2.join() |
---|
2734 | + t3.join() |
---|
2735 | + err = self.thread_errors() |
---|
2736 | + if err: |
---|
2737 | + import traceback |
---|
2738 | + for e in err: |
---|
2739 | + traceback.print_exception(*e) |
---|
2740 | + raise AssertionError("%s thread%s failed" % |
---|
2741 | + (len(err), len(err) > 1 and 's' or |
---|
2742 | + '')) |
---|
2743 | + |
---|
2744 | === tests/regressiontests/thread_isolation/models.py |
---|
2745 | ================================================================== |
---|
2746 | --- tests/regressiontests/thread_isolation/models.py (/mirror/django/trunk) (revision 4246) |
---|
2747 | |
---|
2748 | +++ tests/regressiontests/thread_isolation/models.py (/local/django/multidb) (revision 4246) |
---|
2749 | |
---|
2750 | @@ -0,0 +1,19 @@ |
---|
2751 | |
---|
2752 | +from django.db import models |
---|
2753 | + |
---|
2754 | +# models |
---|
2755 | +class MQ(models.Model): |
---|
2756 | + val = models.CharField(maxlength=10) |
---|
2757 | + class Meta: |
---|
2758 | + app_label = 'ti' |
---|
2759 | + |
---|
2760 | + |
---|
2761 | +class MX(models.Model): |
---|
2762 | + val = models.CharField(maxlength=10) |
---|
2763 | + class Meta: |
---|
2764 | + app_label = 'ti' |
---|
2765 | + |
---|
2766 | + |
---|
2767 | +class MY(models.Model): |
---|
2768 | + val = models.CharField(maxlength=10) |
---|
2769 | + class Meta: |
---|
2770 | + app_label = 'ti' |
---|
2771 | |
---|
2772 | Property changes on: tests/regressiontests/thread_isolation |
---|
2773 | ___________________________________________________________________ |
---|
2774 | Name: svn:ignore |
---|
2775 | +*.pyc |
---|
2776 | + |
---|
2777 | |
---|
2778 | |
---|
2779 | Property changes on: tests/regressiontests/initial_sql_regress/sql |
---|
2780 | ___________________________________________________________________ |
---|
2781 | Name: svn:ignore |
---|
2782 | +*.pyc |
---|
2783 | + |
---|
2784 | |
---|
2785 | === tests/regressiontests/request_isolation (new directory) |
---|
2786 | ================================================================== |
---|
2787 | === tests/regressiontests/request_isolation/__init__.py |
---|
2788 | ================================================================== |
---|
2789 | === tests/regressiontests/request_isolation/tests.py |
---|
2790 | ================================================================== |
---|
2791 | --- tests/regressiontests/request_isolation/tests.py (/mirror/django/trunk) (revision 4246) |
---|
2792 | |
---|
2793 | +++ tests/regressiontests/request_isolation/tests.py (/local/django/multidb) (revision 4246) |
---|
2794 | |
---|
2795 | @@ -0,0 +1,100 @@ |
---|
2796 | |
---|
2797 | +# tests that db settings can change between requests |
---|
2798 | +import copy |
---|
2799 | +import os |
---|
2800 | +import unittest |
---|
2801 | +from django.conf import settings, UserSettingsHolder |
---|
2802 | +from django.core.handlers.wsgi import WSGIHandler |
---|
2803 | +from django.db import models, model_connection_name, _default, connection |
---|
2804 | +from django.http import HttpResponse |
---|
2805 | +from regressiontests.request_isolation.models import * |
---|
2806 | + |
---|
2807 | + |
---|
2808 | +# helpers |
---|
2809 | +class MockHandler(WSGIHandler): |
---|
2810 | + |
---|
2811 | + def __init__(self, test): |
---|
2812 | + self.test = test |
---|
2813 | + super(MockHandler, self).__init__() |
---|
2814 | + |
---|
2815 | + def get_response(self, request): |
---|
2816 | + # debug("mock handler answering %s, %s", path, request) |
---|
2817 | + return HttpResponse(self.test(request)) |
---|
2818 | + |
---|
2819 | + |
---|
2820 | +def debug(*arg): |
---|
2821 | + pass |
---|
2822 | + # msg, arg = arg[0], arg[1:] |
---|
2823 | + # print msg % arg |
---|
2824 | + |
---|
2825 | + |
---|
2826 | +def start_response(code, headers): |
---|
2827 | + debug("start response: %s %s", code, headers) |
---|
2828 | + pass |
---|
2829 | + |
---|
2830 | +# tests |
---|
2831 | +class TestRequestIsolation(unittest.TestCase): |
---|
2832 | + |
---|
2833 | + def setUp(self): |
---|
2834 | + debug("setup") |
---|
2835 | + self.settings = settings._target |
---|
2836 | + settings._target = UserSettingsHolder(copy.deepcopy(settings._target)) |
---|
2837 | + settings.OTHER_DATABASES['_a']['MODELS'] = ['ri.MX'] |
---|
2838 | + settings.OTHER_DATABASES['_b']['MODELS'] = ['ri.MY'] |
---|
2839 | + |
---|
2840 | + def tearDown(self): |
---|
2841 | + debug("teardown") |
---|
2842 | + settings._target = self.settings |
---|
2843 | + |
---|
2844 | + def testRequestIsolation(self): |
---|
2845 | + env = os.environ.copy() |
---|
2846 | + env['PATH_INFO'] = '/' |
---|
2847 | + env['REQUEST_METHOD'] = 'GET' |
---|
2848 | + |
---|
2849 | + def request_one(request): |
---|
2850 | + """Start out with settings as originally configured""" |
---|
2851 | + self.assertEqual(model_connection_name(MX), '_a') |
---|
2852 | + self.assertEqual( |
---|
2853 | + MX._default_manager.db.connection.settings.DATABASE_NAME, |
---|
2854 | + settings.OTHER_DATABASES['_a']['DATABASE_NAME']) |
---|
2855 | + self.assertEqual(model_connection_name(MY), '_b') |
---|
2856 | + self.assertEqual( |
---|
2857 | + MY._default_manager.db.connection.settings.DATABASE_NAME, |
---|
2858 | + settings.OTHER_DATABASES['_b']['DATABASE_NAME']) |
---|
2859 | + |
---|
2860 | + def request_two(request): |
---|
2861 | + """Between the first and second requests, settings change to assign |
---|
2862 | + model MY to a different connection |
---|
2863 | + """ |
---|
2864 | + self.assertEqual(model_connection_name(MX), '_a') |
---|
2865 | + self.assertEqual( |
---|
2866 | + MX._default_manager.db.connection.settings.DATABASE_NAME, |
---|
2867 | + settings.OTHER_DATABASES['_a']['DATABASE_NAME']) |
---|
2868 | + self.assertEqual(model_connection_name(MY), _default) |
---|
2869 | + self.assertEqual( |
---|
2870 | + MY._default_manager.db.connection.settings.DATABASE_NAME, |
---|
2871 | + settings.DATABASE_NAME) |
---|
2872 | + |
---|
2873 | + def request_three(request): |
---|
2874 | + """Between the 2nd and 3rd requests, the settings at the names in |
---|
2875 | + OTHER_DATABASES have changed. |
---|
2876 | + """ |
---|
2877 | + self.assertEqual(model_connection_name(MX), '_b') |
---|
2878 | + self.assertEqual( |
---|
2879 | + MX._default_manager.db.connection.settings.DATABASE_NAME, |
---|
2880 | + settings.OTHER_DATABASES['_b']['DATABASE_NAME']) |
---|
2881 | + self.assertEqual(model_connection_name(MY), '_a') |
---|
2882 | + self.assertEqual( |
---|
2883 | + MY._default_manager.db.connection.settings.DATABASE_NAME, |
---|
2884 | + settings.OTHER_DATABASES['_a']['DATABASE_NAME']) |
---|
2885 | + |
---|
2886 | + MockHandler(request_one)(env, start_response) |
---|
2887 | + |
---|
2888 | + settings.OTHER_DATABASES['_b']['MODELS'] = [] |
---|
2889 | + MockHandler(request_two)(env, start_response) |
---|
2890 | + |
---|
2891 | + settings.OTHER_DATABASES['_b']['MODELS'] = ['ri.MY'] |
---|
2892 | + settings.OTHER_DATABASES['_b'], \ |
---|
2893 | + settings.OTHER_DATABASES['_a'] = \ |
---|
2894 | + settings.OTHER_DATABASES['_a'], \ |
---|
2895 | + settings.OTHER_DATABASES['_b'] |
---|
2896 | + MockHandler(request_three)(env, start_response) |
---|
2897 | === tests/regressiontests/request_isolation/models.py |
---|
2898 | ================================================================== |
---|
2899 | --- tests/regressiontests/request_isolation/models.py (/mirror/django/trunk) (revision 4246) |
---|
2900 | |
---|
2901 | +++ tests/regressiontests/request_isolation/models.py (/local/django/multidb) (revision 4246) |
---|
2902 | |
---|
2903 | @@ -0,0 +1,13 @@ |
---|
2904 | |
---|
2905 | +from django.db import models |
---|
2906 | + |
---|
2907 | +# models |
---|
2908 | +class MX(models.Model): |
---|
2909 | + val = models.CharField(maxlength=10) |
---|
2910 | + class Meta: |
---|
2911 | + app_label = 'ri' |
---|
2912 | + |
---|
2913 | + |
---|
2914 | +class MY(models.Model): |
---|
2915 | + val = models.CharField(maxlength=10) |
---|
2916 | + class Meta: |
---|
2917 | + app_label = 'ri' |
---|
2918 | |
---|
2919 | Property changes on: tests/regressiontests/request_isolation |
---|
2920 | ___________________________________________________________________ |
---|
2921 | Name: svn:ignore |
---|
2922 | +*.pyc |
---|
2923 | + |
---|
2924 | |
---|
2925 | === tests/runtests.py |
---|
2926 | ================================================================== |
---|
2927 | --- tests/runtests.py (/mirror/django/trunk) (revision 4246) |
---|
2928 | |
---|
2929 | +++ tests/runtests.py (/local/django/multidb) (revision 4246) |
---|
2930 | |
---|
2931 | @@ -18,6 +18,14 @@ |
---|
2932 | |
---|
2933 | TEST_TEMPLATE_DIR = 'templates' |
---|
2934 | |
---|
2935 | CONTRIB_DIR = os.path.dirname(contrib.__file__) |
---|
2936 | +TEST_OTHER_DATABASES = { |
---|
2937 | + '_a': { 'DATABASE_NAME': 'django_test_a', |
---|
2938 | + 'MODELS': [ 'multiple_databases.Artist', |
---|
2939 | + 'multiple_databases.Opus' ]}, |
---|
2940 | + '_b': { 'DATABASE_NAME': 'django_test_b', |
---|
2941 | + 'MODELS': [ 'multiple_databases.Widget', |
---|
2942 | + 'multiple_databases.DooHickey' ]} |
---|
2943 | +} |
---|
2944 | MODEL_TEST_DIR = os.path.join(os.path.dirname(__file__), MODEL_TESTS_DIR_NAME) |
---|
2945 | REGRESSION_TEST_DIR = os.path.join(os.path.dirname(__file__), REGRESSION_TESTS_DIR_NAME) |
---|
2946 | |
---|
2947 | @@ -97,6 +105,7 @@ |
---|
2948 | |
---|
2949 | |
---|
2950 | # Redirect some settings for the duration of these tests. |
---|
2951 | settings.INSTALLED_APPS = ALWAYS_INSTALLED_APPS |
---|
2952 | + settings.TEST_OTHER_DATABASES = TEST_OTHER_DATABASES |
---|
2953 | settings.ROOT_URLCONF = 'urls' |
---|
2954 | settings.TEMPLATE_DIRS = (os.path.join(os.path.dirname(__file__), TEST_TEMPLATE_DIR),) |
---|
2955 | settings.USE_I18N = True |
---|
2956 | |
---|
2957 | Property changes on: tests/templates |
---|
2958 | ___________________________________________________________________ |
---|
2959 | Name: svn:ignore |
---|
2960 | +*.pyc |
---|
2961 | + |
---|
2962 | |
---|
2963 | === docs/settings.txt |
---|
2964 | ================================================================== |
---|
2965 | --- docs/settings.txt (/mirror/django/trunk) (revision 4246) |
---|
2966 | |
---|
2967 | +++ docs/settings.txt (/local/django/multidb) (revision 4246) |
---|
2968 | |
---|
2969 | @@ -667,6 +667,13 @@ |
---|
2970 | |
---|
2971 | See `allowed date format strings`_. See also ``DATE_FORMAT``, |
---|
2972 | ``DATETIME_FORMAT``, ``TIME_FORMAT`` and ``YEAR_MONTH_FORMAT``. |
---|
2973 | |
---|
2974 | +OTHER_DATABASES |
---|
2975 | +--------------- |
---|
2976 | + |
---|
2977 | +Default: ``{}`` |
---|
2978 | + |
---|
2979 | +Other database connections to use in addition to the default connection. See the `multiple database support docs`_. |
---|
2980 | + |
---|
2981 | PREPEND_WWW |
---|
2982 | ----------- |
---|
2983 | |
---|
2984 | === docs/multiple_database_support.txt |
---|
2985 | ================================================================== |
---|
2986 | --- docs/multiple_database_support.txt (/mirror/django/trunk) (revision 4246) |
---|
2987 | |
---|
2988 | +++ docs/multiple_database_support.txt (/local/django/multidb) (revision 4246) |
---|
2989 | |
---|
2990 | @@ -0,0 +1,163 @@ |
---|
2991 | |
---|
2992 | +======================== |
---|
2993 | +Using Multiple Databases |
---|
2994 | +======================== |
---|
2995 | + |
---|
2996 | +Standard Django practice is to use a single database connection for |
---|
2997 | +all models in all applications. However, Django supports configuring |
---|
2998 | +and using multiple database connections on a per-application, per-model |
---|
2999 | +or an ad-hoc basis. Using multiple database connections is optional. |
---|
3000 | + |
---|
3001 | +Configuring other database connections |
---|
3002 | +====================================== |
---|
3003 | + |
---|
3004 | +Django's default database connection is configured via the settings |
---|
3005 | +DATABASE_ENGINE, DATABASE_NAME, DATABASE_USER, DATABASE_PASSWORD, |
---|
3006 | +DATABASE_HOST, and DATABASE_PORT. Other connections are configured via |
---|
3007 | +the OTHER_DATABASES setting. Define OTHER_DATABASES as a dict, with a |
---|
3008 | +name for each connection as the key and a dict of settings as the |
---|
3009 | +value. In each OTHER_DATABASES entry (called a "named connection"), |
---|
3010 | +the keys are the same as the DATABASE_ENGINE, etc, settings used to |
---|
3011 | +configure the default connection. All keys are optional; any that are |
---|
3012 | +missing in a named connection's settings will inherit their values |
---|
3013 | +from the default connection. |
---|
3014 | + |
---|
3015 | +Here's an example:: |
---|
3016 | + |
---|
3017 | + DATABASE_ENGINE = 'postgresql' |
---|
3018 | + DATABASE_NAME = 'django_apps' |
---|
3019 | + DATABASE_USER = 'default_user' |
---|
3020 | + DATABASE_PASSWORD = 'xxx' |
---|
3021 | + |
---|
3022 | + OTHER_DATABASES = { |
---|
3023 | + 'local': { 'DATABASE_ENGINE': 'sqlite3', |
---|
3024 | + 'DATABASE_NAME': '/tmp/cache.db' }, |
---|
3025 | + 'public': { 'DATABASE_HOST': 'public', |
---|
3026 | + 'DATABASE_USER': 'public_user', |
---|
3027 | + 'DATABASE_PASSWORD': 'xxx' } |
---|
3028 | + 'private': { 'DATABASE_HOST': 'private', |
---|
3029 | + 'DATABASE_USER': 'private_user', |
---|
3030 | + 'DATABASE_PASSWORD': 'xxx' } |
---|
3031 | + } |
---|
3032 | + |
---|
3033 | +In addition to the DATABASE_* settings, each named connection in |
---|
3034 | +OTHER_DATABASES may optionally include a MODELS setting. This should |
---|
3035 | +be a list of app or app.model names, and is used to configure which |
---|
3036 | +models should use this connection instead of the default connection. |
---|
3037 | + |
---|
3038 | +Here's the example above, with ``MODELS``:: |
---|
3039 | + |
---|
3040 | + OTHER_DATABASES = { |
---|
3041 | + 'local': { 'DATABASE_ENGINE': 'sqlite3', |
---|
3042 | + 'DATABASE_NAME': '/tmp/cache.db', |
---|
3043 | + # A model name: only the model ContentItem |
---|
3044 | + # with the app_label myapp will use this connection |
---|
3045 | + 'MODELS': ['myapp.ContentItem'] }, |
---|
3046 | + 'public': { 'DATABASE_HOST': 'public', |
---|
3047 | + 'DATABASE_USER': 'public_user', |
---|
3048 | + 'DATABASE_PASSWORD': 'xxx', |
---|
3049 | + # Two models in myapp will use the connection |
---|
3050 | + # named 'public', as will ALL models in |
---|
3051 | + # django.contribe.comments |
---|
3052 | + 'MODELS': ['myapp.Blog','myapp.Article', |
---|
3053 | + 'django.contrib.comments' ] } |
---|
3054 | + # No models or apps are configured to use the private db |
---|
3055 | + 'private': { 'DATABASE_HOST': 'private', |
---|
3056 | + 'DATABASE_USER': 'private_user', |
---|
3057 | + 'DATABASE_PASSWORD': 'xxx' } |
---|
3058 | + } |
---|
3059 | + |
---|
3060 | +Accessing a model's connection |
---|
3061 | +============================== |
---|
3062 | + |
---|
3063 | +Each manager has a ``db`` attribute that can be used to access the model's |
---|
3064 | +connection. Access the ``db`` attribute of a model's manager to obtain the |
---|
3065 | +model's currently configured connection. |
---|
3066 | + |
---|
3067 | +Example:: |
---|
3068 | + |
---|
3069 | + from django.db import models |
---|
3070 | + |
---|
3071 | + class Blog(models.Model) |
---|
3072 | + name = models.CharField(maxlength=50) |
---|
3073 | + |
---|
3074 | + class Article(models.Model) |
---|
3075 | + blog = models.ForeignKey(Blog) |
---|
3076 | + title = models.CharField(maxlength=100) |
---|
3077 | + slug = models.SlugField() |
---|
3078 | + summary = models.CharField(maxlength=500) |
---|
3079 | + body = models.TextField() |
---|
3080 | + |
---|
3081 | + class ContentItem(models.Model) |
---|
3082 | + slug = models.SlugField() |
---|
3083 | + mimetype = models.CharField(maxlength=50) |
---|
3084 | + file = models.FileField() |
---|
3085 | + |
---|
3086 | + # Get a ConnectionInfo instance that describes the connection |
---|
3087 | + article_db = Article.objects.db |
---|
3088 | + |
---|
3089 | + # Get a connection and a cursor |
---|
3090 | + connection = article_db.connection |
---|
3091 | + cursor = connection.cursor() |
---|
3092 | + |
---|
3093 | + # Get the ``quote_name`` function from the backend |
---|
3094 | + qn = article_db.backend.quote_name |
---|
3095 | + |
---|
3096 | +Ordinarily you won't have to access a model's connection directly; |
---|
3097 | +just use the model and manager normally and they will use the |
---|
3098 | +connection configured for the model. |
---|
3099 | + |
---|
3100 | +ConnectionInfo objects |
---|
3101 | +====================== |
---|
3102 | + |
---|
3103 | +FIXME Describe the ConnectionInfo object and each of its attributes. |
---|
3104 | + |
---|
3105 | + |
---|
3106 | +Accessing connections by name |
---|
3107 | +============================= |
---|
3108 | + |
---|
3109 | +Access named connections directly through |
---|
3110 | +``django.db.connections``. Each entry in ``django.db.connections`` is |
---|
3111 | +a ``ConnectionInfo`` instance bound to the settings configured in the |
---|
3112 | +OTHER_DATABASES entry under the same key. |
---|
3113 | + |
---|
3114 | +Example:: |
---|
3115 | + |
---|
3116 | + from django.db import connections |
---|
3117 | + |
---|
3118 | + private_db = connections['private'] |
---|
3119 | + cursor = private_db.connection.cursor() |
---|
3120 | + |
---|
3121 | + |
---|
3122 | +Using transactions with other database connections |
---|
3123 | +================================================== |
---|
3124 | + |
---|
3125 | +Transaction managed state applies across all connections |
---|
3126 | +commit/rollback apply to all connections by default |
---|
3127 | +but you can specify individual connections or lists or dicts of connections |
---|
3128 | + |
---|
3129 | + |
---|
3130 | +Changing model connections on the fly |
---|
3131 | +===================================== |
---|
3132 | + |
---|
3133 | +Here's an example of primitive mirroring:: |
---|
3134 | + |
---|
3135 | + # Read all articles from the private db |
---|
3136 | + # Note that we pull the articles into a list; this is necessary |
---|
3137 | + # because query sets are lazy. If we were to change the model's |
---|
3138 | + # connection without copying the articles into a local list, we'd |
---|
3139 | + # wind up reading from public instead of private. |
---|
3140 | + |
---|
3141 | + Article.objects.db = connections['private'] |
---|
3142 | + all_articles = list(Article.objects.all()) |
---|
3143 | + |
---|
3144 | + # Save each article in the public db |
---|
3145 | + Article.objects.db = connections['public'] |
---|
3146 | + for article in all_articles: |
---|
3147 | + article.save() |
---|
3148 | + |
---|
3149 | +Thread and request isolation |
---|
3150 | +============================ |
---|
3151 | + |
---|
3152 | +connections close after each request |
---|
3153 | +connection settings are thread-local |
---|
3154 | + |
---|
3155 | |
---|
3156 | Property changes on: |
---|
3157 | ___________________________________________________________________ |
---|
3158 | Name: svk:merge |
---|
3159 | -bcc190cf-cafb-0310-a4f2-bffc1f526a37:/django/trunk:1054 |
---|
3160 | +bbbf0183-8649-de40-ae96-8c00a8d06f91:/local/django/db2_9:3912 |
---|
3161 | +bcc190cf-cafb-0310-a4f2-bffc1f526a37:/django/trunk:6453 |
---|
3162 | |
---|