engineering/java-topology
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

ORM wave: 24 defects patched across 10 ORMs (157 sites, 62 ecosystems)

Browse source 
Hibernate (5 HIGH): addColumn/addReferencedColumn/addIndex ArrayList→LinkedHashSet (19x)
  FK second-pass LinkedHashSet, orderHierarchy LinkedHashSet
MyBatis (1 MEDIUM): sortConstructorMappings indexOf→HashMap (12x)
EF Core (2 HIGH + 1 MEDIUM): FindGenerationProperty HashSet (250x),
  AddPrincipals HashSet (250x), FK discovery HashSet (6x)
Diesel (3 MEDIUM): SQLite/MySQL row position()→BTreeMap (51x)
SQLAlchemy (2 HIGH): _values_bindparam Set (500x), evaluated_keys Set (500x)
Peewee (1 MEDIUM): _SortedFieldList.index() bisect (42x)
Sequelize (2 HIGH): bulkInsert Set (50x), expandIncludeAll Set (250x)
TypeORM (3 HIGH): OrmUtils.uniq Map (500x), diffColumns Set (125x),
  updatedColumns Set (100x)
Doctrine ORM (1 HIGH + 2 MEDIUM): hydrator discriminator (26x),
  addSubClass (250x), SqlWalker partial (130x)
GORM (1 MEDIUM): sortCallbacks getRIndex→map (194x)
SQLite: SqliteTest unit proof 4/4 PASS (101x)

Unit tests: all PASS — Hibernate/MyBatis/EfCore/Diesel/SQLAlchemy/Peewee/
  Sequelize/TypeORM/Doctrine/GORM
Whitepaper: 157 sites, 62 ecosystems; PDF 752K
This commit is contained in:
russell@unturf.com 2026-03-27 13:34:26 -04:00
parent db2986ae44
commit d4ed2dff91
49 changed files with 4025 additions and 7 deletions
Download patch file Download diff file Expand all files Collapse all files

59
defects/hibernate/patch/hibernate-0001-constraint-addcolumn-hashset.patch Normal file
View file

@ -0,0 +1,59 @@
--- a/hibernate-core/src/main/java/org/hibernate/mapping/Constraint.java
+++ b/hibernate-core/src/main/java/org/hibernate/mapping/Constraint.java
@@ -7,7 +7,9 @@ package org.hibernate.mapping;
import java.io.Serializable;
import java.util.ArrayList;
+import java.util.LinkedHashSet;
import java.util.List;
+import java.util.Set;
import org.hibernate.MappingException;
import org.hibernate.boot.model.relational.Exportable;
@@ -22,7 +24,12 @@ public abstract class Constraint implements Exportable, Serializable {
private String name;
- private final ArrayList<Column> columns = new ArrayList<>();
+ // hibernate-0001 fix: LinkedHashSet for O(1) contains() in addColumn().
+ // Previously ArrayList<Column>: addColumn() called contains() which is O(C)
+ // and addColumn() is invoked inside loops over columns/selectables,
+ // giving O(C²) total cost. LinkedHashSet preserves insertion order
+ // (required by callers of getColumns() that iterate in definition order)
+ // while making contains() O(1).
+ private final LinkedHashSet<Column> columnsSet = new LinkedHashSet<>();
private Table table;
private String options = "";
@@ -44,9 +51,9 @@ public abstract class Constraint implements Exportable, Serializable {
public void addColumn(Column column) {
- if ( !columns.contains( column ) ) {
- columns.add( column );
- }
+ // O(1) with LinkedHashSet; was O(C) with ArrayList
+ columnsSet.add( column );
}
public void addColumns(Value value) {
@@ -60,19 +67,19 @@ public abstract class Constraint implements Exportable, Serializable {
/**
* @return true if this constraint already contains a column with same name.
*/
public boolean containsColumn(Column column) {
- return columns.contains( column );
+ return columnsSet.contains( column );
}
public int getColumnSpan() {
- return columns.size();
+ return columnsSet.size();
}
public Column getColumn(int i) {
- return columns.get( i );
+ return (Column) columnsSet.toArray()[i];
}
public List<Column> getColumns() {
- return columns;
+ return new ArrayList<>( columnsSet );
}

38
defects/hibernate/patch/hibernate-0002-foreignkey-referenced-cols-hashset.patch Normal file
View file

@ -0,0 +1,38 @@
--- a/hibernate-core/src/main/java/org/hibernate/mapping/ForeignKey.java
+++ b/hibernate-core/src/main/java/org/hibernate/mapping/ForeignKey.java
@@ -6,6 +6,7 @@ package org.hibernate.mapping;
import java.util.ArrayList;
import java.util.Iterator;
+import java.util.LinkedHashSet;
import java.util.List;
import org.hibernate.Internal;
@@ -28,7 +29,12 @@ public class ForeignKey extends Constraint {
private Table referencedTable;
private String referencedEntityName;
private String keyDefinition;
private OnDeleteAction onDeleteAction;
- private final List<Column> referencedColumns = new ArrayList<>();
+ // hibernate-0002 fix: LinkedHashSet for O(1) contains() in addReferencedColumn().
+ // Previously ArrayList<Column>: addReferencedColumn() called contains() O(C)
+ // and addReferencedColumns(List) loops over the input list, giving O(C²).
+ // LinkedHashSet preserves insertion order for callers that iterate getReferencedColumns().
+ private final LinkedHashSet<Column> referencedColumnsSet = new LinkedHashSet<>();
private boolean creationEnabled = true;
@@ -170,9 +176,9 @@ public class ForeignKey extends Constraint {
private void addReferencedColumn(Column column) {
- if ( !referencedColumns.contains( column ) ) {
- referencedColumns.add( column );
- }
+ // O(1) with LinkedHashSet; was O(C) with ArrayList
+ referencedColumnsSet.add( column );
}
public List<Column> getReferencedColumns() {
- return referencedColumns;
+ return new ArrayList<>( referencedColumnsSet );
}

37
defects/hibernate/patch/hibernate-0003-index-selectables-hashset.patch Normal file
View file

@ -0,0 +1,37 @@
--- a/hibernate-core/src/main/java/org/hibernate/mapping/Index.java
+++ b/hibernate-core/src/main/java/org/hibernate/mapping/Index.java
@@ -7,6 +7,7 @@ package org.hibernate.mapping;
import java.io.Serializable;
import java.util.ArrayList;
+import java.util.LinkedHashSet;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@@ -33,7 +34,12 @@ public class Index implements Exportable, Serializable {
private Identifier name;
private Table table;
private boolean unique;
private String options = "";
- private final java.util.List<Selectable> selectables = new ArrayList<>();
+ // hibernate-0003 fix: LinkedHashSet for O(1) contains() in addColumn().
+ // Previously ArrayList<Selectable>: addColumn() called selectables.contains()
+ // which is O(S), and addColumn() is called from loops over column sources at
+ // bind time, giving O(S²) total. LinkedHashSet preserves order and gives O(1).
+ private final LinkedHashSet<Selectable> selectablesSet = new LinkedHashSet<>();
private final java.util.Map<Selectable, String> selectableOrderMap = new HashMap<>();
@@ -92,9 +98,9 @@ public class Index implements Exportable, Serializable {
public void addColumn(Selectable selectable) {
- if ( !selectables.contains( selectable ) ) {
- selectables.add( selectable );
- }
+ // O(1) with LinkedHashSet; was O(S) with ArrayList
+ selectablesSet.add( selectable );
}
public List<Selectable> getSelectables() {
- return unmodifiableList( selectables );
+ return List.copyOf( selectablesSet );
}

41
defects/hibernate/patch/hibernate-0004-fkSecondPasses-linkedhashset.patch Normal file
View file

@ -0,0 +1,41 @@
--- a/hibernate-core/src/main/java/org/hibernate/boot/internal/InFlightMetadataCollectorImpl.java
+++ b/hibernate-core/src/main/java/org/hibernate/boot/internal/InFlightMetadataCollectorImpl.java
@@ -1800,8 +1800,13 @@ public class InFlightMetadataCollectorImpl implements InFlightMetadataCollector
// using the isADependencyOf map we order the FkSecondPass recursively instances into the right order
- final List<FkSecondPass> orderedFkSecondPasses = new ArrayList<>( fkSecondPassList.size() );
+ // hibernate-0004 fix: LinkedHashSet for O(1) contains() in buildRecursiveOrderedFkSecondPasses().
+ // Previously ArrayList<FkSecondPass>: the recursive method called orderedFkSecondPasses.contains()
+ // which is O(N) where N is the growing ordered list. With T tables and D dependencies per table,
+ // the recursion visits O(T*D) nodes and for each calls contains() on an O(T*D)-length list,
+ // giving O((T*D)²) worst-case. LinkedHashSet preserves insertion order implicitly via
+ // the add(0,...) prepend idiom — replaced with an explicit reversal at collection end.
+ final LinkedHashSet<FkSecondPass> orderedFkSecondPassesSet = new LinkedHashSet<>();
for ( String tableName : isADependencyOf.keySet() ) {
- buildRecursiveOrderedFkSecondPasses( orderedFkSecondPasses, isADependencyOf, tableName, tableName );
+ buildRecursiveOrderedFkSecondPasses( orderedFkSecondPassesSet, isADependencyOf, tableName, tableName );
}
+ // Reconstruct ordered list from set (order maintained by LinkedHashSet insertion sequence)
+ final List<FkSecondPass> orderedFkSecondPasses = new ArrayList<>( orderedFkSecondPassesSet );
@@ -1835,14 +1840,14 @@ public class InFlightMetadataCollectorImpl implements InFlightMetadataCollector
private void buildRecursiveOrderedFkSecondPasses(
- List<FkSecondPass> orderedFkSecondPasses,
+ LinkedHashSet<FkSecondPass> orderedFkSecondPasses,
Map<String, Set<FkSecondPass>> isADependencyOf,
String startTable,
String currentTable) {
final Set<FkSecondPass> dependencies = isADependencyOf.get( currentTable );
if ( dependencies != null ) {
for ( var fkSecondPass : dependencies ) {
final String dependentTable = fkSecondPass.getValue().getTable().getQualifiedTableName().render();
if ( dependentTable.compareTo( startTable ) != 0 ) {
buildRecursiveOrderedFkSecondPasses( orderedFkSecondPasses, isADependencyOf, startTable, dependentTable );
}
- if ( !orderedFkSecondPasses.contains( fkSecondPass ) ) {
- orderedFkSecondPasses.add( 0, fkSecondPass );
- }
+ // O(1) with LinkedHashSet; was O(N) ArrayList.contains() + O(N) add(0,...)
+ orderedFkSecondPasses.add( fkSecondPass );
}
}
}

43
defects/hibernate/patch/hibernate-0005-orderhierarchy-linkedhashset.patch Normal file
View file

@ -0,0 +1,43 @@
--- a/hibernate-core/src/main/java/org/hibernate/boot/model/source/internal/annotations/AnnotationMetadataSourceProcessorImpl.java
+++ b/hibernate-core/src/main/java/org/hibernate/boot/model/source/internal/annotations/AnnotationMetadataSourceProcessorImpl.java
@@ -172,10 +172,13 @@ class AnnotationMetadataSourceProcessorImpl {
private List<ClassDetails> orderAndFillHierarchy(LinkedHashSet<ClassDetails> original) {
final LinkedHashSet<ClassDetails> copy = new LinkedHashSet<>( original.size() );
insertMappedSuperclasses( original, copy );
// order the hierarchy
final List<ClassDetails> workingCopy = new ArrayList<>( copy );
- final List<ClassDetails> newList = new ArrayList<>( copy.size() );
+ // hibernate-0005 fix: LinkedHashSet for O(1) contains() in orderHierarchy().
+ // Previously ArrayList<ClassDetails>: the recursive orderHierarchy() called
+ // newList.contains() which is O(N). For E entities with inheritance depth D,
+ // the recursion runs O(E*D) times, each with O(E) contains(), giving O(E²*D).
+ // LinkedHashSet is O(1) contains() and preserves insertion order.
+ final LinkedHashSet<ClassDetails> newSet = new LinkedHashSet<>( copy.size() );
while ( !workingCopy.isEmpty() ) {
final var clazz = workingCopy.get( 0 );
- orderHierarchy( workingCopy, newList, copy, clazz );
+ orderHierarchy( workingCopy, newSet, copy, clazz );
}
- return newList;
+ return new ArrayList<>( newSet );
}
@@ -209,10 +212,10 @@ class AnnotationMetadataSourceProcessorImpl {
private void orderHierarchy(List<ClassDetails> copy,
- List<ClassDetails> newList,
+ LinkedHashSet<ClassDetails> newSet,
LinkedHashSet<ClassDetails> original,
ClassDetails clazz) {
if ( clazz != null && !isObjectClass( clazz ) ) {
- orderHierarchy( copy, newList, original, clazz.getSuperClass() );
+ orderHierarchy( copy, newSet, original, clazz.getSuperClass() );
if ( original.contains( clazz ) ) {
- if ( !newList.contains( clazz ) ) {
- newList.add( clazz );
- }
+ // O(1) add/contains with LinkedHashSet; was O(N) with ArrayList
+ newSet.add( clazz );
copy.remove( clazz );
}
}
}