Exemple "Hello World" pour Slick 2.0 avec MySQL

Est-il un exemple d'utilisation de la Nappe 2.0.1 bibliothèque pour Scala pour se connecter à une base de données MySQL? Je ne pouvais pas trouver la mise à jour des exemples avec Googler...

Récemment, j'ai été la réflexion sur le portage du code de l'application web que j'ai développé avec PHP en Scala. J'ai été à la recherche d'un langage de programmation qui a (i) un cadre d'application de web avec un bon nombre d'utilisateurs, (ii) vous propose moment de la compilation, de vérification des erreurs, (iii) de nice, outils de test, et ainsi de suite... Après avoir lu sur quelques études de cas (par exemple, huffpost et cousera) de développer des applications web à l'aide de la Scala et de Jouer de cadre, il a commencé à regarder attrayant pour moi, et j'ai décidé de donner un coup de feu.

Que toutes les données de l'ancien projet de résider dans une base de données MySQL, j'étais en train de regarder ce que Scala offre pour mon programme pour se connecter à MySQL. Je suis tombé sur Slick. J'ai suivi le Bonjour-Slick exemple dans le Typesafe Activateur, qui m'a guidé comment utiliser une base de données en mémoire (c'est à dire, h2) et j'ai aimé sa syntaxe et le niveau d'abstraction. Maintenant, je veux utiliser Lisse avec MySQL. J'ai essayé de changer les déclarations d'importation

import scala.slick.driver.H2Driver.simple._

à

import scala.slick.driver.MySQLDriver.simple._

dans les deux HelloSlick.scala et Tables.scala dans ledit exemple (voir la copie intégrale du code ci-dessous). Cependant, je reçois le message d'erreur suivant quand je compile:

/Utilisateurs/kotaro/Documents/Scala/bonjour-slick/src/test/scala/TablesSuite.scala

valeur ddl n'est pas un membre de la scala.slick.levées.TableQuery[Fournisseurs]

def createSchema() = (fournisseurs.ddl ++ cafés.ddl).créer

                              ^

Personne ne sait ce qui en est la cause? Selon ce post (nappe d'exception lorsque vous tentez de vous connecter à MySql), j'ai peut-être manquant pour ajouter des dépendances si le message d'erreur que j'obtiens est différent. Si il est un bon exemple que je peux suivre pour comprendre comment utiliser Lisse avec MySQL, ça aiderait beaucoup trop.

Je suis en utilisant Scala 2.10.3, MySQL dans XAMPP 1.7.3 avec OS X 10.8 et JRE 1.6.

Merci beaucoup pour votre aide à l'avance!

Qui suit est la copie complète du code.

HelloSlick.scala

import scala.slick.driver.MySQLDriver.simple._
//import scala.slick.driver.H2Driver.simple._
//The main application
object HelloSlick extends App {
//The query interface for the Suppliers table
val suppliers: TableQuery[Suppliers] = TableQuery[Suppliers]
//the query interface for the Coffees table
val coffees: TableQuery[Coffees] = TableQuery[Coffees]
//Create a connection (called a "session") to an in-memory H2 database
Database.forURL("jdbc:mysql://localhost:3306/test", driver="com.mysql.jdbc.Driver", user="root", password="").withSession { implicit session =>
//Create the schema by combining the DDLs for the Suppliers and Coffees tables using the query interfaces
(suppliers.ddl ++ coffees.ddl).create
/* Create /Insert */
//Insert some suppliers
suppliers += (101, "Acme, Inc.", "99 Market Street", "Groundsville", "CA", "95199")
suppliers += (49, "Superior Coffee", "1 Party Place", "Mendocino", "CA", "95460")
suppliers += (150, "The High Ground", "100 Coffee Lane", "Meadows", "CA", "93966")
//Insert some coffees (using JDBC's batch insert feature)
val coffeesInsertResult: Option[Int] = coffees ++= Seq (
("Colombian",         101, 7.99, 0, 0),
("French_Roast",       49, 8.99, 0, 0),
("Espresso",          150, 9.99, 0, 0),
("Colombian_Decaf",   101, 8.99, 0, 0),
("French_Roast_Decaf", 49, 9.99, 0, 0)
)
val allSuppliers: List[(Int, String, String, String, String, String)] = suppliers.list
//Print the number of rows inserted
coffeesInsertResult foreach (numRows => println(s"Inserted $numRows rows into the Coffees table"))
/* Read /Query /Select */
//Print the SQL for the Coffees query
println("Generated SQL for base Coffees query:\n" + coffees.selectStatement)
//Query the Coffees table using a foreach and print each row
coffees foreach { case (name, supID, price, sales, total) =>
println("  " + name + "\t" + supID + "\t" + price + "\t" + sales + "\t" + total)
}
/* Filtering /Where */
//Construct a query where the price of Coffees is > 9.0
val filterQuery: Query[Coffees, (String, Int, Double, Int, Int)] = coffees.filter(_.price > 9.0)
println("Generated SQL for filter query:\n" + filterQuery.selectStatement)
//Execute the query
println(filterQuery.list)
/* Update */
//Construct an update query with the sales column being the one to update
val updateQuery: Query[Column[Int], Int] = coffees.map(_.sales)
//Print the SQL for the Coffees update query
println("Generated SQL for Coffees update:\n" + updateQuery.updateStatement)
//Perform the update
val numUpdatedRows = updateQuery.update(1)
println(s"Updated $numUpdatedRows rows")
/* Delete */
//Construct a delete query that deletes coffees with a price less than 8.0
val deleteQuery: Query[Coffees,(String, Int, Double, Int, Int)] = coffees.filter(_.price < 8.0)
//Print the SQL for the Coffees delete query
println("Generated SQL for Coffees delete:\n" + deleteQuery.deleteStatement)
//Perform the delete
val numDeletedRows = deleteQuery.delete
println(s"Deleted $numDeletedRows rows")
/* Selecting Specific Columns */
//Construct a new coffees query that just selects the name
val justNameQuery: Query[Column[String], String] = coffees.map(_.name)
println("Generated SQL for query returning just the name:\n" + justNameQuery.selectStatement)
//Execute the query
println(justNameQuery.list)
/* Sorting /Order By */
val sortByPriceQuery: Query[Coffees, (String, Int, Double, Int, Int)] = coffees.sortBy(_.price)
println("Generated SQL for query sorted by price:\n" + sortByPriceQuery.selectStatement)
//Execute the query
println(sortByPriceQuery.list)
/* Query Composition */
val composedQuery: Query[Column[String], String] = coffees.sortBy(_.name).take(3).filter(_.price > 9.0).map(_.name)
println("Generated SQL for composed query:\n" + composedQuery.selectStatement)
//Execute the composed query
println(composedQuery.list)
/* Joins */
//Join the tables using the relationship defined in the Coffees table
val joinQuery: Query[(Column[String], Column[String]), (String, String)] = for {
c <- coffees if c.price > 9.0
s <- c.supplier
} yield (c.name, s.name)
println("Generated SQL for the join query:\n" + joinQuery.selectStatement)
//Print the rows which contain the coffee name and the supplier name
println(joinQuery.list)
/* Computed Values */
//Create a new computed column that calculates the max price
val maxPriceColumn: Column[Option[Double]] = coffees.map(_.price).max
println("Generated SQL for max price column:\n" + maxPriceColumn.selectStatement)
//Execute the computed value query
println(maxPriceColumn.run)
/* Manual SQL /String Interpolation */
//Required import for the sql interpolator
import scala.slick.jdbc.StaticQuery.interpolation
//A value to insert into the statement
val state = "CA"
//Construct a SQL statement manually with an interpolated value
val plainQuery = sql"select SUP_NAME from SUPPLIERS where STATE = $state".as[String]
println("Generated SQL for plain query:\n" + plainQuery.getStatement)
//Execute the query
println(plainQuery.list)
}
}

Tables.scala

import scala.slick.driver.MySQLDriver.simple._
import scala.slick.lifted.{ProvenShape, ForeignKeyQuery}
//A Suppliers table with 6 columns: id, name, street, city, state, zip
class Suppliers(tag: Tag) extends Table[(Int, String, String, String, String, String)](tag, "SUPPLIERS") {
def id: Column[Int] = column[Int]("SUP_ID", O.PrimaryKey) //This is the primary key column
def name: Column[String] = column[String]("SUP_NAME")
def street: Column[String] = column[String]("STREET")
def city: Column[String] = column[String]("CITY")
def state: Column[String] = column[String]("STATE")
def zip: Column[String] = column[String]("ZIP")
//Every table needs a * projection with the same type as the table's type parameter
def * : ProvenShape[(Int, String, String, String, String, String)] = (id, name, street, city, state, zip)
}
//A Coffees table with 5 columns: name, supplier id, price, sales, total
class Coffees(tag: Tag) extends Table[(String, Int, Double, Int, Int)](tag, "COFFEES") {
def name: Column[String] = column[String]("COF_NAME", O.PrimaryKey)
def supID: Column[Int] = column[Int]("SUP_ID")
def price: Column[Double] = column[Double]("PRICE")
def sales: Column[Int] = column[Int]("SALES")
def total: Column[Int] = column[Int]("TOTAL")
def * : ProvenShape[(String, Int, Double, Int, Int)] = (name, supID, price, sales, total)
//A reified foreign key relation that can be navigated to create a join
def supplier: ForeignKeyQuery[Suppliers, (Int, String, String, String, String, String)] = 
foreignKey("SUP_FK", supID, TableQuery[Suppliers])(_.id)
}

source d'informationauteur Kotaro | 2014-03-25