Django

Code

Changeset 4456

Show
Ignore:
Timestamp:
02/02/07 11:35:55 (2 years ago)
Author:
bouldersprinters
Message:

boulder-oracle-sprint: Merged to trunk [4455].

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • django/branches/boulder-oracle-sprint/django/contrib/admin/templates/admin/auth/user/change_password.html

    r4279 r4456  
    2626{% endif %} 
    2727 
    28 <p>{% blocktrans with original.username|escape as username %}Enter a new username and password for the user <strong>{{ username }}</strong>.{% endblocktrans %}</p> 
     28<p>{% blocktrans with original.username|escape as username %}Enter a new password for the user <strong>{{ username }}</strong>.{% endblocktrans %}</p> 
    2929 
    3030<fieldset class="module aligned"> 

  • django/branches/boulder-oracle-sprint/django/contrib/admin/templatetags/admin_list.py

    r4279 r4456  
    101101                       "url": cl.get_query_string({ORDER_VAR: i, ORDER_TYPE_VAR: new_order_type}), 
    102102                       "class_attrib": (th_classes and ' class="%s"' % ' '.join(th_classes) or '')} 
     103 
     104def _boolean_icon(field_val): 
     105    BOOLEAN_MAPPING = {True: 'yes', False: 'no', None: 'unknown'} 
     106    return '<img src="%simg/admin/icon-%s.gif" alt="%s" />' % (settings.ADMIN_MEDIA_PREFIX, BOOLEAN_MAPPING[field_val], field_val) 
    103107 
    104108def items_for_result(cl, result): 
    …… 
    115119                attr = getattr(result, field_name) 
    116120                allow_tags = getattr(attr, 'allow_tags', False) 
     121                boolean = getattr(attr, 'boolean', False) 
    117122                if callable(attr): 
    118123                    attr = attr() 
    119                 result_repr = str(attr) 
     124                if boolean: 
     125                    allow_tags = True 
     126                    result_repr = _boolean_icon(attr) 
     127                else: 
     128                    result_repr = str(attr) 
    120129            except (AttributeError, ObjectDoesNotExist): 
    121130                result_repr = EMPTY_CHANGELIST_VALUE 
    …… 
    148157            # Booleans are special: We use images. 
    149158            elif isinstance(f, models.BooleanField) or isinstance(f, models.NullBooleanField): 
    150                 BOOLEAN_MAPPING = {True: 'yes', False: 'no', None: 'unknown'} 
    151                 result_repr = '<img src="%simg/admin/icon-%s.gif" alt="%s" />' % (settings.ADMIN_MEDIA_PREFIX, BOOLEAN_MAPPING[field_val], field_val) 
     159                result_repr = _boolean_icon(field_val) 
    152160            # FloatFields are special: Zero-pad the decimals. 
    153161            elif isinstance(f, models.FloatField): 

  • django/branches/boulder-oracle-sprint/django/contrib/contenttypes/models.py

    r4279 r4456  
    22from django.utils.translation import gettext_lazy as _ 
    33 
     4CONTENT_TYPE_CACHE = {} 
    45class ContentTypeManager(models.Manager): 
    56    def get_for_model(self, model): 
    …… 
    910        """ 
    1011        opts = model._meta 
    11         # The str() is needed around opts.verbose_name because it's a 
    12         # django.utils.functional.__proxy__ object. 
    13         ct, created = self.model._default_manager.get_or_create(app_label=opts.app_label, 
    14             model=opts.object_name.lower(), defaults={'name': str(opts.verbose_name)}) 
     12        key = (opts.app_label, opts.object_name.lower()) 
     13        try: 
     14            ct = CONTENT_TYPE_CACHE[key] 
     15        except KeyError: 
     16            # The str() is needed around opts.verbose_name because it's a 
     17            # django.utils.functional.__proxy__ object. 
     18            ct, created = self.model._default_manager.get_or_create(app_label=key[0], 
     19                model=key[1], defaults={'name': str(opts.verbose_name)}) 
     20            CONTENT_TYPE_CACHE[key] = ct 
    1521        return ct 
    1622 

  • django/branches/boulder-oracle-sprint/django/contrib/sessions/middleware.py

    r4279 r4456  
    11from django.conf import settings 
    22from django.contrib.sessions.models import Session 
     3from django.core.exceptions import SuspiciousOperation 
    34from django.utils.cache import patch_vary_headers 
    45import datetime 
    …… 
    5657                        expire_date__gt=datetime.datetime.now()) 
    5758                    self._session_cache = s.get_decoded() 
    58                 except Session.DoesNotExist: 
     59                except (Session.DoesNotExist, SuspiciousOperation): 
    5960                    self._session_cache = {} 
    6061                    # Set the session_key to None to force creation of a new 

  • django/branches/boulder-oracle-sprint/django/core/cache/backends/dummy.py

    r4279 r4456  
    77        pass 
    88 
    9     def get(self, *args, **kwargs): 
    10         pass 
     9    def get(self, key, default=None): 
     10        return default 
    1111 
    1212    def set(self, *args, **kwargs): 
    …… 
    1717 
    1818    def get_many(self, *args, **kwargs): 
    19         pass 
     19        return {} 
    2020 
    2121    def has_key(self, *args, **kwargs): 

  • django/branches/boulder-oracle-sprint/django/core/management.py

    r4279 r4456  
    2626PROJECT_TEMPLATE_DIR = os.path.join(django.__path__[0], 'conf', '%s_template') 
    2727 
    28 INVALID_PROJECT_NAMES = ('django', 'test') 
     28INVALID_PROJECT_NAMES = ('django', 'site', 'test') 
    2929 
    3030# Set up the terminal color scheme. 
    …… 
    736736    from random import choice 
    737737    if project_name in INVALID_PROJECT_NAMES: 
    738         sys.stderr.write(style.ERROR("Error: %r isn't a valid project name. Please try another.\n" % project_name)) 
     738        sys.stderr.write(style.ERROR("Error: '%r' conflicts with the name of an existing Python module and cannot be used as a project name. Please try another name.\n" % project_name)) 
    739739        sys.exit(1) 
    740740    _start_helper('project', project_name, directory) 

  • django/branches/boulder-oracle-sprint/django/core/serializers/python.py

    r4279 r4456  
    5858        # Look up the model and starting build a dict of data for it. 
    5959        Model = _get_model(d["model"]) 
    60         data = {Model._meta.pk.name : d["pk"]} 
     60        data = {Model._meta.pk.attname : d["pk"]} 
    6161        m2m_data = {} 
    6262         

  • django/branches/boulder-oracle-sprint/django/db/backends/ado_mssql/creation.py

    r4279 r4456  
    2222    'TextField':         'text', 
    2323    'TimeField':         'time', 
    24     'URLField':          'varchar(200)', 
    2524    'USStateField':      'varchar(2)', 
    2625} 

  • django/branches/boulder-oracle-sprint/django/db/backends/mysql/creation.py

    r4279 r4456  
    2626    'TextField':         'longtext', 
    2727    'TimeField':         'time', 
    28     'URLField':          'varchar(200)', 
    2928    'USStateField':      'varchar(2)', 
    3029} 

  • django/branches/boulder-oracle-sprint/django/db/backends/postgresql/creation.py

    r4279 r4456  
    2626    'TextField':         'text', 
    2727    'TimeField':         'time', 
    28     'URLField':          'varchar(200)', 
    2928    'USStateField':      'varchar(2)', 
    3029} 

  • django/branches/boulder-oracle-sprint/django/db/backends/sqlite3/creation.py

    r4279 r4456  
    2525    'TextField':                    'text', 
    2626    'TimeField':                    'time', 
    27     'URLField':                     'varchar(200)', 
    2827    'USStateField':                 'varchar(2)', 
    2928} 

  • django/branches/boulder-oracle-sprint/django/db/models/fields/__init__.py

    r4279 r4456  
    338338    choices = property(_get_choices) 
    339339 
    340     def formfield(self, initial=None): 
     340    def formfield(self, **kwargs): 
    341341        "Returns a django.newforms.Field instance for this database Field." 
    342         from django.newforms import CharField 
    343         # TODO: This is just a temporary default during development. 
    344         return forms.CharField(required=not self.blank, label=capfirst(self.verbose_name), initial=initial) 
     342        defaults = {'required': not self.blank, 'label': capfirst(self.verbose_name), 'help_text': self.help_text} 
     343        defaults.update(kwargs) 
     344        return forms.CharField(**defaults) 
    345345 
    346346    def value_from_object(self, obj): 
    …… 
    384384        cls._meta.has_auto_field = True 
    385385 
    386     def formfield(self, initial=None): 
     386    def formfield(self, **kwargs): 
    387387        return None 
    388388 
    …… 
    401401        return [oldforms.CheckboxField] 
    402402 
    403     def formfield(self, initial=None): 
    404         return forms.BooleanField(required=not self.blank, label=capfirst(self.verbose_name), initial=initial) 
     403    def formfield(self, **kwargs): 
     404        defaults = {'required': not self.blank, 'label': capfirst(self.verbose_name), 'help_text': self.help_text} 
     405        defaults.update(kwargs) 
     406        return forms.BooleanField(**defaults) 
    405407 
    406408class CharField(Field): 
    …… 
    418420        return str(value) 
    419421 
    420     def formfield(self, initial=None): 
    421         return forms.CharField(max_length=self.maxlength, required=not self.blank, label=capfirst(self.verbose_name), initial=initial) 
     422    def formfield(self, **kwargs): 
     423        defaults = {'max_length': self.maxlength, 'required': not self.blank, 'label': capfirst(self.verbose_name), 'help_text': self.help_text} 
     424        defaults.update(kwargs) 
     425        return forms.CharField(**defaults) 
    422426 
    423427# TODO: Maybe move this into contrib, because it's specialized. 
    …… 
    498502        return {self.attname: (val is not None and val.strftime("%Y-%m-%d") or '')} 
    499503 
    500     def formfield(self, initial=None): 
    501         return forms.DateField(required=not self.blank, label=capfirst(self.verbose_name), initial=initial) 
     504    def formfield(self, **kwargs): 
     505        defaults = {'required': not self.blank, 'label': capfirst(self.verbose_name), 'help_text': self.help_text} 
     506        defaults.update(kwargs) 
     507        return forms.DateField(**defaults) 
    502508 
    503509class DateTimeField(DateField): 
    …… 
    570576                    time_field: (val is not None and val.strftime("%H:%M:%S") or '')} 
    571577 
    572     def formfield(self, initial=None): 
    573         return forms.DateTimeField(required=not self.blank, label=capfirst(self.verbose_name), initial=initial) 
     578    def formfield(self, **kwargs): 
     579        defaults = {'required': not self.blank, 'label': capfirst(self.verbose_name), 'help_text': self.help_text} 
     580        defaults.update(kwargs) 
     581        return forms.DateTimeField(**defaults) 
    574582 
    575583class EmailField(CharField): 
    …… 
    587595        validators.isValidEmail(field_data, all_data) 
    588596 
    589     def formfield(self, initial=None): 
    590         return forms.EmailField(required=not self.blank, label=capfirst(self.verbose_name), initial=initial) 
     597    def formfield(self, **kwargs): 
     598        defaults = {'required': not self.blank, 'label': capfirst(self.verbose_name), 'help_text': self.help_text} 
     599        defaults.update(kwargs) 
     600        return forms.EmailField(**defaults) 
    591601 
    592602class FileField(Field): 
    …… 
    722732        return [oldforms.IntegerField] 
    723733 
    724     def formfield(self, initial=None): 
    725         return forms.IntegerField(required=not self.blank, label=capfirst(self.verbose_name), initial=initial) 
     734    def formfield(self, **kwargs): 
     735        defaults = {'required': not self.blank, 'label': capfirst(self.verbose_name), 'help_text': self.help_text} 
     736        defaults.update(kwargs) 
     737        return forms.IntegerField(**defaults) 
    726738 
    727739class IPAddressField(Field): 
    …… 
    778790    def get_manipulator_field_objs(self): 
    779791        return [oldforms.LargeTextField] 
     792 
     793    def formfield(self, **kwargs): 
     794        defaults = {'required': not self.blank, 'widget': forms.Textarea, 'label': capfirst(self.verbose_name), 'help_text': self.help_text} 
     795        defaults.update(kwargs) 
     796        return forms.CharField(**defaults) 
    780797 
    781798class TimeField(Field): 
    …… 
    825842        return {self.attname: (val is not None and val.strftime("%H:%M:%S") or '')} 
    826843 
    827     def formfield(self, initial=None): 
    828         return forms.TimeField(required=not self.blank, label=capfirst(self.verbose_name), initial=initial) 
    829  
    830 class URLField(Field): 
     844    def formfield(self, **kwargs): 
     845        defaults = {'required': not self.blank, 'label': capfirst(self.verbose_name), 'help_text': self.help_text} 
     846        defaults.update(kwargs) 
     847        return forms.TimeField(**defaults) 
     848 
     849class URLField(CharField): 
    831850    def __init__(self, verbose_name=None, name=None, verify_exists=True, **kwargs): 
     851        kwargs['maxlength'] = kwargs.get('maxlength', 200) 
    832852        if verify_exists: 
    833853            kwargs.setdefault('validator_list', []).append(validators.isExistingURL) 
    834854        self.verify_exists = verify_exists 
    835         Field.__init__(self, verbose_name, name, **kwargs) 
     855        CharField.__init__(self, verbose_name, name, **kwargs) 
    836856 
    837857    def get_manipulator_field_objs(self): 
    838858        return [oldforms.URLField] 
    839859 
    840     def formfield(self, initial=None): 
    841         return forms.URLField(required=not self.blank, verify_exists=self.verify_exists, label=capfirst(self.verbose_name), initial=initial) 
     860    def get_internal_type(self): 
     861        return "CharField" 
     862 
     863    def formfield(self, **kwargs): 
     864        defaults = {'required': not self.blank, 'verify_exists': self.verify_exists, 'label': capfirst(self.verbose_name), 'help_text': self.help_text} 
     865        defaults.update(kwargs) 
     866        return forms.URLField(**defaults) 
    842867 
    843868class USStateField(Field): 

  • django/branches/boulder-oracle-sprint/django/db/models/fields/related.py

    r4279 r4456  
    317317            # source_col_name: the PK colname in join_table for the source object 
    318318            # target_col_name: the PK colname in join_table for the target object 
    319             # *objs - objects to add 
     319            # *objs - objects to add. Either object instances, or primary keys of object instances. 
    320320            from django.db import connection 
    321321 
    …… 
    323323            if objs: 
    324324                # Check that all the objects are of the right type 
     325                new_ids = set() 
    325326                for obj in objs: 
    326                     if not isinstance(obj, self.model): 
    327                         raise ValueError, "objects to add() must be %s instances" % self.model._meta.object_name 
     327                    if isinstance(obj, self.model): 
     328                        new_ids.add(obj._get_pk_val()) 
     329                    else: 
     330                        new_ids.add(obj) 
    328331                # Add the newly created or already existing objects to the join table. 
    329332                # First find out which items are already added, to avoid adding them twice 
    330                 new_ids = set([obj._get_pk_val() for obj in objs]) 
    331333                cursor = connection.cursor() 
    332334                cursor.execute("SELECT %s FROM %s WHERE %s = %%s AND %s IN (%s)" % \ 
    …… 
    355357            if objs: 
    356358                # Check that all the objects are of the right type 
     359                old_ids = set() 
    357360                for obj in objs: 
    358                     if not isinstance(obj, self.model): 
    359                         raise ValueError, "objects to remove() must be %s instances" % self.model._meta.object_name 
     361                    if isinstance(obj, self.model): 
     362                        old_ids.add(obj._get_pk_val()) 
     363                    else: 
     364                        old_ids.add(obj) 
    360365                # Remove the specified objects from the join table 
    361                 old_ids = set([obj._get_pk_val() for obj in objs]) 
    362366                cursor = connection.cursor() 
    363367                cursor.execute("DELETE FROM %s WHERE %s = %%s AND %s IN (%s)" % \ 
    …… 
    549553        setattr(cls, related.get_accessor_name(), ForeignRelatedObjectsDescriptor(related)) 
    550554 
    551     def formfield(self, initial=None): 
    552         return forms.ChoiceField(choices=self.get_choices_default(), required=not self.blank, label=capfirst(self.verbose_name), initial=initial) 
     555    def formfield(self, **kwargs): 
     556        defaults = {'choices': self.get_choices_default(), 'required': not self.blank, 'label': capfirst(self.verbose_name), 'help_text': self.help_text} 
     557        defaults.update(kwargs) 
     558        return forms.ChoiceField(**defaults) 
    553559 
    554560class OneToOneField(RelatedField, IntegerField): 
    …… 
    613619            cls._meta.one_to_one_field = self 
    614620 
    615     def formfield(self, initial=None): 
    616         return forms.ChoiceField(choices=self.get_choices_default(), required=not self.blank, label=capfirst(self.verbose_name), initial=initial) 
     621    def formfield(self, **kwargs): 
     622        defaults = {'choices': self.get_choices_default(), 'required': not self.blank, 'label': capfirst(self.verbose_name), 'help_text': self.help_text} 
     623        defaults.update(kwargs) 
     624        return forms.ChoiceField(**kwargs) 
    617625 
    618626class ManyToManyField(RelatedField, Field): 
    …… 
    626634            raw_id_admin=kwargs.pop('raw_id_admin', False), 
    627635            symmetrical=kwargs.pop('symmetrical', True)) 
     636        self.db_table = kwargs.pop('db_table', None) 
    628637        if kwargs["rel"].raw_id_admin: 
    629638            kwargs.setdefault("validator_list", []).append(self.isValidIDList) 
    …… 
    648657    def _get_m2m_db_table(self, opts): 
    649658        "Function that can be curried to provide the m2m table name for this relation" 
    650         from django.db import backend 
    651         from django.db.backends.util import truncate_name 
    652         name = '%s_%s' % (opts.db_table, self.name) 
    653         return truncate_name(name, backend.get_max_name_length()) 
     659        if self.db_table: 
     660            return self.db_table 
     661        else: 
     662            return '%s_%s' % (opts.db_table, self.name) 
    654663 
    655664    def _get_m2m_column_name(self, related): 
    …… 
    729738        return getattr(obj, self.attname).all() 
    730739 
    731     def formfield(self, initial=None): 
     740    def formfield(self, **kwargs): 
    732741        # If initial is passed in, it's a list of related objects, but the 
    733742        # MultipleChoiceField takes a list of IDs. 
    734         if initial is not None: 
    735             initial = [i._get_pk_val() for i in initial] 
    736         return forms.MultipleChoiceField(choices=self.get_choices_default(), required=not self.blank, label=capfirst(self.verbose_name), initial=initial) 
     743        if kwargs.get('initial') is not None: 
     744            kwargs['initial'] = [i._get_pk_val() for i in kwargs['initial']] 
     745        defaults = {'choices': self.get_choices_default(), 'required': not self.blank, 'label': capfirst(self.verbose_name), 'help_text': self.help_text} 
     746        defaults.update(kwargs) 
     747        return forms.MultipleChoiceField(**defaults) 
    737748 
    738749class ManyToOneRel(object): 

  • django/branches/boulder-oracle-sprint/django/db/models/manager.py

    r4279 r4456  
    1 from django.db.models.query import QuerySet 
     1from django.db.models.query import QuerySet, EmptyQuerySet 
    22from django.dispatch import dispatcher 
    33from django.db.models import signals 
    …… 
    4242    # PROXIES TO QUERYSET # 
    4343    ####################### 
     44     
     45    def get_empty_query_set(self): 
     46        return EmptyQuerySet(self.model) 
    4447 
    4548    def get_query_set(self): 
    …… 
    4851        """ 
    4952        return QuerySet(self.model) 
     53     
     54    def none(self): 
     55        return self.get_empty_query_set() 
    5056 
    5157    def all(self): 

  • django/branches/boulder-oracle-sprint/django/db/models/query.py

    r4279 r4456  
    11from django.db import backend, connection, get_query_module, transaction 
    22from django.db.models.fields import DateField, FieldDoesNotExist 
     3from django.db.models.fields.generic import GenericRelation 
    34from django.db.models import signals 
    45from django.dispatch import dispatcher 
    …… 
    2526# Larger values are slightly faster at the expense of more storage space. 
    2627GET_ITERATOR_CHUNK_SIZE = 100 
     28 
     29class EmptyResultSet(Exception): 
     30    pass 
    2731 
    2832#################### 
    …… 
    170174        cursor = connection.cursor() 
    171175 
    172         select, sql, params, full_query = self._get_sql_clause() 
     176        try: 
     177            select, sql, params, full_query = self._get_sql_clause() 
     178        except EmptyResultSet: 
     179            raise StopIteration 
     180 
    173181        cursor.execute("SELECT " + (self._distinct and "DISTINCT " or "") + ",".join(select) + sql, params) 
    174182 
    …… 
    195203        counter._limit = None 
    196204        counter._select_related = False 
    197         select, sql, params, full_query = counter._get_sql_clause() 
     205 
     206        try: 
     207            select, sql, params, full_query = counter._get_sql_clause() 
     208        except EmptyResultSet: 
     209            return 0 
     210 
    198211        cursor = connection.cursor() 
    199212        if self._distinct: 
    …… 
    533546 
    534547        cursor = connection.cursor() 
    535         select, sql, params, full_query = self._get_sql_clause() 
     548 
     549        try: 
     550            select, sql, params, full_query = self._get_sql_clause() 
     551        except EmptyResultSet: 
     552            raise StopIteration 
     553 
    536554        select = ['%s.%s' % (backend.quote_name(self.model._meta.db_table), backend.quote_name(c)) for c in columns] 
    537555        cursor.execute("SELECT " + (self._distinct and "DISTINCT " or "") + ",".join(select) + sql, params) 
    …… 
    555573            self._where.append('%s.%s IS NOT NULL' % \ 
    556574                (backend.quote_name(self.model._meta.db_table), backend.quote_name(self._field.column))) 
    557         select, sql, params, full_query = self._get_sql_clause() 
     575        try: 
     576            select, sql, params, full_query = self._get_sql_clause() 
     577        except EmptyResultSet: 
     578            raise StopIteration 
     579 
    558580        table_name = backend.quote_name(self.model._meta.db_table) 
    559581        field_name = backend.quote_name(self._field.column) 
    560         date_trunc_sql = backend.get_date_trunc_sql(self._kind, 
    561                                                     '%s.%s' % (table_name, field_name)) 
     582 
    562583        if backend.allows_group_by_ordinal: 
    563584            group_by = '1' 
    564585        else: 
    565             group_by = date_trunc_sql 
    566         fmt = 'SELECT %s %s GROUP BY %s ORDER BY 1 %s' 
    567         stmt = fmt % (date_trunc_sql, sql, group_by, self._order) 
     586            group_by = backend.get_date_trunc_sql(self._kind, 
     587                                                  '%s.%s' % (table_name, field_name)) 
     588 
     589        sql = 'SELECT %s %s GROUP BY %s ORDER BY 1 %s' % \ 
     590            (backend.get_date_trunc_sql(self._kind, '%s.%s' % (backend.quote_name(self.model._meta.db_table), 
     591            backend.quote_name(self._field.column))), sql, group_by, self._order) 
    568592        cursor = connection.cursor() 
    569         cursor.execute(stmt, params) 
     593        cursor.execute(sql, params) 
    570594        if backend.needs_datetime_string_cast: 
    571595            return [typecast_timestamp(str(row[0])) for row in cursor.fetchall()] 
    …… 
    580604        return c 
    581605 
     606class EmptyQuerySet(QuerySet): 
     607    def __init__(self, model=None): 
     608        super(EmptyQuerySet, self).__init__(model) 
     609        self._result_cache = [] 
     610 
     611    def iterator(self): 
     612        raise StopIteration 
     613 
     614    def count(self): 
     615        return 0 
     616 
     617    def delete(self): 
     618        pass 
     619 
     620    def _clone(self, klass=None, **kwargs): 
     621        c = super(EmptyQuerySet, self)._clone(klass, **kwargs) 
     622        c._result_cache = [] 
     623        return c 
     624 
    582625class QOperator(object): 
    583626    "Base class for QAnd and QOr" 
    …… 
    588631        joins, where, params = SortedDict(), [], [] 
    589632        for val in self.args: 
    590             joins2, where2, params2 = val.get_sql(opts) 
    591             joins.update(joins2) 
    592             where.extend(where2) 
    593             params.extend(params2) 
     633            try: 
     634                joins2, where2, params2 = val.get_sql(opts) 
     635                joins.update(joins2) 
     636                where.extend(where2) 
     637                params.extend(params2) 
     638            except EmptyResultSet: 
     639                if not isinstance(self, QOr): 
     640                    raise EmptyResultSet 
    594641        if where: 
    595642            return joins, ['(%s)' % self.operator.join(where)], params 
    …… 
    645692 
    646693    def get_sql(self, opts): 
    647         joins, where, params = self.q.get_sql(opts) 
    648         where2 = ['(NOT (%s))' % " AND ".join(where)] 
     694        try: 
     695            joins, where, params = self.q.get_sql(opts) 
     696            where2 = ['(NOT (%s))' % " AND ".join(where)] 
     697        except EmptyResultSet: 
     698            return SortedDict(), [], [] 
    649699        return joins, where2, params 
    650700 
    …… 
    663713        pass 
    664714    if lookup_type == 'in': 
    665         return '%s%s IN (%s)' % (table_prefix, field_name, ','.join(['%s' for v in value])) 
     715        in_string = ','.join(['%s' for id in value]) 
     716        if in_string: 
     717            return '%s%s IN (%s)' % (table_prefix, field_name, in_string) 
     718        else: 
     719            raise EmptyResultSet 
    666720    elif lookup_type == 'range': 
    667721        return '%s%s BETWEEN %%s AND %%s' % (table_prefix, field_name) 
    …… 
    9491003        pk_list = [pk for pk,instance in seen_objs[cls]] 
    9501004        for related in cls._meta.get_all_related_many_to_many_objects(): 
     1005            if not isinstance(related.field, GenericRelation): 
     1006                for offset in range(0, len(pk_list), GET_ITERATOR_CHUNK_SIZE): 
     1007                    cursor.execute("DELETE FROM %s WHERE %s IN (%s)" % \ 
     1008                        (qn(related.field.m2m_db_table()), 
     1009                            qn(related.field.m2m_reverse_name()), 
     1010                            ','.join(['%s' for pk in pk_list[offset:offset+GET_ITERATOR_CHUNK_SIZE]])), 
     1011                        pk_list[offset:offset+GET_ITERATOR_CHUNK_SIZE]) 
     1012        for f in cls._meta.many_to_many: 
     1013            if isinstance(f, GenericRelation): 
     1014                from django.contrib.contenttypes.models import ContentType 
     1015                query_extra = 'AND %s=%%s' % f.rel.to._meta.get_field(f.content_type_field_name).column 
     1016                args_extra = [ContentType.objects.get_for_model(cls).id] 
     1017            else: 
     1018                query_extra = '' 
     1019                args_extra = [] 
    9511020            for offset in range(0, len(pk_list), GET_ITERATOR_CHUNK_SIZE): 
    952                 cursor.execute("DELETE FROM %s WHERE %s IN (%s)" % \ 
    953                     (qn(related.field.m2m_db_table()), 
    954                         qn(related.field.m2m_reverse_name()), 
    955                         ','.join(['%s' for pk in pk_list[offset:offset+GET_ITERATOR_CHUNK_SIZE]])), 
    956                     pk_list[offset:offset+GET_ITERATOR_CHUNK_SIZE]) 
    957         for f in cls._meta.many_to_many: 
    958             for offset in range(0, len(pk_list), GET_ITERATOR_CHUNK_SIZE): 
    959                 cursor.execute("DELETE FROM %s WHERE %s IN (%s)" % \ 
     1021                cursor.execute(("DELETE FROM %s WHERE %s IN (%s)" % \ 
    9601022                    (qn(f.m2m_db_table()), qn(f.m2m_column_name()), 
    961                     ','.join(['%s' for pk in pk_list[offset:offset+GET_ITERATOR_CHUNK_SIZE]])), 
    962                     pk_list[offset:offset+GET_ITERATOR_CHUNK_SIZE]) 
     1023                    ','.join(['%s' for pk in pk_list[offset:offset+GET_ITERATOR_CHUNK_SIZE]]))) + query_extra, 
     1024                    pk_list[offset:offset+GET_ITERATOR_CHUNK_SIZE] + args_extra) 
    9631025        for field in cls._meta.fields: 
    9641026            if field.rel and field.null and field.rel.to in seen_objs: 

  • django/branches/boulder-oracle-sprint/django/newforms/fields.py