slick

How do you update multiple columns using Slick Lifted Embedding ? This document doesn't say much. I expected it to be something like this Query(AbilitiesTable).filter((ab: AbilitiesTable.type) => ab.id === ability_id).map((ab: AbilitiesTable.type) => (ab.verb, ab.subject)).update("edit", "doc") expert I figured it out. It should be like this val map = Query(AbilitiesTable) .filter(_.id === ability_id) .map(ab => ab.verb ~ ab.context) map.update(("", "")) Typesafe , why your documentation is so bad ? I have to Google pretty much every silly thing or dig through unit-tests for hours. Please

I'm trying to get familiar with Slick 3.0 and Futures (using Scala 2.11.6). I use simple code based on Slick's Multi-DB Cake Pattern example . Why does the following code terminate with an exception and how to fix it? import scala.concurrent.Await import scala.concurrent.duration._ import slick.jdbc.JdbcBackend.Database import scala.concurrent.ExecutionContext.Implicits.global class Dispatcher(db: Database, dal: DAL) { import dal.driver.api._ def init() = { db.run(dal.create) try db.run(dal.stuffTable += Stuff(23,"hi")) finally db.close val x = { try db.run(dal.stuffTable.filter(_.serial ===

How can we overcome the 22 limit when calling procedures with Slick? We currently have: val q3 = sql"""call getStatements(${accountNumber})""".as[Transaction] The problem is that we have to return more than 22 columns and Transaction case class cannot have more than 22 columns since when we do JSONFormat we get an error: [error] E:\IdeaProjects\admin\Transaction.scala:59: No unapply or unapplySeq function found [error] implicit val jsonFormat = Json.format[Transaction] Any suggestions? Alright - so if you can actually modify your Transaction case class than there is a better solution than

I have this base trait trait MyBase { type M type T <: Table[M] val query: TableQuery[T] } Where TableQuery is scala.slick.lifted.TableQuery My subclasses instantiate TableQuery like so: type M = Account type T = AccountsTable val query = TableQuery[T] I'd like to instantiate the TableQuery in the base trait, possibly by using a lazy val , i.e. lazy val query: TableQuery[T] = { ... } I've been playing around with reflection, but haven't had much luck. Régis Jean-Gilles If I understand correctly, what you want is to be able to extend MyBase by simply defining M and T but without having to

I have methods in my Play app that query database tables with over hundred columns. I can't define case class for each such query, because it would be just ridiculously big and would have to be changed with each alter of the table on the database. I'm using this approach, where result of the query looks like this: Map(columnName1 -> columnVal1, columnName2 -> columnVal2, ...) Example of the code: implicit val getListStringResult = GetResult[List[Any]] ( r => (1 to r.numColumns).map(_ => r.nextObject).toList ) def getSomething(): Map[String, Any] = DB.withSession { val columns = MTable

I'm new to Slick. I'm creating a test suite for a Java application with Scala, ScalaTest and Slick. I'm using slick to prepare data before the test and to do assertions on the data after the test. The database used has some tables with more than 22 columns. I use slick-codegen to generate my schema code. For tables with more than 22 columns, slick-codegen does not generate a case class, but a HList-based custom type and a companion ‘constructor’ method. As I understand it, this is because the limitation that tuples and case classes can only have 22 fields. The way the code is generated, the

I was walking through the documentation of Slick to setup a quick working prototype. I was going through this link . In the Mapped Tables section I see a <> operator in the example mentioned but cant find any documentation for that anywhere. Need help in understanding this. Andreas Neumann The <> operator defines a relation between a Row in the Table and a case class . case class User(id: Option[Int], first: String, last: String) ROW |id | first | last | So the data first is taken out of the Tabels as an n-tuple (left side of <> ) and then transformed to the case class (right side of <> ). To