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()
