Merge pull request #2 from typesafehub/wip/slick-2.0

slick 2.0.0

Author: szeiger

.gitignore

@@ -6,3 +6,4 @@
 /project/activator-*
 /logs/
 /RUNNING_PID
+*.iml

build.sbt

@@ -4,8 +4,11 @@ version := "1.0"
 
 scalaVersion := "2.10.2"
 
+mainClass in Compile := Some("HelloSlick")
+
 libraryDependencies ++= List(
-  "com.typesafe.slick" %% "slick" % "1.0.1",
+  "com.typesafe.slick" %% "slick" % "2.0.0",
   "org.slf4j" % "slf4j-nop" % "1.6.4",
-  "com.h2database" % "h2" % "1.3.166"
+  "com.h2database" % "h2" % "1.3.170",
+  "org.scalatest" %% "scalatest" % "2.0"
 )

src/main/scala/CaseClassMapping.scala

@@ -0,0 +1,32 @@
+import scala.slick.driver.H2Driver.simple._
+
+object CaseClassMapping extends App {
+
+  // the base query for the Users table
+  val users = TableQuery[Users]
+
+  Database.forURL("jdbc:h2:mem:hello", driver = "org.h2.Driver").withSession { implicit session =>
+    
+    // create the schema
+    users.ddl.create
+    
+    // insert two User instances
+    users += User("John Doe")
+    users += User("Fred Smith")
+    
+    // print the users (select * from USERS)
+    println(users.list)
+  }
+  
+}
+
+case class User(name: String, id: Option[Int] = None)
+
+class Users(tag: Tag) extends Table[User](tag, "USERS") {
+  // Auto Increment the id primary key column
+  def id = column[Int]("ID", O.PrimaryKey, O.AutoInc)
+  // The name can't be null
+  def name = column[String]("NAME", O.NotNull)
+  // the * projection (e.g. select * ...) auto-transform the tupled column values to / from a User
+  def * = (name, id.?) <> (User.tupled, User.unapply)
+}

src/main/scala/Hello.scala

@@ -0,0 +1,164 @@
+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:h2:mem:hello", driver = "org.h2.Driver").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)
+    
+  }
+}

src/main/scala/HelloSlick.scala

@@ -0,0 +1,30 @@
+import scala.slick.driver.H2Driver.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)
+}

src/main/scala/Tables.scala

@@ -0,0 +1,50 @@
+import org.scalatest._
+import scala.slick.driver.H2Driver.simple._
+import scala.slick.jdbc.meta._
+
+
+class TablesSuite extends FunSuite with BeforeAndAfter {
+
+  val suppliers = TableQuery[Suppliers]
+  val coffees = TableQuery[Coffees]
+  
+  implicit var session: Session = _
+
+  def createSchema() = (suppliers.ddl ++ coffees.ddl).create
+  
+  def insertSupplier(): Int = suppliers += (101, "Acme, Inc.", "99 Market Street", "Groundsville", "CA", "95199")
+  
+  before {
+    session = Database.forURL("jdbc:h2:mem:test1", driver = "org.h2.Driver").createSession()
+  }
+  
+  test("Creating the Schema works") {
+    createSchema()
+    
+    val tables = MTable.getTables().list()
+
+    assert(tables.size == 2)
+    assert(tables.count(_.name.name.equalsIgnoreCase("suppliers")) == 1)
+    assert(tables.count(_.name.name.equalsIgnoreCase("coffees")) == 1)
+  }
+
+  test("Inserting a Supplier works") {
+    createSchema()
+    
+    val insertCount = insertSupplier()
+    assert(insertCount == 1)
+  }
+  
+  test("Query Suppliers works") {
+    createSchema()
+    insertSupplier()
+    val results = suppliers.list()
+    assert(results.size == 1)
+    assert(results.head._1 == 101)
+  }
+  
+  after {
+    session.close()
+  }
+
+}