cubicweb: comparison server/sources/native.py

equal deleted inserted replaced

-:ffb269e60348
+:729f36a1bcfa
 res = self._eid_type_source(cnx, eid, sql)
 if not isinstance(res, list):
 res = list(res)
 if res[-1] is not None:
 res[-1] = b64decode(res[-1])
-res.append(res[1])
+res.append("system")
 return res
 def extid2eid(self, cnx, extid):
 """get eid from an external id. Return None if no record found."""
 assert isinstance(extid, str)
 The backup and restore methods are used to dump / restore the
 system database in a database independent format. The file is a
 Zip archive containing the following files:
-* format.txt: the format of the archive. Currently '1.0'
+* format.txt: the format of the archive. Currently '1.1'
 * tables.txt: list of filenames in the archive tables/ directory
 * sequences.txt: list of filenames in the archive sequences/ directory
+* numranges.txt: list of filenames in the archive numrange/ directory
 * versions.txt: the list of cube versions from CWProperty
 * tables/<tablename>.<chunkno>: pickled data
 * sequences/<sequencename>: pickled data
-The pickled data format for tables and sequences is a tuple of 3 elements:
+The pickled data format for tables, numranges and sequences is a tuple of 3 elements:
 * the table name
 * a tuple of column names
 * a list of rows (as tuples with one element per column)
 Tables are saved in chunks in different files in order to prevent
 self.logger.info('writing metadata')
 self.write_metadata(archive)
 for seq in self.get_sequences():
 self.logger.info('processing sequence %s', seq)
 self.write_sequence(archive, seq)
+for numrange in self.get_numranges():
+self.logger.info('processing numrange %s', numrange)
+self.write_numrange(archive, numrange)
 for table in self.get_tables():
 self.logger.info('processing table %s', table)
 self.write_table(archive, table)
 finally:
 archive.close()
 continue
 relation_tables.append('%s_relation' % rtype)
 return non_entity_tables + etype_tables + relation_tables
 def get_sequences(self):
+return []
+def get_numranges(self):
 return ['entities_id_seq']
 def write_metadata(self, archive):
-archive.writestr('format.txt', '1.0')
+archive.writestr('format.txt', '1.1')
 archive.writestr('tables.txt', '\n'.join(self.get_tables()))
 archive.writestr('sequences.txt', '\n'.join(self.get_sequences()))
+archive.writestr('numranges.txt', '\n'.join(self.get_numranges()))
 versions = self._get_versions()
 versions_str = '\n'.join('%s %s' % (k, v)
 for k, v in versions)
 archive.writestr('versions.txt', versions_str)
 sql = self.dbhelper.sql_sequence_current_state(seq)
 columns, rows_iterator = self._get_cols_and_rows(sql)
 rows = list(rows_iterator)
 serialized = self._serialize(seq, columns, rows)
 archive.writestr('sequences/%s' % seq, serialized)
+def write_numrange(self, archive, numrange):
+sql = self.dbhelper.sql_numrange_current_state(numrange)
+columns, rows_iterator = self._get_cols_and_rows(sql)
+rows = list(rows_iterator)
+serialized = self._serialize(numrange, columns, rows)
+archive.writestr('numrange/%s' % numrange, serialized)
 def write_table(self, archive, table):
 nb_lines_sql = 'SELECT COUNT(*) FROM %s' % table
 self.cursor.execute(nb_lines_sql)
 rowcount = self.cursor.fetchone()[0]
 def restore(self, backupfile):
 archive = zipfile.ZipFile(backupfile, 'r', allowZip64=True)
 self.cnx = self.get_connection()
 self.cursor = self.cnx.cursor()
-sequences, tables, table_chunks = self.read_metadata(archive, backupfile)
+sequences, numranges, tables, table_chunks = self.read_metadata(archive, backupfile)
 for seq in sequences:
 self.logger.info('restoring sequence %s', seq)
 self.read_sequence(archive, seq)
+for numrange in numranges:
+self.logger.info('restoring numrange %s', seq)
+self.read_numrange(archive, numrange)
 for table in tables:
 self.logger.info('restoring table %s', table)
 self.read_table(archive, table, sorted(table_chunks[table]))
 self.cnx.close()
 archive.close()
 self.logger.info('done')
 def read_metadata(self, archive, backupfile):
 formatinfo = archive.read('format.txt')
 self.logger.info('checking metadata')
-if formatinfo.strip() != "1.0":
+if formatinfo.strip() != "1.1":
 self.logger.critical('Unsupported format in archive: %s', formatinfo)
 raise ValueError('Unknown format in %s: %s' % (backupfile, formatinfo))
 tables = archive.read('tables.txt').splitlines()
 sequences = archive.read('sequences.txt').splitlines()
+numranges = archive.read('numranges.txt').splitlines()
 file_versions = self._parse_versions(archive.read('versions.txt'))
 versions = set(self._get_versions())
 if file_versions != versions:
 self.logger.critical('Unable to restore : versions do not match')
 self.logger.critical('Expected:\n%s', '\n'.join('%s : %s' % (cube, ver)
 if not name.startswith('tables/'):
 continue
 filename = basename(name)
 tablename, _ext = filename.rsplit('.', 1)
 table_chunks.setdefault(tablename, []).append(name)
-return sequences, tables, table_chunks
+return sequences, numranges, tables, table_chunks
 def read_sequence(self, archive, seq):
 seqname, columns, rows = loads(archive.read('sequences/%s' % seq))
 assert seqname == seq
 assert len(rows) == 1
 assert len(rows[0]) == 1
 value = rows[0][0]
 sql = self.dbhelper.sql_restart_sequence(seq, value)
+self.cursor.execute(sql)
+self.cnx.commit()
+def read_numrange(self, archive, numrange):
+rangename, columns, rows = loads(archive.read('numrange/%s' % numrange))
+assert rangename == numrange
+assert len(rows) == 1
+assert len(rows[0]) == 1
+value = rows[0][0]
+sql = self.dbhelper.sql_restart_numrange(numrange, value)
 self.cursor.execute(sql)
 self.cnx.commit()
 def read_table(self, archive, table, filenames):
 merge_args = self._source.merge_args

changeset 10301	729f36a1bcfa
parent 10265	9bdc74142164
parent 10272	3231fd2fa7a5
child 10351	91e63306e277