adds TransformerUseCase

src/main/kotlin/unibz.cs.semint.kprime/Starter.kt

 package unibz.cs.semint.kprime
 
-import unibz.cs.semint.kprime.scenario.SakilaScenario
 
 class Starter {
 
@@ -12,7 +11,6 @@ class Starter {
      fun main(args:Array<String>) {
          val version = "0.1.0-SNAPSHOT"
          println("KPrime $version")
-         SakilaScenario().run()
      }
 
  }

src/main/kotlin/unibz.cs.semint.kprime/domain/Constraint.kt

@@ -6,7 +6,7 @@ import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement
 @JacksonXmlRootElement(localName = "constraint")
 class Constraint () {
     enum class TYPE {
-        FOREIGN_KEY,PRIMARY_KEY,FUNCTIONAL,INCLUSION,DISJUNCTION,COVER
+        FOREIGN_KEY,PRIMARY_KEY,FUNCTIONAL,DOUBLE_INCLUSION,INCLUSION,DISJUNCTION,COVER
     }
     @JacksonXmlProperty(isAttribute = true)
     var name: String =""

src/main/kotlin/unibz.cs.semint.kprime/scenario/SakilaScenario.kt

-package unibz.cs.semint.kprime.scenario
-
-import unibz.cs.semint.kprime.adapter.repository.MetaSchemaJdbcAdapter
-import unibz.cs.semint.kprime.adapter.service.XMLSerializerJacksonAdapter
-import unibz.cs.semint.kprime.domain.DataSource
-import unibz.cs.semint.kprime.domain.Database
-import unibz.cs.semint.kprime.usecase.MetaSchemaReadUseCase
-
-class SakilaScenario {
-
-    fun run() {
-        val sakilaMeta = readSakilaMeta()
-        if (sakilaMeta!=null) {
-            vsplitSakila(sakilaMeta)
-            hsplitSakila(sakilaMeta)
-            identifySakila(sakilaMeta)
-        }
-    }
-
-    private fun readSakilaMeta(): Database? {
-        val type = "psql"
-        val name = "sakila-source"
-        val driver = "org.postgresql.Driver"
-        val path = "jdbc:postgresql://localhost:5432/sakila"
-        val user = "sammy"
-        val pass = "pass"
-        val sakilaSource = DataSource(type,name,driver,path,user,pass)
-        val result = MetaSchemaReadUseCase().doit(sakilaSource,
-                "read-meta-schema sakila-source",
-                MetaSchemaJdbcAdapter(),
-                XMLSerializerJacksonAdapter())
-        return result.ok
-    }
-
-    private fun vsplitSakila(db: Database) {
-        // if detect(db):result
-        //  apply(db,result):db
-    }
-
-    private fun hsplitSakila(db: Database) {
-        // if detect(db):result
-        //  apply(db,result):db
-    }
-
-    private fun identifySakila(db: Database) {
-        // if detect(db):result
-        //  apply(db,result):db
-    }
-
-}
\ No newline at end of file

src/main/kotlin/unibz.cs.semint.kprime/usecase/ApplyChangeSetUseCase.kt

@@ -3,6 +3,9 @@ package unibz.cs.semint.kprime.usecase
 import unibz.cs.semint.kprime.domain.ChangeSet
 import unibz.cs.semint.kprime.domain.Database
 
+/**
+ * Given a Databse will apply changes following a given changeSet modification.
+ */
 class ApplyChangeSetUseCase {
     fun apply(db: Database, changeset:ChangeSet):Database {
         // TODO for every create* and remove* will do it on a cloned db

src/main/kotlin/unibz.cs.semint.kprime/usecase/VSplitApplyUseCase.kt → src/main/kotlin/unibz.cs.semint.kprime/usecase/HJoinUseCase.kt

 package unibz.cs.semint.kprime.usecase
 
-class VSplitApplyUseCase {}
\ No newline at end of file

src/main/kotlin/unibz.cs.semint.kprime/usecase/HSplitApplyUseCase.kt

-package unibz.cs.semint.kprime.usecase
-
-class HSplitApplyUseCase {
-
-}
\ No newline at end of file

src/main/kotlin/unibz.cs.semint.kprime/usecase/HSplitDetectUseCase.kt

-package unibz.cs.semint.kprime.usecase
-
-import unibz.cs.semint.kprime.domain.ChangeSet
-import unibz.cs.semint.kprime.domain.Database
-
-class HSplitDetectUseCase: TransformerUseCase {
-    override fun compute(db: Database): ChangeSet {
-        TODO("not implemented")
-    }
-}
\ No newline at end of file

src/main/kotlin/unibz.cs.semint.kprime/scenario/PersonHSplitScenario.kt → src/main/kotlin/unibz.cs.semint.kprime/usecase/HSplitUseCase.kt

-package unibz.cs.semint.kprime.scenario
+package unibz.cs.semint.kprime.usecase
 
 import unibz.cs.semint.kprime.adapter.service.XMLSerializerJacksonAdapter
 import unibz.cs.semint.kprime.domain.*
 import unibz.cs.semint.kprime.usecase.SQLizeUseCase
 import unibz.cs.semint.kprime.usecase.XMLSerializeUseCase
 
-class PersonHSplitScenario {
+class HSplitUseCase {
 
-    fun run() {
-        val personMetadata = buildPersonMetadata()
-        hsplitPersonMetadata(personMetadata)
-    }
-
-    private fun buildPersonMetadata(): Database {
-        val db = Database()
-        val personTable = Table()
-        personTable.name= "person"
-        val colSSN = Column("SSN", "id.SSN", "dbname.SSN")
-        personTable.columns.add(colSSN)
-        colSSN.nullable=false
-        val colT = Column("T", "id.T", "dbname.T")
-        personTable.columns.add(colT)
-        colT.nullable=false
-        val colS = Column("S", "id.S", "dbname.S")
-        colS.nullable=true
-        personTable.columns.add(colS)
-        db.schema.tables.add(personTable)
-
-        val primaryConstraint = Constraint()
-        primaryConstraint.name="primaryKey.person"
-        primaryConstraint.source.table="person"
-        primaryConstraint.source.columns.add(colSSN)
-        primaryConstraint.source.columns.add(colT)
-        primaryConstraint.type=Constraint.TYPE.PRIMARY_KEY.name
-        db.schema.constraints.add(primaryConstraint)
-
-        return db
-    }
-
-    private fun hsplitPersonMetadata(personMetadata: Database) {
-        printDb(personMetadata)
-        val  detected = detect(personMetadata)
+    fun compute(databaseMetadata: Database) {
+        printDb(databaseMetadata)
+        val  detected = detect(databaseMetadata)
         if (detected.ok!=null) {
-            val applied = apply(personMetadata, detected)
+            val applied = apply(databaseMetadata, detected)
             if (applied.ok!=null) {
                 printDb(applied.ok)
                 printSql(SQLizeUseCase().sqlize(applied.ok))

src/main/kotlin/unibz.cs.semint.kprime/usecase/IdentifierApplyUseCase.kt

-package unibz.cs.semint.kprime.usecase
-
-class IdentifierApplyUseCase {}
\ No newline at end of file

src/main/kotlin/unibz.cs.semint.kprime/usecase/IdentifierDetectUseCase.kt

-package unibz.cs.semint.kprime.usecase
-
-class IdentifierDetectUseCase {
-}
\ No newline at end of file

src/main/kotlin/unibz.cs.semint.kprime/usecase/TransformerHUseCase.kt

+package unibz.cs.semint.kprime.usecase
+
+import unibz.cs.semint.kprime.domain.Database
+
+class TransformerHUseCase :TransformerUseCase {
+    override fun decompose(db: Database): Database {
+        // TODO("not implemented")
+        return Database()
+    }
+
+    override fun compose(db: Database): Database {
+        // TODO("not implemented")
+        return Database()
+    }
+
+}
\ No newline at end of file

src/main/kotlin/unibz.cs.semint.kprime/usecase/TransformerUseCase.kt

@@ -4,5 +4,6 @@ import unibz.cs.semint.kprime.domain.ChangeSet
 import unibz.cs.semint.kprime.domain.Database
 
 interface TransformerUseCase {
-    fun compute(db: Database):ChangeSet
+    fun decompose(db: Database):Database
+    fun compose(db:Database): Database
 }
\ No newline at end of file

src/main/kotlin/unibz.cs.semint.kprime/usecase/TransformerVUseCase.kt

+package unibz.cs.semint.kprime.usecase
+
+import unibz.cs.semint.kprime.domain.Database
+
+class TransformerVUseCase :TransformerUseCase {
+
+    override fun decompose(db: Database): Database {
+        val changeSet = VSplitUseCase().compute(db)
+        return ApplyChangeSetUseCase().apply(db,changeSet)
+    }
+
+    override fun compose(db: Database): Database {
+        val changeSet = VJoinUseCase().compute(db)
+        return ApplyChangeSetUseCase().apply(db,changeSet)
+    }
+
+}
\ No newline at end of file

src/main/kotlin/unibz.cs.semint.kprime/usecase/VJoinUseCase.kt

+package unibz.cs.semint.kprime.usecase
+
+import unibz.cs.semint.kprime.domain.ChangeSet
+import unibz.cs.semint.kprime.domain.Constraint
+import unibz.cs.semint.kprime.domain.CreateView
+import unibz.cs.semint.kprime.domain.Database
+
+class VJoinUseCase {
+
+    fun compute(database: Database): ChangeSet {
+        val changeSet: ChangeSet = ChangeSet()
+
+
+        var tab1 = ""
+        var tab2 = ""
+        var colJoin1 = ""
+        var colJoin2 = ""
+
+        // if there is a double inclusion in tab1 and tab2 and a primary key on colJoin
+        for (const in database.schema.constraints) {
+            if (const.type==Constraint.TYPE.DOUBLE_INCLUSION.name) {
+                tab1 = const.source.table
+                tab2= const.target.table
+                colJoin1 = const.source.columns[0].name
+                colJoin2 = const.target.columns[0].name
+                break
+            }
+        }
+        if (tab1=="") {
+            return changeSet
+        }
+
+        val view1cols = "select * from $tab1 join $tab2 on $tab1.$colJoin1 = $tab2.$colJoin2"
+        val view1 = CreateView()
+        view1.viewName="tableJoin"
+        view1.text=view1cols
+        changeSet.createView.add(view1)
+        return changeSet
+    }
+
+}
\ No newline at end of file

src/main/kotlin/unibz.cs.semint.kprime/usecase/VSplitDetectUseCase.kt

-package unibz.cs.semint.kprime.usecase
-
-class VSplitDetectUseCase {
-}
\ No newline at end of file

src/main/kotlin/unibz.cs.semint.kprime/scenario/PersonVSplitScenario.kt → src/main/kotlin/unibz.cs.semint.kprime/usecase/VSplitUseCase.kt

-package unibz.cs.semint.kprime.scenario
+package unibz.cs.semint.kprime.usecase
 
-import unibz.cs.semint.kprime.adapter.service.XMLSerializerJacksonAdapter
 import unibz.cs.semint.kprime.domain.*
-import unibz.cs.semint.kprime.usecase.XMLSerializeUseCase
 
-class PersonVSplitScenario {
+class VSplitUseCase {
 
-    fun run(): ChangeSet {
-        val personMetadata = buildPersonMetadata()
-        println(XMLSerializeUseCase(XMLSerializerJacksonAdapter()).prettyDatabase(personMetadata))
-        return vsplitPersonMetadata(personMetadata)
-    }
-
-    private fun buildPersonMetadata(): Database {
-        val db = Database()
-        val personTable = Table()
-        personTable.name= "person"
-        val colSSN = Column("SSN", "id.SSN", "dbname.SSN")
-        personTable.columns.add(colSSN)
-        colSSN.nullable=false
-
-        val colT = Column("T", "id.T", "dbname.T")
-        personTable.columns.add(colT)
-        colT.nullable=false
-
-        val colS = Column("S", "id.S", "dbname.S")
-        colS.nullable=true
-        personTable.columns.add(colS)
-
-        val colX = Column("X", "id.X", "dbname.X")
-        colX.nullable=true
-        personTable.columns.add(colX)
-
-        db.schema.key("person", mutableSetOf(colSSN))
-        db.schema.functional("person", mutableSetOf(colT), mutableSetOf(colS))
-
-        db.schema.tables.add(personTable)
-
-        return db
-    }
-
-    private fun vsplitPersonMetadata(personMetadata: Database): ChangeSet {
+    fun compute(metadataDatabase: Database): ChangeSet {
         // check for functional dep
         // create changeset
         var changeSet = ChangeSet()
 
         // compute K
-        val keyCols = personMetadata.schema.key("person")
+        val keyCols = metadataDatabase.schema.key("person")
         var key = keyCols.map { x -> x.name }.toSet()
         println("key $key")
         // compute LHS
-        var lhsCols = personMetadata.schema.functionalLHS("person")
+        var lhsCols = metadataDatabase.schema.functionalLHS("person")
                 var lhs= lhsCols.map { x -> x.name }.toSet()
         println("lhs $lhs")
         if (lhs.isEmpty()) return changeSet
         // compute RHS
-        val rhsCols = personMetadata.schema.functionalRHS("person")
+        val rhsCols = metadataDatabase.schema.functionalRHS("person")
         var rhs = rhsCols.map { x -> x.name }.toSet()
         println("rhs $rhs")
         // compute Rest
-        val allCols = personMetadata.schema.table("person").columns.toSet()
+        val allCols = metadataDatabase.schema.table("person").columns.toSet()
         val all = allCols.map { x -> x.name }.toSet()
         var rest = all.minus(key).minus(lhs).minus(rhs)
         val allNotKey = all.minus(key)
@@ -89,20 +53,12 @@ class PersonVSplitScenario {
         changeSet.createConstraint.add(inclusionTab1Tab2)
         // create inclusion constraint tab2 tab1
         val inclusionTab2Tab1 = Constraint()
-        inclusionTab2Tab1.type=Constraint.TYPE.INCLUSION.name
+        inclusionTab2Tab1.type=Constraint.TYPE.DOUBLE_INCLUSION.name
         inclusionTab2Tab1.source.table="tableName2"
         inclusionTab2Tab1.source.columns.addAll(lhsCols)
         inclusionTab2Tab1.target.table="tableName1"
         inclusionTab2Tab1.target.columns.addAll(lhsCols)
         changeSet.createConstraint.add(inclusionTab2Tab1)
-        // create primary key on tab2
-        val primaryTab2 = Constraint()
-        primaryTab2.type=Constraint.TYPE.PRIMARY_KEY.name
-        primaryTab2.source.table="tableName2"
-        primaryTab2.source.columns.addAll(lhsCols)
-        primaryTab2.target.table="tableName2"
-        primaryTab2.target.columns.addAll(rhsCols)
-        changeSet.createConstraint.add(primaryTab2)
         return changeSet
     }
 }
\ No newline at end of file

src/test/kotlin/unibz.cs.semint.kprime/scenario/PersonHSplitScenarioTI.kt

 package unibz.cs.semint.kprime.scenario
 
 import org.junit.Test
+import unibz.cs.semint.kprime.domain.Column
+import unibz.cs.semint.kprime.domain.Constraint
+import unibz.cs.semint.kprime.domain.Database
+import unibz.cs.semint.kprime.domain.Table
+import unibz.cs.semint.kprime.usecase.HSplitUseCase
 
 class PersonHSplitScenarioTI {
 
+    private fun buildPersonMetadata(): Database {
+        val db = Database()
+        val personTable = Table()
+        personTable.name= "person"
+        val colSSN = Column("SSN", "id.SSN", "dbname.SSN")
+        personTable.columns.add(colSSN)
+        colSSN.nullable=false
+        val colT = Column("T", "id.T", "dbname.T")
+        personTable.columns.add(colT)
+        colT.nullable=false
+        val colS = Column("S", "id.S", "dbname.S")
+        colS.nullable=true
+        personTable.columns.add(colS)
+        db.schema.tables.add(personTable)
+
+        val primaryConstraint = Constraint()
+        primaryConstraint.name="primaryKey.person"
+        primaryConstraint.source.table="person"
+        primaryConstraint.source.columns.add(colSSN)
+        primaryConstraint.source.columns.add(colT)
+        primaryConstraint.type= Constraint.TYPE.PRIMARY_KEY.name
+        db.schema.constraints.add(primaryConstraint)
+
+        return db
+    }
+
     @Test
     fun test_person_hsplit_scenario() {
         // given
-        val personHSplitScenario = PersonHSplitScenario()
+        val personHSplitUseCase = HSplitUseCase()
         // when
-        personHSplitScenario.run()
+        personHSplitUseCase.compute(databaseMetadata = buildPersonMetadata())
         // then
         // prints splitted database
     }

src/test/kotlin/unibz.cs.semint.kprime/scenario/PersonVJoinScenarioTI.kt

+package unibz.cs.semint.kprime.scenario
+
+import org.junit.Test
+import unibz.cs.semint.kprime.adapter.service.XMLSerializerJacksonAdapter
+import unibz.cs.semint.kprime.domain.Column
+import unibz.cs.semint.kprime.domain.Database
+import unibz.cs.semint.kprime.domain.Table
+import unibz.cs.semint.kprime.usecase.VJoinUseCase
+import unibz.cs.semint.kprime.usecase.XMLSerializeUseCase
+
+class PersonVJoinScenarioTI {
+
+    private fun buildMetadata(): Database {
+        val db = Database()
+        val personTable1 = Table()
+        personTable1.name= "person1"
+        val colSSN = Column("SSN", "id.SSN", "dbname.SSN")
+        personTable1.columns.add(colSSN)
+        colSSN.nullable=false
+
+        val colT = Column("T", "id.T", "dbname.T")
+        personTable1.columns.add(colT)
+        colT.nullable=false
+
+        val colX = Column("X", "id.X", "dbname.X")
+        colX.nullable=true
+        personTable1.columns.add(colX)
+
+        db.schema.key("person1", mutableSetOf(colSSN))
+
+        db.schema.tables.add(personTable1)
+
+        val personTable2 = Table()
+        personTable2.name= "person2"
+
+        val colT2 = Column("T", "id.T", "dbname.T")
+        personTable2.columns.add(colT2)
+        colT2.nullable=false
+
+        val colS2 = Column("S", "id.S", "dbname.S")
+        colS2.nullable=true
+        personTable2.columns.add(colS2)
+
+        db.schema.key("person2", mutableSetOf(colT2))
+
+        db.schema.tables.add(personTable2)
+        return db
+    }
+
+    @Test
+    fun test_person_vsplit_scenario() {
+        // given
+        val personVJoinUseCase = VJoinUseCase()
+        // when
+        val changeSet = personVJoinUseCase.compute(buildMetadata())
+        // then
+        // prints changeset
+        println(XMLSerializeUseCase(XMLSerializerJacksonAdapter()).prettyChangeSet(changeSet))
+    }
+}
\ No newline at end of file

src/test/kotlin/unibz.cs.semint.kprime/scenario/PersonVSplitScenarioTI.kt

@@ -2,16 +2,51 @@ package unibz.cs.semint.kprime.scenario
 
 import org.junit.Test
 import unibz.cs.semint.kprime.adapter.service.XMLSerializerJacksonAdapter
+import unibz.cs.semint.kprime.domain.Column
+import unibz.cs.semint.kprime.domain.Database
+import unibz.cs.semint.kprime.domain.Table
+import unibz.cs.semint.kprime.usecase.VSplitUseCase
 import unibz.cs.semint.kprime.usecase.XMLSerializeUseCase
 
 class PersonVSplitScenarioTI {
 
+    private fun buildPersonMetadata(): Database {
+        val db = Database()
+        val personTable = Table()
+        personTable.name= "person"
+        val colSSN = Column("SSN", "id.SSN", "dbname.SSN")
+        personTable.columns.add(colSSN)
+        colSSN.nullable=false
+
+        val colT = Column("T", "id.T", "dbname.T")
+        personTable.columns.add(colT)
+        colT.nullable=false
+
+        val colS = Column("S", "id.S", "dbname.S")
+        colS.nullable=true
+        personTable.columns.add(colS)
+
+        val colX = Column("X", "id.X", "dbname.X")
+        colX.nullable=true
+        personTable.columns.add(colX)
+
+        db.schema.key("person", mutableSetOf(colSSN))
+        db.schema.functional("person", mutableSetOf(colT), mutableSetOf(colS))
+
+        db.schema.tables.add(personTable)
+
+        return db
+    }
+
+
+
     @Test
     fun test_person_vsplit_scenario() {
         // given
-        val personVSplitScenario = PersonVSplitScenario()
+        val database = buildPersonMetadata()
+        val personVSplitUseCase = VSplitUseCase()
         // when
-        val changeSet = personVSplitScenario.run()
+        val changeSet = personVSplitUseCase.compute(database)
         // then
         // prints changeset
         println(XMLSerializeUseCase(XMLSerializerJacksonAdapter()).prettyChangeSet(changeSet))

src/test/kotlin/unibz.cs.semint.kprime/scenario/SakilaScenarioTI.kt

 package unibz.cs.semint.kprime.scenario
 
 import org.junit.Test
+import unibz.cs.semint.kprime.adapter.repository.MetaSchemaJdbcAdapter
+import unibz.cs.semint.kprime.adapter.service.XMLSerializerJacksonAdapter
+import unibz.cs.semint.kprime.domain.DataSource
+import unibz.cs.semint.kprime.domain.Database
+import unibz.cs.semint.kprime.usecase.MetaSchemaReadUseCase
 
 class SakilaScenarioTI {
 
     @Test
     fun test_sakila_scenario() {
         // given
-        val sakilaScenario = SakilaScenario()
+        val sakilaScenario = SakilaScenarioTI()
         // when
         sakilaScenario.run()
         // then
         // prints manipulated sakila database
     }
+
+    fun run() {
+        val sakilaMeta = readSakilaMeta()
+        if (sakilaMeta!=null) {
+            vsplitSakila(sakilaMeta)
+            hsplitSakila(sakilaMeta)
+            identifySakila(sakilaMeta)
+        }
+    }
+
+    private fun readSakilaMeta(): Database? {
+        val type = "psql"
+        val name = "sakila-source"
+        val driver = "org.postgresql.Driver"
+        val path = "jdbc:postgresql://localhost:5432/sakila"
+        val user = "sammy"
+        val pass = "pass"
+        val sakilaSource = DataSource(type,name,driver,path,user,pass)
+        val result = MetaSchemaReadUseCase().doit(sakilaSource,
+                "read-meta-schema sakila-source",
+                MetaSchemaJdbcAdapter(),
+                XMLSerializerJacksonAdapter())
+        return result.ok
+    }
+
+    private fun vsplitSakila(db: Database) {
+        // if detect(db):result
+        //  apply(db,result):db
+    }
+
+    private fun hsplitSakila(db: Database) {
+        // if detect(db):result
+        //  apply(db,result):db
+    }
+
+    private fun identifySakila(db: Database) {
+        // if detect(db):result
+        //  apply(db,result):db
+    }
+
 }
\ No newline at end of file