author | Julien Cristau <julien.cristau@logilab.fr> |
Mon, 23 Nov 2015 17:58:10 +0100 | |
changeset 10897 | 7c386161ebd6 |
parent 10789 | d5671a61f281 |
child 11146 | 517e7cdd7b1b |
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""" |
10589
7c23b7de2b8d
[py3k] print function
Samuel Trégouët <samuel.tregouet@logilab.fr>
parents:
10553
diff
changeset
|
19 |
from __future__ import print_function |
0 | 20 |
|
21 |
__docformat__ = "restructuredtext en" |
|
22 |
||
3854
8633cd05b6b5
no progress bar in apycot environment
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3689
diff
changeset
|
23 |
import os |
8945
ba9e3fbfa5a5
[schemaserial] serialize additional yams parameter for customs type
Vincent Michel <vincent.michel@logilab.fr>
parents:
8748
diff
changeset
|
24 |
import json |
10375
28ec01db78b3
[server] Do not use progress bar when stdout is not a TTY
Denis Laxalde <denis.laxalde@logilab.fr>
parents:
10191
diff
changeset
|
25 |
import sys |
0 | 26 |
|
10683
e83de6c409fd
[py3k] unicode → six.text_type
Rémi Cardona <remi.cardona@logilab.fr>
parents:
10663
diff
changeset
|
27 |
from six import PY2, text_type, string_types |
10612
84468b90e9c1
[py3k] basestring → six.string_types
Rémi Cardona <remi.cardona@logilab.fr>
parents:
10589
diff
changeset
|
28 |
|
10375
28ec01db78b3
[server] Do not use progress bar when stdout is not a TTY
Denis Laxalde <denis.laxalde@logilab.fr>
parents:
10191
diff
changeset
|
29 |
from logilab.common.shellutils import ProgressBar, DummyProgressBar |
0 | 30 |
|
10200
cceb2c7c02f4
Use our version of schema2sql
Julien Cristau <julien.cristau@logilab.fr>
parents:
10191
diff
changeset
|
31 |
from yams import BadSchemaDefinition, schema as schemamod, buildobjs as ybo |
0 | 32 |
|
9468
39b7a91a3f4c
[repo] pylint cleanup, mainly of imports, with a bit of style
Julien Cristau <julien.cristau@logilab.fr>
parents:
9463
diff
changeset
|
33 |
from cubicweb import Binary |
8945
ba9e3fbfa5a5
[schemaserial] serialize additional yams parameter for customs type
Vincent Michel <vincent.michel@logilab.fr>
parents:
8748
diff
changeset
|
34 |
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
|
35 |
VIRTUAL_RTYPES) |
10200
cceb2c7c02f4
Use our version of schema2sql
Julien Cristau <julien.cristau@logilab.fr>
parents:
10191
diff
changeset
|
36 |
from cubicweb.server import sqlutils, schema2sql as y2sql |
0 | 37 |
|
8945
ba9e3fbfa5a5
[schemaserial] serialize additional yams parameter for customs type
Vincent Michel <vincent.michel@logilab.fr>
parents:
8748
diff
changeset
|
38 |
|
9503
562cef272a35
[schemaserial] Replace 'cursor' with 'cnx'
Julien Cristau <julien.cristau@logilab.fr>
parents:
9490
diff
changeset
|
39 |
def group_mapping(cnx, interactive=True): |
0 | 40 |
"""create a group mapping from an rql cursor |
41 |
||
42 |
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
|
43 |
and the actual CWGroup entity's eid as associated value. |
0 | 44 |
In interactive mode (the default), missing groups'eid will be prompted |
45 |
from the user. |
|
46 |
""" |
|
47 |
res = {} |
|
9503
562cef272a35
[schemaserial] Replace 'cursor' with 'cnx'
Julien Cristau <julien.cristau@logilab.fr>
parents:
9490
diff
changeset
|
48 |
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
|
49 |
build_descr=False): |
0 | 50 |
res[name] = eid |
51 |
if not interactive: |
|
52 |
return res |
|
53 |
missing = [g for g in ('owners', 'managers', 'users', 'guests') if not g in res] |
|
54 |
if missing: |
|
10589
7c23b7de2b8d
[py3k] print function
Samuel Trégouët <samuel.tregouet@logilab.fr>
parents:
10553
diff
changeset
|
55 |
print('some native groups are missing but the following groups have been found:') |
7c23b7de2b8d
[py3k] print function
Samuel Trégouët <samuel.tregouet@logilab.fr>
parents:
10553
diff
changeset
|
56 |
print('\n'.join('* %s (%s)' % (n, eid) for n, eid in res.items())) |
7c23b7de2b8d
[py3k] print function
Samuel Trégouët <samuel.tregouet@logilab.fr>
parents:
10553
diff
changeset
|
57 |
print() |
7c23b7de2b8d
[py3k] print function
Samuel Trégouët <samuel.tregouet@logilab.fr>
parents:
10553
diff
changeset
|
58 |
print('enter the eid of a to group to map to each missing native group') |
7c23b7de2b8d
[py3k] print function
Samuel Trégouët <samuel.tregouet@logilab.fr>
parents:
10553
diff
changeset
|
59 |
print('or just type enter to skip permissions granted to a group') |
0 | 60 |
for group in missing: |
61 |
while True: |
|
62 |
value = raw_input('eid for group %s: ' % group).strip() |
|
63 |
if not value: |
|
64 |
continue |
|
65 |
try: |
|
8748
f5027f8d2478
drop typed_eid() in favour of int() (closes #2742462)
Nicolas Chauvat <nicolas.chauvat@logilab.fr>
parents:
8695
diff
changeset
|
66 |
eid = int(value) |
0 | 67 |
except ValueError: |
10589
7c23b7de2b8d
[py3k] print function
Samuel Trégouët <samuel.tregouet@logilab.fr>
parents:
10553
diff
changeset
|
68 |
print('eid should be an integer') |
0 | 69 |
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
|
70 |
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
|
71 |
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
|
72 |
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
|
73 |
else: |
10589
7c23b7de2b8d
[py3k] print function
Samuel Trégouët <samuel.tregouet@logilab.fr>
parents:
10553
diff
changeset
|
74 |
print('eid is not a group eid') |
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
|
75 |
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
|
76 |
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
|
77 |
break |
0 | 78 |
return res |
79 |
||
9489
0581f6d2812e
[server/schemaserial] rename cursor argument to cnx
Julien Cristau <julien.cristau@logilab.fr>
parents:
9468
diff
changeset
|
80 |
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
|
81 |
"""cached constraint types mapping""" |
9489
0581f6d2812e
[server/schemaserial] rename cursor argument to cnx
Julien Cristau <julien.cristau@logilab.fr>
parents:
9468
diff
changeset
|
82 |
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
|
83 |
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
|
84 |
|
0 | 85 |
# 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
|
86 |
|
9490
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
87 |
def deserialize_schema(schema, cnx): |
0 | 88 |
"""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
|
89 |
as CWRType and CWEType entities |
0 | 90 |
""" |
9490
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
91 |
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
|
92 |
dbhelper = repo.system_source.dbhelper |
9956
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
93 |
|
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
94 |
# Computed Rtype |
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
95 |
with cnx.ensure_cnx_set: |
10191
cc4b8021bdf3
[schemaserial] fix detection of CWComputedRType table, closes #4901150
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
10115
diff
changeset
|
96 |
tables = set(t.lower() for t in dbhelper.list_tables(cnx.cnxset.cu)) |
cc4b8021bdf3
[schemaserial] fix detection of CWComputedRType table, closes #4901150
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
10115
diff
changeset
|
97 |
has_computed_relations = 'cw_cwcomputedrtype' in tables |
9968
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
98 |
# computed attribute |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
99 |
try: |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
100 |
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
|
101 |
has_computed_attributes = True |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
102 |
except Exception: |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
103 |
cnx.rollback() |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
104 |
has_computed_attributes = False |
9956
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
105 |
|
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
|
106 |
# XXX bw compat (3.6 migration) |
10365
21461f80f348
[connection] remove ensure_cnx_set context manager uses
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
10200
diff
changeset
|
107 |
sqlcu = cnx.system_sql("SELECT * FROM cw_CWRType WHERE cw_name='symetric'") |
21461f80f348
[connection] remove ensure_cnx_set context manager uses
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
10200
diff
changeset
|
108 |
if sqlcu.fetchall(): |
21461f80f348
[connection] remove ensure_cnx_set context manager uses
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
10200
diff
changeset
|
109 |
sql = dbhelper.sql_rename_col('cw_CWRType', 'cw_symetric', 'cw_symmetric', |
21461f80f348
[connection] remove ensure_cnx_set context manager uses
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
10200
diff
changeset
|
110 |
dbhelper.TYPE_MAPPING['Boolean'], True) |
21461f80f348
[connection] remove ensure_cnx_set context manager uses
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
10200
diff
changeset
|
111 |
sqlcu.execute(sql) |
21461f80f348
[connection] remove ensure_cnx_set context manager uses
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
10200
diff
changeset
|
112 |
sqlcu.execute("UPDATE cw_CWRType SET cw_name='symmetric' WHERE cw_name='symetric'") |
21461f80f348
[connection] remove ensure_cnx_set context manager uses
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
10200
diff
changeset
|
113 |
cnx.commit() |
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
|
114 |
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
|
115 |
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
|
116 |
permsidx = deserialize_ertype_permissions(cnx) |
0 | 117 |
schema.reading_from_database = True |
9959
6047bf8df9e5
[schema serial] add some comments
Laura Médioni <laura.medioni@logilab.fr>
parents:
9956
diff
changeset
|
118 |
# 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
|
119 |
for eid, etype, desc in cnx.execute( |
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
120 |
'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
|
121 |
build_descr=False): |
0 | 122 |
# base types are already in the schema, skip them |
123 |
if etype in schemamod.BASE_TYPES: |
|
124 |
# just set the eid |
|
125 |
eschema = schema.eschema(etype) |
|
126 |
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
|
127 |
ertidx[eid] = etype |
0 | 128 |
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
|
129 |
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
|
130 |
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
|
131 |
netype = ETYPE_NAME_MAP[etype] |
0 | 132 |
# 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
|
133 |
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
|
134 |
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
|
135 |
% {'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
|
136 |
# 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
|
137 |
# 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
|
138 |
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
|
139 |
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
|
140 |
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
|
141 |
# 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
|
142 |
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
|
143 |
% {'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
|
144 |
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
|
145 |
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
|
146 |
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
|
147 |
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
|
148 |
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
|
149 |
{'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
|
150 |
cnx.commit(False) |
0 | 151 |
tocleanup = [eid] |
10662
10942ed172de
[py3k] dict.iteritems → dict.items
Rémi Cardona <remi.cardona@logilab.fr>
parents:
10612
diff
changeset
|
152 |
tocleanup += (eid for eid, cached in repo._type_source_cache.items() |
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
|
153 |
if etype == cached[0]) |
1630
41aadba8b29f
delete-trailing-whitespaces, check table existance
sylvain.thenault@logilab.fr
parents:
1398
diff
changeset
|
154 |
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
|
155 |
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
|
156 |
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
|
157 |
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
|
158 |
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
|
159 |
# 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
|
160 |
# 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
|
161 |
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
|
162 |
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
|
163 |
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
|
164 |
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
|
165 |
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
|
166 |
set_perms(eschema, permsidx) |
9959
6047bf8df9e5
[schema serial] add some comments
Laura Médioni <laura.medioni@logilab.fr>
parents:
9956
diff
changeset
|
167 |
# 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
|
168 |
for etype, stype in cnx.execute( |
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
169 |
'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
|
170 |
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
|
171 |
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
|
172 |
stype = ETYPE_NAME_MAP.get(stype, stype) |
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
173 |
schema.eschema(etype)._specialized_type = stype |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
174 |
schema.eschema(stype)._specialized_by.append(etype) |
10553
1d824df4f2bd
Fix (de)serialization of ComputedRelation read permissions
Julien Cristau <julien.cristau@logilab.fr>
parents:
10411
diff
changeset
|
175 |
if has_computed_relations: |
1d824df4f2bd
Fix (de)serialization of ComputedRelation read permissions
Julien Cristau <julien.cristau@logilab.fr>
parents:
10411
diff
changeset
|
176 |
rset = cnx.execute( |
1d824df4f2bd
Fix (de)serialization of ComputedRelation read permissions
Julien Cristau <julien.cristau@logilab.fr>
parents:
10411
diff
changeset
|
177 |
'Any X, N, R, D WHERE X is CWComputedRType, X name N, ' |
1d824df4f2bd
Fix (de)serialization of ComputedRelation read permissions
Julien Cristau <julien.cristau@logilab.fr>
parents:
10411
diff
changeset
|
178 |
'X rule R, X description D') |
1d824df4f2bd
Fix (de)serialization of ComputedRelation read permissions
Julien Cristau <julien.cristau@logilab.fr>
parents:
10411
diff
changeset
|
179 |
for eid, rule_name, rule, description in rset.rows: |
1d824df4f2bd
Fix (de)serialization of ComputedRelation read permissions
Julien Cristau <julien.cristau@logilab.fr>
parents:
10411
diff
changeset
|
180 |
rtype = ybo.ComputedRelation(name=rule_name, rule=rule, eid=eid, |
1d824df4f2bd
Fix (de)serialization of ComputedRelation read permissions
Julien Cristau <julien.cristau@logilab.fr>
parents:
10411
diff
changeset
|
181 |
description=description) |
1d824df4f2bd
Fix (de)serialization of ComputedRelation read permissions
Julien Cristau <julien.cristau@logilab.fr>
parents:
10411
diff
changeset
|
182 |
rschema = schema.add_relation_type(rtype) |
1d824df4f2bd
Fix (de)serialization of ComputedRelation read permissions
Julien Cristau <julien.cristau@logilab.fr>
parents:
10411
diff
changeset
|
183 |
set_perms(rschema, permsidx) |
9959
6047bf8df9e5
[schema serial] add some comments
Laura Médioni <laura.medioni@logilab.fr>
parents:
9956
diff
changeset
|
184 |
# 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
|
185 |
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
|
186 |
'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
|
187 |
'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
|
188 |
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
|
189 |
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
|
190 |
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
|
191 |
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
|
192 |
fulltext_container=ftc, eid=eid)) |
9959
6047bf8df9e5
[schema serial] add some comments
Laura Médioni <laura.medioni@logilab.fr>
parents:
9956
diff
changeset
|
193 |
# 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
|
194 |
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
|
195 |
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
|
196 |
# 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
|
197 |
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
|
198 |
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
|
199 |
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
|
200 |
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
|
201 |
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
|
202 |
# 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
|
203 |
# 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
|
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 |
# * 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
|
206 |
# 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
|
207 |
# |
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 |
# * 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
|
209 |
# 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
|
210 |
# 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
|
211 |
# 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
|
212 |
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
|
213 |
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
|
214 |
# 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
|
215 |
# 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
|
216 |
# 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
|
217 |
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
|
218 |
if rdefs is not None: |
6208
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
219 |
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
|
220 |
set_perms(rdefs, permsidx) |
8945
ba9e3fbfa5a5
[schemaserial] serialize additional yams parameter for customs type
Vincent Michel <vincent.michel@logilab.fr>
parents:
8748
diff
changeset
|
221 |
# 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
|
222 |
try: |
9490
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
223 |
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
|
224 |
'X extra_props XTP')) |
8945
ba9e3fbfa5a5
[schemaserial] serialize additional yams parameter for customs type
Vincent Michel <vincent.michel@logilab.fr>
parents:
8748
diff
changeset
|
225 |
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
|
226 |
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
|
227 |
'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
|
228 |
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
|
229 |
|
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
230 |
# load attributes |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
231 |
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
|
232 |
'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
|
233 |
' 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
|
234 |
' 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
|
235 |
' 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
|
236 |
if has_computed_attributes: |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
237 |
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
|
238 |
else: |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
239 |
rql = rql % {'fm': '', 'fmsnip': ''} |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
240 |
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
|
241 |
attrs = dict(zip( |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
242 |
('rdefeid', 'seid', 'reid', 'oeid', 'cardinality', |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
243 |
'order', 'description', 'indexed', 'fulltextindexed', |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
244 |
'internationalizable', 'default', 'formula'), values)) |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
245 |
typeparams = extra_props.get(attrs['rdefeid']) |
10789
d5671a61f281
[server/schemaserial] fix extra_props on py3k
Julien Cristau <julien.cristau@logilab.fr>
parents:
10683
diff
changeset
|
246 |
attrs.update(json.loads(typeparams.getvalue().decode('ascii')) if typeparams else {}) |
9968
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
247 |
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
|
248 |
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
|
249 |
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
|
250 |
# 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
|
251 |
# handle String defaults |
9968
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
252 |
attrs['default'] = default.unzpickle() |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
253 |
_add_rdef(**attrs) |
50f046bf0e50
[CWEP002] properly handle serialization of computed attributes
Lea Capgen <lea.capgen@logilab.fr>
parents:
9964
diff
changeset
|
254 |
# 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
|
255 |
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
|
256 |
'Any X,SE,RT,OE,CARD,ORD,DESC,C WHERE X is CWRelation, X relation_type RT,' |
0 | 257 |
'X cardinality CARD, X ordernum ORD, X description DESC, ' |
258 |
'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
|
259 |
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
|
260 |
_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
|
261 |
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
|
262 |
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
|
263 |
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
|
264 |
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
|
265 |
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
|
266 |
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
|
267 |
continue |
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
268 |
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
|
269 |
set_perms(rdefs, permsidx) |
6208
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
270 |
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
|
271 |
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
|
272 |
'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
|
273 |
'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
|
274 |
'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
|
275 |
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
|
276 |
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
|
277 |
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
|
278 |
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
|
279 |
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
|
280 |
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
|
281 |
# 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
|
282 |
# 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
|
283 |
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
|
284 |
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
|
285 |
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
|
286 |
relations[1].append(rtype) |
10663
54b8a1f249fb
[py3k] dict.itervalues → dict.values
Rémi Cardona <remi.cardona@logilab.fr>
parents:
10662
diff
changeset
|
287 |
for eschema, unique_together in unique_togethers.values(): |
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
|
288 |
eschema._unique_together.append(tuple(sorted(unique_together))) |
0 | 289 |
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
|
290 |
cnx.commit() |
9956
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
291 |
schema.finalize() |
0 | 292 |
schema.reading_from_database = False |
293 |
||
294 |
||
9490
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
295 |
def deserialize_ertype_permissions(cnx): |
0 | 296 |
"""return sect action:groups associations for the given |
297 |
entity or relation schema with its eid, according to schema's |
|
298 |
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
|
299 |
relations between CWEType/CWRType and CWGroup entities |
0 | 300 |
""" |
301 |
res = {} |
|
302 |
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
|
303 |
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
|
304 |
for eid, gname in cnx.execute(rql, build_descr=False): |
0 | 305 |
res.setdefault(eid, {}).setdefault(action, []).append(gname) |
306 |
rql = ('Any E,X,EXPR,V WHERE X is RQLExpression, X expression EXPR, ' |
|
307 |
'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
|
308 |
for eid, expreid, expr, mainvars in cnx.execute(rql, build_descr=False): |
0 | 309 |
# we don't know yet if it's a rql expr for an entity or a relation, |
310 |
# so append a tuple to differentiate from groups and so we'll be |
|
311 |
# able to instantiate it later |
|
312 |
res.setdefault(eid, {}).setdefault(action, []).append( (expr, mainvars, expreid) ) |
|
313 |
return res |
|
314 |
||
9490
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
315 |
def deserialize_rdef_constraints(cnx): |
4760
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
316 |
"""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
|
317 |
res = {} |
9490
b3d2c4065e6a
[server] use internal_cnx instead of internal_session in deserialize_schema
Julien Cristau <julien.cristau@logilab.fr>
parents:
9489
diff
changeset
|
318 |
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
|
319 |
'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
|
320 |
'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
|
321 |
cstr = CONSTRAINTS[ct].deserialize(val) |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
322 |
cstr.eid = ceid |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
323 |
res.setdefault(rdefeid, []).append(cstr) |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
324 |
return res |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
325 |
|
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
|
326 |
def set_perms(erschema, permsidx): |
0 | 327 |
"""set permissions on the given erschema according to the permission |
328 |
definition dictionary as built by deserialize_ertype_permissions for a |
|
329 |
given erschema's eid |
|
330 |
""" |
|
4570
ede247bbbf62
follow yams api change: attributes permissions are now defined for
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4475
diff
changeset
|
331 |
# 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
|
332 |
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
|
333 |
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
|
334 |
thispermsdict = permsidx[erschema.eid] |
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
335 |
except KeyError: |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
336 |
return |
10662
10942ed172de
[py3k] dict.iteritems → dict.items
Rémi Cardona <remi.cardona@logilab.fr>
parents:
10612
diff
changeset
|
337 |
for action, somethings in thispermsdict.items(): |
4570
ede247bbbf62
follow yams api change: attributes permissions are now defined for
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4475
diff
changeset
|
338 |
erschema.permissions[action] = tuple( |
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
339 |
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
|
340 |
for p in somethings) |
0 | 341 |
|
342 |
||
343 |
# schema / perms serialization ################################################ |
|
344 |
||
9503
562cef272a35
[schemaserial] Replace 'cursor' with 'cnx'
Julien Cristau <julien.cristau@logilab.fr>
parents:
9490
diff
changeset
|
345 |
def serialize_schema(cnx, schema): |
0 | 346 |
"""synchronize schema and permissions in the database according to |
347 |
current schema |
|
348 |
""" |
|
9891
3386fd89c914
remove references to global environment variable APYCOT_ROOT
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9503
diff
changeset
|
349 |
_title = '-> storing the schema in the database ' |
10589
7c23b7de2b8d
[py3k] print function
Samuel Trégouët <samuel.tregouet@logilab.fr>
parents:
10553
diff
changeset
|
350 |
print(_title, end=' ') |
9503
562cef272a35
[schemaserial] Replace 'cursor' with 'cnx'
Julien Cristau <julien.cristau@logilab.fr>
parents:
9490
diff
changeset
|
351 |
execute = cnx.execute |
0 | 352 |
eschemas = schema.entities() |
9891
3386fd89c914
remove references to global environment variable APYCOT_ROOT
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9503
diff
changeset
|
353 |
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
|
354 |
+ len(CONSTRAINTS) |
3386fd89c914
remove references to global environment variable APYCOT_ROOT
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9503
diff
changeset
|
355 |
+ len([x for x in eschemas if x.specializes()])) |
10375
28ec01db78b3
[server] Do not use progress bar when stdout is not a TTY
Denis Laxalde <denis.laxalde@logilab.fr>
parents:
10191
diff
changeset
|
356 |
if sys.stdout.isatty(): |
28ec01db78b3
[server] Do not use progress bar when stdout is not a TTY
Denis Laxalde <denis.laxalde@logilab.fr>
parents:
10191
diff
changeset
|
357 |
pb = ProgressBar(pb_size, title=_title) |
28ec01db78b3
[server] Do not use progress bar when stdout is not a TTY
Denis Laxalde <denis.laxalde@logilab.fr>
parents:
10191
diff
changeset
|
358 |
else: |
28ec01db78b3
[server] Do not use progress bar when stdout is not a TTY
Denis Laxalde <denis.laxalde@logilab.fr>
parents:
10191
diff
changeset
|
359 |
pb = DummyProgressBar() |
9503
562cef272a35
[schemaserial] Replace 'cursor' with 'cnx'
Julien Cristau <julien.cristau@logilab.fr>
parents:
9490
diff
changeset
|
360 |
groupmap = group_mapping(cnx, interactive=False) |
4800
686419cd2dff
nicer explanation
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4799
diff
changeset
|
361 |
# 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
|
362 |
# is / is_instance_of insertion |
4760
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
363 |
eschemas.remove(schema.eschema('CWEType')) |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
364 |
eschemas.insert(0, schema.eschema('CWEType')) |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
365 |
for eschema in eschemas: |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
366 |
execschemarql(execute, eschema, eschema2rql(eschema, groupmap)) |
10115
6fd167b140cd
[server] Remove useless 'is None' checks
Rémi Cardona <remi.cardona@logilab.fr>
parents:
10095
diff
changeset
|
367 |
pb.update() |
4760
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
368 |
# 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
|
369 |
cstrtypemap = {} |
2597
d9c5a7e0563c
[C schema seria] cleanup
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2596
diff
changeset
|
370 |
rql = 'INSERT CWConstraintType X: X name %(ct)s' |
0 | 371 |
for cstrtype in CONSTRAINTS: |
10683
e83de6c409fd
[py3k] unicode → six.text_type
Rémi Cardona <remi.cardona@logilab.fr>
parents:
10663
diff
changeset
|
372 |
cstrtypemap[cstrtype] = execute(rql, {'ct': text_type(cstrtype)}, |
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
|
373 |
build_descr=False)[0][0] |
10115
6fd167b140cd
[server] Remove useless 'is None' checks
Rémi Cardona <remi.cardona@logilab.fr>
parents:
10095
diff
changeset
|
374 |
pb.update() |
4760
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
375 |
# serialize relations |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
376 |
for rschema in schema.relations(): |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
377 |
# 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
|
378 |
if rschema in VIRTUAL_RTYPES: |
10115
6fd167b140cd
[server] Remove useless 'is None' checks
Rémi Cardona <remi.cardona@logilab.fr>
parents:
10095
diff
changeset
|
379 |
pb.update() |
0 | 380 |
continue |
9956
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
381 |
if rschema.rule: |
10553
1d824df4f2bd
Fix (de)serialization of ComputedRelation read permissions
Julien Cristau <julien.cristau@logilab.fr>
parents:
10411
diff
changeset
|
382 |
execschemarql(execute, rschema, crschema2rql(rschema, groupmap)) |
10115
6fd167b140cd
[server] Remove useless 'is None' checks
Rémi Cardona <remi.cardona@logilab.fr>
parents:
10095
diff
changeset
|
383 |
pb.update() |
9956
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
384 |
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
|
385 |
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
|
386 |
if rschema.symmetric: |
10662
10942ed172de
[py3k] dict.iteritems → dict.items
Rémi Cardona <remi.cardona@logilab.fr>
parents:
10612
diff
changeset
|
387 |
rdefs = [rdef for k, rdef in rschema.rdefs.items() |
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
|
388 |
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
|
389 |
else: |
10663
54b8a1f249fb
[py3k] dict.itervalues → dict.values
Rémi Cardona <remi.cardona@logilab.fr>
parents:
10662
diff
changeset
|
390 |
rdefs = rschema.rdefs.values() |
4763
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
391 |
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
|
392 |
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
|
393 |
rdef2rql(rdef, cstrtypemap, groupmap)) |
10115
6fd167b140cd
[server] Remove useless 'is None' checks
Rémi Cardona <remi.cardona@logilab.fr>
parents:
10095
diff
changeset
|
394 |
pb.update() |
6208
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
395 |
# serialize unique_together constraints |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
396 |
for eschema in eschemas: |
9375
8e88576787c3
[schema] fix unique together index handling
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9299
diff
changeset
|
397 |
if eschema._unique_together: |
8e88576787c3
[schema] fix unique together index handling
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9299
diff
changeset
|
398 |
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
|
399 |
# serialize yams inheritance relationships |
0 | 400 |
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
|
401 |
execute(rql, kwargs, build_descr=False) |
10115
6fd167b140cd
[server] Remove useless 'is None' checks
Rémi Cardona <remi.cardona@logilab.fr>
parents:
10095
diff
changeset
|
402 |
pb.update() |
10589
7c23b7de2b8d
[py3k] print function
Samuel Trégouët <samuel.tregouet@logilab.fr>
parents:
10553
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 = [] |
10054
8f7291354095
[schemaserial] be robust against duplicated CWUniqueTogetherConstrain entities arising from bug in the pre 3.18 era
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9395
diff
changeset
|
457 |
# robustness against duplicated CWUniqueTogetherConstraint (pre 3.18) |
8f7291354095
[schemaserial] be robust against duplicated CWUniqueTogetherConstrain entities arising from bug in the pre 3.18 era
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9395
diff
changeset
|
458 |
columnset = set() |
9375
8e88576787c3
[schema] fix unique together index handling
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9299
diff
changeset
|
459 |
for columns in eschema._unique_together: |
10054
8f7291354095
[schemaserial] be robust against duplicated CWUniqueTogetherConstrain entities arising from bug in the pre 3.18 era
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9395
diff
changeset
|
460 |
if columns in columnset: |
10589
7c23b7de2b8d
[py3k] print function
Samuel Trégouët <samuel.tregouet@logilab.fr>
parents:
10553
diff
changeset
|
461 |
print('schemaserial: skipping duplicate unique together %r %r' % |
7c23b7de2b8d
[py3k] print function
Samuel Trégouët <samuel.tregouet@logilab.fr>
parents:
10553
diff
changeset
|
462 |
(eschema.type, columns)) |
10054
8f7291354095
[schemaserial] be robust against duplicated CWUniqueTogetherConstrain entities arising from bug in the pre 3.18 era
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9395
diff
changeset
|
463 |
continue |
8f7291354095
[schemaserial] be robust against duplicated CWUniqueTogetherConstrain entities arising from bug in the pre 3.18 era
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9395
diff
changeset
|
464 |
columnset.add(columns) |
9375
8e88576787c3
[schema] fix unique together index handling
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9299
diff
changeset
|
465 |
rql, args = _uniquetogether2rql(eschema, columns) |
8e88576787c3
[schema] fix unique together index handling
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9299
diff
changeset
|
466 |
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
|
467 |
rql_args.append((rql, args)) |
8e88576787c3
[schema] fix unique together index handling
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9299
diff
changeset
|
468 |
return rql_args |
8e88576787c3
[schema] fix unique together index handling
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9299
diff
changeset
|
469 |
|
8e88576787c3
[schema] fix unique together index handling
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9299
diff
changeset
|
470 |
def _uniquetogether2rql(eschema, unique_together): |
6208
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
471 |
relations = [] |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
472 |
restrictions = [] |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
473 |
substs = {} |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
474 |
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
|
475 |
rschema = eschema.schema.rschema(name) |
6208
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
476 |
rtype = 'T%d' % i |
10683
e83de6c409fd
[py3k] unicode → six.text_type
Rémi Cardona <remi.cardona@logilab.fr>
parents:
10663
diff
changeset
|
477 |
substs[rtype] = text_type(rschema.type) |
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
|
478 |
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
|
479 |
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
|
480 |
relations = ', '.join(relations) |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
481 |
restrictions = ', '.join(restrictions) |
9375
8e88576787c3
[schema] fix unique together index handling
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
9299
diff
changeset
|
482 |
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
|
483 |
'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
|
484 |
return rql % (relations, restrictions), substs |
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
485 |
|
07b176640a8c
unique_together integration in CW (alf+syt)
Alexandre Fayolle <alexandre.fayolle@logilab.fr>
parents:
6199
diff
changeset
|
486 |
|
0 | 487 |
def _ervalues(erschema): |
488 |
try: |
|
10683
e83de6c409fd
[py3k] unicode → six.text_type
Rémi Cardona <remi.cardona@logilab.fr>
parents:
10663
diff
changeset
|
489 |
type_ = text_type(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
|
490 |
except UnicodeDecodeError as e: |
0 | 491 |
raise Exception("can't decode %s [was %s]" % (erschema.type, e)) |
492 |
try: |
|
10683
e83de6c409fd
[py3k] unicode → six.text_type
Rémi Cardona <remi.cardona@logilab.fr>
parents:
10663
diff
changeset
|
493 |
desc = text_type(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
|
494 |
except UnicodeDecodeError as e: |
0 | 495 |
raise Exception("can't decode %s [was %s]" % (erschema.description, e)) |
496 |
return { |
|
497 |
'name': type_, |
|
3689
deb13e88e037
follow yams 0.25 api changes to improve performance
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2955
diff
changeset
|
498 |
'final': erschema.final, |
0 | 499 |
'description': desc, |
500 |
} |
|
501 |
||
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
|
502 |
# 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
|
503 |
|
81b0df087375
schema serialization optimization 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 |
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
|
505 |
"""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
|
506 |
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
|
507 |
""" |
81b0df087375
schema serialization optimization 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 |
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
|
509 |
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
|
510 |
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
|
511 |
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
|
512 |
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
|
513 |
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
|
514 |
# sort for testing purpose |
10663
54b8a1f249fb
[py3k] dict.itervalues → dict.values
Rémi Cardona <remi.cardona@logilab.fr>
parents:
10662
diff
changeset
|
515 |
for rdef in sorted(rschema.rdefs.values(), |
4763
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
516 |
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
|
517 |
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
|
518 |
yield rql, values |
0 | 519 |
|
520 |
def rschema_relations_values(rschema): |
|
521 |
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
|
522 |
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
|
523 |
values['symmetric'] = rschema.symmetric |
0 | 524 |
values['inlined'] = rschema.inlined |
10683
e83de6c409fd
[py3k] unicode → six.text_type
Rémi Cardona <remi.cardona@logilab.fr>
parents:
10663
diff
changeset
|
525 |
if PY2 and isinstance(rschema.fulltext_container, str): |
4719
aaed3f813ef8
kill dead/useless code as suggested by pylint
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4631
diff
changeset
|
526 |
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
|
527 |
else: |
aaed3f813ef8
kill dead/useless code as suggested by pylint
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4631
diff
changeset
|
528 |
values['fulltext_container'] = rschema.fulltext_container |
0 | 529 |
relations = ['X %s %%(%s)s' % (attr, attr) for attr in sorted(values)] |
530 |
return relations, values |
|
531 |
||
10553
1d824df4f2bd
Fix (de)serialization of ComputedRelation read permissions
Julien Cristau <julien.cristau@logilab.fr>
parents:
10411
diff
changeset
|
532 |
def crschema2rql(crschema, groupmap): |
9956
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
533 |
relations, values = crschema_relations_values(crschema) |
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
534 |
yield 'INSERT CWComputedRType X: %s' % ','.join(relations), values |
10553
1d824df4f2bd
Fix (de)serialization of ComputedRelation read permissions
Julien Cristau <julien.cristau@logilab.fr>
parents:
10411
diff
changeset
|
535 |
if groupmap: |
1d824df4f2bd
Fix (de)serialization of ComputedRelation read permissions
Julien Cristau <julien.cristau@logilab.fr>
parents:
10411
diff
changeset
|
536 |
for rql, args in _erperms2rql(crschema, groupmap): |
1d824df4f2bd
Fix (de)serialization of ComputedRelation read permissions
Julien Cristau <julien.cristau@logilab.fr>
parents:
10411
diff
changeset
|
537 |
yield rql, args |
9956
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
538 |
|
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
539 |
def crschema_relations_values(crschema): |
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
540 |
values = _ervalues(crschema) |
10683
e83de6c409fd
[py3k] unicode → six.text_type
Rémi Cardona <remi.cardona@logilab.fr>
parents:
10663
diff
changeset
|
541 |
values['rule'] = text_type(crschema.rule) |
9956
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
542 |
# XXX why oh why? |
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
543 |
del values['final'] |
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
544 |
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
|
545 |
return relations, values |
19a683a0047c
[CWEP002] properly handle serialization of computed relations
Lea Capgen <lea.capgen@logilab.fr>
parents:
9891
diff
changeset
|
546 |
|
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
|
547 |
# 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
|
548 |
|
81b0df087375
schema serialization optimization 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 |
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
|
550 |
# 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
|
551 |
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
|
552 |
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
|
553 |
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
|
554 |
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
|
555 |
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
|
556 |
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
|
557 |
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
|
558 |
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
|
559 |
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
|
560 |
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
|
561 |
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
|
562 |
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
|
563 |
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
|
564 |
# 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
|
565 |
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
|
566 |
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
|
567 |
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
|
568 |
|
10025
7b72ecc3f4d2
[migration] hackish black magic to bootstrap addition of formula attr during migration
Julien Cristau <julien.cristau@logilab.fr>
parents:
9968
diff
changeset
|
569 |
_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
|
570 |
|
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
|
571 |
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
|
572 |
amap = {'order': 'ordernum', 'default': 'defaultval'} |
0 | 573 |
values = {} |
8945
ba9e3fbfa5a5
[schemaserial] serialize additional yams parameter for customs type
Vincent Michel <vincent.michel@logilab.fr>
parents:
8748
diff
changeset
|
574 |
extra = {} |
ba9e3fbfa5a5
[schemaserial] serialize additional yams parameter for customs type
Vincent Michel <vincent.michel@logilab.fr>
parents:
8748
diff
changeset
|
575 |
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
|
576 |
if prop in _IGNORED_PROPS: |
0 | 577 |
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
|
578 |
value = getattr(rdef, prop) |
8945
ba9e3fbfa5a5
[schemaserial] serialize additional yams parameter for customs type
Vincent Michel <vincent.michel@logilab.fr>
parents:
8748
diff
changeset
|
579 |
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
|
580 |
extra[prop] = value |
ba9e3fbfa5a5
[schemaserial] serialize additional yams parameter for customs type
Vincent Michel <vincent.michel@logilab.fr>
parents:
8748
diff
changeset
|
581 |
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
|
582 |
# XXX type cast really necessary? |
0 | 583 |
if prop in ('indexed', 'fulltextindexed', 'internationalizable'): |
584 |
value = bool(value) |
|
585 |
elif prop == 'ordernum': |
|
586 |
value = int(value) |
|
10683
e83de6c409fd
[py3k] unicode → six.text_type
Rémi Cardona <remi.cardona@logilab.fr>
parents:
10663
diff
changeset
|
587 |
elif PY2 and isinstance(value, str): |
0 | 588 |
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
|
589 |
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
|
590 |
value = Binary.zpickle(value) |
0 | 591 |
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
|
592 |
if extra: |
10789
d5671a61f281
[server/schemaserial] fix extra_props on py3k
Julien Cristau <julien.cristau@logilab.fr>
parents:
10683
diff
changeset
|
593 |
values['extra_props'] = Binary(json.dumps(extra).encode('ascii')) |
0 | 594 |
relations = ['X %s %%(%s)s' % (attr, attr) for attr in sorted(values)] |
595 |
return relations, values |
|
596 |
||
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
|
597 |
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
|
598 |
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
|
599 |
values = {'ct': cstrtypemap[constraint.type()], |
10683
e83de6c409fd
[py3k] unicode → six.text_type
Rémi Cardona <remi.cardona@logilab.fr>
parents:
10663
diff
changeset
|
600 |
'value': text_type(constraint.serialize()), |
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
|
601 |
'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
|
602 |
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
|
603 |
CT eid %(ct)s, EDEF eid %(x)s', values |
0 | 604 |
|
605 |
||
4011
394f853bb653
[migration] write migration instructions for permissions handling on relation definition
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
4010
diff
changeset
|
606 |
def _erperms2rql(erschema, groupmap): |
0 | 607 |
"""return rql insert statements to enter the entity or relation |
608 |
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
|
609 |
[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
|
610 |
and CWGroup entities |
0 | 611 |
""" |
612 |
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
|
613 |
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
|
614 |
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
|
615 |
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
|
616 |
# 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
|
617 |
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
|
618 |
for group_or_rqlexpr in grantedto: |
10612
84468b90e9c1
[py3k] basestring → six.string_types
Rémi Cardona <remi.cardona@logilab.fr>
parents:
10589
diff
changeset
|
619 |
if isinstance(group_or_rqlexpr, string_types): |
3877
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
620 |
# group |
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
621 |
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
|
622 |
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
|
623 |
{'g': groupmap[group_or_rqlexpr]}) |
3877
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
624 |
except KeyError: |
10589
7c23b7de2b8d
[py3k] print function
Samuel Trégouët <samuel.tregouet@logilab.fr>
parents:
10553
diff
changeset
|
625 |
print("WARNING: group %s used in permissions for %s was ignored because it doesn't exist." |
7c23b7de2b8d
[py3k] print function
Samuel Trégouët <samuel.tregouet@logilab.fr>
parents:
10553
diff
changeset
|
626 |
" 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
|
627 |
continue |
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
628 |
else: |
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
629 |
# rqlexpr |
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
630 |
rqlexpr = group_or_rqlexpr |
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
631 |
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
|
632 |
'E mainvars %%(v)s, X %s_permission E WHERE X eid %%(x)s' % action, |
10683
e83de6c409fd
[py3k] unicode → six.text_type
Rémi Cardona <remi.cardona@logilab.fr>
parents:
10663
diff
changeset
|
633 |
{'e': text_type(rqlexpr.expression), |
e83de6c409fd
[py3k] unicode → six.text_type
Rémi Cardona <remi.cardona@logilab.fr>
parents:
10663
diff
changeset
|
634 |
'v': text_type(','.join(sorted(rqlexpr.mainvars))), |
e83de6c409fd
[py3k] unicode → six.text_type
Rémi Cardona <remi.cardona@logilab.fr>
parents:
10663
diff
changeset
|
635 |
't': text_type(rqlexpr.__class__.__name__)}) |
0 | 636 |
|
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
|
637 |
# update functions |
0 | 638 |
|
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
|
639 |
def updateeschema2rql(eschema, eid): |
0 | 640 |
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
|
641 |
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
|
642 |
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
|
643 |
|
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
|
644 |
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
|
645 |
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
|
646 |
yield ('SET X rule %(r)s WHERE X eid %(x)s', |
10683
e83de6c409fd
[py3k] unicode → six.text_type
Rémi Cardona <remi.cardona@logilab.fr>
parents:
10663
diff
changeset
|
647 |
{'x': eid, 'r': text_type(rschema.rule)}) |
9964
f4a3ee05cf9d
[CWEP002 migration] support sync_schema_props_perms for computed relations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9963
diff
changeset
|
648 |
else: |
f4a3ee05cf9d
[CWEP002 migration] support sync_schema_props_perms for computed relations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
9963
diff
changeset
|
649 |
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
|
650 |
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
|
651 |
yield 'SET %s WHERE X eid %%(x)s' % ','.join(relations), values |
0 | 652 |
|
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
|
653 |
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
|
654 |
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
|
655 |
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
|
656 |
yield 'SET %s WHERE X eid %%(x)s' % ','.join(relations), values |