Scala Slick, come creare schema SOLO se non esiste

Question

In Scala Slick, uno schema di database può essere creato con il seguente:

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

Dal fondo di questa pagina di documentazione http://slick.typesafe.com/doc/3.0.0/schemas.html

Tuttavia , se lo schema del database esiste già, ciò genera un'eccezione.

C'è un modo normale o giusto per creare lo schema SE E SOLO SE non esiste già?

Answer 1

Questo è quello che faccio per più tabelle, con la chiazza di petrolio 3.1.1 e 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

perché non si controlla semplicemente l'esistenza prima di create?

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

Answer 3

Con Slick 3.0, Mtable.getTables è un DBAction così qualcosa come questo dovrebbe funzionare:

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

Come JoshSGoman comment punti conoscere il answer of Mike-s, non viene creata la tabella. Sono riuscito a farlo funzionare modificando leggermente il codice della prima risposta:

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 

Con le seguenti importazioni:

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