Number of Object's inheritors changes between runs #203 (#205)

Author: lehvolk

jacodb-core/src/main/kotlin/org/jacodb/impl/features/HierarchyExtension.kt

@@ -32,8 +32,10 @@ import org.jacodb.impl.storage.defaultBatchSize
 import org.jacodb.impl.storage.jooq.tables.references.CLASSES
 import org.jacodb.impl.storage.jooq.tables.references.CLASSHIERARCHIES
 import org.jacodb.impl.storage.jooq.tables.references.SYMBOLS
+import org.jooq.Condition
 import org.jooq.Record3
 import org.jooq.SelectConditionStep
+import org.jooq.impl.DSL
 import java.util.concurrent.Future
 
 @Suppress("SqlResolve")
@@ -169,25 +171,28 @@ private fun SelectConditionStep<Record3<Long?, String?, Long?>>.batchingProcess(
         }
 }
 
+private fun List<Long>.where(offset: Long?): Condition {
+    return when (offset) {
+        null -> CLASSES.LOCATION_ID.`in`(this)
+        else -> CLASSES.LOCATION_ID.`in`(this).and(CLASSES.ID.greaterThan(offset))
+    }
+}
+
 internal fun JcClasspath.allClassesExceptObject(direct: Boolean): Sequence<PersistenceClassSource> {
     val locationIds = registeredLocations.map { it.id }
     if (direct) {
         return BatchedSequence(defaultBatchSize) { offset, batchSize ->
             db.persistence.read { jooq ->
-                val whereCondition = if (offset == null) {
-                    CLASSES.LOCATION_ID.`in`(locationIds)
-                } else {
-                    CLASSES.LOCATION_ID.`in`(locationIds).and(
-                        CLASSES.ID.greaterThan(offset)
-                    )
-                }
+                val whereCondition = locationIds.where(offset)
                 jooq.select(CLASSES.ID, SYMBOLS.NAME, CLASSES.LOCATION_ID)
                     .from(CLASSES)
                     .join(SYMBOLS).on(SYMBOLS.ID.eq(CLASSES.NAME))
                     .where(
                         whereCondition
-                            .and(CLASSES.ID.notIn(jooq.select(CLASSHIERARCHIES.SUPER_ID).from(
-                                CLASSHIERARCHIES)))
+                            .and(DSL.notExists(
+                                jooq.select(CLASSHIERARCHIES.ID).from(CLASSHIERARCHIES)
+                                .where(CLASSHIERARCHIES.CLASS_ID.eq(CLASSES.ID).and(CLASSHIERARCHIES.IS_CLASS_REF.eq(true)))
+                            ))
                             .and(SYMBOLS.NAME.notEqual(JAVA_OBJECT))
                     )
                     .batchingProcess(this, batchSize)
@@ -196,13 +201,7 @@ internal fun JcClasspath.allClassesExceptObject(direct: Boolean): Sequence<Persi
         }
         return BatchedSequence(defaultBatchSize) { offset, batchSize ->
             db.persistence.read { jooq ->
-                val whereCondition = if (offset == null) {
-                    CLASSES.LOCATION_ID.`in`(locationIds)
-                } else {
-                    CLASSES.LOCATION_ID.`in`(locationIds).and(
-                        CLASSES.ID.greaterThan(offset)
-                    )
-                }
+                val whereCondition = locationIds.where(offset)
 
                 jooq.select(CLASSES.ID, SYMBOLS.NAME, CLASSES.LOCATION_ID)
                     .from(CLASSES)

jacodb-core/src/main/kotlin/org/jacodb/impl/features/InMemoryHierarchy.kt

@@ -16,15 +16,7 @@
 
 package org.jacodb.impl.features
 
-import org.jacodb.api.ByteCodeIndexer
-import org.jacodb.api.ClassSource
-import org.jacodb.api.JcClassOrInterface
-import org.jacodb.api.JcClasspath
-import org.jacodb.api.JcDatabase
-import org.jacodb.api.JcDatabasePersistence
-import org.jacodb.api.JcFeature
-import org.jacodb.api.JcSignal
-import org.jacodb.api.RegisteredLocation
+import org.jacodb.api.*
 import org.jacodb.api.ext.JAVA_OBJECT
 import org.jacodb.impl.fs.PersistenceClassSource
 import org.jacodb.impl.fs.className
@@ -33,6 +25,7 @@ import org.jacodb.impl.storage.defaultBatchSize
 import org.jacodb.impl.storage.jooq.tables.references.CLASSES
 import org.jacodb.impl.storage.jooq.tables.references.CLASSHIERARCHIES
 import org.jacodb.impl.storage.jooq.tables.references.SYMBOLS
+import org.jacodb.impl.storage.withoutAutoCommit
 import org.jooq.DSLContext
 import org.jooq.impl.DSL
 import org.objectweb.asm.Type
@@ -45,19 +38,21 @@ typealias InMemoryHierarchyCache = ConcurrentHashMap<Long, ConcurrentHashMap<Lon
 private val objectJvmName = Type.getInternalName(Any::class.java)
 
 class InMemoryHierarchyIndexer(
-    private val persistence: JcDatabasePersistence,
+    persistence: JcDatabasePersistence,
     private val location: RegisteredLocation,
     private val hierarchy: InMemoryHierarchyCache
 ) : ByteCodeIndexer {
 
+    private val interner = persistence.symbolInterner
+
     override fun index(classNode: ClassNode) {
-        val clazzSymbolId = persistence.findSymbolId(classNode.name.className) ?: return
+        val clazzSymbolId = interner.findOrNew(classNode.name.className)
         val superName = classNode.superName
         val superclasses = when {
             superName != null && superName != objectJvmName -> classNode.interfaces + superName
             else -> classNode.interfaces
         }
-        superclasses.mapNotNull { persistence.findSymbolId(it.className) }
+        superclasses.map { interner.findOrNew(it.className) }
             .forEach {
                 hierarchy.getOrPut(it) { ConcurrentHashMap() }
                     .getOrPut(location.id) { ConcurrentHashMap.newKeySet() }
@@ -66,6 +61,9 @@ class InMemoryHierarchyIndexer(
     }
 
     override fun flush(jooq: DSLContext) {
+        jooq.withoutAutoCommit { conn ->
+            interner.flush(conn)
+        }
     }
 }
 

jacodb-core/src/test/kotlin/org/jacodb/testing/SubclassesTest.kt

@@ -0,0 +1,59 @@
+/*
+ *  Copyright 2022 UnitTestBot contributors (utbot.org)
+ * <p>
+ *  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
+ * <p>
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ *  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.jacodb.testing
+
+import kotlinx.coroutines.runBlocking
+import org.jacodb.api.JcClasspath
+import org.jacodb.api.ext.JAVA_OBJECT
+import org.jacodb.impl.features.hierarchyExt
+import org.junit.jupiter.api.AfterEach
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.Test
+
+@LifecycleTest
+class SubclassesTest : BaseTest() {
+
+    companion object : WithGlobalDB()
+
+    private val withDB = WithDB()
+
+    private val anotherDb = withDB.db
+    private val anotherCp: JcClasspath by lazy {
+        runBlocking {
+            anotherDb.awaitBackgroundJobs()
+            anotherDb.classpath(allClasspath)
+        }
+    }
+
+    @Test
+    fun `Object subclasses should be the same`() {
+        runBlocking {
+            val hierarchy = cp.hierarchyExt()
+            val anotherHierarchy = anotherCp.hierarchyExt()
+            Assertions.assertEquals(
+                hierarchy.findSubClasses(JAVA_OBJECT, false, includeOwn = true).count(),
+                anotherHierarchy.findSubClasses(JAVA_OBJECT, false, includeOwn = true).count()
+            )
+        }
+    }
+
+    @AfterEach
+    fun `cleanup another db`() = runBlocking {
+        withDB.cleanup()
+    }
+
+}