-
Notifications
You must be signed in to change notification settings - Fork 7
/
AbstractDomainKind.java
314 lines (273 loc) · 10.6 KB
/
AbstractDomainKind.java
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
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
/*
* Copyright (c) 2010-2018 LabKey Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.labkey.api.exp.property;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.labkey.api.collections.CaseInsensitiveHashSet;
import org.labkey.api.data.ColumnInfo;
import org.labkey.api.data.Container;
import org.labkey.api.data.CoreSchema;
import org.labkey.api.data.DbSchema;
import org.labkey.api.data.DbSchemaType;
import org.labkey.api.data.DbScope;
import org.labkey.api.data.PropertyStorageSpec;
import org.labkey.api.data.SQLFragment;
import org.labkey.api.data.SqlSelector;
import org.labkey.api.data.TableInfo;
import org.labkey.api.data.dialect.SqlDialect;
import org.labkey.api.exp.PropertyDescriptor;
import org.labkey.api.exp.TemplateInfo;
import org.labkey.api.exp.api.ExperimentService;
import org.labkey.api.exp.api.ExperimentUrls;
import org.labkey.api.exp.api.StorageProvisioner;
import org.labkey.api.gwt.client.model.GWTDomain;
import org.labkey.api.gwt.client.model.GWTPropertyDescriptor;
import org.labkey.api.query.ValidationException;
import org.labkey.api.security.User;
import org.labkey.api.security.permissions.AdminPermission;
import org.labkey.api.util.PageFlowUtil;
import org.labkey.api.view.ActionURL;
import org.labkey.api.view.NavTree;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import static org.labkey.api.exp.api.ExpData.DATA_INPUTS_PREFIX;
import static org.labkey.api.exp.api.SampleTypeService.MATERIAL_INPUTS_PREFIX;
/**
* User: kevink
* Date: Jun 4, 2010
* Time: 3:29:46 PM
*/
public abstract class AbstractDomainKind<T> extends DomainKind<T>
{
public static final String OBJECT_URI_COLUMN_NAME = "lsid";
public static final Set<String> LINEAGE_FIELD_NAME_PREFIXES;
static {
LINEAGE_FIELD_NAME_PREFIXES = new HashSet<>(Arrays.asList(MATERIAL_INPUTS_PREFIX, DATA_INPUTS_PREFIX));
}
@Override
public String generateDomainURI(String schemaName, String queryName, Container container, User user)
{
return null;
}
@Override
public boolean canCreateDefinition(User user, Container container)
{
return false;
}
@Override
public boolean canEditDefinition(User user, Domain domain)
{
return domain.getContainer().hasPermission(user, AdminPermission.class);
}
@Override
public boolean canDeleteDefinition(User user, Domain domain)
{
return domain.getContainer().hasPermission(user, AdminPermission.class);
}
@Override
public ActionURL urlCreateDefinition(String schemaName, String queryName, Container container, User user)
{
String domainURI = generateDomainURI(schemaName, queryName, container, user);
if (domainURI == null)
return null;
return PageFlowUtil.urlProvider(ExperimentUrls.class).getDomainEditorURL(container, domainURI, true);
}
// Override to customize the nav trail on shared pages like edit domain
@Override
public void addNavTrail(NavTree root, Container c, User user)
{
}
// Do any special handling before a PropertyDescriptor is deleted -- do nothing by default
@Override
public void deletePropertyDescriptor(Domain domain, User user, PropertyDescriptor pd)
{
}
@Override
public Domain createDomain(GWTDomain<GWTPropertyDescriptor> domain, T arguments, Container container, User user, @Nullable TemplateInfo templateInfo)
{
return null;
}
@Override
public @Nullable T getDomainKindProperties(GWTDomain domain, Container container, User user)
{
return null;
}
/** @return Errors encountered during the save attempt */
@Override
@NotNull
public ValidationException updateDomain(GWTDomain<? extends GWTPropertyDescriptor> original, GWTDomain<? extends GWTPropertyDescriptor> update,
@Nullable T options, Container container, User user, boolean includeWarnings)
{
return DomainUtil.updateDomainDescriptor(original, update, container, user);
}
@Override
public void deleteDomain(User user, Domain domain)
{
}
@Override
public Set<PropertyStorageSpec> getBaseProperties(Domain domain)
{
return Collections.emptySet();
}
@Override
public Set<PropertyStorageSpec.Index> getPropertyIndices(Domain domain)
{
return Collections.emptySet();
}
@Override
public Set<PropertyStorageSpec.ForeignKey> getPropertyForeignKeys(Container container)
{
return Collections.emptySet();
}
@Override
public DbScope getScope()
{
return null;
}
@Override
public String getStorageSchemaName()
{
return null;
}
@Override
public boolean hasNullValues(Domain domain, DomainProperty prop)
{
SQLFragment allRowsSQL = new SQLFragment();
SQLFragment nonBlankRowsSQL = new SQLFragment();
if (getTotalAndNonBlankSql(domain, prop, allRowsSQL, nonBlankRowsSQL))
{
long totalRows = new SqlSelector(ExperimentService.get().getSchema(), allRowsSQL).getRowCount();
long nonBlankRows = new SqlSelector(ExperimentService.get().getSchema(), nonBlankRowsSQL).getRowCount();
return totalRows != nonBlankRows;
}
else
{
return false;
}
}
protected boolean getTotalAndNonBlankSql(Domain domain, DomainProperty prop, SQLFragment allRowsSQL, SQLFragment nonBlankRowsSQL)
{
if (getStorageSchemaName() == null)
{
SQLFragment sqlObjectIds = sqlObjectIdsInDomain(domain);
allRowsSQL.append("SELECT exp.object.objectId FROM exp.object WHERE exp.object.objectid IN (");
allRowsSQL.append(sqlObjectIds);
allRowsSQL.append(")");
nonBlankRowsSQL.append("SELECT op.objectId FROM exp.objectproperty op WHERE ");
nonBlankRowsSQL.append("(op.StringValue IS NOT NULL OR op.FloatValue IS NOT NULL OR ");
nonBlankRowsSQL.append("op.DateTimeValue IS NOT NULL OR op.MVIndicator IS NULL) AND op.objectid IN (");
nonBlankRowsSQL.append(sqlObjectIds);
nonBlankRowsSQL.append(") AND op.PropertyId = ?");
nonBlankRowsSQL.add(prop.getPropertyId());
return true;
}
else if (domain.getStorageTableName() != null)
{
String table = domain.getStorageTableName();
allRowsSQL.append("SELECT * FROM " + getStorageSchemaName() + "." + table);
nonBlankRowsSQL.append("SELECT * FROM " + getStorageSchemaName() + "." + table + " x WHERE ");
SqlDialect dialect = CoreSchema.getInstance().getSqlDialect();
// Issue 17183 - Postgres uses lower case column names when quoting is required
nonBlankRowsSQL.append("x.");
// Issue 29047
nonBlankRowsSQL.append(dialect.makeLegalIdentifier(prop.getPropertyDescriptor().getStorageColumnName().toLowerCase()));
nonBlankRowsSQL.append(" IS NOT NULL");
if (prop.isMvEnabled())
{
TableInfo storageTable = DbSchema.get(getStorageSchemaName(), DbSchemaType.Provisioned).getTable(table);
ColumnInfo mvColumn = StorageProvisioner.get().getMvIndicatorColumn(storageTable, prop.getPropertyDescriptor(), "No MV column found for" + prop.getName());
nonBlankRowsSQL.append(" OR x.");
nonBlankRowsSQL.append(mvColumn.getName().toLowerCase());
nonBlankRowsSQL.append(" IS NOT NULL");
}
return true;
}
else
{
return false;
}
}
@Override
public Set<String> getMandatoryPropertyNames(Domain domain)
{
CaseInsensitiveHashSet ret = new CaseInsensitiveHashSet();
for (PropertyStorageSpec spec : getBaseProperties(domain))
ret.add(spec.getName());
DomainTemplate template = getDomainTemplate(domain);
if (template != null)
ret.addAll(template.getMandatoryPropertyNames());
return ret;
}
@Nullable
protected DomainTemplate getDomainTemplate(Domain domain)
{
return DomainTemplate.findTemplate(domain.getTemplateInfo(), getKindName());
}
@Override
public Set<String> getNonProvisionedTableNames()
{
return Collections.emptySet();
}
@Override
public PropertyStorageSpec getPropertySpec(PropertyDescriptor pd, Domain domain)
{
return new PropertyStorageSpec(pd);
}
@Nullable
@Override
public String getMetaDataSchemaName()
{
return null;
}
@Nullable
@Override
public String getMetaDataTableName()
{
return null;
}
@Override
public boolean hasPropertiesIncludeBaseProperties()
{
return true;
}
/**
* Check if existing string data fits in property scale
* @param domain to execute within
* @param prop property to check
* @return true if the DomainProperty is a string and a value exists that is greater than the DomainProperty's max length
*/
@Override
public boolean exceedsMaxLength(Domain domain, DomainProperty prop)
{
if (!prop.getPropertyDescriptor().isStringType())
return false;
String schema = getStorageSchemaName();
if (schema == null || domain.getStorageTableName() == null)
return false;
SqlDialect dialect = CoreSchema.getInstance().getSqlDialect();
SQLFragment sql = new SQLFragment(String.format("SELECT coalesce(MAX(%s(%s)),0) FROM %s.%s",
dialect.getVarcharLengthFunction(),
//Lowercase names for postgres (MSSQL is case insensitive in this case)
dialect.makeLegalIdentifier(prop.getName().toLowerCase()),
dialect.makeLegalIdentifier(schema.toLowerCase()),
dialect.makeLegalIdentifier(domain.getStorageTableName().toLowerCase())
));
int maxSize = new SqlSelector(ExperimentService.get().getSchema(), sql).getObject(Integer.class);
return prop.getScale() < maxSize;
}
}