def init(self): from trytond.modules import get_module_info Flavor.set(self.flavor) with self.get_connection() as conn: cursor = conn.cursor() sql_file = os.path.join(os.path.dirname(__file__), 'init.sql') with open(sql_file) as fp: for line in fp.read().split(';'): if (len(line) > 0) and (not line.isspace()): cursor.execute(line) ir_module = Table('ir_module') ir_module_dependency = Table('ir_module_dependency') for module in ('ir', 'res'): state = 'not activated' if module in ('ir', 'res'): state = 'to activate' info = get_module_info(module) insert = ir_module.insert([ ir_module.create_uid, ir_module.create_date, ir_module.name, ir_module.state ], [[0, CurrentTimestamp(), module, state]]) cursor.execute(*insert) cursor.execute('SELECT last_insert_rowid()') module_id, = cursor.fetchone() for dependency in info.get('depends', []): insert = ir_module_dependency.insert([ ir_module_dependency.create_uid, ir_module_dependency.create_date, ir_module_dependency.module, ir_module_dependency.name, ], [[0, CurrentTimestamp(), module_id, dependency]]) cursor.execute(*insert) conn.commit()
def init(cursor): from trytond.modules import get_module_info sql_file = os.path.join(os.path.dirname(__file__), 'init.sql') with open(sql_file) as fp: for line in fp.read().split(';'): if (len(line) > 0) and (not line.isspace()): cursor.execute(line) ir_module = Table('ir_module') ir_module_dependency = Table('ir_module_dependency') for module in ('ir', 'res', 'webdav'): state = 'uninstalled' if module in ('ir', 'res'): state = 'to install' info = get_module_info(module) insert = ir_module.insert([ ir_module.create_uid, ir_module.create_date, ir_module.name, ir_module.state ], [[0, CurrentTimestamp(), module, state]]) cursor.execute(*insert) cursor.execute('SELECT last_insert_rowid()') module_id, = cursor.fetchone() for dependency in info.get('depends', []): insert = ir_module_dependency.insert([ ir_module_dependency.create_uid, ir_module_dependency.create_date, ir_module_dependency.module, ir_module_dependency.name ], [[0, CurrentTimestamp(), module_id, dependency]]) cursor.execute(*insert)
def init(self): from trytond.modules import get_module_info with self.get_connection() as conn: cursor = conn.cursor() sql_file = os.path.join(os.path.dirname(__file__), 'init.sql') with open(sql_file) as fp: for line in fp.read().split(';'): if (len(line) > 0) and (not line.isspace()): cursor.execute(line) ir_module = Table('ir_module') ir_module_dependency = Table('ir_module_dependency') for module in ('ir', 'res'): state = 'uninstalled' if module in ('ir', 'res'): state = 'to install' info = get_module_info(module) insert = ir_module.insert( [ir_module.create_uid, ir_module.create_date, ir_module.name, ir_module.state], [[0, CurrentTimestamp(), module, state]]) cursor.execute(*insert) cursor.execute('SELECT last_insert_rowid()') module_id, = cursor.fetchone() for dependency in info.get('depends', []): insert = ir_module_dependency.insert( [ir_module_dependency.create_uid, ir_module_dependency.create_date, ir_module_dependency.module, ir_module_dependency.name, ], [[0, CurrentTimestamp(), module_id, dependency]]) cursor.execute(*insert) conn.commit()
def migrate(self): obj = objectify.fromstring(self.content) t = Table('ir_model_data') for xml_record in obj.iter(tag='record'): record = self._record(xml_record) self.records.append(record) sp = [] for field in self.search_params.get(record.model, record.vals.keys()): sp.append((field, '=', record.vals[field])) logger.info('Trying to find existing record with query: {}'.format( sp )) table = record.model.replace('.', '_') q = OOQuery(table) sql = q.select(['id']).where(sp) logger.debug(tuple(sql)) self.cursor.execute(*sql) res_id = self.cursor.fetchone() if res_id: res_id = res_id[0] logger.info('Record {}.{} found! ({} id:{})'.format( self.module, record.id, record.model, res_id )) else: logger.info('Record {}.{} not found!'.format( self.module, record.id )) # We have to create the model table_model = Table(record.model.replace('.', '_')) columns = [] values = [] for col, value in record.vals.items(): columns.append(getattr(table_model, col)) values.append(value) sql = table_model.insert( columns=columns, values=[values], returning=[table_model.id] ) logger.debug(tuple(sql)) self.cursor.execute(*sql) res_id = self.cursor.fetchone()[0] logger.info('Creating record {}.{} ({} id:{})'.format( self.module, record.id, record.model, res_id )) sql = t.insert( columns=[t.name, t.model, t.noupdate, t.res_id, t.module], values=[(record.id, record.model, record.noupdate, res_id, self.module)] ) logger.debug(tuple(sql)) logger.info('Linking model data {}.{} -> record {} id:{}'.format( self.module, record.id, record.model, res_id )) self.cursor.execute(*sql)
def create_db(name=DB_NAME, lang='en'): Database = backend.get('Database') if not db_exist(name): with Transaction().start( None, 0, close=True, autocommit=True, _nocache=True) \ as transaction: transaction.database.create(transaction.connection, name) with Transaction().start(name, 0, _nocache=True) as transaction,\ transaction.connection.cursor() as cursor: Database(name).init() ir_configuration = Table('ir_configuration') cursor.execute(*ir_configuration.insert( [ir_configuration.language], [[lang]])) pool = Pool(name) pool.init(update=['res', 'ir'], lang=[lang]) with Transaction().start(name, 0) as transaction: User = pool.get('res.user') Lang = pool.get('ir.lang') language, = Lang.search([('code', '=', lang)]) language.translatable = True language.save() users = User.search([('login', '!=', 'root')]) User.write(users, { 'language': language.id, }) Module = pool.get('ir.module') Module.update_list()
def test_insert_subselect(self): t1 = Table("t1") t2 = Table("t2") subquery = t2.select(t2.c1, t2.c2) query = t1.insert([t1.c1, t1.c2], subquery) self.assertEqual(str(query), 'INSERT INTO "t1" ("c1", "c2") ' 'SELECT "a"."c1", "a"."c2" FROM "t2" AS "a"') self.assertEqual(query.params, ())
def test_schema(self): t1 = Table('t1', 'default') query = t1.insert([t1.c1], [['foo']]) self.assertEqual(str(query), 'INSERT INTO "default"."t1" ("c1") VALUES (%s)') self.assertEqual(query.params, ('foo',))
def test_insert_subselect(self): t1 = Table('t1') t2 = Table('t2') subquery = t2.select(t2.c1, t2.c2) query = t1.insert([t1.c1, t1.c2], subquery) self.assertEqual( str(query), 'INSERT INTO "t1" ("c1", "c2") ' 'SELECT "a"."c1", "a"."c2" FROM "t2" AS "a"') self.assertEqual(query.params, ())
def test_insert_returning_select(self): t1 = Table('t1') t2 = Table('t2') query = t1.insert([t1.c], [['foo']], returning=[ t2.select(t2.c, where=(t2.c1 == t1.c) & (t2.c2 == 'bar'))]) self.assertEqual(str(query), 'INSERT INTO "t1" ("c") VALUES (%s) ' 'RETURNING (SELECT "b"."c" FROM "t2" AS "b" ' 'WHERE (("b"."c1" = "t1"."c") AND ("b"."c2" = %s)))') self.assertEqual(query.params, ('foo', 'bar'))
def write_db_data(cls, nb): bench_table = Table('benchmark_table') cursor = Transaction().connection.cursor() cursor.execute(*bench_table.delete(where=bench_table.id >= 0)) for x in range(nb): cursor.execute(*bench_table.insert( columns=[ bench_table.id, bench_table.some_string, bench_table.some_date ], values=[[x, str(x) * 10, datetime.date(2016, 1, 1)]]))
def commit(cls, transaction): table = Table(cls._table) reset = cls._reset.pop(transaction, None) if not reset: return database = transaction.database dbname = database.name if not _clear_timeout and transaction.database.has_channel(): with transaction.connection.cursor() as cursor: # The count computed as # 8000 (max notify size) / 64 (max name data len) for sub_reset in grouped_slice(reset, 125): cursor.execute( 'NOTIFY "%s", %%s' % cls._channel, (json.dumps(list(sub_reset), separators=(',', ':')),)) else: connection = database.get_connection( readonly=False, autocommit=True) try: with connection.cursor() as cursor: for name in reset: cursor.execute(*table.select(table.name, table.id, table.timestamp, where=table.name == name, limit=1)) if cursor.fetchone(): # It would be better to insert only cursor.execute(*table.update([table.timestamp], [CurrentTimestamp()], where=table.name == name)) else: cursor.execute(*table.insert( [table.timestamp, table.name], [[CurrentTimestamp(), name]])) cursor.execute(*table.select( Max(table.timestamp), where=table.name == name)) timestamp, = cursor.fetchone() cursor.execute(*table.select( _cast(Max(table.timestamp)), where=table.name == name)) timestamp, = cursor.fetchone() inst = cls._instances[name] inst._clear(dbname, timestamp) connection.commit() finally: database.put_connection(connection) cls._clean_last = datetime.now() reset.clear()
def commit(cls, transaction): table = Table(cls._table) reset = cls._reset.setdefault(transaction, set()) if not reset: return database = transaction.database dbname = database.name if not _clear_timeout and transaction.database.has_channel(): with transaction.connection.cursor() as cursor: # JCA: Fix for https://bugs.tryton.org/issue8781 resets = list(reset) for i in range(0, len(resets), 10): cursor.execute('NOTIFY "%s", %%s' % cls._channel, (json.dumps(resets[i:i + 10], separators=(',', ':')), )) else: connection = database.get_connection(readonly=False, autocommit=True) try: with connection.cursor() as cursor: for name in reset: cursor.execute(*table.select(table.name, table.id, table.timestamp, where=table.name == name, limit=1)) if cursor.fetchone(): # It would be better to insert only cursor.execute(*table.update( [table.timestamp], [CurrentTimestamp()], where=table.name == name)) else: cursor.execute( *table.insert([table.timestamp, table.name], [[CurrentTimestamp(), name]])) cursor.execute(*table.select(Max(table.timestamp), where=table.name == name)) timestamp, = cursor.fetchone() cursor.execute( *table.select(_cast(Max(table.timestamp)), where=table.name == name)) timestamp, = cursor.fetchone() inst = cls._instances[name] inst._clear(dbname, timestamp) connection.commit() finally: database.put_connection(connection) reset.clear()
def resets(dbname): table = Table('ir_cache') with Transaction().new_transaction(_nocache=True) as transaction,\ transaction.connection.cursor() as cursor,\ Cache._resets_lock: Cache._resets.setdefault(dbname, set()) for name in Cache._resets[dbname]: cursor.execute(*table.select( table.name, where=table.name == name, limit=1)) if cursor.fetchone(): # It would be better to insert only cursor.execute( *table.update([table.timestamp], [CurrentTimestamp()], where=table.name == name)) else: cursor.execute(*table.insert([table.timestamp, table.name], [[CurrentTimestamp(), name]])) Cache._resets[dbname].clear()
def resets(dbname): with Transaction().new_cursor(): cursor = Transaction().cursor table = Table('ir_cache') with Cache._resets_lock: Cache._resets.setdefault(dbname, set()) for name in Cache._resets[dbname]: cursor.execute( *table.select(table.name, where=table.name == name)) if cursor.fetchone(): # It would be better to insert only cursor.execute( *table.update([table.timestamp], [Now()], where=table.name == name)) else: cursor.execute(*table.insert( [table.timestamp, table.name], [[Now(), name]])) Cache._resets[dbname].clear() cursor.commit()
def resets(cls, dbname): table = Table('ir_cache') with Transaction().new_transaction() as transaction,\ transaction.connection.cursor() as cursor,\ cls._resets_lock: cls._resets.setdefault(dbname, set()) for name in cls._resets[dbname]: cursor.execute(*table.select(table.name, where=table.name == name)) if cursor.fetchone(): # It would be better to insert only cursor.execute(*table.update([table.timestamp], [CurrentTimestamp()], where=table.name == name)) else: cursor.execute(*table.insert( [table.timestamp, table.name], [[CurrentTimestamp(), name]])) cls._resets[dbname].clear()
def create_db(name=DB_NAME, lang='en'): Database = backend.get('Database') if not db_exist(name): database = Database() database.connect() connection = database.get_connection(autocommit=True) try: database.create(connection, name) finally: database.put_connection(connection, True) database = Database(name) connection = database.get_connection() try: with connection.cursor() as cursor: database.init() ir_configuration = Table('ir_configuration') cursor.execute(*ir_configuration.insert( [ir_configuration.language], [[lang]])) connection.commit() finally: database.put_connection(connection) pool = Pool(name) pool.init(update=['res', 'ir'], lang=[lang]) with Transaction().start(name, 0): User = pool.get('res.user') Lang = pool.get('ir.lang') language, = Lang.search([('code', '=', lang)]) language.translatable = True language.save() users = User.search([('login', '!=', 'root')]) User.write(users, { 'language': language.id, }) Module = pool.get('ir.module') Module.update_list()