author | Sylvain Thénault <sylvain.thenault@logilab.fr> |
Wed, 10 Jun 2009 12:09:06 +0200 | |
branch | stable |
changeset 2087 | 88fa02f50e71 |
parent 2044 | d5589c5bc4e6 |
child 2126 | a25859917ccc |
child 2130 | caa5acbecc08 |
child 2172 | cf8f9180e63e |
permissions | -rw-r--r-- |
0 | 1 |
"""functions for schema / permissions (de)serialization using RQL |
2 |
||
3 |
:organization: Logilab |
|
1977
606923dff11b
big bunch of copyright / docstring update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1913
diff
changeset
|
4 |
:copyright: 2001-2009 LOGILAB S.A. (Paris, FRANCE), license is LGPL v2. |
0 | 5 |
:contact: http://www.logilab.fr/ -- mailto:contact@logilab.fr |
1977
606923dff11b
big bunch of copyright / docstring update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1913
diff
changeset
|
6 |
:license: GNU Lesser General Public License, v2.1 - http://www.gnu.org/licenses |
0 | 7 |
""" |
8 |
__docformat__ = "restructuredtext en" |
|
9 |
||
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
10 |
import sys |
0 | 11 |
from itertools import chain |
12 |
||
13 |
from logilab.common.shellutils import ProgressBar |
|
14 |
||
15 |
from yams import schema as schemamod, buildobjs as ybo |
|
16 |
||
17 |
from cubicweb.schema import CONSTRAINTS, ETYPE_NAME_MAP |
|
1869
642a1a120a92
should use sql prefix here
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1630
diff
changeset
|
18 |
from cubicweb.server import sqlutils |
0 | 19 |
|
20 |
def group_mapping(cursor, interactive=True): |
|
21 |
"""create a group mapping from an rql cursor |
|
22 |
||
23 |
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
|
24 |
and the actual CWGroup entity's eid as associated value. |
0 | 25 |
In interactive mode (the default), missing groups'eid will be prompted |
26 |
from the user. |
|
27 |
""" |
|
28 |
res = {} |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
29 |
for eid, name in cursor.execute('Any G, N WHERE G is CWGroup, G name N'): |
0 | 30 |
res[name] = eid |
31 |
if not interactive: |
|
32 |
return res |
|
33 |
missing = [g for g in ('owners', 'managers', 'users', 'guests') if not g in res] |
|
34 |
if missing: |
|
35 |
print 'some native groups are missing but the following groups have been found:' |
|
36 |
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
|
37 |
print |
0 | 38 |
print 'enter the eid of a to group to map to each missing native group' |
39 |
print 'or just type enter to skip permissions granted to a group' |
|
40 |
for group in missing: |
|
41 |
while True: |
|
42 |
value = raw_input('eid for group %s: ' % group).strip() |
|
43 |
if not value: |
|
44 |
continue |
|
45 |
try: |
|
46 |
res[group] = int(value) |
|
47 |
except ValueError: |
|
48 |
print 'eid should be an integer' |
|
49 |
continue |
|
50 |
return res |
|
51 |
||
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
52 |
def _set_sql_prefix(prefix): |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
53 |
"""3.2.0 migration function: allow to unset/reset SQL_PREFIX""" |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
54 |
for module in ('checkintegrity', 'migractions', 'schemahooks', |
1913
7d7bfd30c7f5
should reset sqlutils.SQL_PREFIX as well
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1869
diff
changeset
|
55 |
'sources.rql2sql', 'sources.native', 'sqlutils'): |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
56 |
try: |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
57 |
sys.modules['cubicweb.server.%s' % module].SQL_PREFIX = prefix |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
58 |
print 'changed SQL_PREFIX for %s' % module |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
59 |
except KeyError: |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
60 |
pass |
1630
41aadba8b29f
delete-trailing-whitespaces, check table existance
sylvain.thenault@logilab.fr
parents:
1398
diff
changeset
|
61 |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
62 |
def _update_database(schema, sqlcu): |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
63 |
"""3.2.0 migration function: update database schema by adding SQL_PREFIX to |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
64 |
entity type tables and columns |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
65 |
""" |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
66 |
for etype in schema.entities(): |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
67 |
if etype.is_final(): |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
68 |
continue |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
69 |
try: |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
70 |
sql = 'ALTER TABLE %s RENAME TO cw_%s' % ( |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
71 |
etype, ETYPE_NAME_MAP.get(etype, etype)) |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
72 |
print sql |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
73 |
sqlcu.execute(sql) |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
74 |
except: |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
75 |
pass |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
76 |
for rschema in etype.subject_relations(): |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
77 |
if rschema == 'has_text': |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
78 |
continue |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
79 |
if rschema.is_final() or rschema.inlined: |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
80 |
sql = 'ALTER TABLE cw_%s RENAME %s TO cw_%s' % ( |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
81 |
etype, rschema, rschema) |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
82 |
print sql |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
83 |
sqlcu.execute(sql) |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
84 |
|
0 | 85 |
# schema / perms deserialization ############################################## |
2044
d5589c5bc4e6
alter table in schema serial when a renamed type is detected
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
86 |
OLD_SCHEMA_TYPES = frozenset(('EFRDef', 'ENFRDef', 'ERType', 'EEType', |
d5589c5bc4e6
alter table in schema serial when a renamed type is detected
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
87 |
'EConstraintType', 'EConstraint', 'EGroup', |
d5589c5bc4e6
alter table in schema serial when a renamed type is detected
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
88 |
'EUser', 'ECache', 'EPermission', 'EProperty')) |
0 | 89 |
|
90 |
def deserialize_schema(schema, session): |
|
91 |
"""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
|
92 |
as CWRType and CWEType entities |
0 | 93 |
""" |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
94 |
# |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
95 |
repo = session.repo |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
96 |
sqlcu = session.pool['system'] |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
97 |
_3_2_migration = 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
|
98 |
dbhelper = repo.system_source.dbhelper |
d5589c5bc4e6
alter table in schema serial when a renamed type is detected
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
99 |
tables = set(t.lower() for t in dbhelper.list_tables(sqlcu)) |
1630
41aadba8b29f
delete-trailing-whitespaces, check table existance
sylvain.thenault@logilab.fr
parents:
1398
diff
changeset
|
100 |
if 'eetype' in tables: |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
101 |
_3_2_migration = True |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
102 |
# 3.2 migration |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
103 |
_set_sql_prefix('') |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
104 |
# first rename entity types whose name changed in 3.2 without adding the |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
105 |
# cw_ prefix |
2044
d5589c5bc4e6
alter table in schema serial when a renamed type is detected
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
106 |
for etype in OLD_SCHEMA_TYPES: |
1630
41aadba8b29f
delete-trailing-whitespaces, check table existance
sylvain.thenault@logilab.fr
parents:
1398
diff
changeset
|
107 |
if etype.lower() in tables: |
41aadba8b29f
delete-trailing-whitespaces, check table existance
sylvain.thenault@logilab.fr
parents:
1398
diff
changeset
|
108 |
sql = 'ALTER TABLE %s RENAME TO %s' % (etype, |
41aadba8b29f
delete-trailing-whitespaces, check table existance
sylvain.thenault@logilab.fr
parents:
1398
diff
changeset
|
109 |
ETYPE_NAME_MAP[etype]) |
41aadba8b29f
delete-trailing-whitespaces, check table existance
sylvain.thenault@logilab.fr
parents:
1398
diff
changeset
|
110 |
print sql |
41aadba8b29f
delete-trailing-whitespaces, check table existance
sylvain.thenault@logilab.fr
parents:
1398
diff
changeset
|
111 |
sqlcu.execute(sql) |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
112 |
# other table renaming done once schema has been readen |
0 | 113 |
# print 'reading schema from the database...' |
114 |
index = {} |
|
115 |
permsdict = deserialize_ertype_permissions(session) |
|
116 |
schema.reading_from_database = True |
|
117 |
for eid, etype, desc, meta in session.execute('Any X, N, D, M WHERE ' |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
118 |
'X is CWEType, X name N, ' |
0 | 119 |
'X description D, X meta M', |
120 |
build_descr=False): |
|
121 |
# base types are already in the schema, skip them |
|
122 |
if etype in schemamod.BASE_TYPES: |
|
123 |
# just set the eid |
|
124 |
eschema = schema.eschema(etype) |
|
125 |
eschema.eid = eid |
|
126 |
index[eid] = eschema |
|
127 |
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
|
128 |
if etype in ETYPE_NAME_MAP: |
d5589c5bc4e6
alter table in schema serial when a renamed type is detected
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
129 |
netype = ETYPE_NAME_MAP[etype] |
d5589c5bc4e6
alter table in schema serial when a renamed type is detected
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
130 |
print 'fixing etype name from %s to %s' % (etype, netype) |
0 | 131 |
# can't use write rql queries at this point, use raw sql |
1869
642a1a120a92
should use sql prefix here
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1630
diff
changeset
|
132 |
session.system_sql('UPDATE %(p)sCWEType SET %(p)sname=%%(n)s WHERE %(p)seid=%%(x)s' |
642a1a120a92
should use sql prefix here
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1630
diff
changeset
|
133 |
% {'p': sqlutils.SQL_PREFIX}, |
2044
d5589c5bc4e6
alter table in schema serial when a renamed type is detected
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
134 |
{'x': eid, 'n': netype}) |
0 | 135 |
session.system_sql('UPDATE entities SET type=%(n)s WHERE type=%(x)s', |
2044
d5589c5bc4e6
alter table in schema serial when a renamed type is detected
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
136 |
{'x': etype, 'n': netype}) |
d5589c5bc4e6
alter table in schema serial when a renamed type is detected
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
137 |
# XXX should be donne as well on sqlite based sources |
d5589c5bc4e6
alter table in schema serial when a renamed type is detected
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
138 |
if not etype in OLD_SCHEMA_TYPES and \ |
d5589c5bc4e6
alter table in schema serial when a renamed type is detected
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
139 |
(getattr(dbhelper, 'case_sensitive', False) |
d5589c5bc4e6
alter table in schema serial when a renamed type is detected
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
140 |
or etype.lower() != netype.lower()): |
d5589c5bc4e6
alter table in schema serial when a renamed type is detected
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
141 |
session.system_sql('ALTER TABLE %s%s RENAME TO %s%s' % ( |
d5589c5bc4e6
alter table in schema serial when a renamed type is detected
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
142 |
sqlutils.SQL_PREFIX, etype, sqlutils.SQL_PREFIX, netype)) |
0 | 143 |
session.commit(False) |
144 |
try: |
|
145 |
session.system_sql('UPDATE deleted_entities SET type=%(n)s WHERE type=%(x)s', |
|
2044
d5589c5bc4e6
alter table in schema serial when a renamed type is detected
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
146 |
{'x': etype, 'n': netype}) |
0 | 147 |
except: |
148 |
pass |
|
149 |
tocleanup = [eid] |
|
1630
41aadba8b29f
delete-trailing-whitespaces, check table existance
sylvain.thenault@logilab.fr
parents:
1398
diff
changeset
|
150 |
tocleanup += (eid for eid, (eidetype, uri, extid) in repo._type_source_cache.items() |
0 | 151 |
if etype == eidetype) |
1630
41aadba8b29f
delete-trailing-whitespaces, check table existance
sylvain.thenault@logilab.fr
parents:
1398
diff
changeset
|
152 |
repo.clear_caches(tocleanup) |
0 | 153 |
session.commit(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
|
154 |
etype = netype |
0 | 155 |
etype = ybo.EntityType(name=etype, description=desc, meta=meta, eid=eid) |
156 |
eschema = schema.add_entity_type(etype) |
|
157 |
index[eid] = eschema |
|
158 |
set_perms(eschema, permsdict.get(eid, {})) |
|
159 |
try: |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
160 |
rset = session.execute('Any XN, ETN WHERE X is CWEType, X name XN, ' |
0 | 161 |
'X specializes ET, ET name ETN') |
162 |
except: # `specializes` relation not available for versions prior to 2.50 |
|
163 |
session.rollback(False) |
|
164 |
else: |
|
165 |
for etype, stype in rset: |
|
166 |
eschema = schema.eschema(etype) |
|
167 |
seschema = schema.eschema(stype) |
|
168 |
eschema._specialized_type = stype |
|
169 |
seschema._specialized_by.append(etype) |
|
170 |
for eid, rtype, desc, meta, sym, il in session.execute( |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
171 |
'Any X,N,D,M,S,I WHERE X is CWRType, X name N, X description D, ' |
0 | 172 |
'X meta M, X symetric S, X inlined I', build_descr=False): |
173 |
try: |
|
174 |
# bw compat: fulltext_container added in 2.47 |
|
175 |
ft_container = session.execute('Any FTC WHERE X eid %(x)s, X fulltext_container FTC', |
|
176 |
{'x': eid}).rows[0][0] |
|
177 |
except: |
|
178 |
ft_container = None |
|
179 |
session.rollback(False) |
|
180 |
rtype = ybo.RelationType(name=rtype, description=desc, meta=bool(meta), |
|
181 |
symetric=bool(sym), inlined=bool(il), |
|
182 |
fulltext_container=ft_container, eid=eid) |
|
183 |
rschema = schema.add_relation_type(rtype) |
|
184 |
index[eid] = rschema |
|
1630
41aadba8b29f
delete-trailing-whitespaces, check table existance
sylvain.thenault@logilab.fr
parents:
1398
diff
changeset
|
185 |
set_perms(rschema, permsdict.get(eid, {})) |
0 | 186 |
cstrsdict = deserialize_rdef_constraints(session) |
187 |
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
|
188 |
'Any X,SE,RT,OE,CARD,ORD,DESC,IDX,FTIDX,I18N,DFLT WHERE X is CWAttribute,' |
0 | 189 |
'X relation_type RT, X cardinality CARD, X ordernum ORD, X indexed IDX,' |
190 |
'X description DESC, X internationalizable I18N, X defaultval DFLT,' |
|
191 |
'X fulltextindexed FTIDX, X from_entity SE, X to_entity OE', |
|
192 |
build_descr=False): |
|
193 |
rdefeid, seid, reid, teid, card, ord, desc, idx, ftidx, i18n, default = values |
|
194 |
constraints = cstrsdict.get(rdefeid, ()) |
|
195 |
frometype = index[seid].type |
|
196 |
rtype = index[reid].type |
|
197 |
toetype = index[teid].type |
|
198 |
rdef = ybo.RelationDefinition(frometype, rtype, toetype, cardinality=card, |
|
1630
41aadba8b29f
delete-trailing-whitespaces, check table existance
sylvain.thenault@logilab.fr
parents:
1398
diff
changeset
|
199 |
order=ord, description=desc, |
0 | 200 |
constraints=constraints, |
201 |
indexed=idx, fulltextindexed=ftidx, |
|
202 |
internationalizable=i18n, |
|
203 |
default=default, eid=rdefeid) |
|
204 |
schema.add_relation_def(rdef) |
|
205 |
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
|
206 |
'Any X,SE,RT,OE,CARD,ORD,DESC,C WHERE X is CWRelation, X relation_type RT,' |
0 | 207 |
'X cardinality CARD, X ordernum ORD, X description DESC, ' |
208 |
'X from_entity SE, X to_entity OE, X composite C', build_descr=False): |
|
209 |
rdefeid, seid, reid, teid, card, ord, desc, c = values |
|
210 |
frometype = index[seid].type |
|
211 |
rtype = index[reid].type |
|
212 |
toetype = index[teid].type |
|
213 |
constraints = cstrsdict.get(rdefeid, ()) |
|
214 |
rdef = ybo.RelationDefinition(frometype, rtype, toetype, cardinality=card, |
|
1630
41aadba8b29f
delete-trailing-whitespaces, check table existance
sylvain.thenault@logilab.fr
parents:
1398
diff
changeset
|
215 |
order=ord, description=desc, |
0 | 216 |
composite=c, constraints=constraints, |
217 |
eid=rdefeid) |
|
218 |
schema.add_relation_def(rdef) |
|
219 |
schema.infer_specialization_rules() |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
220 |
if _3_2_migration: |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
221 |
_update_database(schema, sqlcu) |
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
222 |
_set_sql_prefix('cw_') |
0 | 223 |
session.commit() |
224 |
schema.reading_from_database = False |
|
225 |
||
226 |
||
227 |
def deserialize_ertype_permissions(session): |
|
228 |
"""return sect action:groups associations for the given |
|
229 |
entity or relation schema with its eid, according to schema's |
|
230 |
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
|
231 |
relations between CWEType/CWRType and CWGroup entities |
0 | 232 |
""" |
233 |
res = {} |
|
234 |
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
|
235 |
rql = 'Any E,N WHERE G is CWGroup, G name N, E %s_permission G' % action |
0 | 236 |
for eid, gname in session.execute(rql, build_descr=False): |
237 |
res.setdefault(eid, {}).setdefault(action, []).append(gname) |
|
238 |
rql = ('Any E,X,EXPR,V WHERE X is RQLExpression, X expression EXPR, ' |
|
239 |
'E %s_permission X, X mainvars V' % action) |
|
240 |
for eid, expreid, expr, mainvars in session.execute(rql, build_descr=False): |
|
241 |
# we don't know yet if it's a rql expr for an entity or a relation, |
|
242 |
# so append a tuple to differentiate from groups and so we'll be |
|
243 |
# able to instantiate it later |
|
244 |
res.setdefault(eid, {}).setdefault(action, []).append( (expr, mainvars, expreid) ) |
|
245 |
return res |
|
246 |
||
247 |
def set_perms(erschema, permsdict): |
|
248 |
"""set permissions on the given erschema according to the permission |
|
249 |
definition dictionary as built by deserialize_ertype_permissions for a |
|
250 |
given erschema's eid |
|
251 |
""" |
|
252 |
for action in erschema.ACTIONS: |
|
253 |
actperms = [] |
|
254 |
for something in permsdict.get(action, ()): |
|
255 |
if isinstance(something, tuple): |
|
256 |
actperms.append(erschema.rql_expression(*something)) |
|
257 |
else: # group name |
|
258 |
actperms.append(something) |
|
1630
41aadba8b29f
delete-trailing-whitespaces, check table existance
sylvain.thenault@logilab.fr
parents:
1398
diff
changeset
|
259 |
erschema.set_permissions(action, actperms) |
0 | 260 |
|
261 |
||
262 |
def deserialize_rdef_constraints(session): |
|
263 |
"""return the list of relation definition's constraints as instances""" |
|
264 |
res = {} |
|
265 |
for rdefeid, ceid, ct, val in session.execute( |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
266 |
'Any E, X,TN,V WHERE E constrained_by X, X is CWConstraint, ' |
0 | 267 |
'X cstrtype T, T name TN, X value V', build_descr=False): |
268 |
cstr = CONSTRAINTS[ct].deserialize(val) |
|
269 |
cstr.eid = ceid |
|
270 |
res.setdefault(rdefeid, []).append(cstr) |
|
271 |
return res |
|
1630
41aadba8b29f
delete-trailing-whitespaces, check table existance
sylvain.thenault@logilab.fr
parents:
1398
diff
changeset
|
272 |
|
41aadba8b29f
delete-trailing-whitespaces, check table existance
sylvain.thenault@logilab.fr
parents:
1398
diff
changeset
|
273 |
|
0 | 274 |
# schema / perms serialization ################################################ |
275 |
||
276 |
def serialize_schema(cursor, schema, verbose=False): |
|
277 |
"""synchronize schema and permissions in the database according to |
|
278 |
current schema |
|
279 |
""" |
|
280 |
print 'serializing the schema, this may take some time' |
|
281 |
eschemas = schema.entities() |
|
282 |
aller = eschemas + schema.relations() |
|
283 |
if not verbose: |
|
284 |
pb_size = len(aller) + len(CONSTRAINTS) + len([x for x in eschemas if x.specializes()]) |
|
285 |
pb = ProgressBar(pb_size) |
|
286 |
for cstrtype in CONSTRAINTS: |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
287 |
rql = 'INSERT CWConstraintType X: X name "%s"' % cstrtype |
0 | 288 |
if verbose: |
289 |
print rql |
|
290 |
cursor.execute(rql) |
|
291 |
if not verbose: |
|
292 |
pb.update() |
|
293 |
groupmap = group_mapping(cursor, interactive=False) |
|
294 |
for ertype in aller: |
|
295 |
# skip eid and has_text relations |
|
296 |
if ertype in ('eid', 'identity', 'has_text',): |
|
297 |
pb.update() |
|
298 |
continue |
|
299 |
for rql, kwargs in erschema2rql(schema[ertype]): |
|
300 |
if verbose: |
|
301 |
print rql % kwargs |
|
302 |
cursor.execute(rql, kwargs) |
|
303 |
for rql, kwargs in erperms2rql(schema[ertype], groupmap): |
|
304 |
if verbose: |
|
305 |
print rql |
|
306 |
cursor.execute(rql, kwargs) |
|
307 |
if not verbose: |
|
308 |
pb.update() |
|
309 |
for rql, kwargs in specialize2rql(schema): |
|
310 |
if verbose: |
|
311 |
print rql % kwargs |
|
312 |
cursor.execute(rql, kwargs) |
|
313 |
if not verbose: |
|
314 |
pb.update() |
|
315 |
print |
|
316 |
||
317 |
||
318 |
def _ervalues(erschema): |
|
319 |
try: |
|
320 |
type_ = unicode(erschema.type) |
|
321 |
except UnicodeDecodeError, e: |
|
322 |
raise Exception("can't decode %s [was %s]" % (erschema.type, e)) |
|
323 |
try: |
|
324 |
desc = unicode(erschema.description) or u'' |
|
325 |
except UnicodeDecodeError, e: |
|
326 |
raise Exception("can't decode %s [was %s]" % (erschema.description, e)) |
|
327 |
return { |
|
328 |
'name': type_, |
|
329 |
'meta': erschema.meta, |
|
330 |
'final': erschema.is_final(), |
|
331 |
'description': desc, |
|
332 |
} |
|
333 |
||
334 |
def eschema_relations_values(eschema): |
|
335 |
values = _ervalues(eschema) |
|
336 |
relations = ['X %s %%(%s)s' % (attr, attr) for attr in sorted(values)] |
|
337 |
return relations, values |
|
338 |
||
339 |
# XXX 2.47 migration |
|
340 |
HAS_FULLTEXT_CONTAINER = True |
|
341 |
||
342 |
def rschema_relations_values(rschema): |
|
343 |
values = _ervalues(rschema) |
|
344 |
values['final'] = rschema.is_final() |
|
345 |
values['symetric'] = rschema.symetric |
|
346 |
values['inlined'] = rschema.inlined |
|
347 |
if HAS_FULLTEXT_CONTAINER: |
|
348 |
if isinstance(rschema.fulltext_container, str): |
|
349 |
values['fulltext_container'] = unicode(rschema.fulltext_container) |
|
350 |
else: |
|
351 |
values['fulltext_container'] = rschema.fulltext_container |
|
352 |
relations = ['X %s %%(%s)s' % (attr, attr) for attr in sorted(values)] |
|
353 |
return relations, values |
|
354 |
||
355 |
def _rdef_values(rschema, objtype, props): |
|
356 |
amap = {'order': 'ordernum'} |
|
357 |
values = {} |
|
358 |
for prop, default in rschema.rproperty_defs(objtype).iteritems(): |
|
359 |
if prop in ('eid', 'constraints', 'uid', 'infered'): |
|
360 |
continue |
|
361 |
value = props.get(prop, default) |
|
362 |
if prop in ('indexed', 'fulltextindexed', 'internationalizable'): |
|
363 |
value = bool(value) |
|
364 |
elif prop == 'ordernum': |
|
365 |
value = int(value) |
|
366 |
elif isinstance(value, str): |
|
367 |
value = unicode(value) |
|
368 |
values[amap.get(prop, prop)] = value |
|
369 |
return values |
|
1630
41aadba8b29f
delete-trailing-whitespaces, check table existance
sylvain.thenault@logilab.fr
parents:
1398
diff
changeset
|
370 |
|
0 | 371 |
def nfrdef_relations_values(rschema, objtype, props): |
372 |
values = _rdef_values(rschema, objtype, props) |
|
373 |
relations = ['X %s %%(%s)s' % (attr, attr) for attr in sorted(values)] |
|
374 |
return relations, values |
|
1630
41aadba8b29f
delete-trailing-whitespaces, check table existance
sylvain.thenault@logilab.fr
parents:
1398
diff
changeset
|
375 |
|
0 | 376 |
def frdef_relations_values(rschema, objtype, props): |
377 |
values = _rdef_values(rschema, objtype, props) |
|
378 |
default = values['default'] |
|
379 |
del values['default'] |
|
380 |
if default is not None: |
|
381 |
if default is False: |
|
382 |
default = u'' |
|
383 |
elif not isinstance(default, unicode): |
|
384 |
default = unicode(default) |
|
385 |
values['defaultval'] = default |
|
386 |
relations = ['X %s %%(%s)s' % (attr, attr) for attr in sorted(values)] |
|
387 |
return relations, values |
|
388 |
||
1630
41aadba8b29f
delete-trailing-whitespaces, check table existance
sylvain.thenault@logilab.fr
parents:
1398
diff
changeset
|
389 |
|
0 | 390 |
def __rdef2rql(genmap, rschema, subjtype=None, objtype=None, props=None): |
391 |
if subjtype is None: |
|
392 |
assert objtype is None |
|
393 |
assert props is None |
|
394 |
targets = rschema.iter_rdefs() |
|
395 |
else: |
|
396 |
assert not objtype is None |
|
397 |
targets = [(subjtype, objtype)] |
|
398 |
for subjtype, objtype in targets: |
|
399 |
if props is None: |
|
400 |
_props = rschema.rproperties(subjtype, objtype) |
|
401 |
else: |
|
402 |
_props = props |
|
403 |
# don't serialize infered relations |
|
404 |
if _props.get('infered'): |
|
405 |
continue |
|
406 |
gen = genmap[rschema.is_final()] |
|
407 |
for rql, values in gen(rschema, subjtype, objtype, _props): |
|
408 |
yield rql, values |
|
409 |
||
410 |
||
411 |
def schema2rql(schema, skip=None, allow=None): |
|
412 |
"""return a list of rql insert statements to enter the schema in the |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
413 |
database as CWRType and CWEType entities |
0 | 414 |
""" |
415 |
assert not (skip is not None and allow is not None), \ |
|
416 |
'can\'t use both skip and allow' |
|
417 |
all = schema.entities() + schema.relations() |
|
418 |
if skip is not None: |
|
419 |
return chain(*[erschema2rql(schema[t]) for t in all if not t in skip]) |
|
420 |
elif allow is not None: |
|
421 |
return chain(*[erschema2rql(schema[t]) for t in all if t in allow]) |
|
422 |
return chain(*[erschema2rql(schema[t]) for t in all]) |
|
1630
41aadba8b29f
delete-trailing-whitespaces, check table existance
sylvain.thenault@logilab.fr
parents:
1398
diff
changeset
|
423 |
|
0 | 424 |
def erschema2rql(erschema): |
425 |
if isinstance(erschema, schemamod.EntitySchema): |
|
426 |
return eschema2rql(erschema) |
|
427 |
return rschema2rql(erschema) |
|
428 |
||
429 |
def eschema2rql(eschema): |
|
430 |
"""return a list of rql insert statements to enter an entity schema |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
431 |
in the database as an CWEType entity |
0 | 432 |
""" |
433 |
relations, values = eschema_relations_values(eschema) |
|
434 |
# NOTE: 'specializes' relation can't be inserted here since there's no |
|
435 |
# way to make sure the parent type is inserted before the child type |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
436 |
yield 'INSERT CWEType X: %s' % ','.join(relations) , values |
0 | 437 |
|
438 |
def specialize2rql(schema): |
|
439 |
for eschema in schema.entities(): |
|
440 |
for rql, kwargs in eschemaspecialize2rql(eschema): |
|
441 |
yield rql, kwargs |
|
442 |
||
443 |
def eschemaspecialize2rql(eschema): |
|
444 |
specialized_type = eschema.specializes() |
|
445 |
if specialized_type: |
|
446 |
values = {'x': eschema.type, 'et': specialized_type.type} |
|
447 |
yield 'SET X specializes ET WHERE X name %(x)s, ET name %(et)s', values |
|
448 |
||
449 |
def rschema2rql(rschema, addrdef=True): |
|
450 |
"""return a list of rql insert statements to enter a relation schema |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
451 |
in the database as an CWRType entity |
0 | 452 |
""" |
453 |
if rschema.type == 'has_text': |
|
454 |
return |
|
455 |
relations, values = rschema_relations_values(rschema) |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
456 |
yield 'INSERT CWRType X: %s' % ','.join(relations), values |
0 | 457 |
if addrdef: |
458 |
for rql, values in rdef2rql(rschema): |
|
459 |
yield rql, values |
|
1630
41aadba8b29f
delete-trailing-whitespaces, check table existance
sylvain.thenault@logilab.fr
parents:
1398
diff
changeset
|
460 |
|
0 | 461 |
def rdef2rql(rschema, subjtype=None, objtype=None, props=None): |
462 |
genmap = {True: frdef2rql, False: nfrdef2rql} |
|
463 |
return __rdef2rql(genmap, rschema, subjtype, objtype, props) |
|
464 |
||
465 |
||
466 |
_LOCATE_RDEF_RQL0 = 'X relation_type ER,X from_entity SE,X to_entity OE' |
|
467 |
_LOCATE_RDEF_RQL1 = 'SE name %(se)s,ER name %(rt)s,OE name %(oe)s' |
|
468 |
||
469 |
def frdef2rql(rschema, subjtype, objtype, props): |
|
470 |
relations, values = frdef_relations_values(rschema, objtype, props) |
|
471 |
relations.append(_LOCATE_RDEF_RQL0) |
|
472 |
values.update({'se': str(subjtype), 'rt': str(rschema), 'oe': str(objtype)}) |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
473 |
yield 'INSERT CWAttribute X: %s WHERE %s' % (','.join(relations), _LOCATE_RDEF_RQL1), values |
0 | 474 |
for rql, values in rdefrelations2rql(rschema, subjtype, objtype, props): |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
475 |
yield rql + ', EDEF is CWAttribute', values |
1630
41aadba8b29f
delete-trailing-whitespaces, check table existance
sylvain.thenault@logilab.fr
parents:
1398
diff
changeset
|
476 |
|
0 | 477 |
def nfrdef2rql(rschema, subjtype, objtype, props): |
478 |
relations, values = nfrdef_relations_values(rschema, objtype, props) |
|
479 |
relations.append(_LOCATE_RDEF_RQL0) |
|
480 |
values.update({'se': str(subjtype), 'rt': str(rschema), 'oe': str(objtype)}) |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
481 |
yield 'INSERT CWRelation X: %s WHERE %s' % (','.join(relations), _LOCATE_RDEF_RQL1), values |
0 | 482 |
for rql, values in rdefrelations2rql(rschema, subjtype, objtype, props): |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
483 |
yield rql + ', EDEF is CWRelation', values |
1630
41aadba8b29f
delete-trailing-whitespaces, check table existance
sylvain.thenault@logilab.fr
parents:
1398
diff
changeset
|
484 |
|
0 | 485 |
def rdefrelations2rql(rschema, subjtype, objtype, props): |
486 |
iterators = [] |
|
487 |
for constraint in props['constraints']: |
|
488 |
iterators.append(constraint2rql(rschema, subjtype, objtype, constraint)) |
|
489 |
return chain(*iterators) |
|
490 |
||
491 |
def constraint2rql(rschema, subjtype, objtype, constraint): |
|
492 |
values = {'ctname': unicode(constraint.type()), |
|
493 |
'value': unicode(constraint.serialize()), |
|
494 |
'rt': str(rschema), 'se': str(subjtype), 'oe': str(objtype)} |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
495 |
yield 'INSERT CWConstraint X: X value %(value)s, X cstrtype CT, EDEF constrained_by X WHERE \ |
0 | 496 |
CT name %(ctname)s, EDEF relation_type ER, EDEF from_entity SE, EDEF to_entity OE, \ |
497 |
ER name %(rt)s, SE name %(se)s, OE name %(oe)s', values |
|
498 |
||
499 |
def perms2rql(schema, groupmapping): |
|
500 |
"""return rql insert statements to enter the schema's permissions in |
|
501 |
the database as [read|add|delete|update]_permission relations between |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
502 |
CWEType/CWRType and CWGroup entities |
0 | 503 |
|
504 |
groupmapping is a dictionnary mapping standard group names to |
|
505 |
eids |
|
506 |
""" |
|
507 |
for etype in sorted(schema.entities()): |
|
508 |
yield erperms2rql(schema[etype], groupmapping) |
|
509 |
for rtype in sorted(schema.relations()): |
|
510 |
yield erperms2rql(schema[rtype], groupmapping) |
|
511 |
||
512 |
def erperms2rql(erschema, groupmapping): |
|
513 |
"""return rql insert statements to enter the entity or relation |
|
514 |
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
|
515 |
[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
|
516 |
and CWGroup entities |
0 | 517 |
""" |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
518 |
etype = isinstance(erschema, schemamod.EntitySchema) and 'CWEType' or 'CWRType' |
0 | 519 |
for action in erschema.ACTIONS: |
520 |
for group in sorted(erschema.get_groups(action)): |
|
521 |
try: |
|
522 |
yield ('SET X %s_permission Y WHERE X is %s, X name "%s", Y eid %s' |
|
523 |
% (action, etype, erschema, groupmapping[group]), None) |
|
524 |
except KeyError: |
|
525 |
continue |
|
526 |
for rqlexpr in sorted(erschema.get_rqlexprs(action)): |
|
527 |
yield ('INSERT RQLExpression E: E expression %%(e)s, E exprtype %%(t)s, ' |
|
528 |
'E mainvars %%(v)s, X %s_permission E ' |
|
529 |
'WHERE X is %s, X name "%s"' % (action, etype, erschema), |
|
530 |
{'e': unicode(rqlexpr.expression), 'v': unicode(rqlexpr.mainvars), |
|
531 |
't': unicode(rqlexpr.__class__.__name__)}) |
|
532 |
||
533 |
||
534 |
def updateeschema2rql(eschema): |
|
535 |
relations, values = eschema_relations_values(eschema) |
|
536 |
values['et'] = eschema.type |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
537 |
yield 'SET %s WHERE X is CWEType, X name %%(et)s' % ','.join(relations), values |
0 | 538 |
|
539 |
def updaterschema2rql(rschema): |
|
540 |
relations, values = rschema_relations_values(rschema) |
|
541 |
values['rt'] = rschema.type |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
542 |
yield 'SET %s WHERE X is CWRType, X name %%(rt)s' % ','.join(relations), values |
1630
41aadba8b29f
delete-trailing-whitespaces, check table existance
sylvain.thenault@logilab.fr
parents:
1398
diff
changeset
|
543 |
|
0 | 544 |
def updaterdef2rql(rschema, subjtype=None, objtype=None, props=None): |
545 |
genmap = {True: updatefrdef2rql, False: updatenfrdef2rql} |
|
546 |
return __rdef2rql(genmap, rschema, subjtype, objtype, props) |
|
547 |
||
548 |
def updatefrdef2rql(rschema, subjtype, objtype, props): |
|
549 |
relations, values = frdef_relations_values(rschema, objtype, props) |
|
550 |
values.update({'se': subjtype, 'rt': str(rschema), 'oe': objtype}) |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
551 |
yield 'SET %s WHERE %s, %s, X is CWAttribute' % (','.join(relations), |
0 | 552 |
_LOCATE_RDEF_RQL0, |
553 |
_LOCATE_RDEF_RQL1), values |
|
1630
41aadba8b29f
delete-trailing-whitespaces, check table existance
sylvain.thenault@logilab.fr
parents:
1398
diff
changeset
|
554 |
|
0 | 555 |
def updatenfrdef2rql(rschema, subjtype, objtype, props): |
556 |
relations, values = nfrdef_relations_values(rschema, objtype, props) |
|
557 |
values.update({'se': subjtype, 'rt': str(rschema), 'oe': objtype}) |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
558 |
yield 'SET %s WHERE %s, %s, X is CWRelation' % (','.join(relations), |
0 | 559 |
_LOCATE_RDEF_RQL0, |
560 |
_LOCATE_RDEF_RQL1), values |