/** * Add an entry to clear a query cache. */ public void addInvalidate(BeanDescriptor<?> descriptor) { touchedTables.add(descriptor.getBaseTable()); }
@Override public void registerColumn(BeanDescriptor<?> desc, String prefix) { if (targetDescriptor != null) { desc.registerTable(targetDescriptor.getBaseTable(), this); } } /**
/** * Update a bean entry. */ public <T> void addBeanUpdate(BeanDescriptor<T> desc, String key, Map<String, Object> changes, boolean updateNaturalKey, long version) { touchedTables.add(desc.getBaseTable()); entries.add(new CacheChangeBeanUpdate(desc, key, changes, updateNaturalKey, version)); }
/** * Return the table to update depending if the request is a 'publish' one or normal. */ public String getUpdateTable() { return publish ? beanDescriptor.getBaseTable() : beanDescriptor.getDraftTable(); }
UpdateMeta(boolean emptyStringAsNull, BeanDescriptor<?> desc, BindableList set, BindableId id, Bindable version, Bindable tenantId) { this.emptyStringAsNull = emptyStringAsNull; this.tableName = desc.getBaseTable(); this.set = set; this.id = id; this.version = version; this.tenantId = tenantId; String sqlNone = genSql(ConcurrencyMode.NONE, set, desc.getBaseTable()); String sqlVersion = genSql(ConcurrencyMode.VERSION, set, desc.getBaseTable()); this.modeNoneUpdatePlan = new UpdatePlan(ConcurrencyMode.NONE, sqlNone, set); this.modeVersionUpdatePlan = new UpdatePlan(ConcurrencyMode.VERSION, sqlVersion, set); }
/** * Remove a bean from the cache. */ public <T> void addBeanRemove(BeanDescriptor<T> desc, Object id) { CacheChangeBeanRemove entry = beanRemoveMap.get(desc); if (entry != null) { entry.addId(id); } else { beanRemoveMap.put(desc, new CacheChangeBeanRemove(id, desc)); touchedTables.add(desc.getBaseTable()); } }
/** * Remove a bean from the cache. */ public <T> void addBeanRemoveMany(BeanDescriptor<T> desc, Collection<Object> ids) { CacheChangeBeanRemove entry = beanRemoveMap.get(desc); if (entry != null) { entry.addIds(ids); } else { beanRemoveMap.put(desc, new CacheChangeBeanRemove(desc, ids)); touchedTables.add(desc.getBaseTable()); } }
void cacheUpdateQuery(boolean update, SpiTransaction transaction) { if (invalidateQueryCache || cacheNotifyOnAll || (!update && cacheNotifyOnDelete)) { transaction.getEvent().add(desc.getBaseTable(), false, update, !update); } }
@Override public String getDeployWord(String expression) { if (expression.equalsIgnoreCase(beanDescriptor.getName())) { return beanDescriptor.getBaseTable(); } ElPropertyDeploy elProp = beanDescriptor.getElPropertyDeploy(expression); if (elProp != null) { return elProp.getDbColumn(); } else { return null; } }
@Override public <T> Update<T> createUpdate(Class<T> beanType, String ormUpdate) { BeanDescriptor<?> desc = getBeanDescriptor(beanType); if (desc == null) { String m = beanType.getName() + " is NOT an Entity Bean registered with this server?"; throw new PersistenceException(m); } return new DefaultOrmUpdate<>(beanType, this, desc.getBaseTable(), ormUpdate); }
/** * Build a map of table names to BeanDescriptors. * <p> * This is generally used to maintain caches from table names. * </p> */ private void readTableToDescriptor() { for (BeanDescriptor<?> desc : descMap.values()) { String baseTable = desc.getBaseTable(); if (baseTable != null) { baseTable = baseTable.toLowerCase(); List<BeanDescriptor<?>> list = tableToDescMap.computeIfAbsent(baseTable, k -> new ArrayList<>(1)); list.add(desc); } if (desc.getEntityType() == EntityType.VIEW && desc.isQueryCaching()) { // build map of tables to view entities dependent on those tables // for the purpose of invalidating appropriate query caches String[] dependentTables = desc.getDependentTables(); if (dependentTables != null && dependentTables.length > 0) { for (String depTable : dependentTables) { depTable = depTable.toLowerCase(); List<BeanDescriptor<?>> list = tableToViewDescMap.computeIfAbsent(depTable, k -> new ArrayList<>(1)); list.add(desc); } } } } }
sb.append(query.isAsDraft() ? intersectionDraftTable : intersectionPublishTable); } else { sb.append(targetDescriptor.getBaseTable(query.getTemporalMode())); sb.append(targetDescriptor.getBaseTable(query.getTemporalMode())); sb.append(" x2 on "); inverseJoin.addJoin("x2", "x", sb);
DeleteMeta(boolean emptyStringAsNull, BeanDescriptor<?> desc, BindableId id, Bindable version, Bindable tenantId) { this.emptyStringAsNull = emptyStringAsNull; this.tableName = desc.getBaseTable(); this.id = id; this.version = version; this.tenantId = tenantId; String tableName = desc.getBaseTable(); this.sqlNone = genSql(ConcurrencyMode.NONE, tableName); this.sqlVersion = genSql(ConcurrencyMode.VERSION, tableName); if (desc.isDraftable()) { String draftTableName = desc.getDraftTable(); this.sqlDraftNone = genSql(ConcurrencyMode.NONE, draftTableName); this.sqlDraftVersion = genSql(ConcurrencyMode.VERSION, draftTableName); } else { this.sqlDraftNone = sqlNone; this.sqlDraftVersion = sqlVersion; } }
private <T> String buildUpdateSql(OrmQueryRequest<T> request, String rootTableAlias, CQueryPredicates predicates, SqlTree sqlTree) { StringBuilder sb = new StringBuilder(200); sb.append("update ").append(request.getBeanDescriptor().getBaseTable()); if (rootTableAlias != null) { sb.append(" ").append(rootTableAlias); } sb.append(" set ").append(predicates.getDbUpdateClause()); String updateClause = sb.toString(); if (!sqlTree.isIncludeJoins()) { // simple - update table set ... where ... return aliasStrip(buildSqlUpdate(updateClause, request, predicates, sqlTree).getSql()); } // wrap as - update table set ... where id in (select id ...) String sql = buildSqlUpdate(null, request, predicates, sqlTree).getSql(); sql = updateClause + " " + request.getBeanDescriptor().getWhereIdInSql() + "in (" + sql + ")"; sql = aliasReplace(sql, alias(rootTableAlias)); return sql; }
/** * Add a foreign key based on the table join. */ public FkeyBuilder addForeignKey(BeanDescriptor<?> desc, TableJoin tableJoin, boolean direction) { String baseTable = ctx.normaliseTable(desc.getBaseTable()); String fkName = ctx.foreignKeyConstraintName(tableName, baseTable, count.incrementAndGet()); String fkIndex = ctx.foreignKeyIndexName(tableName, baseTable, count.get()); MCompoundForeignKey foreignKey = new MCompoundForeignKey(fkName, desc.getBaseTable(), fkIndex); for (TableJoinColumn column : tableJoin.columns()) { String localCol = direction ? column.getForeignDbColumn() : column.getLocalDbColumn(); String refCol = !direction ? column.getForeignDbColumn() : column.getLocalDbColumn(); foreignKey.addColumnPair(localCol, refCol); } destTable.addForeignKey(foreignKey); return this; }
private String tableAliasIntern(BeanDescriptor<?> descriptor, String s, boolean dbEncrypted, String dbColumn) { if (descriptor != null) { s = StringHelper.replaceString(s, "${ta}.", "${}"); s = StringHelper.replaceString(s, "${ta}", "${}"); if (dbEncrypted) { s = dbEncryptFunction.getDecryptSql(s); String namedParam = ":encryptkey_" + descriptor.getBaseTable() + "___" + dbColumn; s = StringHelper.replaceString(s, "?", namedParam); } } return InternString.intern(s); }
/** * Add appropriate cache changes to support insert. */ void persistInsert(PersistRequestBean<T> insertRequest, CacheChangeSet changeSet) { if (invalidateQueryCache) { changeSet.addInvalidate(desc); } else { queryCacheClear(changeSet); cacheDeleteImported(false, insertRequest.getEntityBean(), changeSet); changeSet.addBeanInsert(desc.getBaseTable()); } }
@Override public void registerColumn(BeanDescriptor<?> desc, String prefix) { if (embedded) { for (BeanProperty prop : embeddedProps) { prop.registerColumn(desc, SplitName.add(prefix, name)); } } else { if (targetIdProperty != null) { BeanDescriptor<T> target = getTargetDescriptor(); String basePath = SplitName.add(prefix, name); if (dbColumn != null) { BeanProperty idProperty = target.getIdProperty(); desc.registerColumn(dbColumn, SplitName.add(basePath, idProperty.getName())); } desc.registerTable(target.getBaseTable(), this); } } }
private void initialiseAssocOne(String embeddedPrefix) { localHelp = createHelp(embedded, oneToOneExported, embeddedPrefix); if (!isTransient) { //noinspection StatementWithEmptyBody if (embedded || descriptor.isDocStoreOnly()) { // no imported or exported information } else if (!oneToOneExported) { importedId = createImportedId(this, targetDescriptor, tableJoin); if (importedId.isScalar()) { // limit JoinColumn mapping to the @Id / primary key TableJoinColumn[] columns = tableJoin.columns(); String foreignJoinColumn = columns[0].getForeignDbColumn(); String foreignIdColumn = targetDescriptor.getIdProperty().getDbColumn(); if (!foreignJoinColumn.equalsIgnoreCase(foreignIdColumn)) { throw new PersistenceException("Mapping limitation - @JoinColumn on " + getFullBeanName() + " needs to map to a primary key as per Issue #529 " + " - joining to " + foreignJoinColumn + " and not " + foreignIdColumn); } } } else { exportedProperties = createExported(); String delStmt = "delete from " + targetDescriptor.getBaseTable() + " where "; deleteByParentIdSql = delStmt + deriveWhereParentIdSql(false); deleteByParentIdInSql = delStmt + deriveWhereParentIdSql(true); } } }
this.shadowFKey = shadowFKey; String tableName = desc.getBaseTable(); String draftTableName = desc.getDraftTable();