Code

Ticket #1990: 0.95_plus_timestamp.patch

File 0.95_plus_timestamp.patch, 19.6 KB (added by Winston Lee <lee.winston@…>, 8 years ago)

Binding of datetime.time is to the timestamp field. cx_Oracle expects datetime.datetime to persist to timestamp field. Hard-coded 1900-01-01 as the date, not pretty but gets it saving the time.

  • contrib/admin/models.py

     
    1616    action_time = models.DateTimeField(_('action time'), auto_now=True) 
    1717    user = models.ForeignKey(User) 
    1818    content_type = models.ForeignKey(ContentType, blank=True, null=True) 
    19     object_id = models.TextField(_('object id'), blank=True, null=True) 
     19    #changed for Oracle support 
     20    object_id = models.CharField(_('object id'), maxlength=200, blank=True, null=True) 
    2021    object_repr = models.CharField(_('object repr'), maxlength=200) 
    2122    action_flag = models.PositiveSmallIntegerField(_('action flag')) 
    2223    change_message = models.TextField(_('change message'), blank=True) 
  • contrib/sessions/models.py

     
    5151    session_key = models.CharField(_('session key'), maxlength=40, primary_key=True) 
    5252    session_data = models.TextField(_('session data')) 
    5353    expire_date = models.DateTimeField(_('expire date')) 
     54 
    5455    objects = SessionManager() 
    5556    class Meta: 
    5657        db_table = 'django_session' 
  • core/management.py

     
    66import os, re, shutil, sys, textwrap 
    77from optparse import OptionParser 
    88from django.utils import termcolors 
     9from django.conf import settings  
    910 
    1011# For Python 2.3 
    1112if not hasattr(__builtins__, 'set'): 
     
    8384 
    8485def get_sql_create(app): 
    8586    "Returns a list of the CREATE TABLE SQL statements for the given app." 
    86     from django.db import get_creation_module, models 
     87    from django.db import models,get_creation_module, backend 
    8788    data_types = get_creation_module().DATA_TYPES 
    8889 
    8990    if not data_types: 
     
    157158                field_output.append(style.SQL_KEYWORD('UNIQUE')) 
    158159            if f.primary_key: 
    159160                field_output.append(style.SQL_KEYWORD('PRIMARY KEY')) 
     161            if (settings.DATABASE_ENGINE == 'oracle') and f.unique and f.primary_key:  
     162                # Suppress UNIQUE/PRIMARY KEY for Oracle (ORA-02259)  
     163                field_output.remove(style.SQL_KEYWORD('UNIQUE')) 
    160164            if f.rel: 
    161165                if f.rel.to in known_models: 
    162166                    field_output.append(style.SQL_KEYWORD('REFERENCES') + ' ' + \ 
     
    181185        full_statement.append('    %s%s' % (line, i < len(table_output)-1 and ',' or '')) 
    182186    full_statement.append(');') 
    183187    final_output.append('\n'.join(full_statement)) 
     188     
     189    # To simulate auto-incrementing primary keys in Oracle -- creating primary tables  
     190    if (settings.DATABASE_ENGINE == 'oracle') & (opts.has_auto_field):  
     191        sequence_statement = 'CREATE SEQUENCE %s_sq;' % opts.db_table  
     192        final_output.append(sequence_statement)  
     193        trigger_statement = '' + \ 
     194            'CREATE OR REPLACE trigger %s_tr\n'    % opts.db_table + \ 
     195            '  before insert on %s\n'           % backend.quote_name(opts.db_table) + \ 
     196            '    for each row\n'  + \ 
     197            '      when (new.id is NULL)\n' + \ 
     198            '        begin\n' + \ 
     199            '         select %s_sq.NEXTVAL into :new.id from DUAL;\n' % opts.db_table + \ 
     200            '      end;\n'                                                                         
     201        final_output.append(trigger_statement)  
    184202 
     203 
    185204    return final_output, pending_references 
    186205 
    187206def _get_sql_for_pending_references(model, pending_references): 
     
    208227                    r_name += '_%s' % reference_names[r_name] 
    209228                else: 
    210229                    reference_names[r_name] = 0 
    211                 final_output.append(style.SQL_KEYWORD('ALTER TABLE') + ' %s ADD CONSTRAINT %s FOREIGN KEY (%s) REFERENCES %s (%s);' % \ 
    212                     (backend.quote_name(r_table), r_name, 
    213                     backend.quote_name(r_col), backend.quote_name(table), backend.quote_name(col))) 
     230                # if constraint name size is over 29 char and db is oracle, chop it  
     231                if settings.DATABASE_ENGINE == 'oracle' and len(r_name) > 29:  
     232                    final_output.append(style.SQL_KEYWORD('ALTER TABLE') + ' %s ADD CONSTRAINT %s FOREIGN KEY (%s) REFERENCES %s (%s);' % \ 
     233                                        (backend.quote_name(r_table), r_name[0:29],  
     234                                         backend.quote_name(r_col), backend.quote_name(table), backend.quote_name(col)))  
     235                else:  
     236                    final_output.append(style.SQL_KEYWORD('ALTER TABLE') + ' %s ADD CONSTRAINT %s FOREIGN KEY (%s) REFERENCES %s (%s);' % \ 
     237                                        (backend.quote_name(r_table), r_name, 
     238                                         backend.quote_name(r_col), backend.quote_name(table), backend.quote_name(col))) 
    214239            del pending_references[model] 
    215240    return final_output 
    216241 
     
    248273                style.SQL_FIELD(backend.quote_name(f.m2m_reverse_name())))) 
    249274            table_output.append(');') 
    250275            final_output.append('\n'.join(table_output)) 
     276        # To simulate auto-incrementing primary keys in Oracle -- creating m2m tables  
     277        if (settings.DATABASE_ENGINE == 'oracle'):  
     278            m_table = f.m2m_db_table()  
     279            sequence_statement = 'CREATE SEQUENCE %s_sq;' % m_table  
     280            final_output.append(sequence_statement)  
     281            trigger_statement = '' + \ 
     282            'CREATE OR REPLACE trigger %s_tr\n'    % m_table + \ 
     283            '  before insert on %s\n'           % backend.quote_name(m_table) + \ 
     284            '    for each row\n'  + \ 
     285            '      when (new.id is NULL)\n' + \ 
     286            '        begin\n' + \ 
     287            '         select %s_sq.NEXTVAL into :new.id from DUAL;\n' % m_table + \ 
     288            '      end;\n'  
     289            final_output.append(trigger_statement)  
    251290    return final_output 
    252291 
    253292def get_sql_delete(app): 
     
    471510            sql.extend(_get_sql_for_pending_references(model, pending_references)) 
    472511            print "Creating table %s" % model._meta.db_table 
    473512            for statement in sql: 
    474                 cursor.execute(statement) 
     513                # go on if one table could not be created  
     514                try:  
     515                    cursor.execute(statement)  
     516                except Exception, e:  
     517                    print statement  
     518                    print e  
    475519            table_list.append(model._meta.db_table) 
    476520 
    477521        for model in model_list: 
     
    12811325        if not mod_list: 
    12821326            parser.print_usage_and_exit() 
    12831327        if action not in NO_SQL_TRANSACTION: 
    1284             print style.SQL_KEYWORD("BEGIN;") 
     1328            if settings.DATABASE_ENGINE != 'oracle': 
     1329                print style.SQL_KEYWORD("BEGIN;") 
    12851330        for mod in mod_list: 
    12861331            output = action_mapping[action](mod) 
    12871332            if output: 
    12881333                print '\n'.join(output) 
    12891334        if action not in NO_SQL_TRANSACTION: 
    1290             print style.SQL_KEYWORD("COMMIT;") 
     1335            if settings.DATABASE_ENGINE != 'oracle': 
     1336                print style.SQL_KEYWORD("COMMIT;") 
    12911337 
    12921338def execute_manager(settings_mod, argv=None): 
    12931339    # Add this project to sys.path so that it's importable in the conventional 
  • db/backends/oracle/base.py

     
    3939            else: 
    4040                conn_string = "%s/%s@%s" % (settings.DATABASE_USER, settings.DATABASE_PASSWORD, settings.DATABASE_NAME) 
    4141                self.connection = Database.connect(conn_string) 
     42        # set oracle date to ansi date format 
     43        cursor =  self.connection.cursor() 
     44        cursor.execute("alter session set nls_date_format = 'YYYY-MM-DD HH24:MI:SS'") 
     45        cursor.close()                                        
    4246        return FormatStylePlaceholderCursor(self.connection) 
    4347 
    4448    def _commit(self): 
     
    6771    def execute(self, query, params=None): 
    6872        if params is None: params = [] 
    6973        query = self.convert_arguments(query, len(params)) 
    70         return Database.Cursor.execute(self, query, params) 
     74        # cx can not execute the query with the closing ';'  
     75        if query.endswith(';') : 
     76            query = query[0:len(query)-1]                        
     77        print query 
     78        print params     
     79        return Database.Cursor.execute(self, query, params) 
    7180 
    7281    def executemany(self, query, params=None): 
    7382        if params is None: params = [] 
    7483        query = self.convert_arguments(query, len(params[0])) 
     84        # cx can not execute the query with the closing ';'  
     85        if query.endswith(';') : 
     86            query = query[0:len(query)-1]                                                    
    7587        return Database.Cursor.executemany(self, query, params) 
    7688 
    7789    def convert_arguments(self, query, num_params): 
  • db/models/base.py

     
    171171        record_exists = True 
    172172        if pk_set: 
    173173            # Determine whether a record with the primary key already exists. 
    174             cursor.execute("SELECT 1 FROM %s WHERE %s=%%s LIMIT 1" % \ 
    175                 (backend.quote_name(self._meta.db_table), backend.quote_name(self._meta.pk.column)), [pk_val]) 
     174            lim = settings.DATABASE_ENGINE != 'oracle' and ' LIMIT 1' or '' 
     175            cursor.execute("SELECT 1 FROM %s WHERE %s=%%s %s" % \ 
     176                (backend.quote_name(self._meta.db_table), backend.quote_name(self._meta.pk.column), lim), [pk_val]) 
    176177            # If it does already exist, do an UPDATE. 
    177178            if cursor.fetchone(): 
    178179                db_values = [f.get_db_prep_save(f.pre_save(self, False)) for f in non_pks] 
  • db/models/fields/__init__.py

     
    158158 
    159159    def get_db_prep_save(self, value): 
    160160        "Returns field's value prepared for saving into a database." 
     161        # Oracle treats empty strings ('') the same as NULLs.   
     162        # To get around this wart, we need to change it to something else...   
     163        if settings.DATABASE_ENGINE == 'oracle' and  value == '':  
     164            value = ' ' 
    161165        return value 
    162166 
    163167    def get_db_prep_lookup(self, lookup_type, value): 
     
    446450    def get_db_prep_save(self, value): 
    447451        # Casts dates into string format for entry into database. 
    448452        if value is not None: 
    449             value = value.strftime('%Y-%m-%d') 
     453            if settings.DATABASE_ENGINE != 'oracle':  
     454                #Oracle does not need a string conversion 
     455                value = value.strftime('%Y-%m-%d') 
    450456        return Field.get_db_prep_save(self, value) 
    451457 
    452458    def get_manipulator_field_objs(self): 
     
    476482    def get_db_prep_save(self, value): 
    477483        # Casts dates into string format for entry into database. 
    478484        if value is not None: 
    479             # MySQL will throw a warning if microseconds are given, because it 
     485            # MySQL/Oracle will throw a warning if microseconds are given, because it 
    480486            # doesn't support microseconds. 
    481             if settings.DATABASE_ENGINE == 'mysql' and hasattr(value, 'microsecond'): 
     487            if (settings.DATABASE_ENGINE == 'mysql' or settings.DATABASE_ENGINE=='oracle') and hasattr(value, 'microsecond'): 
    482488                value = value.replace(microsecond=0) 
    483489            value = str(value) 
    484490        return Field.get_db_prep_save(self, value) 
    485491 
    486492    def get_db_prep_lookup(self, lookup_type, value): 
     493        # Oracle will throw an error if microseconds are given, because it  
     494        # doesn't support microseconds.  
     495        if (settings.DATABASE_ENGINE=='oracle') and hasattr(value, 'microsecond'):  
     496            value = value.replace(microsecond=0) 
    487497        if lookup_type == 'range': 
    488498            value = [str(v) for v in value] 
    489499        else: 
     
    511521    def flatten_data(self,follow, obj = None): 
    512522        val = self._get_val_from_obj(obj) 
    513523        date_field, time_field = self.get_manipulator_field_names('') 
    514         return {date_field: (val is not None and val.strftime("%Y-%m-%d") or ''), 
    515                 time_field: (val is not None and val.strftime("%H:%M:%S") or '')} 
     524        #cx_Oracle does not support strftime  
     525        if (settings.DATABASE_ENGINE=='oracle'):  
     526            return {date_field: (val is not None or ''),  
     527                    time_field: (val is not None or '')}  
     528        else:  
     529            return {date_field: (val is not None and val.strftime("%Y-%m-%d") or ''),  
     530                    time_field: (val is not None and val.strftime("%H:%M:%S") or '')} 
    516531 
    517532class EmailField(CharField): 
    518533    def __init__(self, *args, **kwargs): 
     
    744759            # doesn't support microseconds. 
    745760            if settings.DATABASE_ENGINE == 'mysql': 
    746761                value = value.replace(microsecond=0) 
    747             value = str(value) 
     762                value = str(value)  
     763            elif settings.DATABASE_ENGINE == 'oracle':  
     764                value = value.replace(microsecond=0)  
     765                # cx_Oracle expects a datetime.datetime to persist into TIMESTAMP field. 
     766                value = datetime.datetime(1900, 1, 1, value.hour, value.minute, value.second) 
     767            else:  
     768                value = str(value) 
    748769        return Field.get_db_prep_save(self, value) 
    749770 
    750771    def get_manipulator_field_objs(self): 
  • db/models/query.py

     
    33from django.db.models import signals 
    44from django.dispatch import dispatcher 
    55from django.utils.datastructures import SortedDict 
     6from django.conf import settings 
    67import operator 
    78import re 
    89 
     
    168169        extra_select = self._select.items() 
    169170 
    170171        cursor = connection.cursor() 
    171         select, sql, params = self._get_sql_clause() 
    172         cursor.execute("SELECT " + (self._distinct and "DISTINCT " or "") + ",".join(select) + sql, params) 
     172        select, sql, params, full_query = self._get_sql_clause()  
     173 
     174        if not full_query:  
     175            cursor.execute("SELECT " + (self._distinct and "DISTINCT " or "") + ",".join(select) + sql, params)  
     176        else:  
     177            cursor.execute(full_query, params)  
    173178        fill_cache = self._select_related 
    174179        index_end = len(self.model._meta.fields) 
    175180        while 1: 
     
    192197        counter._offset = None 
    193198        counter._limit = None 
    194199        counter._select_related = False 
    195         select, sql, params = counter._get_sql_clause() 
     200        select, sql, params, full_query = counter._get_sql_clause()  
    196201        cursor = connection.cursor() 
    197202        if self._distinct: 
    198203            id_col = "%s.%s" % (backend.quote_name(self.model._meta.db_table), 
     
    501506            sql.append("ORDER BY " + ", ".join(order_by)) 
    502507 
    503508        # LIMIT and OFFSET clauses 
    504         if self._limit is not None: 
    505             sql.append("%s " % backend.get_limit_offset_sql(self._limit, self._offset)) 
     509        if (settings.DATABASE_ENGINE != 'oracle'):              
     510            if self._limit is not None: 
     511                sql.append("%s " % backend.get_limit_offset_sql(self._limit, self._offset)) 
     512            else: 
     513                assert self._offset is None, "'offset' is not allowed without 'limit'" 
     514 
     515            return select, " ".join(sql), params 
    506516        else: 
    507             assert self._offset is None, "'offset' is not allowed without 'limit'" 
     517            # To support limits and offsets, Oracle requires some funky rewriting of an otherwise normal looking query.  
     518            select_clause = ",".join(select)  
     519            distinct = (self._distinct and "DISTINCT " or "")  
    508520 
    509         return select, " ".join(sql), params 
     521            if order_by:   
     522                order_by_clause = " OVER (ORDER BY %s )" % (", ".join(order_by))  
     523            else: 
     524                #Oracle's row_number() function always requires an order-by clause.  
     525                #So we need to define a default order-by, since none was provided.  
     526                order_by_clause = " OVER (ORDER BY %s.%s)" % \ 
     527                    (backend.quote_name(opts.db_table),   
     528                    backend.quote_name(opts.fields[0].db_column or opts.fields[0].column))  
     529            # limit_and_offset_clause  
     530            offset = self._offset and int(self._offset) or 0  
     531            limit = self._limit and int(self._limit) or None  
     532            limit_and_offset_clause = ''  
     533            if limit:  
     534                limit_and_offset_clause = "WHERE rn > %s AND rn <= %s" % (offset, limit+offset)  
     535            elif offset: 
     536                limit_and_offset_clause = "WHERE rn > %s" % (offset)  
    510537 
     538            if len(limit_and_offset_clause) > 0:  
     539                full_query = """SELECT * FROM   
     540                    (SELECT %s     
     541                    %s,  
     542                    ROW_NUMBER() %s AS rn  
     543                    %s  
     544                    )  
     545                    %s  
     546                    """ % (distinct, select_clause, order_by_clause, " ".join(sql), limit_and_offset_clause) 
     547            else: 
     548                full_query = None  
     549              
     550            return select, " ".join(sql), params, full_query 
    511551class ValuesQuerySet(QuerySet): 
    512552    def iterator(self): 
    513553        # select_related and select aren't supported in values(). 
     
    523563            field_names = [f.attname for f in self.model._meta.fields] 
    524564 
    525565        cursor = connection.cursor() 
    526         select, sql, params = self._get_sql_clause() 
     566        select, sql, params, full_query = self._get_sql_clause()  
    527567        select = ['%s.%s' % (backend.quote_name(self.model._meta.db_table), backend.quote_name(c)) for c in columns] 
    528568        cursor.execute("SELECT " + (self._distinct and "DISTINCT " or "") + ",".join(select) + sql, params) 
    529569        while 1: 
     
    636676    if table_prefix.endswith('.'): 
    637677        table_prefix = backend.quote_name(table_prefix[:-1])+'.' 
    638678    field_name = backend.quote_name(field_name) 
     679    #put some oracle exceptions here  
     680    if lookup_type == "icontains" and settings.DATABASE_ENGINE == 'oracle':  
     681        return 'lower(%s%s) %s' % (table_prefix, field_name, (backend.OPERATOR_MAPPING[lookup_type] % '%s'))  
    639682    try: 
    640683        return '%s%s %s' % (table_prefix, field_name, (backend.OPERATOR_MAPPING[lookup_type] % '%s')) 
    641684    except KeyError: 
     
    667710    Helper function that recursively populates the select, tables and where (in 
    668711    place) for select_related queries. 
    669712    """ 
     713    from django.db.models.fields import AutoField  
    670714    qn = backend.quote_name 
    671715    for f in opts.fields: 
    672716        if f.rel and not f.null: 
     
    680724            cache_tables_seen.append(db_table) 
    681725            where.append('%s.%s = %s.%s' % \ 
    682726                (qn(old_prefix), qn(f.column), qn(db_table), qn(f.rel.get_related_field().column))) 
    683             select.extend(['%s.%s' % (qn(db_table), qn(f2.column)) for f2 in f.rel.to._meta.fields]) 
     727            if settings.DATABASE_ENGINE == 'oracle': 
     728                select.extend(['%s.%s' % (backend.quote_name(db_table), backend.quote_name(f2.column)) for f2 in f.rel.to._meta.fields if not isinstance(f2, AutoField)])  
     729            else: 
     730                select.extend(['%s.%s' % (backend.quote_name(db_table), backend.quote_name(f2.column)) for f2 in f.rel.to._meta.fields])  
    684731            fill_table_cache(f.rel.to._meta, select, tables, where, db_table, cache_tables_seen) 
    685732 
    686733def parse_lookup(kwarg_items, opts):