author | Sylvain Thénault <sylvain.thenault@logilab.fr> |
Fri, 03 Feb 2012 17:53:53 +0100 | |
branch | stable |
changeset 8196 | 50e5ce9dcef1 |
parent 7815 | 2a164a9cf81c |
child 8695 | 358d8bed9626 |
permissions | -rw-r--r-- |
7152
39c1ffc7d93f
[schema, refactoring] use RQLExpression as base class for RQL constraint classes
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
7012
diff
changeset
|
1 |
# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved. |
5421
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4835
diff
changeset
|
2 |
# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4835
diff
changeset
|
3 |
# |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4835
diff
changeset
|
4 |
# This file is part of CubicWeb. |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4835
diff
changeset
|
5 |
# |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4835
diff
changeset
|
6 |
# CubicWeb is free software: you can redistribute it and/or modify it under the |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4835
diff
changeset
|
7 |
# terms of the GNU Lesser General Public License as published by the Free |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4835
diff
changeset
|
8 |
# Software Foundation, either version 2.1 of the License, or (at your option) |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4835
diff
changeset
|
9 |
# any later version. |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4835
diff
changeset
|
10 |
# |
5424
8ecbcbff9777
replace logilab-common by CubicWeb in disclaimer
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5421
diff
changeset
|
11 |
# CubicWeb is distributed in the hope that it will be useful, but WITHOUT |
5421
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4835
diff
changeset
|
12 |
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4835
diff
changeset
|
13 |
# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4835
diff
changeset
|
14 |
# details. |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4835
diff
changeset
|
15 |
# |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4835
diff
changeset
|
16 |
# You should have received a copy of the GNU Lesser General Public License along |
8167de96c523
proper licensing information (LGPL-2.1). Hope I get it right this time.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4835
diff
changeset
|
17 |
# with CubicWeb. If not, see <http://www.gnu.org/licenses/>. |
5896 | 18 |
"""functions for schema / permissions (de)serialization using RQL""" |
0 | 19 |
|
20 |
__docformat__ = "restructuredtext en" |
|
21 |
||
3854
8633cd05b6b5
no progress bar in apycot environment
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3689
diff
changeset
|
22 |
import os |
0 | 23 |
from itertools import chain |
24 |
||
25 |
from logilab.common.shellutils import ProgressBar |
|
26 |
||
6191
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
27 |
from yams import BadSchemaDefinition, schema as schemamod, buildobjs as ybo |
0 | 28 |
|
5970
fb8acdab4e12
[broken schema] fix the group_mapping function in case where some standard group isn't found: we currently loop for ever, boring the user by asking ever and ever the same question...
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5896
diff
changeset
|
29 |
from cubicweb import CW_SOFTWARE_ROOT, typed_eid |
5558
afd1face1faf
[schema migration] make some stuff to ease file 1.9 migration : we want to kill the Image entity so that existing image are turned into (existing entity type) File entities
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
30 |
from cubicweb.schema import (CONSTRAINTS, ETYPE_NAME_MAP, |
afd1face1faf
[schema migration] make some stuff to ease file 1.9 migration : we want to kill the Image entity so that existing image are turned into (existing entity type) File entities
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
31 |
VIRTUAL_RTYPES, PURE_VIRTUAL_RTYPES) |
1869
642a1a120a92
should use sql prefix here
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1630
diff
changeset
|
32 |
from cubicweb.server import sqlutils |
0 | 33 |
|
34 |
def group_mapping(cursor, interactive=True): |
|
35 |
"""create a group mapping from an rql cursor |
|
36 |
||
37 |
A group mapping has standard group names as key (managers, owners at least) |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
38 |
and the actual CWGroup entity's eid as associated value. |
0 | 39 |
In interactive mode (the default), missing groups'eid will be prompted |
40 |
from the user. |
|
41 |
""" |
|
42 |
res = {} |
|
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
43 |
for eid, name in cursor.execute('Any G, N WHERE G is CWGroup, G name N', |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
44 |
build_descr=False): |
0 | 45 |
res[name] = eid |
46 |
if not interactive: |
|
47 |
return res |
|
48 |
missing = [g for g in ('owners', 'managers', 'users', 'guests') if not g in res] |
|
49 |
if missing: |
|
50 |
print 'some native groups are missing but the following groups have been found:' |
|
51 |
print '\n'.join('* %s (%s)' % (n, eid) for n, eid in res.items()) |
|
1630
41aadba8b29f
delete-trailing-whitespaces, check table existance
sylvain.thenault@logilab.fr
parents:
1398
diff
changeset
|
52 |
print |
0 | 53 |
print 'enter the eid of a to group to map to each missing native group' |
54 |
print 'or just type enter to skip permissions granted to a group' |
|
55 |
for group in missing: |
|
56 |
while True: |
|
57 |
value = raw_input('eid for group %s: ' % group).strip() |
|
58 |
if not value: |
|
59 |
continue |
|
60 |
try: |
|
5970
fb8acdab4e12
[broken schema] fix the group_mapping function in case where some standard group isn't found: we currently loop for ever, boring the user by asking ever and ever the same question...
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5896
diff
changeset
|
61 |
eid = typed_eid(value) |
0 | 62 |
except ValueError: |
63 |
print 'eid should be an integer' |
|
64 |
continue |
|
5970
fb8acdab4e12
[broken schema] fix the group_mapping function in case where some standard group isn't found: we currently loop for ever, boring the user by asking ever and ever the same question...
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5896
diff
changeset
|
65 |
for eid_ in res.values(): |
fb8acdab4e12
[broken schema] fix the group_mapping function in case where some standard group isn't found: we currently loop for ever, boring the user by asking ever and ever the same question...
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5896
diff
changeset
|
66 |
if eid == eid_: |
fb8acdab4e12
[broken schema] fix the group_mapping function in case where some standard group isn't found: we currently loop for ever, boring the user by asking ever and ever the same question...
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5896
diff
changeset
|
67 |
break |
fb8acdab4e12
[broken schema] fix the group_mapping function in case where some standard group isn't found: we currently loop for ever, boring the user by asking ever and ever the same question...
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5896
diff
changeset
|
68 |
else: |
fb8acdab4e12
[broken schema] fix the group_mapping function in case where some standard group isn't found: we currently loop for ever, boring the user by asking ever and ever the same question...
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5896
diff
changeset
|
69 |
print 'eid is not a group eid' |
fb8acdab4e12
[broken schema] fix the group_mapping function in case where some standard group isn't found: we currently loop for ever, boring the user by asking ever and ever the same question...
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5896
diff
changeset
|
70 |
continue |
fb8acdab4e12
[broken schema] fix the group_mapping function in case where some standard group isn't found: we currently loop for ever, boring the user by asking ever and ever the same question...
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5896
diff
changeset
|
71 |
res[name] = eid |
fb8acdab4e12
[broken schema] fix the group_mapping function in case where some standard group isn't found: we currently loop for ever, boring the user by asking ever and ever the same question...
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5896
diff
changeset
|
72 |
break |
0 | 73 |
return res |
74 |
||
4763
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
75 |
def cstrtype_mapping(cursor): |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
76 |
"""cached constraint types mapping""" |
5379
c082dea0731b
[schema] update for yams 0.29: BoundConstraint renamed to BoundaryConstraint; new constraint messages; ObjectRelation deprecated
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4835
diff
changeset
|
77 |
map = dict(cursor.execute('Any T, X WHERE X is CWConstraintType, X name T')) |
c082dea0731b
[schema] update for yams 0.29: BoundConstraint renamed to BoundaryConstraint; new constraint messages; ObjectRelation deprecated
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4835
diff
changeset
|
78 |
if not 'BoundConstraint' in map: |
c082dea0731b
[schema] update for yams 0.29: BoundConstraint renamed to BoundaryConstraint; new constraint messages; ObjectRelation deprecated
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4835
diff
changeset
|
79 |
map['BoundConstraint'] = map['BoundaryConstraint'] |
c082dea0731b
[schema] update for yams 0.29: BoundConstraint renamed to BoundaryConstraint; new constraint messages; ObjectRelation deprecated
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4835
diff
changeset
|
80 |
return map |
4763
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
81 |
|
0 | 82 |
# schema / perms deserialization ############################################## |
4791
b9a1b16a8d26
fix schema serialization, bad repartition of changes between stable and default
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4789
diff
changeset
|
83 |
|
0 | 84 |
def deserialize_schema(schema, session): |
85 |
"""return a schema according to information stored in an rql database |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
86 |
as CWRType and CWEType entities |
0 | 87 |
""" |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
88 |
repo = session.repo |
2044
d5589c5bc4e6
alter table in schema serial when a renamed type is detected
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
89 |
dbhelper = repo.system_source.dbhelper |
6191
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
90 |
# XXX bw compat (3.6 migration) |
7398
26695dd703d8
[repository api] definitly kill usage of word 'pool' to refer to connections set used by a session
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
7235
diff
changeset
|
91 |
sqlcu = session.cnxset['system'] |
4467
0e73d299730a
fix long-waiting symetric typo: should be spelled symmetric. Add auto database migration on schema deserialization
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4312
diff
changeset
|
92 |
sqlcu.execute("SELECT * FROM cw_CWRType WHERE cw_name='symetric'") |
0e73d299730a
fix long-waiting symetric typo: should be spelled symmetric. Add auto database migration on schema deserialization
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4312
diff
changeset
|
93 |
if sqlcu.fetchall(): |
0e73d299730a
fix long-waiting symetric typo: should be spelled symmetric. Add auto database migration on schema deserialization
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4312
diff
changeset
|
94 |
sql = dbhelper.sql_rename_col('cw_CWRType', 'cw_symetric', 'cw_symmetric', |
0e73d299730a
fix long-waiting symetric typo: should be spelled symmetric. Add auto database migration on schema deserialization
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4312
diff
changeset
|
95 |
dbhelper.TYPE_MAPPING['Boolean'], True) |
0e73d299730a
fix long-waiting symetric typo: should be spelled symmetric. Add auto database migration on schema deserialization
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4312
diff
changeset
|
96 |
sqlcu.execute(sql) |
0e73d299730a
fix long-waiting symetric typo: should be spelled symmetric. Add auto database migration on schema deserialization
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4312
diff
changeset
|
97 |
sqlcu.execute("UPDATE cw_CWRType SET cw_name='symmetric' WHERE cw_name='symetric'") |
6213
efde9f08f2ae
[migration] commit just after symetric has been renamed to symmetric (else later rollback may cancel this)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6210
diff
changeset
|
98 |
session.commit(False) |
6191
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
99 |
ertidx = {} |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
100 |
copiedeids = set() |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
101 |
permsidx = deserialize_ertype_permissions(session) |
0 | 102 |
schema.reading_from_database = True |
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
103 |
for eid, etype, desc in session.execute( |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
104 |
'Any X, N, D WHERE X is CWEType, X name N, X description D', |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
105 |
build_descr=False): |
0 | 106 |
# base types are already in the schema, skip them |
107 |
if etype in schemamod.BASE_TYPES: |
|
108 |
# just set the eid |
|
109 |
eschema = schema.eschema(etype) |
|
110 |
eschema.eid = eid |
|
6191
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
111 |
ertidx[eid] = etype |
0 | 112 |
continue |
2044
d5589c5bc4e6
alter table in schema serial when a renamed type is detected
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
113 |
if etype in ETYPE_NAME_MAP: |
5558
afd1face1faf
[schema migration] make some stuff to ease file 1.9 migration : we want to kill the Image entity so that existing image are turned into (existing entity type) File entities
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
114 |
needcopy = False |
2044
d5589c5bc4e6
alter table in schema serial when a renamed type is detected
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
115 |
netype = ETYPE_NAME_MAP[etype] |
0 | 116 |
# can't use write rql queries at this point, use raw sql |
5558
afd1face1faf
[schema migration] make some stuff to ease file 1.9 migration : we want to kill the Image entity so that existing image are turned into (existing entity type) File entities
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
117 |
sqlexec = session.system_sql |
afd1face1faf
[schema migration] make some stuff to ease file 1.9 migration : we want to kill the Image entity so that existing image are turned into (existing entity type) File entities
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
118 |
if sqlexec('SELECT 1 FROM %(p)sCWEType WHERE %(p)sname=%%(n)s' |
afd1face1faf
[schema migration] make some stuff to ease file 1.9 migration : we want to kill the Image entity so that existing image are turned into (existing entity type) File entities
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
119 |
% {'p': sqlutils.SQL_PREFIX}, {'n': netype}).fetchone(): |
6191
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
120 |
# the new type already exists, we should copy (eg make existing |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
121 |
# instances of the old type instances of the new type) |
5558
afd1face1faf
[schema migration] make some stuff to ease file 1.9 migration : we want to kill the Image entity so that existing image are turned into (existing entity type) File entities
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
122 |
assert etype.lower() != netype.lower() |
afd1face1faf
[schema migration] make some stuff to ease file 1.9 migration : we want to kill the Image entity so that existing image are turned into (existing entity type) File entities
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
123 |
needcopy = True |
afd1face1faf
[schema migration] make some stuff to ease file 1.9 migration : we want to kill the Image entity so that existing image are turned into (existing entity type) File entities
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
124 |
else: |
afd1face1faf
[schema migration] make some stuff to ease file 1.9 migration : we want to kill the Image entity so that existing image are turned into (existing entity type) File entities
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
125 |
# the new type doesn't exist, we should rename |
afd1face1faf
[schema migration] make some stuff to ease file 1.9 migration : we want to kill the Image entity so that existing image are turned into (existing entity type) File entities
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
126 |
sqlexec('UPDATE %(p)sCWEType SET %(p)sname=%%(n)s WHERE %(p)seid=%%(x)s' |
afd1face1faf
[schema migration] make some stuff to ease file 1.9 migration : we want to kill the Image entity so that existing image are turned into (existing entity type) File entities
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
127 |
% {'p': sqlutils.SQL_PREFIX}, {'x': eid, 'n': netype}) |
afd1face1faf
[schema migration] make some stuff to ease file 1.9 migration : we want to kill the Image entity so that existing image are turned into (existing entity type) File entities
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
128 |
if etype.lower() != netype.lower(): |
6734
ec9a5efdc451
make rename_table work with MS SQL (needs updated logilab.database)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6213
diff
changeset
|
129 |
alter_table_sql = dbhelper.sql_rename_table(sqlutils.SQL_PREFIX+etype, |
ec9a5efdc451
make rename_table work with MS SQL (needs updated logilab.database)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6213
diff
changeset
|
130 |
sqlutils.SQL_PREFIX+netype) |
ec9a5efdc451
make rename_table work with MS SQL (needs updated logilab.database)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6213
diff
changeset
|
131 |
sqlexec(alter_table_sql) |
5558
afd1face1faf
[schema migration] make some stuff to ease file 1.9 migration : we want to kill the Image entity so that existing image are turned into (existing entity type) File entities
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
132 |
sqlexec('UPDATE entities SET type=%(n)s WHERE type=%(x)s', |
afd1face1faf
[schema migration] make some stuff to ease file 1.9 migration : we want to kill the Image entity so that existing image are turned into (existing entity type) File entities
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
133 |
{'x': etype, 'n': netype}) |
0 | 134 |
session.commit(False) |
135 |
try: |
|
5558
afd1face1faf
[schema migration] make some stuff to ease file 1.9 migration : we want to kill the Image entity so that existing image are turned into (existing entity type) File entities
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
136 |
sqlexec('UPDATE deleted_entities SET type=%(n)s WHERE type=%(x)s', |
afd1face1faf
[schema migration] make some stuff to ease file 1.9 migration : we want to kill the Image entity so that existing image are turned into (existing entity type) File entities
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
137 |
{'x': etype, 'n': netype}) |
7815
2a164a9cf81c
[exceptions] stop catching any exception in various places (closes #1942716)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
7543
diff
changeset
|
138 |
except Exception: |
0 | 139 |
pass |
140 |
tocleanup = [eid] |
|
7543
570522300e22
[ms, entity metas] add 'actual source' to entities table / base entity metadata cache. Closes #1767090
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
7398
diff
changeset
|
141 |
tocleanup += (eid for eid, cached in repo._type_source_cache.iteritems() |
570522300e22
[ms, entity metas] add 'actual source' to entities table / base entity metadata cache. Closes #1767090
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
7398
diff
changeset
|
142 |
if etype == cached[0]) |
1630
41aadba8b29f
delete-trailing-whitespaces, check table existance
sylvain.thenault@logilab.fr
parents:
1398
diff
changeset
|
143 |
repo.clear_caches(tocleanup) |
0 | 144 |
session.commit(False) |
5558
afd1face1faf
[schema migration] make some stuff to ease file 1.9 migration : we want to kill the Image entity so that existing image are turned into (existing entity type) File entities
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
145 |
if needcopy: |
6191
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
146 |
ertidx[eid] = netype |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
147 |
copiedeids.add(eid) |
5558
afd1face1faf
[schema migration] make some stuff to ease file 1.9 migration : we want to kill the Image entity so that existing image are turned into (existing entity type) File entities
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
148 |
# copy / CWEType entity removal expected to be done through |
afd1face1faf
[schema migration] make some stuff to ease file 1.9 migration : we want to kill the Image entity so that existing image are turned into (existing entity type) File entities
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
149 |
# rename_entity_type in a migration script |
afd1face1faf
[schema migration] make some stuff to ease file 1.9 migration : we want to kill the Image entity so that existing image are turned into (existing entity type) File entities
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
150 |
continue |
2044
d5589c5bc4e6
alter table in schema serial when a renamed type is detected
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
151 |
etype = netype |
6191
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
152 |
ertidx[eid] = etype |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
153 |
eschema = schema.add_entity_type( |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
154 |
ybo.EntityType(name=etype, description=desc, eid=eid)) |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
155 |
set_perms(eschema, permsidx) |
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
156 |
for etype, stype in session.execute( |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
157 |
'Any XN, ETN WHERE X is CWEType, X name XN, X specializes ET, ET name ETN', |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
158 |
build_descr=False): |
6080
d0cb8fde4957
[schema] consider ETYPE_NAME_MAP when deserializing specialization relations
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
5970
diff
changeset
|
159 |
etype = ETYPE_NAME_MAP.get(etype, etype) |
d0cb8fde4957
[schema] consider ETYPE_NAME_MAP when deserializing specialization relations
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
5970
diff
changeset
|
160 |
stype = ETYPE_NAME_MAP.get(stype, stype) |
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
161 |
schema.eschema(etype)._specialized_type = stype |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
162 |
schema.eschema(stype)._specialized_by.append(etype) |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
163 |
for eid, rtype, desc, sym, il, ftc in session.execute( |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
164 |
'Any X,N,D,S,I,FTC WHERE X is CWRType, X name N, X description D, ' |
4467
0e73d299730a
fix long-waiting symetric typo: should be spelled symmetric. Add auto database migration on schema deserialization
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4312
diff
changeset
|
165 |
'X symmetric S, X inlined I, X fulltext_container FTC', build_descr=False): |
6191
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
166 |
ertidx[eid] = rtype |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
167 |
rschema = schema.add_relation_type( |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
168 |
ybo.RelationType(name=rtype, description=desc, |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
169 |
symmetric=bool(sym), inlined=bool(il), |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
170 |
fulltext_container=ftc, eid=eid)) |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
171 |
cstrsidx = deserialize_rdef_constraints(session) |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
172 |
pendingrdefs = [] |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
173 |
# closure to factorize common code of attribute/relation rdef addition |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
174 |
def _add_rdef(rdefeid, seid, reid, oeid, **kwargs): |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
175 |
rdef = ybo.RelationDefinition(ertidx[seid], ertidx[reid], ertidx[oeid], |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
176 |
constraints=cstrsidx.get(rdefeid, ()), |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
177 |
eid=rdefeid, **kwargs) |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
178 |
if seid in copiedeids or oeid in copiedeids: |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
179 |
# delay addition of this rdef. We'll insert them later if needed. We |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
180 |
# have to do this because: |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
181 |
# |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
182 |
# * on etype renaming, we want relation of the old entity type being |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
183 |
# redirected to the new type during migration |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
184 |
# |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
185 |
# * in the case of a copy, we've to take care that rdef already |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
186 |
# existing in the schema are not overwritten by a redirected one, |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
187 |
# since we want correct eid on them (redirected rdef will be |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
188 |
# removed in rename_entity_type) |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
189 |
pendingrdefs.append(rdef) |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
190 |
else: |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
191 |
# add_relation_def return a RelationDefinitionSchema if it has been |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
192 |
# actually added (can be None on duplicated relation definitions, |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
193 |
# e.g. if the relation type is marked as beeing symmetric) |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
194 |
rdefs = schema.add_relation_def(rdef) |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
195 |
if rdefs is not None: |
6208
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
196 |
ertidx[rdefeid] = rdefs |
6191
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
197 |
set_perms(rdefs, permsidx) |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
198 |
|
0 | 199 |
for values in session.execute( |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
200 |
'Any X,SE,RT,OE,CARD,ORD,DESC,IDX,FTIDX,I18N,DFLT WHERE X is CWAttribute,' |
0 | 201 |
'X relation_type RT, X cardinality CARD, X ordernum ORD, X indexed IDX,' |
202 |
'X description DESC, X internationalizable I18N, X defaultval DFLT,' |
|
203 |
'X fulltextindexed FTIDX, X from_entity SE, X to_entity OE', |
|
204 |
build_descr=False): |
|
6191
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
205 |
rdefeid, seid, reid, oeid, card, ord, desc, idx, ftidx, i18n, default = values |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
206 |
_add_rdef(rdefeid, seid, reid, oeid, |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
207 |
cardinality=card, description=desc, order=ord, |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
208 |
indexed=idx, fulltextindexed=ftidx, internationalizable=i18n, |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
209 |
default=default) |
0 | 210 |
for values in session.execute( |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
211 |
'Any X,SE,RT,OE,CARD,ORD,DESC,C WHERE X is CWRelation, X relation_type RT,' |
0 | 212 |
'X cardinality CARD, X ordernum ORD, X description DESC, ' |
213 |
'X from_entity SE, X to_entity OE, X composite C', build_descr=False): |
|
6191
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
214 |
rdefeid, seid, reid, oeid, card, ord, desc, comp = values |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
215 |
_add_rdef(rdefeid, seid, reid, oeid, |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
216 |
cardinality=card, description=desc, order=ord, |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
217 |
composite=comp) |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
218 |
for rdef in pendingrdefs: |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
219 |
try: |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
220 |
rdefs = schema.add_relation_def(rdef) |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
221 |
except BadSchemaDefinition: |
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
222 |
continue |
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
223 |
if rdefs is not None: |
6191
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
224 |
set_perms(rdefs, permsidx) |
6208
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
225 |
unique_togethers = {} |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
226 |
try: |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
227 |
rset = session.execute( |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
228 |
'Any X,E,R WHERE ' |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
229 |
'X is CWUniqueTogetherConstraint, ' |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
230 |
'X constraint_of E, X relations R', build_descr=False) |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
231 |
except Exception: |
6210
d36104de8459
removed print_exc
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6208
diff
changeset
|
232 |
session.rollback() # first migration introducing CWUniqueTogetherConstraint cw 3.9.6 |
6208
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
233 |
else: |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
234 |
for values in rset: |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
235 |
uniquecstreid, eeid, releid = values |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
236 |
eschema = schema.schema_by_eid(eeid) |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
237 |
relations = unique_togethers.setdefault(uniquecstreid, (eschema, [])) |
7011
f6ec6de03be6
[schema deserialization] enhance fix done in 7010:fa707848a88a to properly deal with cw 3.9 database
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
7010
diff
changeset
|
238 |
rel = ertidx[releid] |
7012
5ff6cb8bd2b3
[schema serialization] for relation type, ertidx contains the relation type as string, for relation def, the RelationDefinitionSchema instance
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
7011
diff
changeset
|
239 |
if isinstance(rel, schemamod.RelationDefinitionSchema): |
7011
f6ec6de03be6
[schema deserialization] enhance fix done in 7010:fa707848a88a to properly deal with cw 3.9 database
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
7010
diff
changeset
|
240 |
# not yet migrated 3.9 database ('relations' target type changed |
f6ec6de03be6
[schema deserialization] enhance fix done in 7010:fa707848a88a to properly deal with cw 3.9 database
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
7010
diff
changeset
|
241 |
# to CWRType in 3.10) |
f6ec6de03be6
[schema deserialization] enhance fix done in 7010:fa707848a88a to properly deal with cw 3.9 database
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
7010
diff
changeset
|
242 |
rtype = rel.rtype.type |
7012
5ff6cb8bd2b3
[schema serialization] for relation type, ertidx contains the relation type as string, for relation def, the RelationDefinitionSchema instance
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
7011
diff
changeset
|
243 |
else: |
5ff6cb8bd2b3
[schema serialization] for relation type, ertidx contains the relation type as string, for relation def, the RelationDefinitionSchema instance
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
7011
diff
changeset
|
244 |
rtype = str(rel) |
7011
f6ec6de03be6
[schema deserialization] enhance fix done in 7010:fa707848a88a to properly deal with cw 3.9 database
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
7010
diff
changeset
|
245 |
relations[1].append(rtype) |
6208
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
246 |
for eschema, unique_together in unique_togethers.itervalues(): |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
247 |
eschema._unique_together.append(tuple(sorted(unique_together))) |
0 | 248 |
schema.infer_specialization_rules() |
249 |
session.commit() |
|
250 |
schema.reading_from_database = False |
|
251 |
||
252 |
||
253 |
def deserialize_ertype_permissions(session): |
|
254 |
"""return sect action:groups associations for the given |
|
255 |
entity or relation schema with its eid, according to schema's |
|
256 |
permissions stored in the database as [read|add|delete|update]_permission |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
257 |
relations between CWEType/CWRType and CWGroup entities |
0 | 258 |
""" |
259 |
res = {} |
|
260 |
for action in ('read', 'add', 'update', 'delete'): |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
261 |
rql = 'Any E,N WHERE G is CWGroup, G name N, E %s_permission G' % action |
0 | 262 |
for eid, gname in session.execute(rql, build_descr=False): |
263 |
res.setdefault(eid, {}).setdefault(action, []).append(gname) |
|
264 |
rql = ('Any E,X,EXPR,V WHERE X is RQLExpression, X expression EXPR, ' |
|
265 |
'E %s_permission X, X mainvars V' % action) |
|
266 |
for eid, expreid, expr, mainvars in session.execute(rql, build_descr=False): |
|
267 |
# we don't know yet if it's a rql expr for an entity or a relation, |
|
268 |
# so append a tuple to differentiate from groups and so we'll be |
|
269 |
# able to instantiate it later |
|
270 |
res.setdefault(eid, {}).setdefault(action, []).append( (expr, mainvars, expreid) ) |
|
271 |
return res |
|
272 |
||
4760
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
273 |
def deserialize_rdef_constraints(session): |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
274 |
"""return the list of relation definition's constraints as instances""" |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
275 |
res = {} |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
276 |
for rdefeid, ceid, ct, val in session.execute( |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
277 |
'Any E, X,TN,V WHERE E constrained_by X, X is CWConstraint, ' |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
278 |
'X cstrtype T, T name TN, X value V', build_descr=False): |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
279 |
cstr = CONSTRAINTS[ct].deserialize(val) |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
280 |
cstr.eid = ceid |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
281 |
res.setdefault(rdefeid, []).append(cstr) |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
282 |
return res |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
283 |
|
6191
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
284 |
def set_perms(erschema, permsidx): |
0 | 285 |
"""set permissions on the given erschema according to the permission |
286 |
definition dictionary as built by deserialize_ertype_permissions for a |
|
287 |
given erschema's eid |
|
288 |
""" |
|
4570
ede247bbbf62
follow yams api change: attributes permissions are now defined for
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4475
diff
changeset
|
289 |
# reset erschema permissions here to avoid getting yams default anyway |
ede247bbbf62
follow yams api change: attributes permissions are now defined for
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4475
diff
changeset
|
290 |
erschema.permissions = dict((action, ()) for action in erschema.ACTIONS) |
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
291 |
try: |
6191
ece6996e6ac8
[schema deserial] fix loading of schema when mapping an entity type to an existing one
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6189
diff
changeset
|
292 |
thispermsdict = permsidx[erschema.eid] |
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
293 |
except KeyError: |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
294 |
return |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
295 |
for action, somethings in thispermsdict.iteritems(): |
4570
ede247bbbf62
follow yams api change: attributes permissions are now defined for
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4475
diff
changeset
|
296 |
# XXX cw < 3.6.1 bw compat |
ede247bbbf62
follow yams api change: attributes permissions are now defined for
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4475
diff
changeset
|
297 |
if isinstance(erschema, schemamod.RelationDefinitionSchema) and erschema.final and action == 'add': |
ede247bbbf62
follow yams api change: attributes permissions are now defined for
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4475
diff
changeset
|
298 |
action = 'update' |
ede247bbbf62
follow yams api change: attributes permissions are now defined for
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4475
diff
changeset
|
299 |
erschema.permissions[action] = tuple( |
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
300 |
isinstance(p, tuple) and erschema.rql_expression(*p) or p |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
301 |
for p in somethings) |
0 | 302 |
|
303 |
||
304 |
# schema / perms serialization ################################################ |
|
305 |
||
4760
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
306 |
def serialize_schema(cursor, schema): |
0 | 307 |
"""synchronize schema and permissions in the database according to |
308 |
current schema |
|
309 |
""" |
|
3737 | 310 |
quiet = os.environ.get('APYCOT_ROOT') |
3723
a961c7cb2644
be quiet w/ apycot
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3689
diff
changeset
|
311 |
if not quiet: |
a961c7cb2644
be quiet w/ apycot
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3689
diff
changeset
|
312 |
_title = '-> storing the schema in the database ' |
a961c7cb2644
be quiet w/ apycot
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3689
diff
changeset
|
313 |
print _title, |
4835
13b0b96d7982
[repo] enhanced security handling: deprecates unsafe_execute, in favor of explicit read/write security control using the `enabled_security` context manager. Also code executed on the repository side is now unsafe by default.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4808
diff
changeset
|
314 |
execute = cursor.execute |
0 | 315 |
eschemas = schema.entities() |
4760
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
316 |
if not quiet: |
4791
b9a1b16a8d26
fix schema serialization, bad repartition of changes between stable and default
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4789
diff
changeset
|
317 |
pb_size = (len(eschemas + schema.relations()) |
b9a1b16a8d26
fix schema serialization, bad repartition of changes between stable and default
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4789
diff
changeset
|
318 |
+ len(CONSTRAINTS) |
b9a1b16a8d26
fix schema serialization, bad repartition of changes between stable and default
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4789
diff
changeset
|
319 |
+ len([x for x in eschemas if x.specializes()])) |
2396
8bfb99d7bbcc
[cw-ctl] improve dialog messages
Nicolas Chauvat <nicolas.chauvat@logilab.fr>
parents:
2395
diff
changeset
|
320 |
pb = ProgressBar(pb_size, title=_title) |
3857
6676a839dc97
ensure pb is not None
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3854
diff
changeset
|
321 |
else: |
6676a839dc97
ensure pb is not None
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3854
diff
changeset
|
322 |
pb = None |
4800
686419cd2dff
nicer explanation
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4799
diff
changeset
|
323 |
groupmap = group_mapping(cursor, interactive=False) |
686419cd2dff
nicer explanation
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4799
diff
changeset
|
324 |
# serialize all entity types, assuring CWEType is serialized first for proper |
686419cd2dff
nicer explanation
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4799
diff
changeset
|
325 |
# is / is_instance_of insertion |
4760
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
326 |
eschemas.remove(schema.eschema('CWEType')) |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
327 |
eschemas.insert(0, schema.eschema('CWEType')) |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
328 |
for eschema in eschemas: |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
329 |
execschemarql(execute, eschema, eschema2rql(eschema, groupmap)) |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
330 |
if pb is not None: |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
331 |
pb.update() |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
332 |
# serialize constraint types |
4763
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
333 |
cstrtypemap = {} |
2597
d9c5a7e0563c
[C schema seria] cleanup
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2596
diff
changeset
|
334 |
rql = 'INSERT CWConstraintType X: X name %(ct)s' |
0 | 335 |
for cstrtype in CONSTRAINTS: |
5379
c082dea0731b
[schema] update for yams 0.29: BoundConstraint renamed to BoundaryConstraint; new constraint messages; ObjectRelation deprecated
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4835
diff
changeset
|
336 |
if cstrtype == 'BoundConstraint': |
c082dea0731b
[schema] update for yams 0.29: BoundConstraint renamed to BoundaryConstraint; new constraint messages; ObjectRelation deprecated
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4835
diff
changeset
|
337 |
continue # XXX deprecated in yams 0.29 / cw 3.8.1 |
4763
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
338 |
cstrtypemap[cstrtype] = execute(rql, {'ct': unicode(cstrtype)}, |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
339 |
build_descr=False)[0][0] |
3857
6676a839dc97
ensure pb is not None
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3854
diff
changeset
|
340 |
if pb is not None: |
0 | 341 |
pb.update() |
5379
c082dea0731b
[schema] update for yams 0.29: BoundConstraint renamed to BoundaryConstraint; new constraint messages; ObjectRelation deprecated
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4835
diff
changeset
|
342 |
cstrtypemap['BoundConstraint'] = cstrtypemap['BoundaryConstraint'] |
4760
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
343 |
# serialize relations |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
344 |
for rschema in schema.relations(): |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
345 |
# skip virtual relations such as eid, has_text and identity |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
346 |
if rschema in VIRTUAL_RTYPES: |
3857
6676a839dc97
ensure pb is not None
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3854
diff
changeset
|
347 |
if pb is not None: |
6676a839dc97
ensure pb is not None
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3854
diff
changeset
|
348 |
pb.update() |
0 | 349 |
continue |
4763
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
350 |
execschemarql(execute, rschema, rschema2rql(rschema, addrdef=False)) |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
351 |
if rschema.symmetric: |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
352 |
rdefs = [rdef for k, rdef in rschema.rdefs.iteritems() |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
353 |
if (rdef.subject, rdef.object) == k] |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
354 |
else: |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
355 |
rdefs = rschema.rdefs.itervalues() |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
356 |
for rdef in rdefs: |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
357 |
execschemarql(execute, rdef, |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
358 |
rdef2rql(rdef, cstrtypemap, groupmap)) |
3857
6676a839dc97
ensure pb is not None
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3854
diff
changeset
|
359 |
if pb is not None: |
0 | 360 |
pb.update() |
6208
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
361 |
# serialize unique_together constraints |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
362 |
for eschema in eschemas: |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
363 |
for unique_together in eschema._unique_together: |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
364 |
execschemarql(execute, eschema, [uniquetogether2rql(eschema, unique_together)]) |
6815
a84190d4e78c
[schema] fix pb with ambiguous relation used within UniqueTogetherConstraint by having CWUniqueTogetherConstraint.relation targeting CWRType instead of CWAttribute/CWRelation. This fixes 3.10.7 migration.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6734
diff
changeset
|
365 |
# serialize yams inheritance relationships |
0 | 366 |
for rql, kwargs in specialize2rql(schema): |
4791
b9a1b16a8d26
fix schema serialization, bad repartition of changes between stable and default
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4789
diff
changeset
|
367 |
execute(rql, kwargs, build_descr=False) |
3857
6676a839dc97
ensure pb is not None
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3854
diff
changeset
|
368 |
if pb is not None: |
0 | 369 |
pb.update() |
3723
a961c7cb2644
be quiet w/ apycot
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3689
diff
changeset
|
370 |
if not quiet: |
a961c7cb2644
be quiet w/ apycot
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3689
diff
changeset
|
371 |
print |
0 | 372 |
|
373 |
||
4763
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
374 |
# high level serialization functions |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
375 |
|
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
376 |
def execschemarql(execute, schema, rqls): |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
377 |
for rql, kwargs in rqls: |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
378 |
kwargs['x'] = schema.eid |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
379 |
rset = execute(rql, kwargs, build_descr=False) |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
380 |
if schema.eid is None: |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
381 |
schema.eid = rset[0][0] |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
382 |
else: |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
383 |
assert rset |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
384 |
|
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
385 |
def erschema2rql(erschema, groupmap): |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
386 |
if isinstance(erschema, schemamod.EntitySchema): |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
387 |
return eschema2rql(erschema, groupmap=groupmap) |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
388 |
return rschema2rql(erschema, groupmap=groupmap) |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
389 |
|
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
390 |
def specialize2rql(schema): |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
391 |
for eschema in schema.entities(): |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
392 |
if eschema.final: |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
393 |
continue |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
394 |
for rql, kwargs in eschemaspecialize2rql(eschema): |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
395 |
yield rql, kwargs |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
396 |
|
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
397 |
# etype serialization |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
398 |
|
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
399 |
def eschema2rql(eschema, groupmap=None): |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
400 |
"""return a list of rql insert statements to enter an entity schema |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
401 |
in the database as an CWEType entity |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
402 |
""" |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
403 |
relations, values = eschema_relations_values(eschema) |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
404 |
# NOTE: 'specializes' relation can't be inserted here since there's no |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
405 |
# way to make sure the parent type is inserted before the child type |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
406 |
yield 'INSERT CWEType X: %s' % ','.join(relations) , values |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
407 |
# entity permissions |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
408 |
if groupmap is not None: |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
409 |
for rql, args in _erperms2rql(eschema, groupmap): |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
410 |
yield rql, args |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
411 |
|
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
412 |
def eschema_relations_values(eschema): |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
413 |
values = _ervalues(eschema) |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
414 |
relations = ['X %s %%(%s)s' % (attr, attr) for attr in sorted(values)] |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
415 |
return relations, values |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
416 |
|
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
417 |
def eschemaspecialize2rql(eschema): |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
418 |
specialized_type = eschema.specializes() |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
419 |
if specialized_type: |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
420 |
values = {'x': eschema.eid, 'et': specialized_type.eid} |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
421 |
yield 'SET X specializes ET WHERE X eid %(x)s, ET eid %(et)s', values |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
422 |
|
6208
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
423 |
def uniquetogether2rql(eschema, unique_together): |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
424 |
relations = [] |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
425 |
restrictions = [] |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
426 |
substs = {} |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
427 |
for i, name in enumerate(unique_together): |
6815
a84190d4e78c
[schema] fix pb with ambiguous relation used within UniqueTogetherConstraint by having CWUniqueTogetherConstraint.relation targeting CWRType instead of CWAttribute/CWRelation. This fixes 3.10.7 migration.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6734
diff
changeset
|
428 |
rschema = eschema.schema.rschema(name) |
6208
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
429 |
rtype = 'T%d' % i |
6815
a84190d4e78c
[schema] fix pb with ambiguous relation used within UniqueTogetherConstraint by having CWUniqueTogetherConstraint.relation targeting CWRType instead of CWAttribute/CWRelation. This fixes 3.10.7 migration.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6734
diff
changeset
|
430 |
substs[rtype] = rschema.type |
a84190d4e78c
[schema] fix pb with ambiguous relation used within UniqueTogetherConstraint by having CWUniqueTogetherConstraint.relation targeting CWRType instead of CWAttribute/CWRelation. This fixes 3.10.7 migration.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6734
diff
changeset
|
431 |
relations.append('C relations %s' % rtype) |
a84190d4e78c
[schema] fix pb with ambiguous relation used within UniqueTogetherConstraint by having CWUniqueTogetherConstraint.relation targeting CWRType instead of CWAttribute/CWRelation. This fixes 3.10.7 migration.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6734
diff
changeset
|
432 |
restrictions.append('%(rtype)s name %%(%(rtype)s)s' % {'rtype': rtype}) |
6208
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
433 |
relations = ', '.join(relations) |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
434 |
restrictions = ', '.join(restrictions) |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
435 |
rql = ('INSERT CWUniqueTogetherConstraint C: ' |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
436 |
' C constraint_of X, %s ' |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
437 |
'WHERE ' |
6815
a84190d4e78c
[schema] fix pb with ambiguous relation used within UniqueTogetherConstraint by having CWUniqueTogetherConstraint.relation targeting CWRType instead of CWAttribute/CWRelation. This fixes 3.10.7 migration.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
6734
diff
changeset
|
438 |
' X eid %%(x)s, %s') |
6208
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
439 |
return rql % (relations, restrictions), substs |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
440 |
|
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
441 |
|
0 | 442 |
def _ervalues(erschema): |
443 |
try: |
|
444 |
type_ = unicode(erschema.type) |
|
445 |
except UnicodeDecodeError, e: |
|
446 |
raise Exception("can't decode %s [was %s]" % (erschema.type, e)) |
|
447 |
try: |
|
448 |
desc = unicode(erschema.description) or u'' |
|
449 |
except UnicodeDecodeError, e: |
|
450 |
raise Exception("can't decode %s [was %s]" % (erschema.description, e)) |
|
451 |
return { |
|
452 |
'name': type_, |
|
3689
deb13e88e037
follow yams 0.25 api changes to improve performance
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2955
diff
changeset
|
453 |
'final': erschema.final, |
0 | 454 |
'description': desc, |
455 |
} |
|
456 |
||
4763
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
457 |
# rtype serialization |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
458 |
|
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
459 |
def rschema2rql(rschema, cstrtypemap=None, addrdef=True, groupmap=None): |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
460 |
"""return a list of rql insert statements to enter a relation schema |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
461 |
in the database as an CWRType entity |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
462 |
""" |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
463 |
if rschema.type == 'has_text': |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
464 |
return |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
465 |
relations, values = rschema_relations_values(rschema) |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
466 |
yield 'INSERT CWRType X: %s' % ','.join(relations), values |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
467 |
if addrdef: |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
468 |
assert cstrtypemap |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
469 |
# sort for testing purpose |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
470 |
for rdef in sorted(rschema.rdefs.itervalues(), |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
471 |
key=lambda x: (x.subject, x.object)): |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
472 |
for rql, values in rdef2rql(rdef, cstrtypemap, groupmap): |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
473 |
yield rql, values |
0 | 474 |
|
475 |
def rschema_relations_values(rschema): |
|
476 |
values = _ervalues(rschema) |
|
3689
deb13e88e037
follow yams 0.25 api changes to improve performance
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2955
diff
changeset
|
477 |
values['final'] = rschema.final |
4467
0e73d299730a
fix long-waiting symetric typo: should be spelled symmetric. Add auto database migration on schema deserialization
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4312
diff
changeset
|
478 |
values['symmetric'] = rschema.symmetric |
0 | 479 |
values['inlined'] = rschema.inlined |
4719
aaed3f813ef8
kill dead/useless code as suggested by pylint
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4631
diff
changeset
|
480 |
if isinstance(rschema.fulltext_container, str): |
aaed3f813ef8
kill dead/useless code as suggested by pylint
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4631
diff
changeset
|
481 |
values['fulltext_container'] = unicode(rschema.fulltext_container) |
aaed3f813ef8
kill dead/useless code as suggested by pylint
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4631
diff
changeset
|
482 |
else: |
aaed3f813ef8
kill dead/useless code as suggested by pylint
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4631
diff
changeset
|
483 |
values['fulltext_container'] = rschema.fulltext_container |
0 | 484 |
relations = ['X %s %%(%s)s' % (attr, attr) for attr in sorted(values)] |
485 |
return relations, values |
|
486 |
||
4763
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
487 |
# rdef serialization |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
488 |
|
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
489 |
def rdef2rql(rdef, cstrtypemap, groupmap=None): |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
490 |
# don't serialize infered relations |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
491 |
if rdef.infered: |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
492 |
return |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
493 |
relations, values = _rdef_values(rdef) |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
494 |
relations.append('X relation_type ER,X from_entity SE,X to_entity OE') |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
495 |
values.update({'se': rdef.subject.eid, 'rt': rdef.rtype.eid, 'oe': rdef.object.eid}) |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
496 |
if rdef.final: |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
497 |
etype = 'CWAttribute' |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
498 |
else: |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
499 |
etype = 'CWRelation' |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
500 |
yield 'INSERT %s X: %s WHERE SE eid %%(se)s,ER eid %%(rt)s,OE eid %%(oe)s' % ( |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
501 |
etype, ','.join(relations), ), values |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
502 |
for rql, values in constraints2rql(cstrtypemap, rdef.constraints): |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
503 |
yield rql, values |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
504 |
# no groupmap means "no security insertion" |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
505 |
if groupmap: |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
506 |
for rql, args in _erperms2rql(rdef, groupmap): |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
507 |
yield rql, args |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
508 |
|
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
509 |
def _rdef_values(rdef): |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
510 |
amap = {'order': 'ordernum', 'default': 'defaultval'} |
0 | 511 |
values = {} |
4763
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
512 |
for prop, default in rdef.rproperty_defs(rdef.object).iteritems(): |
4003
b9436fe77c9e
fix bad merge
Sandrine Ribeau <sandrine.ribeau@logilab.fr>
parents:
3998
diff
changeset
|
513 |
if prop in ('eid', 'constraints', 'uid', 'infered', 'permissions'): |
0 | 514 |
continue |
4763
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
515 |
value = getattr(rdef, prop) |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
516 |
# XXX type cast really necessary? |
0 | 517 |
if prop in ('indexed', 'fulltextindexed', 'internationalizable'): |
518 |
value = bool(value) |
|
519 |
elif prop == 'ordernum': |
|
520 |
value = int(value) |
|
521 |
elif isinstance(value, str): |
|
522 |
value = unicode(value) |
|
4763
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
523 |
if value is not None and prop == 'default': |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
524 |
if value is False: |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
525 |
value = u'' |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
526 |
if not isinstance(value, unicode): |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
527 |
value = unicode(value) |
0 | 528 |
values[amap.get(prop, prop)] = value |
529 |
relations = ['X %s %%(%s)s' % (attr, attr) for attr in sorted(values)] |
|
530 |
return relations, values |
|
531 |
||
4763
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
532 |
def constraints2rql(cstrtypemap, constraints, rdefeid=None): |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
533 |
for constraint in constraints: |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
534 |
values = {'ct': cstrtypemap[constraint.type()], |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
535 |
'value': unicode(constraint.serialize()), |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
536 |
'x': rdefeid} # when not specified, will have to be set by the caller |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
537 |
yield 'INSERT CWConstraint X: X value %(value)s, X cstrtype CT, EDEF constrained_by X WHERE \ |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
538 |
CT eid %(ct)s, EDEF eid %(x)s', values |
0 | 539 |
|
540 |
||
4011
394f853bb653
[migration] write migration instructions for permissions handling on relation definition
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
4010
diff
changeset
|
541 |
def _erperms2rql(erschema, groupmap): |
0 | 542 |
"""return rql insert statements to enter the entity or relation |
543 |
schema's permissions in the database as |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
544 |
[read|add|delete|update]_permission relations between CWEType/CWRType |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
545 |
and CWGroup entities |
0 | 546 |
""" |
547 |
for action in erschema.ACTIONS: |
|
4631
457160bc8cfe
when modifying a persistent schema, erschema may miss some permissions which wil trigger a key error, but we don't want to crash on such cases
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4570
diff
changeset
|
548 |
try: |
457160bc8cfe
when modifying a persistent schema, erschema may miss some permissions which wil trigger a key error, but we don't want to crash on such cases
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4570
diff
changeset
|
549 |
grantedto = erschema.action_permissions(action) |
457160bc8cfe
when modifying a persistent schema, erschema may miss some permissions which wil trigger a key error, but we don't want to crash on such cases
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4570
diff
changeset
|
550 |
except KeyError: |
457160bc8cfe
when modifying a persistent schema, erschema may miss some permissions which wil trigger a key error, but we don't want to crash on such cases
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4570
diff
changeset
|
551 |
# may occurs when modifying persistent schema |
457160bc8cfe
when modifying a persistent schema, erschema may miss some permissions which wil trigger a key error, but we don't want to crash on such cases
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4570
diff
changeset
|
552 |
continue |
457160bc8cfe
when modifying a persistent schema, erschema may miss some permissions which wil trigger a key error, but we don't want to crash on such cases
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4570
diff
changeset
|
553 |
for group_or_rqlexpr in grantedto: |
3877
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
554 |
if isinstance(group_or_rqlexpr, basestring): |
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
555 |
# group |
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
556 |
try: |
4763
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
557 |
yield ('SET X %s_permission Y WHERE Y eid %%(g)s, X eid %%(x)s' % action, |
4011
394f853bb653
[migration] write migration instructions for permissions handling on relation definition
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
4010
diff
changeset
|
558 |
{'g': groupmap[group_or_rqlexpr]}) |
3877
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
559 |
except KeyError: |
7219
d961184f9a86
[schema serialization] add warning on missing group
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
7012
diff
changeset
|
560 |
print ("WARNING: group %s used in permissions for %s was ignored because it doesn't exist." |
d961184f9a86
[schema serialization] add warning on missing group
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
7012
diff
changeset
|
561 |
" You may want to add it into a precreate.py file" % (group_or_rqlexpr, erschema)) |
3877
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
562 |
continue |
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
563 |
else: |
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
564 |
# rqlexpr |
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
565 |
rqlexpr = group_or_rqlexpr |
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
566 |
yield ('INSERT RQLExpression E: E expression %%(e)s, E exprtype %%(t)s, ' |
4763
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
567 |
'E mainvars %%(v)s, X %s_permission E WHERE X eid %%(x)s' % action, |
3877
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
568 |
{'e': unicode(rqlexpr.expression), |
7152
39c1ffc7d93f
[schema, refactoring] use RQLExpression as base class for RQL constraint classes
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
7012
diff
changeset
|
569 |
'v': unicode(','.join(sorted(rqlexpr.mainvars))), |
3877
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
570 |
't': unicode(rqlexpr.__class__.__name__)}) |
0 | 571 |
|
4763
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
572 |
# update functions |
0 | 573 |
|
4763
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
574 |
def updateeschema2rql(eschema, eid): |
0 | 575 |
relations, values = eschema_relations_values(eschema) |
4763
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
576 |
values['x'] = eid |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
577 |
yield 'SET %s WHERE X eid %%(x)s' % ','.join(relations), values |
1630
41aadba8b29f
delete-trailing-whitespaces, check table existance
sylvain.thenault@logilab.fr
parents:
1398
diff
changeset
|
578 |
|
4763
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
579 |
def updaterschema2rql(rschema, eid): |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
580 |
relations, values = rschema_relations_values(rschema) |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
581 |
values['x'] = eid |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
582 |
yield 'SET %s WHERE X eid %%(x)s' % ','.join(relations), values |
0 | 583 |
|
4763
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
584 |
def updaterdef2rql(rdef, eid): |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
585 |
relations, values = _rdef_values(rdef) |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
586 |
values['x'] = eid |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
587 |
yield 'SET %s WHERE X eid %%(x)s' % ','.join(relations), values |