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

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

defects/doctrine/patch/doctrine-0001-hydrator-discriminator-set.patch

@@ -0,0 +1,38 @@
+Fixes doctrine-0001: AbstractHydrator `discriminatorValues` in_array per row.
+
+--- a/src/Doctrine/ORM/Internal/Hydration/AbstractHydrator.php
++++ b/src/Doctrine/ORM/Internal/Hydration/AbstractHydrator.php
+
+@@ DEFECT doctrine-0001: AbstractHydrator.php:328 gatherRowData()
+
+     private function hydrateColumnInfo(array $cacheKeyInfo, mixed $value): mixed
+     {
+         // ...
+-        if (
+-            isset($cacheKeyInfo['discriminatorColumn'], $data[$cacheKeyInfo['discriminatorColumn']])
+-            && ! in_array((string) $data[$cacheKeyInfo['discriminatorColumn']], $cacheKeyInfo['discriminatorValues'], true)
++        // FIX doctrine-0001: convert discriminatorValues from array to Set for O(1) lookup
++        // Previously: in_array() scans the entire discriminatorValues array per row — O(subclasses).
++        // Called once per column per row in queries over inheritance hierarchies.
++        if (
++            isset($cacheKeyInfo['discriminatorColumn'], $data[$cacheKeyInfo['discriminatorColumn']])
++            && ! isset($cacheKeyInfo['discriminatorValuesSet'][(string) $data[$cacheKeyInfo['discriminatorColumn']]])
+         ) {
+             break;
+         }
+     }
+
+@@ SETUP: build the set when cacheKeyInfo is first created (in buildCacheEntry)
+
+-    $cacheKeyInfo['discriminatorValues'] = $this->getDiscriminatorValues($classMetadata);
++    $discriminatorValues = $this->getDiscriminatorValues($classMetadata);
++    $cacheKeyInfo['discriminatorValues'] = $discriminatorValues;
++    // FIX doctrine-0001: pre-build a hash set for O(1) lookup in gatherRowData
++    $cacheKeyInfo['discriminatorValuesSet'] = array_flip($discriminatorValues);
+
+# BEFORE: in_array($disc, $discriminatorValues) — O(S) per row per col, S = subclass count.
+#         Total: O(N × C × S) for N rows, C columns, S subclasses.
+# AFTER:  isset($discriminatorValuesSet[$disc]) — O(1) hash lookup.
+#         Total: O(N × C).
+# Triggered by: any DQL/QueryBuilder query on an entity with CTI/STI inheritance
+#               that returns multiple rows.

defects/doctrine/patch/doctrine-0002-classmetadata-subclasses-set.patch

@@ -0,0 +1,26 @@
+Fixes doctrine-0002: ClassMetadata::addSubClass in_array dedup.
+
+--- a/src/Doctrine/ORM/Mapping/ClassMetadata.php
++++ b/src/Doctrine/ORM/Mapping/ClassMetadata.php
+
+@@ DEFECT doctrine-0002: ClassMetadata.php:2313 addSubClass()
+
++    /** @var array<string, true>  FIX doctrine-0002: hash set for O(1) subclass dedup */
++    public array $subClassesSet = [];
+
+     public function addSubClass(string $className): void
+     {
+-        if (is_subclass_of($className, $this->name) && ! in_array($className, $this->subClasses, true)) {
+-            $this->subClasses[] = $className;
++        // FIX doctrine-0002: replace O(S) in_array scan with O(1) hash check.
++        if (is_subclass_of($className, $this->name) && ! isset($this->subClassesSet[$className])) {
++            $this->subClasses[] = $className;
++            $this->subClassesSet[$className] = true;
+         }
+     }
+
+# BEFORE: in_array($className, $this->subClasses) — O(S) per addSubClass call.
+#         ClassMetadataFactory calls addSubClass in loops over parent hierarchies.
+#         Total: O(H × S) where H = hierarchy depth, S = subclass count.
+# AFTER:  isset($this->subClassesSet[$className]) — O(1).
+# Triggered by: application startup / metadata cache warming.

defects/doctrine/patch/doctrine-0003-sqlwalker-partialfield-set.patch

@@ -0,0 +1,34 @@
+Fixes doctrine-0003: SqlWalker::walkObjectExpression in_array per field.
+
+--- a/src/Doctrine/ORM/Query/SqlWalker.php
++++ b/src/Doctrine/ORM/Query/SqlWalker.php
+
+@@ DEFECT doctrine-0003: SqlWalker.php:1405,1445 walkObjectExpression()
+
+     private function walkObjectExpression(...): string
+     {
++        // FIX doctrine-0003: convert partialFieldSet from array to set for O(1) lookup.
++        // Previously: in_array($fieldName, $partialFieldSet) is O(|partialFieldSet|) per field.
++        // Called for every fieldMapping in every class/subclass in the DQL result.
++        $partialFieldSetFlip = $partialFieldSet !== null ? array_flip($partialFieldSet) : null;
+
+         foreach ($class->fieldMappings as $fieldName => $mapping) {
+-            if ($partialFieldSet && ! in_array($fieldName, $partialFieldSet, true)) {
++            if ($partialFieldSetFlip !== null && ! isset($partialFieldSetFlip[$fieldName])) {
+                 continue;
+             }
+             // ... build SQL
+         }
+
+         foreach ($subClass->fieldMappings as $fieldName => $mapping) {
+-            if (isset($mapping->inherited) || ($partialFieldSet && ! in_array($fieldName, $partialFieldSet, true))) {
++            if (isset($mapping->inherited) || ($partialFieldSetFlip !== null && ! isset($partialFieldSetFlip[$fieldName]))) {
+                 continue;
+             }
+         }
+     }
+
+# BEFORE: in_array($field, $partialFieldSet) — O(P) per field across all mappings.
+#         Total: O(F × P) for F field mappings, P partial field set size.
+# AFTER:  isset($partialFieldSetFlip[$field]) — O(1).
+# Triggered by: any DQL query using SELECT PARTIAL entity.{field1,field2,...}.