Hello community, here is the log from the commit of package trytond for openSUSE:Factory checked in at 2018-07-21 10:25:09 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/trytond (Old) and /work/SRC/openSUSE:Factory/.trytond.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "trytond" Sat Jul 21 10:25:09 2018 rev:21 rq:624101 version:4.2.13 Changes: -------- --- /work/SRC/openSUSE:Factory/trytond/trytond.changes 2018-06-20 15:23:26.795293551 +0200 +++ /work/SRC/openSUSE:Factory/.trytond.new/trytond.changes 2018-07-21 10:25:15.226956997 +0200 @@ -1,0 +2,11 @@ +Thu Jul 19 15:19:55 UTC 2018 - [email protected] + +- trytond42_psql10.diff applied for postgres10 compatibility + Kudos to [email protected]! + +------------------------------------------------------------------- +Wed Jul 11 12:35:03 UTC 2018 - [email protected] + +- Version 4.2.13 - Bugfix Release + +------------------------------------------------------------------- Old: ---- trytond-4.2.12.tar.gz New: ---- trytond-4.2.13.tar.gz trytond42_psql10.diff ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ trytond.spec ++++++ --- /var/tmp/diff_new_pack.cAhyvG/_old 2018-07-21 10:25:15.838956848 +0200 +++ /var/tmp/diff_new_pack.cAhyvG/_new 2018-07-21 10:25:15.838956848 +0200 @@ -20,7 +20,7 @@ %define majorver 4.2 %define base_name tryton Name: trytond -Version: %{majorver}.12 +Version: %{majorver}.13 Release: 0 Summary: An Enterprise Resource Planning (ERP) system @@ -35,9 +35,12 @@ Source4: %{name}_log.conf # GNU Health patch for user login Patch0: trytond_get_login.patch +Patch1: trytond42_psql10.diff Source20: %{name}.service # List of additional build dependencies BuildRequires: fdupes +BuildRequires: postgresql +BuildRequires: postgresql-server BuildRequires: python3-Werkzeug BuildRequires: python3-bcrypt BuildRequires: python3-lxml @@ -47,10 +50,8 @@ BuildRequires: python3-setuptools BuildRequires: python3-wrapt BuildRequires: systemd-rpm-macros -BuildRequires: postgresql -BuildRequires: postgresql96-server Requires: libreoffice-pyuno -Requires: postgresql96-server +Requires: postgresql-server Requires: python3-Genshi Requires: python3-Levenshtein Requires: python3-Sphinx @@ -69,7 +70,7 @@ Requires(pre): /usr/sbin/groupadd Requires(pre): /usr/sbin/useradd # Post requires update-alternatives to install tool update-alternatives. -Requires(post): update-alternatives +#Requires(post): update-alternatives BuildRoot: %{_tmppath}/%{name}-%{version}-build BuildArch: noarch @@ -88,6 +89,7 @@ cp %{S:1} . cp %{S:2} . %patch0 -p0 +%patch1 -p1 -F2 %build python3 setup.py build @@ -115,7 +117,7 @@ %post %service_add_post trytond.service # Postgresql 96 is required for tryton series 4.2.x! -update-alternatives --set postgresql /usr/lib/postgresql96 +#update-alternatives --set postgresql /usr/lib/postgresql96 %preun %service_del_preun trytond.service ++++++ trytond-4.2.12.tar.gz -> trytond-4.2.13.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/trytond-4.2.12/.hgtags new/trytond-4.2.13/.hgtags --- old/trytond-4.2.12/.hgtags 2018-06-11 10:12:39.000000000 +0200 +++ new/trytond-4.2.13/.hgtags 2018-07-05 11:33:50.000000000 +0200 @@ -27,3 +27,4 @@ 85cd8ba33305eb48db50a52d7d8eb473f6387850 4.2.10 0da6fb844986da58c8fff6eacd54ee8ba0708cf7 4.2.11 c2fa5cf885b7e4af05c338bc4ccfdb2f59e5c0a4 4.2.12 +197e594bd737b72af1ea4ceb33d615d4eaadce9d 4.2.13 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/trytond-4.2.12/CHANGELOG new/trytond-4.2.13/CHANGELOG --- old/trytond-4.2.12/CHANGELOG 2018-06-11 10:12:39.000000000 +0200 +++ new/trytond-4.2.13/CHANGELOG 2018-07-05 11:33:49.000000000 +0200 @@ -1,3 +1,6 @@ +Version 4.2.13 - 2018-07-05 +* Bug fixes (see mercurial logs for details) + Version 4.2.12 - 2018-06-11 * Bug fixes (see mercurial logs for details) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/trytond-4.2.12/PKG-INFO new/trytond-4.2.13/PKG-INFO --- old/trytond-4.2.12/PKG-INFO 2018-06-11 10:12:40.000000000 +0200 +++ new/trytond-4.2.13/PKG-INFO 2018-07-05 11:33:51.000000000 +0200 @@ -1,6 +1,6 @@ Metadata-Version: 1.1 Name: trytond -Version: 4.2.12 +Version: 4.2.13 Summary: Tryton server Home-page: http://www.tryton.org/ Author: Tryton diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/trytond-4.2.12/doc/ref/models/models.rst new/trytond-4.2.13/doc/ref/models/models.rst --- old/trytond-4.2.12/doc/ref/models/models.rst 2018-05-07 23:07:37.000000000 +0200 +++ new/trytond-4.2.13/doc/ref/models/models.rst 2018-07-05 11:33:47.000000000 +0200 @@ -281,6 +281,7 @@ Duplicate the records. ``default`` is a dictionary of default value for the created records. + New records are returned following the input order. .. classmethod:: ModelStorage.search(domain[, offset[, limit[, order[, count]]]]) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/trytond-4.2.12/trytond/__init__.py new/trytond-4.2.13/trytond/__init__.py --- old/trytond-4.2.12/trytond/__init__.py 2018-05-07 23:08:12.000000000 +0200 +++ new/trytond-4.2.13/trytond/__init__.py 2018-06-11 10:13:12.000000000 +0200 @@ -5,7 +5,7 @@ import logging from email import charset -__version__ = "4.2.12" +__version__ = "4.2.13" logger = logging.getLogger(__name__) os.environ['TZ'] = 'UTC' diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/trytond-4.2.12/trytond/ir/model.py new/trytond-4.2.13/trytond/ir/model.py --- old/trytond-4.2.12/trytond/ir/model.py 2017-11-10 11:38:17.000000000 +0100 +++ new/trytond-4.2.13/trytond/ir/model.py 2018-07-05 11:33:47.000000000 +0200 @@ -287,15 +287,6 @@ where=ir_model_field.id == model_fields[field_name]['id'])) - # Clean ir_model_field from field that are no more existing. - for field_name in model_fields: - if model_fields[field_name]['module'] == module_name \ - and field_name not in model._fields: - # XXX This delete field even when it is defined later - # in the module - cursor.execute(*ir_model_field.delete( - where=ir_model_field.id == - model_fields[field_name]['id'])) @staticmethod def default_name(): diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/trytond-4.2.12/trytond/model/fields/field.py new/trytond-4.2.13/trytond/model/fields/field.py --- old/trytond-4.2.12/trytond/model/fields/field.py 2018-01-04 23:49:32.000000000 +0100 +++ new/trytond-4.2.13/trytond/model/fields/field.py 2018-07-05 11:33:47.000000000 +0200 @@ -26,9 +26,10 @@ elif (isinstance(arg, tuple) or (isinstance(arg, list) and len(arg) > 2 - and ((arg[1] in OPERATORS) + and ((isinstance(arg[1], basestring) + and arg[1] in OPERATORS) or (isinstance(arg[1], PYSON) - and arg[1].types() == set([str]))))): + and arg[1].types() == set([str]))))): pass elif isinstance(arg, list): if not test_domain(arg): diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/trytond-4.2.12/trytond/model/modelstorage.py new/trytond-4.2.13/trytond/model/modelstorage.py --- old/trytond-4.2.12/trytond/model/modelstorage.py 2018-03-01 22:50:25.000000000 +0100 +++ new/trytond-4.2.13/trytond/model/modelstorage.py 2018-07-05 11:33:47.000000000 +0200 @@ -335,7 +335,7 @@ data = convert_data(field_defs, datas[id]) to_create.append(data) new_records = cls.create(to_create) - new_ids = dict(izip(ids, map(int, new_records))) + id2new_record = dict(izip(ids, new_records)) fields_translate = {} for field_name, field in field_defs.iteritems(): @@ -355,11 +355,13 @@ fuzzy_translation=False): datas = cls.read(ids, fields_names=fields_translate.keys() + ['id']) + to_write = [] for data in datas: - data_id = data['id'] - data = convert_data(fields_translate, data) - cls.write([cls(new_ids[data_id])], data) - return cls.browse(new_ids.values()) + to_write.append([id2new_record[data['id']]]) + to_write.append( + convert_data(fields_translate, data)) + cls.write(*to_write) + return new_records @classmethod def search(cls, domain, offset=0, limit=None, order=None, count=False): diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/trytond-4.2.12/trytond/tests/test_modelstorage.py new/trytond-4.2.13/trytond/tests/test_modelstorage.py --- old/trytond-4.2.12/trytond/tests/test_modelstorage.py 2017-05-03 18:52:27.000000000 +0200 +++ new/trytond-4.2.13/trytond/tests/test_modelstorage.py 2018-07-05 11:33:47.000000000 +0200 @@ -37,6 +37,26 @@ all(x['name'] >= y['name'] for x, y in zip(rows, rows[1:]))) @with_transaction() + def test_copy_order(self): + "Test copy order" + pool = Pool() + ModelStorage = pool.get('test.modelstorage') + + # Use both order to avoid false positive by chance + records = ModelStorage.create( + [{'name': n} for n in ['foo', 'bar', 'test']]) + new_records = ModelStorage.copy(records) + reversed_records = list(reversed(records)) + new_reversed_records = ModelStorage.copy(reversed_records) + + self.assertListEqual( + [r.name for r in records], + [r.name for r in new_records]) + self.assertListEqual( + [r.name for r in reversed_records], + [r.name for r in new_reversed_records]) + + @with_transaction() def test_search_count(self): "Test search_count" pool = Pool() diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/trytond-4.2.12/trytond.egg-info/PKG-INFO new/trytond-4.2.13/trytond.egg-info/PKG-INFO --- old/trytond-4.2.12/trytond.egg-info/PKG-INFO 2018-06-11 10:12:40.000000000 +0200 +++ new/trytond-4.2.13/trytond.egg-info/PKG-INFO 2018-07-05 11:33:50.000000000 +0200 @@ -1,6 +1,6 @@ Metadata-Version: 1.1 Name: trytond -Version: 4.2.12 +Version: 4.2.13 Summary: Tryton server Home-page: http://www.tryton.org/ Author: Tryton ++++++ trytond42_psql10.diff ++++++ # Copyright (c) 2018 Mathias Behrle <[email protected]> diff --git a/trytond/backend/database.py b/trytond/backend/database.py index 22567cd61c7683ee88cb0e38c732a3a5ffb6b887..bff64d62fb45d0dbb45de5972375cb76414f1be4 100644 --- a/trytond/backend/database.py +++ b/trytond/backend/database.py @@ -172,3 +172,46 @@ class DatabaseInterface(object): def has_multirow_insert(self): 'Return True if database supports multirow insert' return False + + @classmethod + def has_sequence(cls): + "Return if database supports sequence querying and assignation" + return False + + def sequence_exist(self, connection, name): + "Return if a sequence exists" + if not self.has_sequence(): + return + raise NotImplementedError + + def sequence_create( + self, connection, name, number_increment=1, start_value=1): + "Creates a sequence" + if not self.has_sequence(): + return + raise NotImplementedError + + def sequence_update( + self, connection, name, number_increment=1, start_value=1): + "Modifies a sequence" + if not self.has_sequence(): + return + raise NotImplementedError + + def sequence_rename(self, connection, old_name, new_name): + "Renames a sequence" + if not self.has_sequence(): + return + raise NotImplementedError + + def sequence_delete(self, connection, name): + "Removes a sequence" + if not self.has_sequence(): + return + raise NotImplementedError + + def sequence_next_number(self, connection, name): + "Gets the next number of a sequence" + if not self.has_sequence(): + return + raise NotImplementedError diff --git a/trytond/backend/mysql/table.py b/trytond/backend/mysql/table.py index bfe6031250787a0ed0d593dd4822ec25bb596b55..c09065f37ccf2c242007e69a44bf111e4e1e8632 100644 --- a/trytond/backend/mysql/table.py +++ b/trytond/backend/mysql/table.py @@ -75,14 +75,6 @@ class TableHandler(TableHandlerInterface): cursor.execute('ALTER TABLE `%s` RENAME TO `%s`' % (old_history, new_history)) - @staticmethod - def sequence_exist(sequence_name): - return True - - @staticmethod - def sequence_rename(old_name, new_name): - pass - def column_exist(self, column_name): return column_name in self._columns diff --git a/trytond/backend/postgresql/database.py b/trytond/backend/postgresql/database.py index 505973a8785ca5c11889aa757222a9242acb182a..6967b7d28c73d1968b216d57814a604f5af10199 100644 --- a/trytond/backend/postgresql/database.py +++ b/trytond/backend/postgresql/database.py @@ -2,7 +2,6 @@ # this repository contains the full copyright notices and license terms. import time import logging -import re import os import urllib from decimal import Decimal @@ -34,8 +33,6 @@ __all__ = ['Database', 'DatabaseIntegrityError', 'DatabaseOperationalError'] logger = logging.getLogger(__name__) -RE_VERSION = re.compile(r'\S+ (\d+)\.(\d+)') - os.environ['PGTZ'] = os.environ.get('TZ', '') @@ -131,10 +128,11 @@ class Database(DatabaseInterface): def get_version(self, connection): if self.name not in self._version_cache: cursor = connection.cursor() - cursor.execute('SELECT version()') + cursor.execute('SHOW server_version_num') version, = cursor.fetchone() - self._version_cache[self.name] = tuple(map(int, - RE_VERSION.search(version).groups())) + major, rest = divmod(int(version), 10000) + minor, patch = divmod(rest, 100) + self._version_cache[self.name] = (major, minor, patch) return self._version_cache[self.name] @staticmethod @@ -353,6 +351,80 @@ class Database(DatabaseInterface): self.put_connection(connection) return self._search_path + @classmethod + def has_sequence(cls): + return True + + def sequence_exist(self, connection, name): + cursor = connection.cursor() + for schema in self.search_path: + cursor.execute('SELECT 1 ' + 'FROM information_schema.sequences ' + 'WHERE sequence_name = %s AND sequence_schema = %s', + (name, schema)) + if cursor.rowcount: + return True + return False + + def sequence_create( + self, connection, name, number_increment=1, start_value=1): + cursor = connection.cursor() + + param = self.flavor.param + cursor.execute( + 'CREATE SEQUENCE "%s" ' + 'INCREMENT BY %s ' + 'START WITH %s' + % (name, param, param), + (number_increment, start_value)) + + def sequence_update( + self, connection, name, number_increment=1, start_value=1): + cursor = connection.cursor() + param = self.flavor.param + cursor.execute( + 'ALTER SEQUENCE "%s" ' + 'INCREMENT BY %s ' + 'RESTART WITH %s' + % (name, param, param), + (number_increment, start_value)) + + def sequence_rename(self, connection, old_name, new_name): + cursor = connection.cursor() + if (self.sequence_exist(connection, old_name) + and not self.sequence_exist(connection, new_name)): + cursor.execute('ALTER TABLE "%s" RENAME TO "%s"' + % (old_name, new_name)) + + def sequence_delete(self, connection, name): + cursor = connection.cursor() + cursor.execute('DROP SEQUENCE "%s"' % name) + + def sequence_next_number(self, connection, name): + cursor = connection.cursor() + version = self.get_version(connection) + if version >= (10, 0): + cursor.execute( + 'SELECT increment_by ' + 'FROM pg_sequences ' + 'WHERE sequencename=%s ' + % self.flavor.param, + (name,)) + increment, = cursor.fetchone() + cursor.execute( + 'SELECT CASE WHEN NOT is_called THEN last_value ' + 'ELSE last_value + %s ' + 'END ' + 'FROM "%s"' % (self.flavor.param, name), + (increment,)) + else: + cursor.execute( + 'SELECT CASE WHEN NOT is_called THEN last_value ' + 'ELSE last_value + increment_by ' + 'END ' + 'FROM "%s"' % name) + return cursor.fetchone()[0] + register_type(UNICODE) if PYDATE: register_type(PYDATE) diff --git a/trytond/backend/postgresql/table.py b/trytond/backend/postgresql/table.py index a3323041c98be880cf9053b98589dc78e16265b5..8cae6ca12fcacf5a5cdd924416f26ef0ca7ca7bf 100644 --- a/trytond/backend/postgresql/table.py +++ b/trytond/backend/postgresql/table.py @@ -22,8 +22,10 @@ class TableHandler(TableHandlerInterface): transaction = Transaction() cursor = transaction.connection.cursor() # Create sequence if necessary - if not self.sequence_exist(self.sequence_name): - cursor.execute('CREATE SEQUENCE "%s"' % self.sequence_name) + if not transaction.database.sequence_exist( + transaction.connection, self.sequence_name): + transaction.database.sequence_create( + transaction.connection, self.sequence_name) # Create new table if necessary if not self.table_exist(self.table_name): @@ -81,7 +83,8 @@ class TableHandler(TableHandlerInterface): @staticmethod def table_rename(old_name, new_name): - cursor = Transaction().connection.cursor() + transaction = Transaction() + cursor = transaction.connection.cursor() # Rename table if (TableHandler.table_exist(old_name) and not TableHandler.table_exist(new_name)): @@ -90,7 +93,8 @@ class TableHandler(TableHandlerInterface): # Rename sequence old_sequence = old_name + '_id_seq' new_sequence = new_name + '_id_seq' - TableHandler.sequence_rename(old_sequence, new_sequence) + transaction.database.sequence_rename( + transaction.connection, old_sequence, new_sequence) # Rename history table old_history = old_name + "__history" new_history = new_name + "__history" @@ -99,30 +103,6 @@ class TableHandler(TableHandlerInterface): cursor.execute('ALTER TABLE "%s" RENAME TO "%s"' % (old_history, new_history)) - @classmethod - def sequence_schema(cls, sequence_name): - transaction = Transaction() - cursor = transaction.connection.cursor() - for schema in transaction.database.search_path: - cursor.execute('SELECT 1 ' - 'FROM information_schema.sequences ' - 'WHERE sequence_name = %s AND sequence_schema = %s', - (sequence_name, schema)) - if cursor.rowcount: - return schema - - @classmethod - def sequence_exist(cls, sequence_name): - return bool(cls.sequence_schema(sequence_name)) - - @staticmethod - def sequence_rename(old_name, new_name): - cursor = Transaction().connection.cursor() - if (TableHandler.sequence_exist(old_name) - and not TableHandler.sequence_exist(new_name)): - cursor.execute('ALTER TABLE "%s" RENAME TO "%s"' - % (old_name, new_name)) - def column_exist(self, column_name): return column_name in self._columns diff --git a/trytond/backend/table.py b/trytond/backend/table.py index 887d415af80a3f69061808797b70621f73c0108d..853c51918e0b918f0aa9ad392eac7d22697990dd 100644 --- a/trytond/backend/table.py +++ b/trytond/backend/table.py @@ -46,26 +46,6 @@ class TableHandlerInterface(object): ''' raise NotImplementedError - @staticmethod - def sequence_exist(sequence_name): - ''' - Sequence exist - - :param sequence_name: the sequence name - :return: a boolean - ''' - raise NotImplementedError - - @staticmethod - def sequence_rename(old_name, new_name): - ''' - Rename sequence - - :param old_name: the old sequence name - :param new_name: the new sequence name - ''' - raise NotImplementedError - def column_exist(self, column_name): ''' Column exist diff --git a/trytond/ir/sequence.py b/trytond/ir/sequence.py index 21bc3c12ee62990ce91fe675520582e3db8c41a8..f6791cf692fb6f9161d7a8607c01f638a576309d 100644 --- a/trytond/ir/sequence.py +++ b/trytond/ir/sequence.py @@ -3,7 +3,7 @@ from string import Template import time from itertools import izip -from sql import Flavor +from sql import Literal, For from ..model import ModelView, ModelSQL, fields, Check from ..tools import datetime_strftime @@ -16,7 +16,7 @@ __all__ = [ 'SequenceType', 'Sequence', 'SequenceStrict', ] -sql_sequence = backend.name() == 'postgresql' +sql_sequence = backend.get('Database').has_sequence() class SequenceType(ModelSQL, ModelView): @@ -104,6 +104,7 @@ class Sequence(ModelSQL, ModelView): def __register__(cls, module_name): TableHandler = backend.get('TableHandler') table = TableHandler(cls, module_name) + transaction = Transaction() # Migration from 2.0 rename number_next into number_next_internal table.column_rename('number_next', 'number_next_internal') @@ -116,8 +117,8 @@ class Sequence(ModelSQL, ModelView): for sequence in sequences: if sequence.type != 'incremental': continue - if not TableHandler.sequence_exist( - sequence._sql_sequence_name): + if not transaction.database.sequence_exist( + transaction.connection, sequence._sql_sequence_name): sequence.create_sql_sequence(sequence.number_next_internal) @staticmethod @@ -159,14 +160,11 @@ class Sequence(ModelSQL, ModelView): def get_number_next(self, name): if self.type != 'incremental': return - cursor = Transaction().connection.cursor() - sql_name = self._sql_sequence_name + + transaction = Transaction() if sql_sequence and not self._strict: - cursor.execute('SELECT ' - 'CASE WHEN NOT is_called THEN last_value ' - 'ELSE last_value + increment_by ' - 'END FROM "%s"' % sql_name) - return cursor.fetchone()[0] + return transaction.database.sequence_next_number( + transaction.connection, self._sql_sequence_name) else: return self.number_next_internal @@ -260,22 +258,22 @@ class Sequence(ModelSQL, ModelView): def create_sql_sequence(self, number_next=None): 'Create the SQL sequence' - cursor = Transaction().connection.cursor() - param = Flavor.get().param + transaction = Transaction() + if self.type != 'incremental': return if number_next is None: number_next = self.number_next - cursor.execute('CREATE SEQUENCE "' + self._sql_sequence_name - + '" INCREMENT BY ' + param + ' START WITH ' + param, - (self.number_increment, number_next)) + if sql_sequence: + transaction.database.sequence_create(transaction.connection, + self._sql_sequence_name, self.number_increment, number_next) def update_sql_sequence(self, number_next=None): 'Update the SQL sequence' - TableHandler = backend.get('TableHandler') - cursor = Transaction().connection.cursor() - param = Flavor.get().param - exist = TableHandler.sequence_exist(self._sql_sequence_name) + transaction = Transaction() + + exist = transaction.database.sequence_exist( + transaction.connection, self._sql_sequence_name) if self.type != 'incremental': if exist: self.delete_sql_sequence() @@ -285,17 +283,16 @@ class Sequence(ModelSQL, ModelView): return if number_next is None: number_next = self.number_next - cursor.execute('ALTER SEQUENCE "' + self._sql_sequence_name - + '" INCREMENT BY ' + param + ' RESTART WITH ' + param, - (self.number_increment, number_next)) + transaction.database.sequence_update(transaction.connection, + self._sql_sequence_name, self.number_increment, number_next) def delete_sql_sequence(self): 'Delete the SQL sequence' - cursor = Transaction().connection.cursor() + transaction = Transaction() if self.type != 'incremental': return - cursor.execute('DROP SEQUENCE "%s"' - % self._sql_sequence_name) + transaction.database.sequence_delete( + transaction.connection, self._sql_sequence_name) @staticmethod def _process(string, date=None): diff --git a/trytond/res/ir.py b/trytond/res/ir.py index 754a6226a6b5e1d7aca4b5575ed8232f9525eb2a..0265c46e4e6857753613a27d6a44575d003c4718 100644 --- a/trytond/res/ir.py +++ b/trytond/res/ir.py @@ -3,6 +3,7 @@ from ..model import ModelSQL, fields from .. import backend from ..pool import Pool, PoolMeta +from ..transaction import Transaction __all__ = [ 'UIMenuGroup', 'ActionGroup', 'ModelFieldGroup', 'ModelButtonGroup', @@ -23,10 +24,11 @@ class UIMenuGroup(ModelSQL): @classmethod def __register__(cls, module_name): TableHandler = backend.get('TableHandler') + transaction = Transaction() # Migration from 1.0 table name change TableHandler.table_rename('ir_ui_menu_group_rel', cls._table) - TableHandler.sequence_rename('ir_ui_menu_group_rel_id_seq', - cls._table + '_id_seq') + transaction.database.sequence_rename(transaction.connection, + 'ir_ui_menu_group_rel_id_seq', cls._table + '_id_seq') # Migration from 2.0 menu_id and gid renamed into menu group table = TableHandler(cls, module_name) table.column_rename('menu_id', 'menu') @@ -64,10 +66,11 @@ class ActionGroup(ModelSQL): @classmethod def __register__(cls, module_name): TableHandler = backend.get('TableHandler') + transaction = Transaction() # Migration from 1.0 table name change TableHandler.table_rename('ir_action_group_rel', cls._table) - TableHandler.sequence_rename('ir_action_group_rel_id_seq', - cls._table + '_id_seq') + transaction.database.sequence_rename(transaction.connection, + 'ir_action_group_rel_id_seq', cls._table + '_id_seq') # Migration from 2.0 action_id and gid renamed into action and group table = TableHandler(cls, module_name) table.column_rename('action_id', 'action') @@ -118,10 +121,12 @@ class ModelFieldGroup(ModelSQL): @classmethod def __register__(cls, module_name): TableHandler = backend.get('TableHandler') + database = Transaction().database + transaction = Transaction() # Migration from 1.0 table name change TableHandler.table_rename('ir_model_field_group_rel', cls._table) - TableHandler.sequence_rename('ir_model_field_group_rel_id_seq', - cls._table + '_id_seq') + transaction.database.sequence_rename(transaction.connection, + 'ir_model_field_group_rel_id_seq', cls._table + '_id_seq') table = TableHandler(cls, module_name) # Migration from 2.6: field_id and group_id renamed to field and group table.column_rename('field_id', 'field') @@ -176,10 +181,11 @@ class RuleGroupGroup(ModelSQL): @classmethod def __register__(cls, module_name): TableHandler = backend.get('TableHandler') + transaction = Transaction() # Migration from 1.0 table name change TableHandler.table_rename('group_rule_group_rel', cls._table) - TableHandler.sequence_rename('group_rule_group_rel_id_seq', - cls._table + '_id_seq') + transaction.database.sequence_rename(transaction.connection, + 'group_rule_group_rel_id_seq', cls._table + '_id_seq') # Migration from 2.0 rule_group_id and group_id renamed into rule_group # and group table = TableHandler(cls, module_name) @@ -199,10 +205,11 @@ class RuleGroupUser(ModelSQL): @classmethod def __register__(cls, module_name): TableHandler = backend.get('TableHandler') + transaction = Transaction() # Migration from 1.0 table name change TableHandler.table_rename('user_rule_group_rel', cls._table) - TableHandler.sequence_rename('user_rule_group_rel_id_seq', - cls._table + '_id_seq') + transaction.database.sequence_rename(transaction.connection, + 'user_rule_group_rel_id_seq', cls._table + '_id_seq') # Migration from 2.0 rule_group_id and user_id renamed into rule_group # and user table = TableHandler(cls, module_name) diff --git a/trytond/res/user.py b/trytond/res/user.py index ac539065b01127b77540c4f3dbdca9b3383d8978..dd13df43b05f9f243d9e1e29573252c0640b7122 100644 --- a/trytond/res/user.py +++ b/trytond/res/user.py @@ -645,10 +645,12 @@ class UserGroup(ModelSQL): @classmethod def __register__(cls, module_name): TableHandler = backend.get('TableHandler') + transaction = Transaction() + # Migration from 1.0 table name change TableHandler.table_rename('res_group_user_rel', cls._table) - TableHandler.sequence_rename('res_group_user_rel_id_seq', - cls._table + '_id_seq') + transaction.database.sequence_rename(transaction.connection, + 'res_group_user_rel_id_seq', cls._table + '_id_seq') # Migration from 2.0 uid and gid rename into user and group table = TableHandler(cls, module_name) table.column_rename('uid', 'user')
