Changeset 2987

Show
Ignore:
Timestamp:
01/06/08 00:34:44 (11 months ago)
Author:
coderanger
Message:

Remove some unneeded files. Journaling support.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • boxdbplugin/0.11/boxdb/api.py

    r2986 r2987  
    1414        """Return an iterable of property names this component will handle.""" 
    1515 
    16     def decode_property(name, values): 
    17         """Return a decoded value for a property.""" 
    18  
    19     def encode_property(name, value): 
    20         """Return an encoded string for a property, suitable for storage.""" 
    21  
    2216    def render_property(name, value): 
    2317        """Return a value suitable for display.""" 
    …… 
    2822 
    2923    renderers = ExtensionPoint(IDocumentPropertyRenderer) 
    30      
     24 
    3125    implements(IEnvironmentSetupParticipant) 
    3226 
    …… 
    4135        self.found_db_version = 0 
    4236        self.upgrade_environment(self.env.get_db_cnx()) 
    43          
     37 
    4438    def environment_needs_upgrade(self, db): 
    4539        cursor = db.cursor() 
    …… 
    5347            #self.log.debug('WeatherWidgetSystem: Found db version %s, current is %s' % (self.found_db_version, db_default.version)) 
    5448            return self.found_db_version < db_default.version 
    55              
     49 
    5650    def upgrade_environment(self, db): 
    5751        db_manager, _ = DatabaseManager(self.env)._get_connector() 
    …… 
    7266                    if 'OperationalError' not in e.__class__.__name__: 
    7367                        raise e # If it is an OperationalError, just move on to the next table 
    74                              
    75                  
     68         
     69         
    7670        for tbl in db_default.tables: 
    7771            for sql in db_manager.to_sql(tbl): 
    7872                cursor.execute(sql) 
    79                      
     73             
    8074            # Try to reinsert any old data 
    8175            if tbl.name in old_data: 

  • boxdbplugin/0.11/boxdb/model.py

    r2986 r2987  
    11# Created by  on 2008-01-02. 
    22# Copyright (c) 2008 Noah Kantrowitz. All rights reserved. 
     3from datetime import datetime 
     4 
     5from trac.util.datefmt import to_timestamp, utc 
     6from trac.util.compat import set 
     7 
     8try: 
     9    import simplejson 
     10except ImportError: 
     11    import _simplejson as simplejson 
    312 
    413from boxdb.api import BoxDBSystem 
    …… 
    1120        self.env = env 
    1221        self.name = name 
     22        self._old_data = {} 
    1323         
    1424        if self.name == 'schema': 
    1525            self._bootstrap() 
    1626        else: 
    17             data = self._fetch(self.name, db) 
    18             if not data: 
     27            self._fetch(self.name, db) 
     28            if not self: 
    1929                self.type = None 
    2030                # Document doesn't exist, return a blank 
    2131                return 
    2232             
     33            self._old_data.update(self) 
     34             
    2335            # Decode the document 
    24             self.type = Document(self.env, data['__type__'][0], db) 
    25             renderers = BoxDBSystem(self.env).renderers_map 
    26             for key, value in data.iteritems(): 
    27                 key_type = self.type.get(key, 'string') 
    28                 if key_type not in renderers: 
    29                     key_type = 'string' 
    30                 self[key] = renderers[key_type].decode_property(key, value) 
     36            self.type = Document(self.env, self.type, db) 
     37            for key, value in self.iteritems(): 
     38                self[key] = simplejson.loads(value) 
    3139 
    3240    def _bootstrap(self): 
    …… 
    3644    def _fetch(self, name, db=None): 
    3745        """Retrieve the raw data for a given document.""" 
    38         data = {} 
    39          
    4046        db = db or self.env.get_db_cnx() 
    4147        cursor = db.cursor() 
    …… 
    4450        if type: 
    4551            # Fetch and decode collection 
    46             type = type[0] 
     52            type = simplejson.loads(type[0]) 
    4753            if type == self.name: 
    4854                raise ValueError('Document cannot be its own type') 
     55            self.type = type 
    4956             
    5057            # Process inheritance 
    5158            inherit = self._get_db(cursor, name, '__inherit__') 
    5259            if inherit: 
    53                 data = self._fetch(inherit[0], db) 
     60                inherit = simplejson.loads(inherit[0]) 
     61                self._fetch(inherit, db) 
    5462             
    55             local_data = {} 
    5663            cursor.execute('SELECT  key, value FROM boxdb WHERE name=%s', 
    5764                           (name,)) 
    5865            for key, value in cursor: 
    59                 local_data.setdefault(key, []).append(value) 
    60              
    61             data.update(local_data) 
    62         return data 
    63      
     66                self[key] = value 
     67 
    6468    def _get_db(self, cursor, name, key): 
    6569        """Get an iterable of raw values for a key in this document.""" 
    6670        cursor.execute('SELECT value FROM boxdb WHERE name=%s AND key=%s', 
    6771                       (name, key)) 
    68         return [v for v, in cursor] 
     72        return cursor.fetchone() 
    6973 
    7074    def save(self, db=None): 
    7175        """Save the changes to the current document.""" 
     76        author = 'coderanger' 
     77        when = None 
     78        comment = 'This is a comment' 
     79         
     80        if when is None: 
     81            when = datetime.now(utc) 
     82        when_ts = to_timestamp(when) 
     83         
    7284        handle_commit = False 
    7385        if db is None: 
    …… 
    7688        cursor = db.cursor() 
    7789         
    78         # Nuke existing data 
    79         cursor.execute('DELETE FROM boxdb WHERE name=%s', (self.name,)) 
     90        data = dict([(key, simplejson.dumps(value)) for key, value in self.iteritems()]) 
    8091         
    81         # Check that we haven't changed schemas 
    82         if self.type is None or self['__type__'] != self.type.name: 
    83             if self['__type__'] == self.name: 
    84                 raise ValueError('Document cannot be its own type') 
    85             self.type = Document(self.env, self['__type__'], db) 
    86         renderers = BoxDBSystem(self.env).renderers_map 
     92        sql_queue = [('__comment__', simplejson.dumps(comment), '')] 
     93        for key in set(data.iterkeys()) | set(self._old_data.iterkeys()): 
     94            if key not in data: 
     95                # Key deleted 
     96                cursor.execute('DELETE FROM boxdb WHERE name=%s AND key=%s', 
     97                               (self.name, key)) 
     98                sql_queue.append((key, self._old_data[key], '')) 
     99            elif key not in self._old_data: 
     100                # Key added 
     101                cursor.execute('INSERT INTO boxdb (name, key, value) VALUES (%s, %s, %s)', 
     102                               (self.name, key, data[key])) 
     103                sql_queue.append((key, '', data[key])) 
     104            elif data[key] != self._old_data[key]: 
     105                # Key changed 
     106                cursor.execute('UPDATE boxdb SET value=%s WHERE name=%s AND key=%s', 
     107                               (data[key], self.name, key)) 
     108                sql_queue.append((key, self._old_data[key], data[key])) 
    87109         
    88         data = [] 
    89         for key, value in self.itervalues(): 
    90             key_type = self.type.get(key, 'string') 
    91             if key_type not in renderers: 
    92                 key_type = 'string' 
    93             for enc in renderers[key_type].encode_property(key, value): 
    94                 data.append((self.name, key, enc)) 
    95         cursor.executemany('INSERT INTO boxdb (name, key, value) VALUES (%s, %s, %s)', ) 
     110        for key, old, new in sql_queue: 
     111            cursor.execute('INSERT INTO boxdb_changes (document, time, author, key, oldvalue, newvalue) VALUES (%s, %s, %s, %s, %s, %s)', 
     112                           (self.name, when_ts, author, key, old, new)) 
     113         
     114        if handle_commit: 
     115            db.commit() 
     116 
     117    def get_changelog(self, when=None, db=None): 
     118        """Return a iterable of the form: 
     119        (time, author, key, oldvalue, newvalue) 
     120        """ 
     121        db = db or self.env.get_db_cnx() 
     122        cursor = db.cursor() 
     123        when_ts = when and to_timestamp(when) or 0 
     124        if when_ts: 
     125            cursor.execute('SELECT time, author, key, oldvalue, newvalue ' 
     126                           'FROM boxdb_changes ' 
     127                           'WHERE document=%s AND time=%s' 
     128                           'ORDER BY time', 
     129                           (self.name, when_ts)) 
     130        else: 
     131            cursor.execute('SELECT time, author, key, oldvalue, newvalue ' 
     132                           'FROM boxdb_changes ' 
     133                           'WHERE document=%s' 
     134                           'ORDER BY time', 
     135                           (self.name,)) 
     136        for t, author, key, oldvalue, newvalue in cursor: 
     137            t = datetime.fromtimestamp(int(t), utc) 
    96138             
    97      
    98          
     139            if oldvalue: 
     140                oldvalue = simplejson.loads(oldvalue) 
     141            else: 
     142                oldvalue = None 
     143             
     144            if newvalue: 
     145                newvalue = simplejson.loads(newvalue) 
     146            else: 
     147                newvalue = None 
     148             
     149            yield t, author, key, oldvalue, newvalue 

  • boxdbplugin/0.11/boxdb/_simplejson/decoder.py

    r2986 r2987  
    44import re 
    55 
    6 from _simplejson.scanner import Scanner, pattern 
     6from scanner import Scanner, pattern 
    77 
    88FLAGS = re.VERBOSE | re.MULTILINE | re.DOTALL 

  • boxdbplugin/0.11/test_data.csv

    r2986 r2987  
    1 equipment,__type__,schema 
    2 equipment,id,string 
    3 equipment,type,string 
    4 computer,__type__,schema 
    5 computer,__inherit__,equipment 
    6 computer,os,string 
    7 computer,id,number 
    8 box,__type__,equipment 
    9 box,id,010100101 
    10 box,type,cardboard 
    11 tower,__type__,computer 
    12 tower,__inherit__,box 
    13 tower,os,xp 
    14 shuttle,__type__,computer 
    15 shuttle,__inherit__,box 
    16 shuttle,os,me 
    17 shuttle,id,12345 
     1equipment,__type__,"schema" 
     2equipment,id,"string" 
     3equipment,type,"string" 
     4computer,__type__,"schema" 
     5computer,__inherit__,"equipment" 
     6computer,os,"string" 
     7computer,id,"number" 
     8box,__type__,"equipment" 
     9box,id,"010100101" 
     10box,type,"cardboard" 
     11tower,__type__,"computer" 
     12tower,__inherit__,"box" 
     13tower,os,"xp" 
     14shuttle,__type__,"computer" 
     15shuttle,__inherit__,"box" 
     16shuttle,os,"me" 
     17shuttle,id,"12345"