org.jooq.meta.DefaultRelations Maven / Gradle / Ivy
/*
* 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
*
* https://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.
*
* Other licenses:
* -----------------------------------------------------------------------------
* Commercial licenses for this work are available. These replace the above
* Apache-2.0 license and offer limited warranties, support, maintenance, and
* commercial database integrations.
*
* For more information, please visit: https://www.jooq.org/legal/licensing
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
package org.jooq.meta;
import static java.util.Collections.emptyList;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.jooq.tools.JooqLogger;
public class DefaultRelations implements Relations {
private static final JooqLogger log = JooqLogger.getLogger(DefaultRelations.class);
private final Map primaryKeys = new LinkedHashMap<>();
private final Map uniqueKeys = new LinkedHashMap<>();
private final Map keys = new LinkedHashMap<>();
private final Map foreignKeys = new LinkedHashMap<>();
private final Map checkConstraints = new LinkedHashMap<>();
private final Set incompleteKeys = new HashSet<>();
private transient Map primaryKeysByColumn;
private transient Map> uniqueKeysByColumn;
private transient Map> keysByColumn;
private transient Map> foreignKeysByColumn;
private transient Map> uniqueKeysByTable;
private transient Map> keysByTable;
private transient Map> foreignKeysByTable;
private transient Map> checkConstraintsByTable;
public void addPrimaryKey(String keyName, TableDefinition table, ColumnDefinition column) {
addPrimaryKey(keyName, table, column, true);
}
public void addPrimaryKey(String keyName, TableDefinition table, ColumnDefinition column, boolean enforced) {
Key key = key(table, keyName);
// [#2718] Column exclusions may hit primary key references. Ignore
// such primary keys
if (column == null) {
if (log.isDebugEnabled())
log.debug("Ignoring primary key", keyName + " (column unavailable)");
// [#7826] Prevent incomplete keys from being generated
if (table != null) {
incompleteKeys.add(key);
primaryKeys.remove(key);
keys.remove(key);
}
return;
}
if (incompleteKeys.contains(key))
return;
if (log.isDebugEnabled())
log.debug("Adding primary key", keyName + " (" + column + ")");
UniqueKeyDefinition result = getUniqueKey(keyName, table, column, true, enforced);
result.getKeyColumns().add(column);
}
public void addUniqueKey(String keyName, TableDefinition table, ColumnDefinition column) {
addUniqueKey(keyName, table, column, true);
}
public void addUniqueKey(String keyName, TableDefinition table, ColumnDefinition column, boolean enforced) {
Key key = key(table, keyName);
// [#2718] Column exclusions may hit unique key references. Ignore
// such unique keys
if (column == null) {
if (log.isDebugEnabled())
log.debug("Ignoring unique key", keyName + " (column unavailable)");
// [#7826] Prevent incomplete keys from being generated
if (table != null) {
incompleteKeys.add(key);
uniqueKeys.remove(key);
keys.remove(key);
}
return;
}
if (incompleteKeys.contains(key))
return;
if (log.isDebugEnabled())
log.debug("Adding unique key", keyName + " (" + column + ")");
UniqueKeyDefinition result = getUniqueKey(keyName, table, column, false, enforced);
result.getKeyColumns().add(column);
}
public void overridePrimaryKey(UniqueKeyDefinition key) {
UniqueKeyDefinition old = null;
// Remove the existing key from the column -> key mapping
primaryKeysByColumn = null;
uniqueKeysByColumn = null;
uniqueKeysByTable = null;
keysByColumn = null;
keysByTable = null;
foreignKeysByColumn = null;
foreignKeysByTable = null;
// Remove the existing key from the primary key mapping (not from the unique key mapping!)
Iterator> it = primaryKeys.entrySet().iterator();
while (it.hasNext()) {
Entry entry = it.next();
if (entry.getValue().getTable().equals(key.getTable())) {
old = entry.getValue();
it.remove();
break;
}
}
// Add the new primary key
Key mapKey = key(key.getTable(), key.getName());
if (incompleteKeys.contains(mapKey))
return;
primaryKeys.put(mapKey, key);
keys.put(mapKey, key);
uniqueKeys.remove(mapKey);
if (old != null)
uniqueKeys.put(mapKey, old);
if (log.isDebugEnabled())
log.debug("Overriding primary key", "Table : " + key.getTable() +
", previous key : " + ((old == null) ? "none" : old.getName()) +
", new key : " + key.getName());
}
private UniqueKeyDefinition getUniqueKey(String keyName, TableDefinition table, ColumnDefinition column, boolean isPK, boolean enforced) {
Key key = key(table, keyName);
UniqueKeyDefinition result = keys.get(key);
if (result == null) {
result = new DefaultUniqueKeyDefinition(column.getSchema(), keyName, table, isPK, enforced);
keys.put(key, result);
if (isPK)
primaryKeys.put(key, result);
else
uniqueKeys.put(key, result);
}
return result;
}
public void addForeignKey(
String foreignKeyName,
TableDefinition foreignKeyTable,
ColumnDefinition foreignKeyColumn,
String uniqueKeyName,
TableDefinition uniqueKeyTable) {
addForeignKey(foreignKeyName, foreignKeyTable, foreignKeyColumn, uniqueKeyName, uniqueKeyTable, true);
}
public void addForeignKey(
String foreignKeyName,
TableDefinition foreignKeyTable,
ColumnDefinition foreignKeyColumn,
String uniqueKeyName,
TableDefinition uniqueKeyTable,
boolean enforced
) {
UniqueKeyDefinition uk = keys.get(key(uniqueKeyTable, uniqueKeyName));
Key key = key(foreignKeyTable, foreignKeyName);
if (uk == null) {
if (log.isDebugEnabled())
log.debug("Ignoring foreign key", uniqueKeyName + " (unique key unavailable)");
// [#7826] Prevent incomplete keys from being generated
if (foreignKeyTable != null) {
incompleteKeys.add(key);
foreignKeys.remove(key);
}
return;
}
addForeignKey(foreignKeyName, foreignKeyTable, foreignKeyColumn, uniqueKeyName, uniqueKeyTable, getNextUkColumn(key, uk), enforced);
}
private final Map nextUkColumnIndex = new HashMap<>();
private ColumnDefinition getNextUkColumn(Key key, UniqueKeyDefinition uk) {
Integer index = nextUkColumnIndex.get(key);
if (index == null)
nextUkColumnIndex.put(key, index = 0);
else
nextUkColumnIndex.put(key, index = index + 1);
return index < uk.getKeyColumns().size() ? uk.getKeyColumns().get(index) : null;
}
public void addForeignKey(
String foreignKeyName,
TableDefinition foreignKeyTable,
ColumnDefinition foreignKeyColumn,
String uniqueKeyName,
TableDefinition uniqueKeyTable,
Integer positionInUniqueKey,
boolean enforced
) {
if (positionInUniqueKey == null) {
addForeignKey(
foreignKeyName,
foreignKeyTable,
foreignKeyColumn,
uniqueKeyName,
uniqueKeyTable,
enforced
);
}
else {
UniqueKeyDefinition uniqueKey = keys.get(key(uniqueKeyTable, uniqueKeyName));
if (uniqueKey != null) {
addForeignKey(
foreignKeyName,
foreignKeyTable,
foreignKeyColumn,
uniqueKeyName,
uniqueKeyTable,
uniqueKey.getKeyColumns().get(positionInUniqueKey - 1),
enforced
);
}
}
}
public void addForeignKey(
String foreignKeyName,
TableDefinition foreignKeyTable,
ColumnDefinition foreignKeyColumn,
String uniqueKeyName,
TableDefinition uniqueKeyTable,
ColumnDefinition uniqueKeyColumn,
boolean enforced
) {
// [#2718] Column exclusions may hit foreign key references. Ignore
// such foreign keys
Key key = key(foreignKeyTable, foreignKeyName);
if (foreignKeyColumn == null || uniqueKeyColumn == null) {
if (log.isDebugEnabled())
log.debug("Ignoring foreign key", foreignKeyColumn + " referencing " + uniqueKeyColumn + " (column unavailable)");
// [#7826] Prevent incomplete keys from being generated
if (foreignKeyTable != null) {
incompleteKeys.add(key);
foreignKeys.remove(key);
}
return;
}
if (incompleteKeys.contains(key))
return;
// [#1134] Prevent NPE's when a foreign key references a unique key
// from another schema
if (uniqueKeyTable == null) {
if (log.isDebugEnabled())
log.debug("Ignoring foreign key", foreignKeyName + " (" + foreignKeyColumn + ") referencing " + uniqueKeyName + " (" + uniqueKeyColumn + ") references a schema out of scope for jooq-meta: " + uniqueKeyTable);
return;
}
if (log.isDebugEnabled())
log.debug("Adding foreign key", foreignKeyName + " (" + foreignKeyColumn + ") referencing " + uniqueKeyName + " (" + uniqueKeyColumn + ")");
ForeignKeyDefinition foreignKey = foreignKeys.get(key);
if (foreignKey == null) {
UniqueKeyDefinition uniqueKey = keys.get(key(uniqueKeyTable, uniqueKeyName));
// If the unique key is not loaded, ignore this foreign key
if (uniqueKey != null) {
foreignKey = new DefaultForeignKeyDefinition(
foreignKeyColumn.getSchema(),
foreignKeyName,
foreignKeyColumn.getContainer(),
uniqueKey,
enforced
);
foreignKeys.put(key, foreignKey);
uniqueKey.getForeignKeys().add(foreignKey);
}
}
if (foreignKey != null) {
foreignKey.getKeyColumns().add(foreignKeyColumn);
foreignKey.getReferencedColumns().add(uniqueKeyColumn);
}
}
public void addCheckConstraint(TableDefinition table, CheckConstraintDefinition constraint) {
checkConstraints.put(key(table, constraint.getName()), constraint);
}
@Override
public UniqueKeyDefinition getPrimaryKey(ColumnDefinition column) {
if (primaryKeysByColumn == null) {
primaryKeysByColumn = new LinkedHashMap<>();
for (UniqueKeyDefinition primaryKey : primaryKeys.values())
for (ColumnDefinition keyColumn : primaryKey.getKeyColumns())
primaryKeysByColumn.put(keyColumn, primaryKey);
}
return primaryKeysByColumn.get(column);
}
@Override
public List getUniqueKeys(ColumnDefinition column) {
if (uniqueKeysByColumn == null) {
uniqueKeysByColumn = new LinkedHashMap<>();
for (UniqueKeyDefinition uniqueKey : uniqueKeys.values())
for (ColumnDefinition keyColumn : uniqueKey.getKeyColumns())
uniqueKeysByColumn.computeIfAbsent(keyColumn, c -> new ArrayList<>()).add(uniqueKey);
uniqueKeysByColumn.forEach((t, l) -> t.getDatabase().sort(l));
}
return nonNull(uniqueKeysByColumn, column);
}
@Override
public List getUniqueKeys(TableDefinition table) {
if (uniqueKeysByTable == null)
uniqueKeysByTable = initByTable(uniqueKeys);
return nonNull(uniqueKeysByTable, table);
}
@Override
public List getUniqueKeys(SchemaDefinition schema) {
Set result = new LinkedHashSet<>();
for (TableDefinition table : schema.getDatabase().getTables(schema))
result.addAll(getUniqueKeys(table));
return sort(new ArrayList<>(result));
}
@Override
public List getUniqueKeys() {
return sort(new ArrayList<>(uniqueKeys.values()));
}
@Override
public List getKeys(ColumnDefinition column) {
if (keysByColumn == null) {
keysByColumn = new LinkedHashMap<>();
for (UniqueKeyDefinition uniqueKey : keys.values())
for (ColumnDefinition keyColumn : uniqueKey.getKeyColumns())
keysByColumn.computeIfAbsent(keyColumn, c -> new ArrayList<>()).add(uniqueKey);
keysByColumn.forEach((t, l) -> t.getDatabase().sort(l));
}
return nonNull(keysByColumn, column);
}
@Override
public List getKeys(TableDefinition table) {
if (keysByTable == null)
keysByTable = initByTable(keys);
return nonNull(keysByTable, table);
}
@Override
public List getKeys(SchemaDefinition schema) {
Set result = new LinkedHashSet<>();
for (TableDefinition table : schema.getDatabase().getTables(schema))
result.addAll(getKeys(table));
return sort(new ArrayList<>(result));
}
@Override
public List getKeys() {
return sort(new ArrayList<>(keys.values()));
}
@Override
public List getForeignKeys(ColumnDefinition column) {
if (foreignKeysByColumn == null) {
foreignKeysByColumn = new LinkedHashMap<>();
for (ForeignKeyDefinition foreignKey : foreignKeys.values())
for (ColumnDefinition keyColumn : foreignKey.getKeyColumns())
foreignKeysByColumn.computeIfAbsent(keyColumn, c -> new ArrayList<>()).add(foreignKey);
foreignKeysByColumn.forEach((t, l) -> t.getDatabase().sort(l));
}
return nonNull(foreignKeysByColumn, column);
}
@Override
public List getForeignKeys(TableDefinition table) {
if (foreignKeysByTable == null)
foreignKeysByTable = initByTable(foreignKeys);
return nonNull(foreignKeysByTable, table);
}
@Override
public List getCheckConstraints(TableDefinition table) {
if (checkConstraintsByTable == null)
checkConstraintsByTable = initByTable(checkConstraints);
return nonNull(checkConstraintsByTable, table);
}
private static Map> initByTable(
Map map
) {
Map> result = new LinkedHashMap<>();
map.forEach((k, v) -> result.computeIfAbsent(k.table, t -> new ArrayList<>()).add(v));
result.forEach((t, l) -> t.getDatabase().sort(l));
return result;
}
private static List nonNull(Map> map, K key) {
List list = map.get(key);
return list != null ? list : emptyList();
}
private static List sort(List list) {
return list.isEmpty() ? list : list.get(0).getDatabase().sort(list);
}
private static Key key(TableDefinition definition, String keyName) {
return new Key(definition, keyName);
}
/**
* A simple local wrapper for a key definition (table + key name)
*/
private static record Key(TableDefinition table, String keyName) {}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy