1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
|
/**
* Copyright (c) 2004 - 2009 Eike Stepper (Berlin, Germany) and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Eike Stepper - initial API and implementation
* Stefan Winkler - 271444: [DB] Multiple refactorings https://bugs.eclipse.org/bugs/show_bug.cgi?id=271444
*/
package org.eclipse.emf.cdo.server.db.mapping;
import org.eclipse.emf.cdo.common.id.CDOID;
import org.eclipse.emf.cdo.common.model.CDOClassifierRef;
import org.eclipse.emf.cdo.server.IStoreAccessor.QueryResourcesContext;
import org.eclipse.emf.cdo.server.db.IDBStore;
import org.eclipse.emf.cdo.server.db.IDBStoreAccessor;
import org.eclipse.emf.cdo.server.internal.db.DBStore;
import org.eclipse.emf.cdo.spi.common.model.InternalCDOPackageUnit;
import org.eclipse.net4j.db.IDBAdapter;
import org.eclipse.net4j.util.collection.CloseableIterator;
import org.eclipse.net4j.util.om.monitor.OMMonitor;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.ENamedElement;
import org.eclipse.emf.ecore.EStructuralFeature;
import java.sql.Connection;
import java.util.Map;
/**
* The mapping strategy acts as a connection between the DBStore and the database management (and OR-mapping) classes.
* The {@link DBStore} uses methods of this interface to create and lookup mappings (or mappers, as they could also be
* named as such) and to get properties and informations about the mappings used. The mapping classes (e.g., instances
* of IClassMapping and IListMapping) also use this class as a central point of information and as a resource of common
* functionalities.
*
* @author Eike Stepper
* @author Stefan Winkler
* @since 2.0
*/
public interface IMappingStrategy
{
/**
* Name of the integer property that configures the maximum length for table names. A value of zero indicates the
* value of the {@link IDBAdapter#getMaxTableNameLength() db adapter} to be used.
*/
public static final String PROP_MAX_TABLE_NAME_LENGTH = "maxTableNameLength";
/**
* Name of the integer property that configures the maximum length for column names. A value of zero indicates the
* value of the {@link IDBAdapter#getMaxFieldNameLength() db adapter} to be used.
*/
public static final String PROP_MAX_FIELD_NAME_LENGTH = "maxFieldNameLength";
/**
* Name of the String property that specifies a common prefix for table names.
*/
public static final String PROP_TABLE_NAME_PREFIX = "tableNamePrefix";
/**
* Name of the boolean property that configures whether the table names are made of simple class names or of qualified
* class names.
*/
public static final String PROP_QUALIFIED_NAMES = "qualifiedNames";
/**
* Name of the boolean property that configures whether table names and column names are always suffixed with the
* internal DBID or only in cases where generated names violate the naming constraints of the underlying backend.
*/
public static final String PROP_FORCE_NAMES_WITH_ID = "forceNamesWithID";
/**
* @return the store, this MappingStrategy instance belongs to.
*/
public IDBStore getStore();
/**
* Set the store to which this MappingStrategy instance belongs. Should only be called by the {@link DBStore}, and
* only once to initialize the connection between {@link DBStore} and mapping strategy.
*
* @param dbStore
* the DBStore instance to which this MappingStrategy instance belongs.
*/
public void setStore(IDBStore dbStore);
/**
* Factory for value mappings of single-valued attributes.
*
* @param feature
* the feature for which a mapping should be created. It must hold <code>feature.isMany() == false</code>.
* @return the mapping created.
*/
public ITypeMapping createValueMapping(EStructuralFeature feature);
/**
* Factory for value mappings of multi-valued-attributes.
*
* @param containingClass
* the class containing the feature.
* @param feature
* the feature for which a mapping should be created. It must hold <code>feature.isMany() == true</code>.
* @return
*/
public IListMapping createListMapping(EClass containingClass, EStructuralFeature feature);
/**
* Create a suitable table name which can be used to map the given element. Should only be called by mapping classes.
*
* @param element
* the element for which the name should be created. It must hold:
* <code>element instanceof EClass || element instanceof EPackage</code>.
* @return the created table name. It is guaranteed that the table name is compatible with the chosen database.
*/
public String getTableName(ENamedElement element);
/**
* Create a suitable table name which can be used to map the given element. Should only be called by mapping classes.
* Should only be called by mapping classes.
*
* @param containingClass
* the class containeng the feature.
* @param feature
* the feature for which the table name should be created.
* @return the created table name. It is guaranteed that the table name is compatible with the chosen database.
*/
public String getTableName(EClass containingClass, EStructuralFeature feature);
/**
* Create a suitable column name which can be used to map the given element. Should only be called by mapping classes.
*
* @param feature
* the feature for which the column name should be created.
* @return the created column name. It is guaranteed that the name is compatible with the chosen database.
*/
public String getFieldName(EStructuralFeature feature);
/**
* Create and initialize the mapping infrastructure for the given packages. Should be called from the DBStore or the
* DBStoreAccessor.
*
* @param connection
* the connection to use.
* @param packageUnits
* the packages whose elements should be mapped.
* @param monitor
* the monitor to report progress.
*/
public void createMapping(Connection connection, InternalCDOPackageUnit[] packageUnits, OMMonitor monitor);
/**
* Look up an existing class mapping for the given class. Before this method is called, the class mapping must have
* been initialized by calling {@link #createMapping(Connection, InternalCDOPackageUnit[], OMMonitor)} on its
* containing package.
*
* @param eClass
* the class to look up.
* @return the class mapping.
*/
public IClassMapping getClassMapping(EClass eClass);
/**
* Query if this mapping supports revision deltas. <br>
* If this method returns <code>true</code>, it is guaranteed that all class mappings returned by
* {@link #getClassMapping(EClass)} implement {@link IClassMappingDeltaSupport}.
*
* @return <code>true</code> if revision deltas are supported, <code>false</code> else.
*/
public boolean hasDeltaSupport();
/**
* Query if this mapping supports audits. <br>
* If this method returns <code>true</code>, it is guaranteed that all class mappings returned by
* {@link #getClassMapping(EClass)} implement {@link IClassMappingAuditSupport}.
*
* @return <code>true</code> if audits are supported, <code>false</code> else.
*/
public boolean hasAuditSupport();
/**
* Execute a resource query.
*
* @param dbStoreAccessor
* the accessor to use.
* @param context
* the context from which the query parameters are read and to which the result is written.
*/
public void queryResources(IDBStoreAccessor dbStoreAccessor, QueryResourcesContext context);
/**
* Read the type (i.e. class) of the object referred to by a given ID.
*
* @param dbStoreAccessor
* the accessor to use to look up the type.
* @param id
* the ID of the object for which the type is to be determined.
* @return the type of the object.
*/
public CDOClassifierRef readObjectType(IDBStoreAccessor dbStoreAccessor, CDOID id);
/**
* Get an iterator over all instances of objects in the store.
*
* @param dbStoreAccessor
* the accessor to use.
* @return the iterator.
*/
public CloseableIterator<CDOID> readObjectIDs(IDBStoreAccessor dbStoreAccessor);
/**
* Return the maximum object id used in the store. This is used by the DBStore if a previous crash is discovered
* during the startup process. Should only be called by the DBStore and only during startup.
*
* @param dbAdapter
* the dbAdapter to use to access the database
* @param connection
* the connection to use to access the database
* @return the maximum object id used in the store.
*/
public long repairAfterCrash(IDBAdapter dbAdapter, Connection connection);
/**
* Set configuration properties for this mapping strategy. Should only be called by the factory creating the mapping
* strategy instance.
*
* @param properties
* the configuration properties to set.
*/
public void setProperties(Map<String, String> properties);
}
|
