author | Julien Cristau <julien.cristau@logilab.fr> |
Fri, 17 Oct 2014 12:14:58 +0200 | |
changeset 10045 | 0a49d61c8cca |
parent 10025 | 7b72ecc3f4d2 |
child 10074 | ab956b780d4e |
permissions | -rw-r--r-- |
8945
ba9e3fbfa5a5
[schemaserial] serialize additional yams parameter for customs type
Vincent Michel <vincent.michel@logilab.fr>
parents:
8748
diff
changeset
|
1 |
# copyright 2003-2013 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 |
8945
ba9e3fbfa5a5
[schemaserial] serialize additional yams parameter for customs type
Vincent Michel <vincent.michel@logilab.fr>
parents:
8748
diff
changeset
|
23 |
import json |
0 | 24 |
|
25 |
from logilab.common.shellutils import ProgressBar |
|
26 |
||
9375
8e88576787c3
[schema] fix unique together index handling
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9299
diff
changeset
|
27 |
from yams import (BadSchemaDefinition, schema as schemamod, buildobjs as ybo, |
8e88576787c3
[schema] fix unique together index handling
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9299
diff
changeset
|
28 |
schema2sql as y2sql) |
0 | 29 |
|
9468
39b7a91a3f4c
[repo] pylint cleanup, mainly of imports, with a bit of style
Julien Cristau <julien.cristau@logilab.fr>
parents:
9463
diff
changeset
|
30 |
from cubicweb import Binary |
8945
ba9e3fbfa5a5
[schemaserial] serialize additional yams parameter for customs type
Vincent Michel <vincent.michel@logilab.fr>
parents:
8748
diff
changeset
|
31 |
from cubicweb.schema import (KNOWN_RPROPERTIES, CONSTRAINTS, ETYPE_NAME_MAP, |
9468
39b7a91a3f4c
[repo] pylint cleanup, mainly of imports, with a bit of style
Julien Cristau <julien.cristau@logilab.fr>
parents:
9463
diff
changeset
|
32 |
VIRTUAL_RTYPES) |
1869
642a1a120a92
should use sql prefix here
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1630
diff
changeset
|
33 |
from cubicweb.server import sqlutils |
0 | 34 |
|
8945
ba9e3fbfa5a5
[schemaserial] serialize additional yams parameter for customs type
Vincent Michel <vincent.michel@logilab.fr>
parents:
8748
diff
changeset
|
35 |
|
9503
562cef272a35
[schemaserial] Replace 'cursor' with 'cnx'
Julien Cristau <julien.cristau@logilab.fr>
parents:
9490
diff
changeset
|
36 |
def group_mapping(cnx, interactive=True): |
0 | 37 |
"""create a group mapping from an rql cursor |
38 |
||
39 |
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
|
40 |
and the actual CWGroup entity's eid as associated value. |
0 | 41 |
In interactive mode (the default), missing groups'eid will be prompted |
42 |
from the user. |
|
43 |
""" |
|
44 |
res = {} |
|
9503
562cef272a35
[schemaserial] Replace 'cursor' with 'cnx'
Julien Cristau <julien.cristau@logilab.fr>
parents:
9490
diff
changeset
|
45 |
for eid, name in cnx.execute('Any G, N WHERE G is CWGroup, G name N', |
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
46 |
build_descr=False): |
0 | 47 |
res[name] = eid |
48 |
if not interactive: |
|
49 |
return res |
|
50 |
missing = [g for g in ('owners', 'managers', 'users', 'guests') if not g in res] |
|
51 |
if missing: |
|
52 |
print 'some native groups are missing but the following groups have been found:' |
|
53 |
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
|
54 |
print |
0 | 55 |
print 'enter the eid of a to group to map to each missing native group' |
56 |
print 'or just type enter to skip permissions granted to a group' |
|
57 |
for group in missing: |
|
58 |
while True: |
|
59 |
value = raw_input('eid for group %s: ' % group).strip() |
|
60 |
if not value: |
|
61 |
continue |
|
62 |
try: |
|
8748
f5027f8d2478
drop typed_eid() in favour of int() (closes #2742462)
Nicolas Chauvat <nicolas.chauvat@logilab.fr>
parents:
8695
diff
changeset
|
63 |
eid = int(value) |
0 | 64 |
except ValueError: |
65 |
print 'eid should be an integer' |
|
66 |
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
|
67 |
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
|
68 |
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
|
69 |
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
|
70 |
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
|
71 |
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
|
72 |
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
|
73 |
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
|
74 |
break |
0 | 75 |
return res |
76 |
||
9489
0581f6d2812e
[server/schemaserial] rename cursor argument to cnx
Julien Cristau <julien.cristau@logilab.fr>
parents:
9468
diff
changeset
|
77 |
def cstrtype_mapping(cnx): |
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
|
78 |
"""cached constraint types mapping""" |
9489
0581f6d2812e
[server/schemaserial] rename cursor argument to cnx
Julien Cristau <julien.cristau@logilab.fr>
parents:
9468
diff
changeset
|
79 |
map = dict(cnx.execute('Any T, X WHERE X is CWConstraintType, X name T')) |
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
|
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 |
|
9490
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
84 |
def deserialize_schema(schema, cnx): |
0 | 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 |
""" |
9490
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
88 |
repo = cnx.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 |
9956
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
90 |
|
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
91 |
# Computed Rtype |
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
92 |
with cnx.ensure_cnx_set: |
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
93 |
tables = set(dbhelper.list_tables(cnx.cnxset.cu)) |
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
94 |
has_computed_relations = 'cw_CWComputedRType' in tables |
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
95 |
if has_computed_relations: |
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
96 |
rset = cnx.execute( |
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
97 |
'Any X, N, R, D WHERE X is CWComputedRType, X name N, ' |
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
98 |
'X rule R, X description D') |
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
99 |
for eid, rule_name, rule, description in rset.rows: |
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
100 |
rtype = ybo.ComputedRelation(name=rule_name, rule=rule, eid=eid, |
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
101 |
description=description) |
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
102 |
schema.add_relation_type(rtype) |
9968
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
103 |
# computed attribute |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
104 |
try: |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
105 |
cnx.system_sql("SELECT cw_formula FROM cw_CWAttribute") |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
106 |
has_computed_attributes = True |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
107 |
except Exception: |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
108 |
cnx.rollback() |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
109 |
has_computed_attributes = False |
9956
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
110 |
|
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 |
# XXX bw compat (3.6 migration) |
9490
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
112 |
with cnx.ensure_cnx_set: |
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
113 |
sqlcu = cnx.system_sql("SELECT * FROM cw_CWRType WHERE cw_name='symetric'") |
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
114 |
if sqlcu.fetchall(): |
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
115 |
sql = dbhelper.sql_rename_col('cw_CWRType', 'cw_symetric', 'cw_symmetric', |
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
116 |
dbhelper.TYPE_MAPPING['Boolean'], True) |
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
117 |
sqlcu.execute(sql) |
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
118 |
sqlcu.execute("UPDATE cw_CWRType SET cw_name='symmetric' WHERE cw_name='symetric'") |
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
119 |
cnx.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
|
120 |
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
|
121 |
copiedeids = set() |
9490
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
122 |
permsidx = deserialize_ertype_permissions(cnx) |
0 | 123 |
schema.reading_from_database = True |
9959
6047bf8df9e5
[schema serial] add some comments
Laura Médioni <laura.medioni@logilab.fr>
parents:
9956
diff
changeset
|
124 |
# load every entity types |
9490
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
125 |
for eid, etype, desc in cnx.execute( |
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
126 |
'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
|
127 |
build_descr=False): |
0 | 128 |
# base types are already in the schema, skip them |
129 |
if etype in schemamod.BASE_TYPES: |
|
130 |
# just set the eid |
|
131 |
eschema = schema.eschema(etype) |
|
132 |
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
|
133 |
ertidx[eid] = etype |
0 | 134 |
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
|
135 |
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
|
136 |
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
|
137 |
netype = ETYPE_NAME_MAP[etype] |
0 | 138 |
# can't use write rql queries at this point, use raw sql |
9490
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
139 |
sqlexec = cnx.system_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
|
140 |
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
|
141 |
% {'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
|
142 |
# 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
|
143 |
# 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
|
144 |
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
|
145 |
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
|
146 |
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
|
147 |
# 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
|
148 |
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
|
149 |
% {'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
|
150 |
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
|
151 |
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
|
152 |
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
|
153 |
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
|
154 |
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
|
155 |
{'x': etype, 'n': netype}) |
9490
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
156 |
cnx.commit(False) |
0 | 157 |
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
|
158 |
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
|
159 |
if etype == cached[0]) |
1630
41aadba8b29f
delete-trailing-whitespaces, check table existance
sylvain.thenault@logilab.fr
parents:
1398
diff
changeset
|
160 |
repo.clear_caches(tocleanup) |
9490
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
161 |
cnx.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
|
162 |
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
|
163 |
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
|
164 |
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
|
165 |
# 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
|
166 |
# 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
|
167 |
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
|
168 |
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
|
169 |
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
|
170 |
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
|
171 |
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
|
172 |
set_perms(eschema, permsidx) |
9959
6047bf8df9e5
[schema serial] add some comments
Laura Médioni <laura.medioni@logilab.fr>
parents:
9956
diff
changeset
|
173 |
# load inheritance relations |
9490
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
174 |
for etype, stype in cnx.execute( |
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
175 |
'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
|
176 |
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
|
177 |
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
|
178 |
stype = ETYPE_NAME_MAP.get(stype, stype) |
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
179 |
schema.eschema(etype)._specialized_type = stype |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
180 |
schema.eschema(stype)._specialized_by.append(etype) |
9959
6047bf8df9e5
[schema serial] add some comments
Laura Médioni <laura.medioni@logilab.fr>
parents:
9956
diff
changeset
|
181 |
# load every relation types |
9490
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
182 |
for eid, rtype, desc, sym, il, ftc in cnx.execute( |
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
183 |
'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
|
184 |
'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
|
185 |
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
|
186 |
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
|
187 |
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
|
188 |
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
|
189 |
fulltext_container=ftc, eid=eid)) |
9959
6047bf8df9e5
[schema serial] add some comments
Laura Médioni <laura.medioni@logilab.fr>
parents:
9956
diff
changeset
|
190 |
# remains to load every relation definitions (ie relations and attributes) |
9490
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
191 |
cstrsidx = deserialize_rdef_constraints(cnx) |
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
|
192 |
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
|
193 |
# 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
|
194 |
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
|
195 |
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
|
196 |
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
|
197 |
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
|
198 |
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
|
199 |
# 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
|
200 |
# 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
|
201 |
# |
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
|
202 |
# * 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
|
203 |
# 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
|
204 |
# |
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 |
# * 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
|
206 |
# 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
|
207 |
# 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
|
208 |
# 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
|
209 |
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
|
210 |
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
|
211 |
# 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
|
212 |
# 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
|
213 |
# 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
|
214 |
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
|
215 |
if rdefs is not None: |
6208
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
216 |
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
|
217 |
set_perms(rdefs, permsidx) |
8945
ba9e3fbfa5a5
[schemaserial] serialize additional yams parameter for customs type
Vincent Michel <vincent.michel@logilab.fr>
parents:
8748
diff
changeset
|
218 |
# Get the type parameters for additional base types. |
ba9e3fbfa5a5
[schemaserial] serialize additional yams parameter for customs type
Vincent Michel <vincent.michel@logilab.fr>
parents:
8748
diff
changeset
|
219 |
try: |
9490
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
220 |
extra_props = dict(cnx.execute('Any X, XTP WHERE X is CWAttribute, ' |
9959
6047bf8df9e5
[schema serial] add some comments
Laura Médioni <laura.medioni@logilab.fr>
parents:
9956
diff
changeset
|
221 |
'X extra_props XTP')) |
8945
ba9e3fbfa5a5
[schemaserial] serialize additional yams parameter for customs type
Vincent Michel <vincent.michel@logilab.fr>
parents:
8748
diff
changeset
|
222 |
except Exception: |
9490
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
223 |
cnx.critical('Previous CRITICAL notification about extra_props is not ' |
9959
6047bf8df9e5
[schema serial] add some comments
Laura Médioni <laura.medioni@logilab.fr>
parents:
9956
diff
changeset
|
224 |
'a problem if you are migrating to cubicweb 3.17') |
8945
ba9e3fbfa5a5
[schemaserial] serialize additional yams parameter for customs type
Vincent Michel <vincent.michel@logilab.fr>
parents:
8748
diff
changeset
|
225 |
extra_props = {} # not yet in the schema (introduced by 3.17 migration) |
9968
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
226 |
|
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
227 |
# load attributes |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
228 |
rql = ('Any X,SE,RT,OE,CARD,ORD,DESC,IDX,FTIDX,I18N,DFLT%(fm)s ' |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
229 |
'WHERE X is CWAttribute, X relation_type RT, X cardinality CARD,' |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
230 |
' X ordernum ORD, X indexed IDX, X description DESC, ' |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
231 |
' X internationalizable I18N, X defaultval DFLT,%(fmsnip)s' |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
232 |
' X fulltextindexed FTIDX, X from_entity SE, X to_entity OE') |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
233 |
if has_computed_attributes: |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
234 |
rql = rql % {'fm': ',FM', 'fmsnip': 'X formula FM,'} |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
235 |
else: |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
236 |
rql = rql % {'fm': '', 'fmsnip': ''} |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
237 |
for values in cnx.execute(rql, build_descr=False): |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
238 |
attrs = dict(zip( |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
239 |
('rdefeid', 'seid', 'reid', 'oeid', 'cardinality', |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
240 |
'order', 'description', 'indexed', 'fulltextindexed', |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
241 |
'internationalizable', 'default', 'formula'), values)) |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
242 |
typeparams = extra_props.get(attrs['rdefeid']) |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
243 |
attrs.update(json.load(typeparams) if typeparams else {}) |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
244 |
default = attrs['default'] |
9299
c5eed908117d
[schema] store default attribute values in a Bytes field, allowing python objects as default values
Aurélien Campeas <aurelien.campeas@logilab.fr>
parents:
9257
diff
changeset
|
245 |
if default is not None: |
c5eed908117d
[schema] store default attribute values in a Bytes field, allowing python objects as default values
Aurélien Campeas <aurelien.campeas@logilab.fr>
parents:
9257
diff
changeset
|
246 |
if isinstance(default, Binary): |
c5eed908117d
[schema] store default attribute values in a Bytes field, allowing python objects as default values
Aurélien Campeas <aurelien.campeas@logilab.fr>
parents:
9257
diff
changeset
|
247 |
# while migrating from 3.17 to 3.18, we still have to |
c5eed908117d
[schema] store default attribute values in a Bytes field, allowing python objects as default values
Aurélien Campeas <aurelien.campeas@logilab.fr>
parents:
9257
diff
changeset
|
248 |
# handle String defaults |
9968
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
249 |
attrs['default'] = default.unzpickle() |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
250 |
_add_rdef(**attrs) |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
251 |
# load relations |
9490
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
252 |
for values in cnx.execute( |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
253 |
'Any X,SE,RT,OE,CARD,ORD,DESC,C WHERE X is CWRelation, X relation_type RT,' |
0 | 254 |
'X cardinality CARD, X ordernum ORD, X description DESC, ' |
255 |
'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
|
256 |
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
|
257 |
_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
|
258 |
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
|
259 |
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
|
260 |
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
|
261 |
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
|
262 |
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
|
263 |
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
|
264 |
continue |
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
265 |
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
|
266 |
set_perms(rdefs, permsidx) |
6208
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
267 |
unique_togethers = {} |
9490
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
268 |
rset = cnx.execute( |
9257
ce338133c92c
remove cw 3.9 bw compat (bw compat other than the interface -> adapter changes)
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9255
diff
changeset
|
269 |
'Any X,E,R WHERE ' |
ce338133c92c
remove cw 3.9 bw compat (bw compat other than the interface -> adapter changes)
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9255
diff
changeset
|
270 |
'X is CWUniqueTogetherConstraint, ' |
ce338133c92c
remove cw 3.9 bw compat (bw compat other than the interface -> adapter changes)
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9255
diff
changeset
|
271 |
'X constraint_of E, X relations R', build_descr=False) |
ce338133c92c
remove cw 3.9 bw compat (bw compat other than the interface -> adapter changes)
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9255
diff
changeset
|
272 |
for values in rset: |
ce338133c92c
remove cw 3.9 bw compat (bw compat other than the interface -> adapter changes)
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9255
diff
changeset
|
273 |
uniquecstreid, eeid, releid = values |
ce338133c92c
remove cw 3.9 bw compat (bw compat other than the interface -> adapter changes)
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9255
diff
changeset
|
274 |
eschema = schema.schema_by_eid(eeid) |
ce338133c92c
remove cw 3.9 bw compat (bw compat other than the interface -> adapter changes)
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9255
diff
changeset
|
275 |
relations = unique_togethers.setdefault(uniquecstreid, (eschema, [])) |
ce338133c92c
remove cw 3.9 bw compat (bw compat other than the interface -> adapter changes)
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9255
diff
changeset
|
276 |
rel = ertidx[releid] |
ce338133c92c
remove cw 3.9 bw compat (bw compat other than the interface -> adapter changes)
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9255
diff
changeset
|
277 |
if isinstance(rel, schemamod.RelationDefinitionSchema): |
ce338133c92c
remove cw 3.9 bw compat (bw compat other than the interface -> adapter changes)
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9255
diff
changeset
|
278 |
# not yet migrated 3.9 database ('relations' target type changed |
ce338133c92c
remove cw 3.9 bw compat (bw compat other than the interface -> adapter changes)
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9255
diff
changeset
|
279 |
# to CWRType in 3.10) |
ce338133c92c
remove cw 3.9 bw compat (bw compat other than the interface -> adapter changes)
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9255
diff
changeset
|
280 |
rtype = rel.rtype.type |
ce338133c92c
remove cw 3.9 bw compat (bw compat other than the interface -> adapter changes)
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9255
diff
changeset
|
281 |
else: |
ce338133c92c
remove cw 3.9 bw compat (bw compat other than the interface -> adapter changes)
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9255
diff
changeset
|
282 |
rtype = str(rel) |
ce338133c92c
remove cw 3.9 bw compat (bw compat other than the interface -> adapter changes)
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9255
diff
changeset
|
283 |
relations[1].append(rtype) |
ce338133c92c
remove cw 3.9 bw compat (bw compat other than the interface -> adapter changes)
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9255
diff
changeset
|
284 |
for eschema, unique_together in unique_togethers.itervalues(): |
ce338133c92c
remove cw 3.9 bw compat (bw compat other than the interface -> adapter changes)
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9255
diff
changeset
|
285 |
eschema._unique_together.append(tuple(sorted(unique_together))) |
0 | 286 |
schema.infer_specialization_rules() |
9490
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
287 |
cnx.commit() |
9956
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
288 |
schema.finalize() |
0 | 289 |
schema.reading_from_database = False |
290 |
||
291 |
||
9490
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
292 |
def deserialize_ertype_permissions(cnx): |
0 | 293 |
"""return sect action:groups associations for the given |
294 |
entity or relation schema with its eid, according to schema's |
|
295 |
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
|
296 |
relations between CWEType/CWRType and CWGroup entities |
0 | 297 |
""" |
298 |
res = {} |
|
299 |
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
|
300 |
rql = 'Any E,N WHERE G is CWGroup, G name N, E %s_permission G' % action |
9490
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
301 |
for eid, gname in cnx.execute(rql, build_descr=False): |
0 | 302 |
res.setdefault(eid, {}).setdefault(action, []).append(gname) |
303 |
rql = ('Any E,X,EXPR,V WHERE X is RQLExpression, X expression EXPR, ' |
|
304 |
'E %s_permission X, X mainvars V' % action) |
|
9490
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
305 |
for eid, expreid, expr, mainvars in cnx.execute(rql, build_descr=False): |
0 | 306 |
# we don't know yet if it's a rql expr for an entity or a relation, |
307 |
# so append a tuple to differentiate from groups and so we'll be |
|
308 |
# able to instantiate it later |
|
309 |
res.setdefault(eid, {}).setdefault(action, []).append( (expr, mainvars, expreid) ) |
|
310 |
return res |
|
311 |
||
9490
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
312 |
def deserialize_rdef_constraints(cnx): |
4760
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
313 |
"""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
|
314 |
res = {} |
9490
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
315 |
for rdefeid, ceid, ct, val in cnx.execute( |
4760
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
316 |
'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
|
317 |
'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
|
318 |
cstr = CONSTRAINTS[ct].deserialize(val) |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
319 |
cstr.eid = ceid |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
320 |
res.setdefault(rdefeid, []).append(cstr) |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
321 |
return res |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
322 |
|
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
|
323 |
def set_perms(erschema, permsidx): |
0 | 324 |
"""set permissions on the given erschema according to the permission |
325 |
definition dictionary as built by deserialize_ertype_permissions for a |
|
326 |
given erschema's eid |
|
327 |
""" |
|
4570
ede247bbbf62
follow yams api change: attributes permissions are now defined for
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4475
diff
changeset
|
328 |
# 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
|
329 |
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
|
330 |
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
|
331 |
thispermsdict = permsidx[erschema.eid] |
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
332 |
except KeyError: |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
333 |
return |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
334 |
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
|
335 |
erschema.permissions[action] = tuple( |
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
336 |
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
|
337 |
for p in somethings) |
0 | 338 |
|
339 |
||
340 |
# schema / perms serialization ################################################ |
|
341 |
||
9503
562cef272a35
[schemaserial] Replace 'cursor' with 'cnx'
Julien Cristau <julien.cristau@logilab.fr>
parents:
9490
diff
changeset
|
342 |
def serialize_schema(cnx, schema): |
0 | 343 |
"""synchronize schema and permissions in the database according to |
344 |
current schema |
|
345 |
""" |
|
9891
3386fd89c914
remove references to global environment variable APYCOT_ROOT
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9503
diff
changeset
|
346 |
_title = '-> storing the schema in the database ' |
3386fd89c914
remove references to global environment variable APYCOT_ROOT
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9503
diff
changeset
|
347 |
print _title, |
9503
562cef272a35
[schemaserial] Replace 'cursor' with 'cnx'
Julien Cristau <julien.cristau@logilab.fr>
parents:
9490
diff
changeset
|
348 |
execute = cnx.execute |
0 | 349 |
eschemas = schema.entities() |
9891
3386fd89c914
remove references to global environment variable APYCOT_ROOT
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9503
diff
changeset
|
350 |
pb_size = (len(eschemas + schema.relations()) |
3386fd89c914
remove references to global environment variable APYCOT_ROOT
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9503
diff
changeset
|
351 |
+ len(CONSTRAINTS) |
3386fd89c914
remove references to global environment variable APYCOT_ROOT
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9503
diff
changeset
|
352 |
+ len([x for x in eschemas if x.specializes()])) |
3386fd89c914
remove references to global environment variable APYCOT_ROOT
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9503
diff
changeset
|
353 |
pb = ProgressBar(pb_size, title=_title) |
9503
562cef272a35
[schemaserial] Replace 'cursor' with 'cnx'
Julien Cristau <julien.cristau@logilab.fr>
parents:
9490
diff
changeset
|
354 |
groupmap = group_mapping(cnx, interactive=False) |
4800
686419cd2dff
nicer explanation
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4799
diff
changeset
|
355 |
# 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
|
356 |
# is / is_instance_of insertion |
4760
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
357 |
eschemas.remove(schema.eschema('CWEType')) |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
358 |
eschemas.insert(0, schema.eschema('CWEType')) |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
359 |
for eschema in eschemas: |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
360 |
execschemarql(execute, eschema, eschema2rql(eschema, groupmap)) |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
361 |
if pb is not None: |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
362 |
pb.update() |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
363 |
# 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
|
364 |
cstrtypemap = {} |
2597
d9c5a7e0563c
[C schema seria] cleanup
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2596
diff
changeset
|
365 |
rql = 'INSERT CWConstraintType X: X name %(ct)s' |
0 | 366 |
for cstrtype in CONSTRAINTS: |
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
|
367 |
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
|
368 |
build_descr=False)[0][0] |
3857
6676a839dc97
ensure pb is not None
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3854
diff
changeset
|
369 |
if pb is not None: |
0 | 370 |
pb.update() |
4760
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
371 |
# serialize relations |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
372 |
for rschema in schema.relations(): |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
373 |
# 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
|
374 |
if rschema in VIRTUAL_RTYPES: |
3857
6676a839dc97
ensure pb is not None
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3854
diff
changeset
|
375 |
if pb is not None: |
6676a839dc97
ensure pb is not None
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3854
diff
changeset
|
376 |
pb.update() |
0 | 377 |
continue |
9956
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
378 |
if rschema.rule: |
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
379 |
execschemarql(execute, rschema, crschema2rql(rschema)) |
9963
5531f5577b50
[CWEP002 migration] support add_relation_type for computed relations
Laura Médioni <laura.medioni@logilab.fr>
parents:
9959
diff
changeset
|
380 |
if pb is not None: |
5531f5577b50
[CWEP002 migration] support add_relation_type for computed relations
Laura Médioni <laura.medioni@logilab.fr>
parents:
9959
diff
changeset
|
381 |
pb.update() |
9956
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
382 |
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
|
383 |
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
|
384 |
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
|
385 |
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
|
386 |
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
|
387 |
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
|
388 |
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
|
389 |
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
|
390 |
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
|
391 |
rdef2rql(rdef, cstrtypemap, groupmap)) |
3857
6676a839dc97
ensure pb is not None
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3854
diff
changeset
|
392 |
if pb is not None: |
0 | 393 |
pb.update() |
6208
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
394 |
# serialize unique_together constraints |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
395 |
for eschema in eschemas: |
9375
8e88576787c3
[schema] fix unique together index handling
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9299
diff
changeset
|
396 |
if eschema._unique_together: |
8e88576787c3
[schema] fix unique together index handling
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9299
diff
changeset
|
397 |
execschemarql(execute, eschema, uniquetogether2rqls(eschema)) |
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
|
398 |
# serialize yams inheritance relationships |
0 | 399 |
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
|
400 |
execute(rql, kwargs, build_descr=False) |
3857
6676a839dc97
ensure pb is not None
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3854
diff
changeset
|
401 |
if pb is not None: |
0 | 402 |
pb.update() |
9891
3386fd89c914
remove references to global environment variable APYCOT_ROOT
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9503
diff
changeset
|
403 |
print |
0 | 404 |
|
405 |
||
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
|
406 |
# 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
|
407 |
|
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 |
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
|
409 |
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
|
410 |
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
|
411 |
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
|
412 |
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
|
413 |
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
|
414 |
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
|
415 |
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
|
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 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
|
418 |
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
|
419 |
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
|
420 |
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
|
421 |
|
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 |
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
|
423 |
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
|
424 |
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
|
425 |
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
|
426 |
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
|
427 |
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
|
428 |
|
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
|
429 |
# 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
|
430 |
|
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
|
431 |
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
|
432 |
"""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
|
433 |
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
|
434 |
""" |
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
|
435 |
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
|
436 |
# 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
|
437 |
# 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
|
438 |
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
|
439 |
# 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
|
440 |
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
|
441 |
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
|
442 |
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
|
443 |
|
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
|
444 |
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
|
445 |
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
|
446 |
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
|
447 |
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
|
448 |
|
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
|
449 |
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
|
450 |
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
|
451 |
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
|
452 |
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
|
453 |
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
|
454 |
|
9375
8e88576787c3
[schema] fix unique together index handling
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9299
diff
changeset
|
455 |
def uniquetogether2rqls(eschema): |
8e88576787c3
[schema] fix unique together index handling
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9299
diff
changeset
|
456 |
rql_args = [] |
8e88576787c3
[schema] fix unique together index handling
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9299
diff
changeset
|
457 |
for columns in eschema._unique_together: |
8e88576787c3
[schema] fix unique together index handling
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9299
diff
changeset
|
458 |
rql, args = _uniquetogether2rql(eschema, columns) |
8e88576787c3
[schema] fix unique together index handling
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9299
diff
changeset
|
459 |
args['name'] = y2sql.unique_index_name(eschema, columns) |
8e88576787c3
[schema] fix unique together index handling
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9299
diff
changeset
|
460 |
rql_args.append((rql, args)) |
8e88576787c3
[schema] fix unique together index handling
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9299
diff
changeset
|
461 |
return rql_args |
8e88576787c3
[schema] fix unique together index handling
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9299
diff
changeset
|
462 |
|
8e88576787c3
[schema] fix unique together index handling
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9299
diff
changeset
|
463 |
def _uniquetogether2rql(eschema, unique_together): |
6208
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
464 |
relations = [] |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
465 |
restrictions = [] |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
466 |
substs = {} |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
467 |
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
|
468 |
rschema = eschema.schema.rschema(name) |
6208
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
469 |
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
|
470 |
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
|
471 |
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
|
472 |
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
|
473 |
relations = ', '.join(relations) |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
474 |
restrictions = ', '.join(restrictions) |
9375
8e88576787c3
[schema] fix unique together index handling
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9299
diff
changeset
|
475 |
rql = ('INSERT CWUniqueTogetherConstraint C: C name %%(name)s, C constraint_of X, %s ' |
8e88576787c3
[schema] fix unique together index handling
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9299
diff
changeset
|
476 |
'WHERE X eid %%(x)s, %s') |
6208
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
477 |
return rql % (relations, restrictions), substs |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
478 |
|
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
479 |
|
0 | 480 |
def _ervalues(erschema): |
481 |
try: |
|
482 |
type_ = unicode(erschema.type) |
|
8695
358d8bed9626
[toward-py3k] rewrite to "except AnException as exc:" (part of #2711624)
Nicolas Chauvat <nicolas.chauvat@logilab.fr>
parents:
7815
diff
changeset
|
483 |
except UnicodeDecodeError as e: |
0 | 484 |
raise Exception("can't decode %s [was %s]" % (erschema.type, e)) |
485 |
try: |
|
486 |
desc = unicode(erschema.description) or u'' |
|
8695
358d8bed9626
[toward-py3k] rewrite to "except AnException as exc:" (part of #2711624)
Nicolas Chauvat <nicolas.chauvat@logilab.fr>
parents:
7815
diff
changeset
|
487 |
except UnicodeDecodeError as e: |
0 | 488 |
raise Exception("can't decode %s [was %s]" % (erschema.description, e)) |
489 |
return { |
|
490 |
'name': type_, |
|
3689
deb13e88e037
follow yams 0.25 api changes to improve performance
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2955
diff
changeset
|
491 |
'final': erschema.final, |
0 | 492 |
'description': desc, |
493 |
} |
|
494 |
||
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
|
495 |
# 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
|
496 |
|
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 |
def rschema2rql(rschema, cstrtypemap=None, addrdef=True, groupmap=None): |
9956
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
498 |
"""generate rql insert statements to enter a relation schema |
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
|
499 |
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
|
500 |
""" |
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 |
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
|
502 |
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
|
503 |
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
|
504 |
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
|
505 |
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
|
506 |
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
|
507 |
# 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
|
508 |
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
|
509 |
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
|
510 |
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
|
511 |
yield rql, values |
0 | 512 |
|
513 |
def rschema_relations_values(rschema): |
|
514 |
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
|
515 |
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
|
516 |
values['symmetric'] = rschema.symmetric |
0 | 517 |
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
|
518 |
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
|
519 |
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
|
520 |
else: |
aaed3f813ef8
kill dead/useless code as suggested by pylint
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4631
diff
changeset
|
521 |
values['fulltext_container'] = rschema.fulltext_container |
0 | 522 |
relations = ['X %s %%(%s)s' % (attr, attr) for attr in sorted(values)] |
523 |
return relations, values |
|
524 |
||
9956
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
525 |
def crschema2rql(crschema): |
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
526 |
relations, values = crschema_relations_values(crschema) |
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
527 |
yield 'INSERT CWComputedRType X: %s' % ','.join(relations), values |
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
528 |
|
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
529 |
def crschema_relations_values(crschema): |
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
530 |
values = _ervalues(crschema) |
9963
5531f5577b50
[CWEP002 migration] support add_relation_type for computed relations
Laura Médioni <laura.medioni@logilab.fr>
parents:
9959
diff
changeset
|
531 |
values['rule'] = unicode(crschema.rule) |
9956
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
532 |
# XXX why oh why? |
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
533 |
del values['final'] |
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
534 |
relations = ['X %s %%(%s)s' % (attr, attr) for attr in sorted(values)] |
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
535 |
return relations, values |
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
536 |
|
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
|
537 |
# 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
|
538 |
|
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
|
539 |
def rdef2rql(rdef, cstrtypemap, groupmap=None): |
9956
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
540 |
# don't serialize inferred relations |
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
|
541 |
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
|
542 |
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
|
543 |
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
|
544 |
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
|
545 |
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
|
546 |
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
|
547 |
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
|
548 |
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
|
549 |
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
|
550 |
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
|
551 |
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
|
552 |
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
|
553 |
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
|
554 |
# 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
|
555 |
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
|
556 |
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
|
557 |
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
|
558 |
|
10025
7b72ecc3f4d2
[migration] hackish black magic to bootstrap addition of formula attr during migration
Julien Cristau <julien.cristau@logilab.fr>
parents:
9968
diff
changeset
|
559 |
_IGNORED_PROPS = ['eid', 'constraints', 'uid', 'infered', 'permissions'] |
7b72ecc3f4d2
[migration] hackish black magic to bootstrap addition of formula attr during migration
Julien Cristau <julien.cristau@logilab.fr>
parents:
9968
diff
changeset
|
560 |
|
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
|
561 |
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
|
562 |
amap = {'order': 'ordernum', 'default': 'defaultval'} |
0 | 563 |
values = {} |
8945
ba9e3fbfa5a5
[schemaserial] serialize additional yams parameter for customs type
Vincent Michel <vincent.michel@logilab.fr>
parents:
8748
diff
changeset
|
564 |
extra = {} |
ba9e3fbfa5a5
[schemaserial] serialize additional yams parameter for customs type
Vincent Michel <vincent.michel@logilab.fr>
parents:
8748
diff
changeset
|
565 |
for prop in rdef.rproperty_defs(rdef.object): |
10025
7b72ecc3f4d2
[migration] hackish black magic to bootstrap addition of formula attr during migration
Julien Cristau <julien.cristau@logilab.fr>
parents:
9968
diff
changeset
|
566 |
if prop in _IGNORED_PROPS: |
0 | 567 |
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
|
568 |
value = getattr(rdef, prop) |
8945
ba9e3fbfa5a5
[schemaserial] serialize additional yams parameter for customs type
Vincent Michel <vincent.michel@logilab.fr>
parents:
8748
diff
changeset
|
569 |
if prop not in KNOWN_RPROPERTIES: |
ba9e3fbfa5a5
[schemaserial] serialize additional yams parameter for customs type
Vincent Michel <vincent.michel@logilab.fr>
parents:
8748
diff
changeset
|
570 |
extra[prop] = value |
ba9e3fbfa5a5
[schemaserial] serialize additional yams parameter for customs type
Vincent Michel <vincent.michel@logilab.fr>
parents:
8748
diff
changeset
|
571 |
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
|
572 |
# XXX type cast really necessary? |
0 | 573 |
if prop in ('indexed', 'fulltextindexed', 'internationalizable'): |
574 |
value = bool(value) |
|
575 |
elif prop == 'ordernum': |
|
576 |
value = int(value) |
|
577 |
elif isinstance(value, str): |
|
578 |
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
|
579 |
if value is not None and prop == 'default': |
9299
c5eed908117d
[schema] store default attribute values in a Bytes field, allowing python objects as default values
Aurélien Campeas <aurelien.campeas@logilab.fr>
parents:
9257
diff
changeset
|
580 |
value = Binary.zpickle(value) |
0 | 581 |
values[amap.get(prop, prop)] = value |
8945
ba9e3fbfa5a5
[schemaserial] serialize additional yams parameter for customs type
Vincent Michel <vincent.michel@logilab.fr>
parents:
8748
diff
changeset
|
582 |
if extra: |
ba9e3fbfa5a5
[schemaserial] serialize additional yams parameter for customs type
Vincent Michel <vincent.michel@logilab.fr>
parents:
8748
diff
changeset
|
583 |
values['extra_props'] = Binary(json.dumps(extra)) |
0 | 584 |
relations = ['X %s %%(%s)s' % (attr, attr) for attr in sorted(values)] |
585 |
return relations, values |
|
586 |
||
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
|
587 |
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
|
588 |
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
|
589 |
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
|
590 |
'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
|
591 |
'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
|
592 |
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
|
593 |
CT eid %(ct)s, EDEF eid %(x)s', values |
0 | 594 |
|
595 |
||
4011
394f853bb653
[migration] write migration instructions for permissions handling on relation definition
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
4010
diff
changeset
|
596 |
def _erperms2rql(erschema, groupmap): |
0 | 597 |
"""return rql insert statements to enter the entity or relation |
598 |
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
|
599 |
[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
|
600 |
and CWGroup entities |
0 | 601 |
""" |
602 |
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
|
603 |
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
|
604 |
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
|
605 |
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
|
606 |
# 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
|
607 |
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
|
608 |
for group_or_rqlexpr in grantedto: |
3877
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
609 |
if isinstance(group_or_rqlexpr, basestring): |
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
610 |
# group |
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
611 |
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
|
612 |
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
|
613 |
{'g': groupmap[group_or_rqlexpr]}) |
3877
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
614 |
except KeyError: |
7219
d961184f9a86
[schema serialization] add warning on missing group
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
7012
diff
changeset
|
615 |
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
|
616 |
" 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
|
617 |
continue |
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
618 |
else: |
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
619 |
# rqlexpr |
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
620 |
rqlexpr = group_or_rqlexpr |
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
621 |
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
|
622 |
'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
|
623 |
{'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
|
624 |
'v': unicode(','.join(sorted(rqlexpr.mainvars))), |
3877
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
625 |
't': unicode(rqlexpr.__class__.__name__)}) |
0 | 626 |
|
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
|
627 |
# update functions |
0 | 628 |
|
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
|
629 |
def updateeschema2rql(eschema, eid): |
0 | 630 |
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
|
631 |
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
|
632 |
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
|
633 |
|
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
|
634 |
def updaterschema2rql(rschema, eid): |
9964
f4a3ee05cf9d
[CWEP002 migration] support sync_schema_props_perms for computed relations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9963
diff
changeset
|
635 |
if rschema.rule: |
f4a3ee05cf9d
[CWEP002 migration] support sync_schema_props_perms for computed relations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9963
diff
changeset
|
636 |
yield ('SET X rule %(r)s WHERE X eid %(x)s', |
f4a3ee05cf9d
[CWEP002 migration] support sync_schema_props_perms for computed relations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9963
diff
changeset
|
637 |
{'x': eid, 'r': unicode(rschema.rule)}) |
f4a3ee05cf9d
[CWEP002 migration] support sync_schema_props_perms for computed relations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9963
diff
changeset
|
638 |
else: |
f4a3ee05cf9d
[CWEP002 migration] support sync_schema_props_perms for computed relations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9963
diff
changeset
|
639 |
relations, values = rschema_relations_values(rschema) |
f4a3ee05cf9d
[CWEP002 migration] support sync_schema_props_perms for computed relations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9963
diff
changeset
|
640 |
values['x'] = eid |
f4a3ee05cf9d
[CWEP002 migration] support sync_schema_props_perms for computed relations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9963
diff
changeset
|
641 |
yield 'SET %s WHERE X eid %%(x)s' % ','.join(relations), values |
0 | 642 |
|
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
|
643 |
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
|
644 |
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
|
645 |
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
|
646 |
yield 'SET %s WHERE X eid %%(x)s' % ','.join(relations), values |