Scala Slick, wie Schema nur zu schaffen, wenn es nicht

Question

existiert

In Scala Slick kann ein Datenbankschema mit dem folgenden erstellt werden:

val schema = coffees.schema ++ suppliers.schema 
db.run(DBIO.seq(
    schema.create 
)) 

Von der Unterseite dieser Dokumentation Seite http://slick.typesafe.com/doc/3.0.0/schemas.html

jedoch Wenn das Datenbankschema bereits existiert, wird eine Ausnahme ausgelöst.

Gibt es einen normalen oder richtigen Weg, um das Schema IF AND ONLY zu erstellen, wenn es nicht bereits existiert?

Answer 1

Dies ist, was ich für mehrere Tabellen zu tun, mit Slick 3.1.1 und Postgres

import slick.driver.PostgresDriver.api._ 
import slick.jdbc.meta.MTable 
import scala.concurrent.Await 
import scala.concurrent.duration.Duration 
import scala.concurrent.ExecutionContext.Implicits.global 

val t1 = TableQuery[Table1] 
val t2 = TableQuery[Table2] 
val t3 = TableQuery[Table3] 
val tables = List(t1, t2, t3) 

val existing = db.run(MTable.getTables) 
val f = existing.flatMap(v => { 
    val names = v.map(mt => mt.name.name) 
    val createIfNotExist = tables.filter(table => 
     (!names.contains(table.baseTableRow.tableName))).map(_.schema.create) 
    db.run(DBIO.sequence(createIfNotExist)) 
}) 
Await.result(f, Duration.Inf) 

Answer 2

Warum überprüfen Sie nicht einfach die Existenz vor create?

val schema = coffees.schema ++ suppliers.schema 
db.run(DBIO.seq(
    if (!MTable.getTables.list.exists(_.name.name == MyTable.tableName)){ 
    schema.create 
    } 
)) 

Answer 3

Mit Slick 3.0 ist Mtable.getTables ein DBAction so etwas wie dies funktionieren würde:

val coffees = TableQuery[Coffees] 
try { 
    Await.result(db.run(DBIO.seq(
    MTable.getTables map (tables => { 
     if (!tables.exists(_.name.name == coffees.baseTableRow.tableName)) 
     coffees.schema.create 
    }) 
)), Duration.Inf) 
} finally db.close 

Answer 4

Als JoshSGoman comment Punkte aus über die answer of Mike-s, wird die Tabelle nicht erstellt. Ich konnte es durch leicht der Code der ersten Antwort zu modifizieren funktioniert:

val coffees = TableQuery[Coffees] 

try { 
    def createTableIfNotInTables(tables: Vector[MTable]): Future[Unit] = { 
    if (!tables.exists(_.name.name == events.baseTableRow.tableName)) { 
     db.run(coffees.schema.create) 
    } else { 
     Future() 
    } 
    } 

    val createTableIfNotExist: Future[Unit] = db.run(MTable.getTables).flatMap(createTableIfNotInTables) 

    Await.result(createTableIfNotExist, Duration.Inf) 
} finally db.close 

Mit den folgenden Importe:

import slick.jdbc.meta.MTable 
import slick.driver.SQLiteDriver.api._ 

import scala.concurrent.{Await, Future} 
import scala.concurrent.duration.Duration 
import scala.concurrent.ExecutionContext.Implicits.global