Code

Ticket #683: meta__init__.patch

File meta__init__.patch, 26.9 KB (added by jdunck@…, 8 years ago)

patch changing .column to .name when it seems to mean that.

  • django/core/meta/__init__.py

     
    153153        exceptions=None, permissions=None, get_latest_by=None, 
    154154        order_with_respect_to=None, module_constants=None): 
    155155 
     156        #jgd 
     157        #print "initing Options for " + verbose_name 
     158         
    156159        # Save the original function args, for use by copy(). Note that we're 
    157160        # NOT using copy.deepcopy(), because that would create a new copy of 
    158161        # everything in memory, and it's better to conserve memory. Of course, 
     
    209212            if f.primary_key: 
    210213                self.pk = f 
    211214                break 
     215        #jgd 
     216        #if self.pk: 
     217        #  print "found pk " + self.pk.name 
     218        #  if self.pk.db_column: 
     219        #    print "col " + self.pk.db_column 
     220        #else: 
     221        #  print "didn't find pk" 
    212222        # If a primary_key field hasn't been specified, add an 
    213223        # auto-incrementing primary-key ID field automatically. 
    214224        if self.pk is None: 
     
    408418        # Gather all attributes that are Field instances. 
    409419        fields = [] 
    410420        for obj_name, obj in attrs.items(): 
     421            print "field: " + obj_name 
    411422            if isinstance(obj, Field): 
    412423                obj.set_name(obj_name) 
    413424                fields.append(obj) 
     
    760771                            val = getattr(rel_obj, f.rel.field_name) 
    761772                        except AttributeError: 
    762773                            raise TypeError, "Invalid value: %r should be a %s instance, not a %s" % (f.name, f.rel.to, type(rel_obj)) 
    763                 setattr(self, f.column, val) 
     774                #jgd 
     775                #setattr(self, f.column, val) 
     776                setattr(self, f.name, val) 
    764777            else: 
    765778                val = kwargs.pop(f.name, f.get_default()) 
    766779                setattr(self, f.name, val) 
    767780        if kwargs: 
    768781            raise TypeError, "'%s' is an invalid keyword argument for this function" % kwargs.keys()[0] 
    769782    for i, arg in enumerate(args): 
    770         setattr(self, opts.fields[i].column, arg) 
     783        #jgd 
     784        #setattr(self, opts.fields[i].column, arg) 
     785        setattr(self, opts.fields[i].name, arg) 
    771786 
    772787def method_eq(opts, self, other): 
    773     return isinstance(other, self.__class__) and getattr(self, opts.pk.column) == getattr(other, opts.pk.column) 
     788    #jgd 
     789    #return isinstance(other, self.__class__) and getattr(self, opts.pk.column) == getattr(other, opts.pk.column) 
     790    return isinstance(other, self.__class__) and getattr(self, opts.pk.name) == getattr(other, opts.pk.name) 
    774791 
    775792def method_save(opts, self): 
    776793    # Run any pre-save hooks. 
     
    779796    non_pks = [f for f in opts.fields if not f.primary_key] 
    780797    cursor = db.db.cursor() 
    781798 
     799    #jgd 
     800    #print "saving" 
    782801    # First, try an UPDATE. If that doesn't update anything, do an INSERT. 
    783     pk_val = getattr(self, opts.pk.column) 
     802    #jgd 
     803    #pk_val = getattr(self, opts.pk.column) 
     804    pk_val = getattr(self, opts.pk.name) 
    784805    pk_set = bool(pk_val) 
    785806    record_exists = True 
    786807    if pk_set: 
     808        #jgd 
     809        #print "pk set" 
    787810        # Determine whether a record with the primary key already exists. 
    788811        cursor.execute("SELECT 1 FROM %s WHERE %s=%%s LIMIT 1" % (opts.db_table, opts.pk.column), [pk_val]) 
    789812        # If it does already exist, do an UPDATE. 
    790813        if cursor.fetchone(): 
    791             db_values = [f.get_db_prep_save(f.pre_save(getattr(self, f.column), False)) for f in non_pks] 
     814            #jgd 
     815            #db_values = [f.get_db_prep_save(f.pre_save(getattr(self, f.column), False)) for f in non_pks] 
     816            db_values = [f.get_db_prep_save(f.pre_save(getattr(self, f.name), False)) for f in non_pks] 
    792817            cursor.execute("UPDATE %s SET %s WHERE %s=%%s" % (opts.db_table, 
    793818                ','.join(['%s=%%s' % f.column for f in non_pks]), opts.pk.column), 
    794819                db_values + [pk_val]) 
    795820        else: 
    796821            record_exists = False 
    797822    if not pk_set or not record_exists: 
     823        #jgd 
     824        #print "pk not set" 
     825        #jgd 
    798826        field_names = [f.column for f in opts.fields if not isinstance(f, AutoField)] 
     827        #>field_names = [f.name for f in opts.fields if not isinstance(f, AutoField)] 
    799828        placeholders = ['%s'] * len(field_names) 
    800         db_values = [f.get_db_prep_save(f.pre_save(getattr(self, f.column), True)) for f in opts.fields if not isinstance(f, AutoField)] 
     829        #jgd 
     830        #<db_values = [f.get_db_prep_save(f.pre_save(getattr(self, f.column), True)) for f in opts.fields if not isinstance(f, AutoField)] 
     831        db_values = [f.get_db_prep_save(f.pre_save(getattr(self, f.name), True)) for f in opts.fields if not isinstance(f, AutoField)] 
    801832        if opts.order_with_respect_to: 
    802833            field_names.append('_order') 
    803834            # TODO: This assumes the database supports subqueries. 
    804835            placeholders.append('(SELECT COUNT(*) FROM %s WHERE %s = %%s)' % \ 
    805836                (opts.db_table, opts.order_with_respect_to.column)) 
    806             db_values.append(getattr(self, opts.order_with_respect_to.column)) 
     837            #jgd 
     838            #db_values.append(getattr(self, opts.order_with_respect_to.column)) 
     839            db_values.append(getattr(self, opts.order_with_respect_to.name)) 
    807840        cursor.execute("INSERT INTO %s (%s) VALUES (%s)" % (opts.db_table, 
    808841            ','.join(field_names), ','.join(placeholders)), db_values) 
    809842        if opts.has_auto_field: 
    810             setattr(self, opts.pk.column, db.get_last_insert_id(cursor, opts.db_table, opts.pk.column)) 
     843            #jgd 
     844            #setattr(self, opts.pk.column, db.get_last_insert_id(cursor, opts.db_table, opts.pk.column)) 
     845            setattr(self, opts.pk.name, db.get_last_insert_id(cursor, opts.db_table, opts.pk.column)) 
    811846    db.db.commit() 
    812847    # Run any post-save hooks. 
    813848    if hasattr(self, '_post_save'): 
    814849        self._post_save() 
    815850 
    816851def method_delete(opts, self): 
    817     assert getattr(self, opts.pk.column) is not None, "%r can't be deleted because it doesn't have an ID." 
     852    #jgd 
     853    #assert getattr(self, opts.pk.column) is not None, "%r can't be deleted because it doesn't have an ID." 
     854    assert getattr(self, opts.pk.name) is not None, "%r can't be deleted because it doesn't have an ID." 
    818855    # Run any pre-delete hooks. 
    819856    if hasattr(self, '_pre_delete'): 
    820857        self._pre_delete() 
     
    832869            for sub_obj in getattr(self, 'get_%s_list' % rel_opts_name)(): 
    833870                sub_obj.delete() 
    834871    for rel_opts, rel_field in opts.get_all_related_many_to_many_objects(): 
     872        #jgd 
     873        #cursor.execute("DELETE FROM %s WHERE %s_id=%%s" % (rel_field.get_m2m_db_table(rel_opts), 
     874        #    self._meta.object_name.lower()), [getattr(self, opts.pk.column)]) 
    835875        cursor.execute("DELETE FROM %s WHERE %s_id=%%s" % (rel_field.get_m2m_db_table(rel_opts), 
    836             self._meta.object_name.lower()), [getattr(self, opts.pk.column)]) 
     876            self._meta.object_name.lower()), [getattr(self, opts.pk.name)]) 
     877         
    837878    for f in opts.many_to_many: 
     879        #jgd 
     880        #cursor.execute("DELETE FROM %s WHERE %s_id=%%s" % (f.get_m2m_db_table(opts), self._meta.object_name.lower()), 
     881        #    [getattr(self, opts.pk.column)]) 
    838882        cursor.execute("DELETE FROM %s WHERE %s_id=%%s" % (f.get_m2m_db_table(opts), self._meta.object_name.lower()), 
    839             [getattr(self, opts.pk.column)]) 
    840     cursor.execute("DELETE FROM %s WHERE %s=%%s" % (opts.db_table, opts.pk.column), [getattr(self, opts.pk.column)]) 
     883            [getattr(self, opts.pk.name)]) 
     884         
     885    #jgd 
     886    #cursor.execute("DELETE FROM %s WHERE %s=%%s" % (opts.db_table, opts.pk.column), [getattr(self, opts.pk.column)]) 
     887    cursor.execute("DELETE FROM %s WHERE %s=%%s" % (opts.db_table, opts.pk.column), [getattr(self, opts.pk.name)]) 
    841888    db.db.commit() 
    842     setattr(self, opts.pk.column, None) 
     889    #jgd 
     890    #setattr(self, opts.pk.column, None) 
     891    setattr(self, opts.pk.name, None) 
    843892    for f in opts.fields: 
    844         if isinstance(f, FileField) and getattr(self, f.column): 
     893        #jgd 
     894        #if isinstance(f, FileField) and getattr(self, f.column): 
     895        if isinstance(f, FileField) and getattr(self, f.name): 
    845896            file_name = getattr(self, 'get_%s_filename' % f.name)() 
    846897            # If the file exists and no other object of this type references it, 
    847898            # delete it from the filesystem. 
     
    856907        self._next_in_order_cache = opts.get_model_module().get_object(order_by=('_order',), 
    857908            where=['_order > (SELECT _order FROM %s WHERE %s=%%s)' % (opts.db_table, opts.pk.column), 
    858909                '%s=%%s' % order_field.column], limit=1, 
    859             params=[getattr(self, opts.pk.column), getattr(self, order_field.column)]) 
     910            #jgd 
     911            #params=[getattr(self, opts.pk.column), getattr(self, order_field.column)]) 
     912            params=[getattr(self, opts.pk.name), getattr(self, order_field.name)]) 
    860913    return self._next_in_order_cache 
    861914 
    862915def method_get_previous_in_order(opts, order_field, self): 
     
    873926def method_get_many_to_one(field_with_rel, self): 
    874927    cache_var = field_with_rel.get_cache_name() 
    875928    if not hasattr(self, cache_var): 
    876         val = getattr(self, field_with_rel.column) 
     929        #jgd 
     930        #val = getattr(self, field_with_rel.column) 
     931        val = getattr(self, field_with_rel.name) 
    877932        mod = field_with_rel.rel.to.get_model_module() 
    878933        if val is None: 
    879934            raise getattr(mod, '%sDoesNotExist' % field_with_rel.rel.to.object_name) 
     
    893948            field_with_rel.get_m2m_db_table(self._meta), rel.pk.column, 
    894949            rel.object_name.lower(), self._meta.object_name.lower(), rel.get_order_sql('a')) 
    895950        cursor = db.db.cursor() 
    896         cursor.execute(sql, [getattr(self, self._meta.pk.column)]) 
     951        #jgd 
     952        #cursor.execute(sql, [getattr(self, self._meta.pk.column)]) 
     953        cursor.execute(sql, [getattr(self, self._meta.pk.name)]) 
    897954        setattr(self, cache_var, [getattr(mod, rel.object_name)(*row) for row in cursor.fetchall()]) 
    898955    return getattr(self, cache_var) 
    899956 
     
    914971    rel = rel_field.rel.to 
    915972    m2m_table = rel_field.get_m2m_db_table(self._meta) 
    916973    cursor = db.db.cursor() 
    917     this_id = getattr(self, self._meta.pk.column) 
     974    #jgd 
     975    #this_id = getattr(self, self._meta.pk.column) 
     976    this_id = getattr(self, self._meta.pk.name) 
    918977    if ids_to_delete: 
    919978        sql = "DELETE FROM %s WHERE %s_id = %%s AND %s_id IN (%s)" % (m2m_table, self._meta.object_name.lower(), rel.object_name.lower(), ','.join(map(str, ids_to_delete))) 
    920979        cursor.execute(sql, [this_id]) 
     
    9541013# Handles related many-to-many object retrieval. 
    9551014# Examples: Album.get_song(), Album.get_song_list(), Album.get_song_count() 
    9561015def method_get_related_many_to_many(method_name, opts, rel_mod, rel_field, self, **kwargs): 
    957     kwargs['%s__%s__exact' % (rel_field.name, opts.pk.name)] = getattr(self, opts.pk.column) 
     1016    #jgd 
     1017    #kwargs['%s__%s__exact' % (rel_field.name, opts.pk.name)] = getattr(self, opts.pk.column) 
     1018    kwargs['%s__%s__exact' % (rel_field.name, opts.pk.name)] = getattr(self, opts.pk.name) 
    9581019    return getattr(rel_mod, method_name)(**kwargs) 
    9591020 
    9601021# Handles setting many-to-many related objects. 
     
    9631024    id_list = map(int, id_list) # normalize to integers 
    9641025    rel = rel_field.rel.to 
    9651026    m2m_table = rel_field.get_m2m_db_table(rel_opts) 
    966     this_id = getattr(self, self._meta.pk.column) 
     1027    #jgd 
     1028    #this_id = getattr(self, self._meta.pk.column) 
     1029    this_id = getattr(self, self._meta.pk.name) 
    9671030    cursor = db.db.cursor() 
    9681031    cursor.execute("DELETE FROM %s WHERE %s_id = %%s" % (m2m_table, rel.object_name.lower()), [this_id]) 
    9691032    sql = "INSERT INTO %s (%s_id, %s_id) VALUES (%%s, %%s)" % (m2m_table, rel.object_name.lower(), rel_opts.object_name.lower()) 
     
    10001063# CHOICE-RELATED METHODS ################### 
    10011064 
    10021065def method_get_display_value(field, self): 
    1003     value = getattr(self, field.column) 
     1066    #jgd 
     1067    #value = getattr(self, field.column) 
     1068    value = getattr(self, field.name) 
    10041069    return dict(field.choices).get(value, value) 
    10051070 
    10061071# FILE-RELATED METHODS ##################### 
     
    11511216 
    11521217    # 'fields' is a list of field names to fetch. 
    11531218    try: 
    1154         fields = [opts.get_field(f).column for f in kwargs.pop('fields')] 
     1219        #jgd 
     1220        #fields = [opts.get_field(f).column for f in kwargs.pop('fields')] 
     1221        fields = [opts.get_field(f).name for f in kwargs.pop('fields')] 
    11551222    except KeyError: # Default to all fields. 
    1156         fields = [f.column for f in opts.fields] 
     1223        #jgd 
     1224        #fields = [f.column for f in opts.fields] 
     1225        fields = [f.name for f in opts.fields] 
    11571226 
    11581227    cursor = db.db.cursor() 
    11591228    _, sql, params = function_get_sql_clause(opts, **kwargs) 
     
    12031272    # table_count is used to ensure table aliases are unique. 
    12041273    tables, join_where, where, params = [], [], [], [] 
    12051274    for kwarg, kwarg_value in kwarg_items: 
     1275        #jgd 
     1276        #print "kw: " + kwarg, kwarg_value 
    12061277        if kwarg in ('order_by', 'limit', 'offset', 'select_related', 'distinct', 'select', 'tables', 'where', 'params'): 
    12071278            continue 
    12081279        if kwarg_value is None: 
     
    12181289        lookup_list = kwarg.split(LOOKUP_SEPARATOR) 
    12191290        # pk="value" is shorthand for (primary key)__exact="value" 
    12201291        if lookup_list[-1] == 'pk': 
     1292            #jgd 
     1293            #print "looking up pk" 
    12211294            if opts.pk.rel: 
     1295                #print "pk rel" 
    12221296                lookup_list = lookup_list[:-1] + [opts.pk.name, opts.pk.rel.field_name, 'exact'] 
    12231297            else: 
     1298                #print "pk no rel" 
    12241299                lookup_list = lookup_list[:-1] + [opts.pk.name, 'exact'] 
    12251300        if len(lookup_list) == 1: 
     1301            #jgd 
     1302            #print "len(lookup_list) == 1" 
    12261303            _throw_bad_kwarg_error(kwarg) 
    12271304        lookup_type = lookup_list.pop() 
    12281305        current_opts = opts # We'll be overwriting this, so keep a reference to the original opts. 
    12291306        current_table_alias = current_opts.db_table 
    12301307        param_required = False 
    12311308        while lookup_list or param_required: 
     1309            #jgd 
     1310            #print "looking up " + str(lookup_list) 
    12321311            table_count += 1 
    12331312            try: 
    12341313                # "current" is a piece of the lookup list. For example, in 
     
    12401319                    # If we're here, lookup_list is empty but param_required 
    12411320                    # is set to True, which means the kwarg was bad. 
    12421321                    # Example: choices.get_list(poll__exact='foo') 
     1322                    #jgd 
     1323                    #print "bad lookup pop" 
    12431324                    _throw_bad_kwarg_error(kwarg) 
    12441325                # Try many-to-many relationships first... 
    12451326                for f in current_opts.many_to_many: 
     1327                    #jgd 
     1328                    #print "trying many to many " + str(f.name) 
    12461329                    if f.name == current: 
     1330                        #jgd 
     1331                        #print "found m-to-m rel" 
    12471332                        rel_table_alias = 't%s' % table_count 
    12481333                        table_count += 1 
    12491334                        tables.append('%s %s' % (f.get_m2m_db_table(current_opts), rel_table_alias)) 
     
    12521337                        # Optimization: In the case of primary-key lookups, we 
    12531338                        # don't have to do an extra join. 
    12541339                        if lookup_list and lookup_list[0] == f.rel.to.pk.name and lookup_type == 'exact': 
     1340                            #jgd 
     1341                            #print "doing m-to-m pk lookup" 
    12551342                            where.append(_get_where_clause(lookup_type, rel_table_alias+'.', 
    12561343                                f.rel.to.object_name.lower()+'_id', kwarg_value)) 
    12571344                            params.extend(f.get_db_prep_lookup(lookup_type, kwarg_value)) 
    12581345                            lookup_list.pop() 
    12591346                            param_required = False 
    12601347                        else: 
     1348                            #jgd 
     1349                            #print "doing m-to-m regular lookup" 
    12611350                            new_table_alias = 't%s' % table_count 
    12621351                            tables.append('%s %s' % (f.rel.to.db_table, new_table_alias)) 
    12631352                            join_where.append('%s.%s_id = %s.%s' % (rel_table_alias, f.rel.to.object_name.lower(), 
    12641353                                new_table_alias, f.rel.to.pk.column)) 
    12651354                            current_table_alias = new_table_alias 
    12661355                            param_required = True 
     1356                        #jgd 
     1357                        #print "switching opts to be relative to m-to-m join target and jumping to next lookup" 
    12671358                        current_opts = f.rel.to 
    12681359                        raise StopIteration 
    12691360                for f in current_opts.fields: 
     1361                    #jgd 
     1362                    #print "trying one to many " + str(f.name) 
     1363 
    12701364                    # Try many-to-one relationships... 
    12711365                    if f.rel and f.name == current: 
     1366                        #jgd 
     1367                        #print "found 1-to-m rel " 
    12721368                        # Optimization: In the case of primary-key lookups, we 
    12731369                        # don't have to do an extra join. 
    12741370                        if lookup_list and lookup_list[0] == f.rel.to.pk.name and lookup_type == 'exact': 
     1371                            #jgd 
     1372                            #print "pk look up" 
    12751373                            where.append(_get_where_clause(lookup_type, current_table_alias+'.', f.column, kwarg_value)) 
    12761374                            params.extend(f.get_db_prep_lookup(lookup_type, kwarg_value)) 
    12771375                            lookup_list.pop() 
     
    12801378                        # because we don't want to do a join. We just want to find out 
    12811379                        # whether the foreign key field is NULL. 
    12821380                        elif lookup_type == 'isnull' and not lookup_list: 
     1381                            #jgd 
     1382                            #print "isnull lookup"                         
    12831383                            where.append(_get_where_clause(lookup_type, current_table_alias+'.', f.column, kwarg_value)) 
    12841384                            params.extend(f.get_db_prep_lookup(lookup_type, kwarg_value)) 
    12851385                        else: 
     1386                            #jgd 
     1387                            #print "regular 1-to-m lookup"                         
    12861388                            new_table_alias = 't%s' % table_count 
    12871389                            tables.append('%s %s' % (f.rel.to.db_table, new_table_alias)) 
    12881390                            join_where.append('%s.%s = %s.%s' % (current_table_alias, f.column, \ 
    12891391                                new_table_alias, f.rel.to.pk.column)) 
    12901392                            current_table_alias = new_table_alias 
    12911393                            param_required = True 
     1394                        #jgd 
     1395                        #print "switching opts to be relative to 1-to-m join target and jumping to next lookup" 
    12921396                        current_opts = f.rel.to 
    12931397                        raise StopIteration 
    12941398                    # Try direct field-name lookups... 
    12951399                    if f.name == current: 
     1400                        #jgd 
     1401                        #print "found direct field name" 
    12961402                        where.append(_get_where_clause(lookup_type, current_table_alias+'.', f.column, kwarg_value)) 
    12971403                        params.extend(f.get_db_prep_lookup(lookup_type, kwarg_value)) 
    12981404                        param_required = False 
    12991405                        raise StopIteration 
    13001406                # If we haven't hit StopIteration at this point, "current" must be 
    13011407                # an invalid lookup, so raise an exception. 
     1408                #jgd 
     1409                #print "can't figure it out" 
    13021410                _throw_bad_kwarg_error(kwarg) 
    13031411            except StopIteration: 
    13041412                continue 
     
    13631471    kwargs['where'] = ["%s.%s IN (%s)" % (opts.db_table, opts.pk.column, ",".join(['%s'] * len(id_list)))] 
    13641472    kwargs['params'] = id_list 
    13651473    obj_list = function_get_list(opts, klass, **kwargs) 
    1366     return dict([(getattr(o, opts.pk.column), o) for o in obj_list]) 
     1474    #jgd 
     1475    #return dict([(getattr(o, opts.pk.column), o) for o in obj_list]) 
     1476    return dict([(getattr(o, opts.pk.name), o) for o in obj_list]) 
    13671477 
    13681478def function_get_latest(opts, klass, does_not_exist_exception, **kwargs): 
    13691479    kwargs['order_by'] = ('-' + opts.get_latest_by,) 
     
    14331543                lookup_kwargs = opts.one_to_one_field.rel.limit_choices_to 
    14341544                lookup_kwargs['%s__exact' % opts.one_to_one_field.rel.field_name] = obj_key 
    14351545                _ = opts.one_to_one_field.rel.to.get_model_module().get_object(**lookup_kwargs) 
    1436                 params = dict([(f.column, f.get_default()) for f in opts.fields]) 
    1437                 params[opts.pk.column] = obj_key 
     1546 
     1547                #jgd 
     1548                #params = dict([(f.column, f.get_default()) for f in opts.fields]) 
     1549                #params[opts.pk.column] = obj_key 
     1550                params = dict([(f.name, f.get_default()) for f in opts.fields]) 
     1551                params[opts.pk.name] = obj_key                 
    14381552                self.original_object = opts.get_model_module().Klass(**params) 
    14391553            else: 
    14401554                raise 
     
    14691583    for f in opts.fields: 
    14701584        # Fields with auto_now_add are another special case; they should keep 
    14711585        # their original value in the change stage. 
     1586 
     1587        #jgd 
    14721588        if change and getattr(f, 'auto_now_add', False): 
    1473             params[f.column] = getattr(self.original_object, f.name) 
     1589            #params[f.column] = getattr(self.original_object, f.name) 
     1590            params[f.name] = getattr(self.original_object, f.name) 
    14741591        else: 
    1475             params[f.column] = f.get_manipulator_new_data(new_data) 
     1592            #params[f.column] = f.get_manipulator_new_data(new_data) 
     1593            params[f.name] = f.get_manipulator_new_data(new_data) 
    14761594 
    14771595    if change: 
    1478         params[opts.pk.column] = self.obj_key 
     1596        #params[opts.pk.column] = self.obj_key 
     1597        params[opts.pk.name] = self.obj_key 
    14791598 
    14801599    # First, save the basic object itself. 
    14811600    new_object = klass(**params) 
     
    14901609    if change: 
    14911610        self.fields_added, self.fields_changed, self.fields_deleted = [], [], [] 
    14921611        for f in opts.fields: 
    1493             if not f.primary_key and str(getattr(self.original_object, f.column)) != str(getattr(new_object, f.column)): 
     1612            #jgd 
     1613            #if not f.primary_key and str(getattr(self.original_object, f.column)) != str(getattr(new_object, f.column)): 
     1614            if not f.primary_key and str(getattr(self.original_object, f.name)) != str(getattr(new_object, f.name)): 
     1615                #jgd really want verbose_name here? 
    14941616                self.fields_changed.append(f.verbose_name) 
    14951617 
    14961618    # Save many-to-many objects. Example: Poll.set_sites() 
     
    15411663                # case, because they'll be dealt with later. 
    15421664                if change and (isinstance(f, FileField) or not f.editable): 
    15431665                    if rel_new_data.get(rel_opts.pk.name, False) and rel_new_data[rel_opts.pk.name][0]: 
    1544                         params[f.column] = getattr(old_rel_obj, f.column) 
     1666                        #jgd 
     1667                        #params[f.column] = getattr(old_rel_obj, f.column) 
     1668                        params[f.name] = getattr(old_rel_obj, f.name) 
    15451669                    else: 
    1546                         params[f.column] = f.get_default() 
     1670                        #jgd 
     1671                        #params[f.column] = f.get_default() 
     1672                        params[f.name] = f.get_default() 
    15471673                elif f == rel_field: 
    1548                     params[f.column] = getattr(new_object, rel_field.rel.field_name) 
     1674                    #jgd 
     1675                    #params[f.column] = getattr(new_object, rel_field.rel.field_name) 
     1676                    params[f.name] = getattr(new_object, rel_field.rel.field_name) 
    15491677                elif add and isinstance(f, AutoField): 
    1550                     params[f.column] = None 
     1678                    #jgd 
     1679                    #params[f.column] = None 
     1680                    params[f.name] = None 
    15511681                else: 
    1552                     params[f.column] = f.get_manipulator_new_data(rel_new_data, rel=True) 
     1682                    #jgd 
     1683                    #params[f.column] = f.get_manipulator_new_data(rel_new_data, rel=True) 
     1684                    params[f.name] = f.get_manipulator_new_data(rel_new_data, rel=True) 
    15531685                # Related links are a special case, because we have to 
    15541686                # manually set the "content_type_id" and "object_id" fields. 
    15551687                if opts.has_related_links and rel_opts.module_name == 'relatedlinks': 
     
    15751707                        self.fields_added.append('%s "%r"' % (rel_opts.verbose_name, new_rel_obj)) 
    15761708                    else: 
    15771709                        for f in rel_opts.fields: 
    1578                             if not f.primary_key and f != rel_field and str(getattr(old_rel_obj, f.column)) != str(getattr(new_rel_obj, f.column)): 
     1710                            #jgd 
     1711                            #if not f.primary_key and f != rel_field and str(getattr(old_rel_obj, f.column)) != str(getattr(new_rel_obj, f.column)): 
     1712                            if not f.primary_key and f != rel_field and str(getattr(old_rel_obj, f.name)) != str(getattr(new_rel_obj, f.name)): 
    15791713                                self.fields_changed.append('%s for %s "%r"' % (f.verbose_name, rel_opts.verbose_name, new_rel_obj)) 
    15801714 
    15811715                # Save many-to-many objects. 
     
    16061740    else: 
    16071741        kwargs = {'%s__iexact' % field_name_list[0]: field_data} 
    16081742    for f in field_list[1:]: 
    1609         field_val = all_data.get(f.column, None) 
     1743        #jgd 
     1744        #field_val = all_data.get(f.column, None) 
     1745        field_val = all_data.get(f.name, None) 
    16101746        if field_val is None: 
    16111747            # This will be caught by another validator, assuming the field 
    16121748            # doesn't have blank=True. 
     
    16201756        old_obj = mod.get_object(**kwargs) 
    16211757    except ObjectDoesNotExist: 
    16221758        return 
    1623     if hasattr(self, 'original_object') and getattr(self.original_object, opts.pk.column) == getattr(old_obj, opts.pk.column): 
     1759    #jgd 
     1760    #if hasattr(self, 'original_object') and getattr(self.original_object, opts.pk.column) == getattr(old_obj, opts.pk.column): 
     1761    if hasattr(self, 'original_object') and getattr(self.original_object, opts.pk.name) == getattr(old_obj, opts.pk.name): 
    16241762        pass 
    16251763    else: 
    16261764        raise validators.ValidationError, "%s with this %s already exists for the given %s." % \ 
     
    16461784    except ObjectDoesNotExist: 
    16471785        return 
    16481786    else: 
    1649         if hasattr(self, 'original_object') and getattr(self.original_object, opts.pk.column) == getattr(old_obj, opts.pk.column): 
     1787        #jgd 
     1788        #if hasattr(self, 'original_object') and getattr(self.original_object, opts.pk.column) == getattr(old_obj, opts.pk.column): 
     1789        if hasattr(self, 'original_object') and getattr(self.original_object, opts.pk.name) == getattr(old_obj, opts.pk.name): 
    16501790            pass 
    16511791        else: 
    16521792            format_string = (lookup_type == 'date') and '%B %d, %Y' or '%B %Y'