author | Sylvain Thénault <sylvain.thenault@logilab.fr> |
Thu, 17 Jun 2010 15:15:52 +0200 | |
changeset 5774 | 0d792bceb25d |
parent 5558 | afd1face1faf |
child 5896 | 67683b7e591a |
permissions | -rw-r--r-- |
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
|
1 |
# copyright 2003-2010 LOGILAB S.A. (Paris, FRANCE), all rights reserved. |
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/>. |
0 | 18 |
"""functions for schema / permissions (de)serialization using RQL |
19 |
||
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 |
0 | 24 |
from itertools import chain |
25 |
||
26 |
from logilab.common.shellutils import ProgressBar |
|
27 |
||
28 |
from yams import schema as schemamod, buildobjs as ybo |
|
29 |
||
5558
afd1face1faf
[schema migration] make some stuff to ease file 1.9 migration : we want to kill the Image entity so that existing image are turned into (existing entity type) File entities
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
30 |
from cubicweb import CW_SOFTWARE_ROOT |
afd1face1faf
[schema migration] make some stuff to ease file 1.9 migration : we want to kill the Image entity so that existing image are turned into (existing entity type) File entities
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
31 |
from cubicweb.schema import (CONSTRAINTS, ETYPE_NAME_MAP, |
afd1face1faf
[schema migration] make some stuff to ease file 1.9 migration : we want to kill the Image entity so that existing image are turned into (existing entity type) File entities
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
32 |
VIRTUAL_RTYPES, PURE_VIRTUAL_RTYPES) |
1869
642a1a120a92
should use sql prefix here
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1630
diff
changeset
|
33 |
from cubicweb.server import sqlutils |
0 | 34 |
|
35 |
def group_mapping(cursor, interactive=True): |
|
36 |
"""create a group mapping from an rql cursor |
|
37 |
||
38 |
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
|
39 |
and the actual CWGroup entity's eid as associated value. |
0 | 40 |
In interactive mode (the default), missing groups'eid will be prompted |
41 |
from the user. |
|
42 |
""" |
|
43 |
res = {} |
|
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
44 |
for eid, name in cursor.execute('Any G, N WHERE G is CWGroup, G name N', |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
45 |
build_descr=False): |
0 | 46 |
res[name] = eid |
47 |
if not interactive: |
|
48 |
return res |
|
49 |
missing = [g for g in ('owners', 'managers', 'users', 'guests') if not g in res] |
|
50 |
if missing: |
|
51 |
print 'some native groups are missing but the following groups have been found:' |
|
52 |
print '\n'.join('* %s (%s)' % (n, eid) for n, eid in res.items()) |
|
1630
41aadba8b29f
delete-trailing-whitespaces, check table existance
sylvain.thenault@logilab.fr
parents:
1398
diff
changeset
|
53 |
print |
0 | 54 |
print 'enter the eid of a to group to map to each missing native group' |
55 |
print 'or just type enter to skip permissions granted to a group' |
|
56 |
for group in missing: |
|
57 |
while True: |
|
58 |
value = raw_input('eid for group %s: ' % group).strip() |
|
59 |
if not value: |
|
60 |
continue |
|
61 |
try: |
|
62 |
res[group] = int(value) |
|
63 |
except ValueError: |
|
64 |
print 'eid should be an integer' |
|
65 |
continue |
|
66 |
return res |
|
67 |
||
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
|
68 |
def cstrtype_mapping(cursor): |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
69 |
"""cached constraint types mapping""" |
5379
c082dea0731b
[schema] update for yams 0.29: BoundConstraint renamed to BoundaryConstraint; new constraint messages; ObjectRelation deprecated
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4835
diff
changeset
|
70 |
map = dict(cursor.execute('Any T, X WHERE X is CWConstraintType, X name T')) |
c082dea0731b
[schema] update for yams 0.29: BoundConstraint renamed to BoundaryConstraint; new constraint messages; ObjectRelation deprecated
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4835
diff
changeset
|
71 |
if not 'BoundConstraint' in map: |
c082dea0731b
[schema] update for yams 0.29: BoundConstraint renamed to BoundaryConstraint; new constraint messages; ObjectRelation deprecated
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4835
diff
changeset
|
72 |
map['BoundConstraint'] = map['BoundaryConstraint'] |
c082dea0731b
[schema] update for yams 0.29: BoundConstraint renamed to BoundaryConstraint; new constraint messages; ObjectRelation deprecated
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4835
diff
changeset
|
73 |
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
|
74 |
|
0 | 75 |
# 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
|
76 |
|
0 | 77 |
def deserialize_schema(schema, session): |
78 |
"""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
|
79 |
as CWRType and CWEType entities |
0 | 80 |
""" |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
81 |
repo = session.repo |
2044
d5589c5bc4e6
alter table in schema serial when a renamed type is detected
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
82 |
dbhelper = repo.system_source.dbhelper |
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
|
83 |
# 3.6 migration |
4475
37c413a07216
kill most pre 3.2 bw compat code
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4467
diff
changeset
|
84 |
sqlcu = session.pool['system'] |
4467
0e73d299730a
fix long-waiting symetric typo: should be spelled symmetric. Add auto database migration on schema deserialization
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4312
diff
changeset
|
85 |
sqlcu.execute("SELECT * FROM cw_CWRType WHERE cw_name='symetric'") |
0e73d299730a
fix long-waiting symetric typo: should be spelled symmetric. Add auto database migration on schema deserialization
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4312
diff
changeset
|
86 |
if sqlcu.fetchall(): |
0e73d299730a
fix long-waiting symetric typo: should be spelled symmetric. Add auto database migration on schema deserialization
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4312
diff
changeset
|
87 |
sql = dbhelper.sql_rename_col('cw_CWRType', 'cw_symetric', 'cw_symmetric', |
0e73d299730a
fix long-waiting symetric typo: should be spelled symmetric. Add auto database migration on schema deserialization
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4312
diff
changeset
|
88 |
dbhelper.TYPE_MAPPING['Boolean'], True) |
0e73d299730a
fix long-waiting symetric typo: should be spelled symmetric. Add auto database migration on schema deserialization
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4312
diff
changeset
|
89 |
sqlcu.execute(sql) |
0e73d299730a
fix long-waiting symetric typo: should be spelled symmetric. Add auto database migration on schema deserialization
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4312
diff
changeset
|
90 |
sqlcu.execute("UPDATE cw_CWRType SET cw_name='symmetric' WHERE cw_name='symetric'") |
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
91 |
sidx = {} |
0 | 92 |
permsdict = deserialize_ertype_permissions(session) |
93 |
schema.reading_from_database = True |
|
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
94 |
for eid, etype, desc in session.execute( |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
95 |
'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
|
96 |
build_descr=False): |
0 | 97 |
# base types are already in the schema, skip them |
98 |
if etype in schemamod.BASE_TYPES: |
|
99 |
# just set the eid |
|
100 |
eschema = schema.eschema(etype) |
|
101 |
eschema.eid = eid |
|
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
102 |
sidx[eid] = eschema |
0 | 103 |
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
|
104 |
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
|
105 |
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
|
106 |
netype = ETYPE_NAME_MAP[etype] |
0 | 107 |
# can't use write rql queries at this point, use raw sql |
5558
afd1face1faf
[schema migration] make some stuff to ease file 1.9 migration : we want to kill the Image entity so that existing image are turned into (existing entity type) File entities
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
108 |
sqlexec = session.system_sql |
afd1face1faf
[schema migration] make some stuff to ease file 1.9 migration : we want to kill the Image entity so that existing image are turned into (existing entity type) File entities
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
109 |
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
|
110 |
% {'p': sqlutils.SQL_PREFIX}, {'n': netype}).fetchone(): |
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
|
111 |
# the new type already exists, we should merge |
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
|
112 |
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
|
113 |
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
|
114 |
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
|
115 |
# 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
|
116 |
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
|
117 |
% {'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
|
118 |
if 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
|
119 |
sqlexec('ALTER TABLE %s%s RENAME TO %s%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
|
120 |
sqlutils.SQL_PREFIX, etype, sqlutils.SQL_PREFIX, 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
|
121 |
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
|
122 |
{'x': etype, 'n': netype}) |
0 | 123 |
session.commit(False) |
124 |
try: |
|
5558
afd1face1faf
[schema migration] make some stuff to ease file 1.9 migration : we want to kill the Image entity so that existing image are turned into (existing entity type) File entities
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
125 |
sqlexec('UPDATE deleted_entities SET type=%(n)s WHERE type=%(x)s', |
afd1face1faf
[schema migration] make some stuff to ease file 1.9 migration : we want to kill the Image entity so that existing image are turned into (existing entity type) File entities
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
126 |
{'x': etype, 'n': netype}) |
0 | 127 |
except: |
128 |
pass |
|
129 |
tocleanup = [eid] |
|
1630
41aadba8b29f
delete-trailing-whitespaces, check table existance
sylvain.thenault@logilab.fr
parents:
1398
diff
changeset
|
130 |
tocleanup += (eid for eid, (eidetype, uri, extid) in repo._type_source_cache.items() |
0 | 131 |
if etype == eidetype) |
1630
41aadba8b29f
delete-trailing-whitespaces, check table existance
sylvain.thenault@logilab.fr
parents:
1398
diff
changeset
|
132 |
repo.clear_caches(tocleanup) |
0 | 133 |
session.commit(False) |
5558
afd1face1faf
[schema migration] make some stuff to ease file 1.9 migration : we want to kill the Image entity so that existing image are turned into (existing entity type) File entities
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
134 |
if needcopy: |
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 |
from logilab.common.testlib import mock_object |
afd1face1faf
[schema migration] make some stuff to ease file 1.9 migration : we want to kill the Image entity so that existing image are turned into (existing entity type) File entities
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
5426
diff
changeset
|
136 |
sidx[eid] = mock_object(type=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
|
137 |
# 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
|
138 |
# 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
|
139 |
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
|
140 |
etype = netype |
2126
a25859917ccc
stop using meta attribute from yams schema. Use instead sets defining meta relations and another defining schema types. Refactor various schema view based on this
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2044
diff
changeset
|
141 |
etype = ybo.EntityType(name=etype, description=desc, eid=eid) |
0 | 142 |
eschema = schema.add_entity_type(etype) |
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
143 |
sidx[eid] = eschema |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
144 |
set_perms(eschema, permsdict) |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
145 |
for etype, stype in session.execute( |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
146 |
'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
|
147 |
build_descr=False): |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
148 |
schema.eschema(etype)._specialized_type = stype |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
149 |
schema.eschema(stype)._specialized_by.append(etype) |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
150 |
for eid, rtype, desc, sym, il, ftc in session.execute( |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
151 |
'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
|
152 |
'X symmetric S, X inlined I, X fulltext_container FTC', build_descr=False): |
2126
a25859917ccc
stop using meta attribute from yams schema. Use instead sets defining meta relations and another defining schema types. Refactor various schema view based on this
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2044
diff
changeset
|
153 |
rtype = ybo.RelationType(name=rtype, description=desc, |
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
|
154 |
symmetric=bool(sym), inlined=bool(il), |
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
155 |
fulltext_container=ftc, eid=eid) |
0 | 156 |
rschema = schema.add_relation_type(rtype) |
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
157 |
sidx[eid] = rschema |
0 | 158 |
cstrsdict = deserialize_rdef_constraints(session) |
159 |
for values in session.execute( |
|
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
160 |
'Any X,SE,RT,OE,CARD,ORD,DESC,IDX,FTIDX,I18N,DFLT WHERE X is CWAttribute,' |
0 | 161 |
'X relation_type RT, X cardinality CARD, X ordernum ORD, X indexed IDX,' |
162 |
'X description DESC, X internationalizable I18N, X defaultval DFLT,' |
|
163 |
'X fulltextindexed FTIDX, X from_entity SE, X to_entity OE', |
|
164 |
build_descr=False): |
|
165 |
rdefeid, seid, reid, teid, card, ord, desc, idx, ftidx, i18n, default = values |
|
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
166 |
rdef = ybo.RelationDefinition(sidx[seid].type, sidx[reid].type, sidx[teid].type, |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
167 |
cardinality=card, |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
168 |
constraints=cstrsdict.get(rdefeid, ()), |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
169 |
order=ord, description=desc, |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
170 |
indexed=idx, fulltextindexed=ftidx, |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
171 |
internationalizable=i18n, |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
172 |
default=default, eid=rdefeid) |
4003
b9436fe77c9e
fix bad merge
Sandrine Ribeau <sandrine.ribeau@logilab.fr>
parents:
3998
diff
changeset
|
173 |
rdefs = schema.add_relation_def(rdef) |
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
|
174 |
# rdefs can be None on duplicated relation definitions (e.g. symmetrics) |
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
175 |
if rdefs is not None: |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
176 |
set_perms(rdefs, permsdict) |
0 | 177 |
for values in session.execute( |
1398
5fe84a5f7035
rename internal entity types to have CW prefix instead of E
sylvain.thenault@logilab.fr
parents:
0
diff
changeset
|
178 |
'Any X,SE,RT,OE,CARD,ORD,DESC,C WHERE X is CWRelation, X relation_type RT,' |
0 | 179 |
'X cardinality CARD, X ordernum ORD, X description DESC, ' |
180 |
'X from_entity SE, X to_entity OE, X composite C', build_descr=False): |
|
181 |
rdefeid, seid, reid, teid, card, ord, desc, c = values |
|
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
182 |
rdef = ybo.RelationDefinition(sidx[seid].type, sidx[reid].type, sidx[teid].type, |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
183 |
constraints=cstrsdict.get(rdefeid, ()), |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
184 |
cardinality=card, order=ord, description=desc, |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
185 |
composite=c, eid=rdefeid) |
4003
b9436fe77c9e
fix bad merge
Sandrine Ribeau <sandrine.ribeau@logilab.fr>
parents:
3998
diff
changeset
|
186 |
rdefs = schema.add_relation_def(rdef) |
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 |
# rdefs can be None on duplicated relation definitions (e.g. symmetrics) |
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
188 |
if rdefs is not None: |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
189 |
set_perms(rdefs, permsdict) |
0 | 190 |
schema.infer_specialization_rules() |
191 |
session.commit() |
|
192 |
schema.reading_from_database = False |
|
193 |
||
194 |
||
195 |
def deserialize_ertype_permissions(session): |
|
196 |
"""return sect action:groups associations for the given |
|
197 |
entity or relation schema with its eid, according to schema's |
|
198 |
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
|
199 |
relations between CWEType/CWRType and CWGroup entities |
0 | 200 |
""" |
201 |
res = {} |
|
202 |
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
|
203 |
rql = 'Any E,N WHERE G is CWGroup, G name N, E %s_permission G' % action |
0 | 204 |
for eid, gname in session.execute(rql, build_descr=False): |
205 |
res.setdefault(eid, {}).setdefault(action, []).append(gname) |
|
206 |
rql = ('Any E,X,EXPR,V WHERE X is RQLExpression, X expression EXPR, ' |
|
207 |
'E %s_permission X, X mainvars V' % action) |
|
208 |
for eid, expreid, expr, mainvars in session.execute(rql, build_descr=False): |
|
209 |
# we don't know yet if it's a rql expr for an entity or a relation, |
|
210 |
# so append a tuple to differentiate from groups and so we'll be |
|
211 |
# able to instantiate it later |
|
212 |
res.setdefault(eid, {}).setdefault(action, []).append( (expr, mainvars, expreid) ) |
|
213 |
return res |
|
214 |
||
4760
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
215 |
def deserialize_rdef_constraints(session): |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
216 |
"""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
|
217 |
res = {} |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
218 |
for rdefeid, ceid, ct, val in session.execute( |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
219 |
'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
|
220 |
'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
|
221 |
cstr = CONSTRAINTS[ct].deserialize(val) |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
222 |
cstr.eid = ceid |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
223 |
res.setdefault(rdefeid, []).append(cstr) |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
224 |
return res |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
225 |
|
0 | 226 |
def set_perms(erschema, permsdict): |
227 |
"""set permissions on the given erschema according to the permission |
|
228 |
definition dictionary as built by deserialize_ertype_permissions for a |
|
229 |
given erschema's eid |
|
230 |
""" |
|
4570
ede247bbbf62
follow yams api change: attributes permissions are now defined for
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4475
diff
changeset
|
231 |
# 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
|
232 |
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
|
233 |
try: |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
234 |
thispermsdict = permsdict[erschema.eid] |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
235 |
except KeyError: |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
236 |
return |
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
237 |
for action, somethings in thispermsdict.iteritems(): |
4570
ede247bbbf62
follow yams api change: attributes permissions are now defined for
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4475
diff
changeset
|
238 |
# XXX cw < 3.6.1 bw compat |
ede247bbbf62
follow yams api change: attributes permissions are now defined for
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4475
diff
changeset
|
239 |
if isinstance(erschema, schemamod.RelationDefinitionSchema) and erschema.final and action == 'add': |
ede247bbbf62
follow yams api change: attributes permissions are now defined for
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4475
diff
changeset
|
240 |
action = 'update' |
ede247bbbf62
follow yams api change: attributes permissions are now defined for
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4475
diff
changeset
|
241 |
erschema.permissions[action] = tuple( |
4312
740397c24ec3
minor schema deserialization optimizations
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4252
diff
changeset
|
242 |
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
|
243 |
for p in somethings) |
0 | 244 |
|
245 |
||
246 |
# schema / perms serialization ################################################ |
|
247 |
||
4760
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
248 |
def serialize_schema(cursor, schema): |
0 | 249 |
"""synchronize schema and permissions in the database according to |
250 |
current schema |
|
251 |
""" |
|
3737 | 252 |
quiet = os.environ.get('APYCOT_ROOT') |
3723
a961c7cb2644
be quiet w/ apycot
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3689
diff
changeset
|
253 |
if not quiet: |
a961c7cb2644
be quiet w/ apycot
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3689
diff
changeset
|
254 |
_title = '-> storing the schema in the database ' |
a961c7cb2644
be quiet w/ apycot
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3689
diff
changeset
|
255 |
print _title, |
4835
13b0b96d7982
[repo] enhanced security handling: deprecates unsafe_execute, in favor of explicit read/write security control using the `enabled_security` context manager. Also code executed on the repository side is now unsafe by default.
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4808
diff
changeset
|
256 |
execute = cursor.execute |
0 | 257 |
eschemas = schema.entities() |
4760
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
258 |
if not quiet: |
4791
b9a1b16a8d26
fix schema serialization, bad repartition of changes between stable and default
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4789
diff
changeset
|
259 |
pb_size = (len(eschemas + schema.relations()) |
b9a1b16a8d26
fix schema serialization, bad repartition of changes between stable and default
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4789
diff
changeset
|
260 |
+ len(CONSTRAINTS) |
b9a1b16a8d26
fix schema serialization, bad repartition of changes between stable and default
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4789
diff
changeset
|
261 |
+ len([x for x in eschemas if x.specializes()])) |
2396
8bfb99d7bbcc
[cw-ctl] improve dialog messages
Nicolas Chauvat <nicolas.chauvat@logilab.fr>
parents:
2395
diff
changeset
|
262 |
pb = ProgressBar(pb_size, title=_title) |
3857
6676a839dc97
ensure pb is not None
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3854
diff
changeset
|
263 |
else: |
6676a839dc97
ensure pb is not None
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3854
diff
changeset
|
264 |
pb = None |
4800
686419cd2dff
nicer explanation
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4799
diff
changeset
|
265 |
groupmap = group_mapping(cursor, interactive=False) |
686419cd2dff
nicer explanation
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4799
diff
changeset
|
266 |
# 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
|
267 |
# is / is_instance_of insertion |
4760
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
268 |
eschemas.remove(schema.eschema('CWEType')) |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
269 |
eschemas.insert(0, schema.eschema('CWEType')) |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
270 |
for eschema in eschemas: |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
271 |
execschemarql(execute, eschema, eschema2rql(eschema, groupmap)) |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
272 |
if pb is not None: |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
273 |
pb.update() |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
274 |
# 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
|
275 |
cstrtypemap = {} |
2597
d9c5a7e0563c
[C schema seria] cleanup
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2596
diff
changeset
|
276 |
rql = 'INSERT CWConstraintType X: X name %(ct)s' |
0 | 277 |
for cstrtype in CONSTRAINTS: |
5379
c082dea0731b
[schema] update for yams 0.29: BoundConstraint renamed to BoundaryConstraint; new constraint messages; ObjectRelation deprecated
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4835
diff
changeset
|
278 |
if cstrtype == 'BoundConstraint': |
c082dea0731b
[schema] update for yams 0.29: BoundConstraint renamed to BoundaryConstraint; new constraint messages; ObjectRelation deprecated
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4835
diff
changeset
|
279 |
continue # XXX deprecated in yams 0.29 / cw 3.8.1 |
4763
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
280 |
cstrtypemap[cstrtype] = execute(rql, {'ct': unicode(cstrtype)}, |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
281 |
build_descr=False)[0][0] |
3857
6676a839dc97
ensure pb is not None
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3854
diff
changeset
|
282 |
if pb is not None: |
0 | 283 |
pb.update() |
5379
c082dea0731b
[schema] update for yams 0.29: BoundConstraint renamed to BoundaryConstraint; new constraint messages; ObjectRelation deprecated
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4835
diff
changeset
|
284 |
cstrtypemap['BoundConstraint'] = cstrtypemap['BoundaryConstraint'] |
4760
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
285 |
# serialize relations |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
286 |
for rschema in schema.relations(): |
fe0e307b9b70
minor schema serialization optimization:
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4722
diff
changeset
|
287 |
# 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
|
288 |
if rschema in VIRTUAL_RTYPES: |
3857
6676a839dc97
ensure pb is not None
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3854
diff
changeset
|
289 |
if pb is not None: |
6676a839dc97
ensure pb is not None
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3854
diff
changeset
|
290 |
pb.update() |
0 | 291 |
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
|
292 |
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
|
293 |
if rschema.symmetric: |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
294 |
rdefs = [rdef for k, rdef in rschema.rdefs.iteritems() |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
295 |
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
|
296 |
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
|
297 |
rdefs = rschema.rdefs.itervalues() |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
298 |
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
|
299 |
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
|
300 |
rdef2rql(rdef, cstrtypemap, groupmap)) |
3857
6676a839dc97
ensure pb is not None
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3854
diff
changeset
|
301 |
if pb is not None: |
0 | 302 |
pb.update() |
303 |
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
|
304 |
execute(rql, kwargs, build_descr=False) |
3857
6676a839dc97
ensure pb is not None
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3854
diff
changeset
|
305 |
if pb is not None: |
0 | 306 |
pb.update() |
3723
a961c7cb2644
be quiet w/ apycot
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3689
diff
changeset
|
307 |
if not quiet: |
a961c7cb2644
be quiet w/ apycot
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3689
diff
changeset
|
308 |
print |
0 | 309 |
|
310 |
||
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
|
311 |
# 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
|
312 |
|
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
313 |
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
|
314 |
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
|
315 |
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
|
316 |
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
|
317 |
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
|
318 |
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
|
319 |
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
|
320 |
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
|
321 |
|
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
322 |
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
|
323 |
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
|
324 |
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
|
325 |
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
|
326 |
|
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
327 |
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
|
328 |
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
|
329 |
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
|
330 |
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
|
331 |
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
|
332 |
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
|
333 |
|
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
334 |
# 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
|
335 |
|
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
336 |
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
|
337 |
"""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
|
338 |
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
|
339 |
""" |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
340 |
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
|
341 |
# 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
|
342 |
# 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
|
343 |
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
|
344 |
# 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
|
345 |
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
|
346 |
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
|
347 |
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
|
348 |
|
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
349 |
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
|
350 |
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
|
351 |
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
|
352 |
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
|
353 |
|
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
354 |
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
|
355 |
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
|
356 |
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
|
357 |
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
|
358 |
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
|
359 |
|
0 | 360 |
def _ervalues(erschema): |
361 |
try: |
|
362 |
type_ = unicode(erschema.type) |
|
363 |
except UnicodeDecodeError, e: |
|
364 |
raise Exception("can't decode %s [was %s]" % (erschema.type, e)) |
|
365 |
try: |
|
366 |
desc = unicode(erschema.description) or u'' |
|
367 |
except UnicodeDecodeError, e: |
|
368 |
raise Exception("can't decode %s [was %s]" % (erschema.description, e)) |
|
369 |
return { |
|
370 |
'name': type_, |
|
3689
deb13e88e037
follow yams 0.25 api changes to improve performance
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2955
diff
changeset
|
371 |
'final': erschema.final, |
0 | 372 |
'description': desc, |
373 |
} |
|
374 |
||
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
|
375 |
# 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
|
376 |
|
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
377 |
def rschema2rql(rschema, cstrtypemap=None, addrdef=True, groupmap=None): |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
378 |
"""return a list of rql insert statements to enter a relation schema |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
379 |
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
|
380 |
""" |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
381 |
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
|
382 |
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
|
383 |
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
|
384 |
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
|
385 |
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
|
386 |
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
|
387 |
# sort for testing purpose |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
388 |
for rdef in sorted(rschema.rdefs.itervalues(), |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
389 |
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
|
390 |
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
|
391 |
yield rql, values |
0 | 392 |
|
393 |
def rschema_relations_values(rschema): |
|
394 |
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
|
395 |
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
|
396 |
values['symmetric'] = rschema.symmetric |
0 | 397 |
values['inlined'] = rschema.inlined |
4719
aaed3f813ef8
kill dead/useless code as suggested by pylint
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4631
diff
changeset
|
398 |
if isinstance(rschema.fulltext_container, str): |
aaed3f813ef8
kill dead/useless code as suggested by pylint
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4631
diff
changeset
|
399 |
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
|
400 |
else: |
aaed3f813ef8
kill dead/useless code as suggested by pylint
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4631
diff
changeset
|
401 |
values['fulltext_container'] = rschema.fulltext_container |
0 | 402 |
relations = ['X %s %%(%s)s' % (attr, attr) for attr in sorted(values)] |
403 |
return relations, values |
|
404 |
||
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
|
405 |
# 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
|
406 |
|
81b0df087375
schema serialization optimization 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 |
def rdef2rql(rdef, cstrtypemap, groupmap=None): |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
408 |
# don't serialize infered relations |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
409 |
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
|
410 |
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
|
411 |
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
|
412 |
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
|
413 |
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
|
414 |
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
|
415 |
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
|
416 |
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
|
417 |
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
|
418 |
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
|
419 |
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
|
420 |
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
|
421 |
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
|
422 |
# 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
|
423 |
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
|
424 |
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
|
425 |
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
|
426 |
|
81b0df087375
schema serialization optimization 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 |
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
|
428 |
amap = {'order': 'ordernum', 'default': 'defaultval'} |
0 | 429 |
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
|
430 |
for prop, default in rdef.rproperty_defs(rdef.object).iteritems(): |
4003
b9436fe77c9e
fix bad merge
Sandrine Ribeau <sandrine.ribeau@logilab.fr>
parents:
3998
diff
changeset
|
431 |
if prop in ('eid', 'constraints', 'uid', 'infered', 'permissions'): |
0 | 432 |
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
|
433 |
value = getattr(rdef, prop) |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
434 |
# XXX type cast really necessary? |
0 | 435 |
if prop in ('indexed', 'fulltextindexed', 'internationalizable'): |
436 |
value = bool(value) |
|
437 |
elif prop == 'ordernum': |
|
438 |
value = int(value) |
|
439 |
elif isinstance(value, str): |
|
440 |
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
|
441 |
if value is not None and prop == 'default': |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
442 |
if value is False: |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
443 |
value = u'' |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
444 |
if not isinstance(value, unicode): |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
445 |
value = unicode(value) |
0 | 446 |
values[amap.get(prop, prop)] = value |
447 |
relations = ['X %s %%(%s)s' % (attr, attr) for attr in sorted(values)] |
|
448 |
return relations, values |
|
449 |
||
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
|
450 |
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
|
451 |
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
|
452 |
values = {'ct': cstrtypemap[constraint.type()], |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
453 |
'value': unicode(constraint.serialize()), |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
454 |
'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
|
455 |
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
|
456 |
CT eid %(ct)s, EDEF eid %(x)s', values |
0 | 457 |
|
458 |
||
4011
394f853bb653
[migration] write migration instructions for permissions handling on relation definition
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
4010
diff
changeset
|
459 |
def _erperms2rql(erschema, groupmap): |
0 | 460 |
"""return rql insert statements to enter the entity or relation |
461 |
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
|
462 |
[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
|
463 |
and CWGroup entities |
0 | 464 |
""" |
465 |
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
|
466 |
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
|
467 |
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
|
468 |
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
|
469 |
# 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
|
470 |
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
|
471 |
for group_or_rqlexpr in grantedto: |
3877
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
472 |
if isinstance(group_or_rqlexpr, basestring): |
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
473 |
# group |
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
474 |
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
|
475 |
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
|
476 |
{'g': groupmap[group_or_rqlexpr]}) |
3877
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
477 |
except KeyError: |
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
478 |
continue |
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
479 |
else: |
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
480 |
# rqlexpr |
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
481 |
rqlexpr = group_or_rqlexpr |
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
482 |
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
|
483 |
'E mainvars %%(v)s, X %s_permission E WHERE X eid %%(x)s' % action, |
3877
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
484 |
{'e': unicode(rqlexpr.expression), |
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
485 |
'v': unicode(rqlexpr.mainvars), |
7ca53fc72a0a
reldefsecurity branch :
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
3876
diff
changeset
|
486 |
't': unicode(rqlexpr.__class__.__name__)}) |
0 | 487 |
|
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
|
488 |
# update functions |
0 | 489 |
|
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
|
490 |
def updateeschema2rql(eschema, eid): |
0 | 491 |
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
|
492 |
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
|
493 |
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
|
494 |
|
4763
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
495 |
def updaterschema2rql(rschema, eid): |
81b0df087375
schema serialization optimization by using eids instead of type names. Heavy refactoring/cleanup on the way
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
4760
diff
changeset
|
496 |
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
|
497 |
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
|
498 |
yield 'SET %s WHERE X eid %%(x)s' % ','.join(relations), values |
0 | 499 |
|
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
|
500 |
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
|
501 |
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
|
502 |
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
|
503 |
yield 'SET %s WHERE X eid %%(x)s' % ','.join(relations), values |