slick: [error] wrong number of type arguments for slick.driver.H2Driver.simple.Query, should be 3

Question

Hi I am trying to run hello-slick example from the type safe activator template when Run it as my own sbt project it gives me error, I am just copy pasting the code but it gives me error

here is my code

HelloSlick.scala

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
  val db = Database.forURL("jdbc:h2:mem:hello", driver = "org.h2.Driver")
  db.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.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") {

  // This is the primary key column:
  def id: Column[Int] = column[Int]("SUP_ID", O.PrimaryKey)
  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)
}

build.sbt

name :="hellos"

version :="1.0"

scalaVersion := "2.11.1"

mainClass in Compile := Some("HelloSlick")

libraryDependencies ++= List(
  "com.typesafe.slick" %% "slick" % "2.1.0",
  "org.slf4j" % "slf4j-nop" % "1.6.4",
  "com.h2database" % "h2" % "1.3.170"
)

resolvers += "typesafe" at "http://repo.typesafe.com/typesafe/releases/"

when I run it as an sbt project it gives me following errors

[error] /opt/progrmas/sbt/hellos/src/main/scala/HelloSlick.scala:60: wrong number of type arguments for slick.driver.H2Driver.simple.Query, should be 3
[error]     val filterQuery: Query[Coffees, (String, Int, Double, Int, Int)] =
[error]                      ^
[error] /opt/progrmas/sbt/hellos/src/main/scala/HelloSlick.scala:72: wrong number of type arguments for slick.driver.H2Driver.simple.Query, should be 3
[error]     val updateQuery: Query[Column[Int], Int] = coffees.map(_.sales)
[error]                      ^
[error] /opt/progrmas/sbt/hellos/src/main/scala/HelloSlick.scala:86: wrong number of type arguments for slick.driver.H2Driver.simple.Query, should be 3
[error]     val deleteQuery: Query[Coffees,(String, Int, Double, Int, Int)] =
[error]                      ^
[error] /opt/progrmas/sbt/hellos/src/main/scala/HelloSlick.scala:101: wrong number of type arguments for slick.driver.H2Driver.simple.Query, should be 3
[error]     val justNameQuery: Query[Column[String], String] = coffees.map(_.name)
[error]                        ^
[error] /opt/progrmas/sbt/hellos/src/main/scala/HelloSlick.scala:112: wrong number of type arguments for slick.driver.H2Driver.simple.Query, should be 3
[error]     val sortByPriceQuery: Query[Coffees, (String, Int, Double, Int, Int)] =
[error]                           ^
[error] /opt/progrmas/sbt/hellos/src/main/scala/HelloSlick.scala:124: wrong number of type arguments for slick.driver.H2Driver.simple.Query, should be 3
[error]     val composedQuery: Query[Column[String], String] =
[error]                        ^
[error] /opt/progrmas/sbt/hellos/src/main/scala/HelloSlick.scala:137: wrong number of type arguments for slick.driver.H2Driver.simple.Query, should be 3
[error]     val joinQuery: Query[(Column[String], Column[String]), (String, String)] = for {
[error]                    ^
[error] 7 errors found
[error] (compile:compile) Compilation failed
[error] Total time: 15 s, completed Aug 25, 2014 1:20:34 AM
> 

please help I am new in slick I am just taking help from the tutorial and got these errors its not even my own code here is the link to the template http://typesafe.com/activator/template/hello-slick

Answer 1

The sample is 2.0 code, while you are using 2.1. The upgrade guide tells you how to upgrade from 2.0 to 2.1:

Query now takes 3 type parameters instead of two. 2.0’s Query[T,E] is equivalent to Slick 2.1’s Query[T,E,Seq]. The third parameter is the collection type to be returned when executing the query using .run, which always returned a Seq in Slick 2.0.

It seems all you need to do is to add Seq as the third parameter:

 Query[Coffees, (String, Int, Double, Int, Int), Seq]

Answer 2

You are trying to use the Slick 2.0 version of the template with Slick 2.1. Query has two type parameters up to Slick 2.0 and three in Slick 2.1. The correct official templates are linked from the manual (http://slick.typesafe.com/doc/2.1.0/gettingstarted.html). Note that all the type annotations in the template are shown for educational purposes. If you leave them out, the code will still compile and it should be compatible between 2.0 and 2.1.