标签: slick-3.0

我写的这段代码完美无缺

class Items(tag: Tag) extends Table[Item](tag, "ITEMS") {
  def id = column[Long]("ITEMS_ID", O.PrimaryKey, O.AutoInc)
  def name = column[String]("ITEMS_NAME")
  def price = column[Double]("ITEMS_PRICE")
  def * = (id, name, price) <> ((Item.apply _).tupled, Item.unapply _)
}

object Shop extends Shop{
  val items = TableQuery[Items]
  val db = Database.forConfig("h2mem1")

  def create(name: String, price: Double) : Int = {
    val action = items ++= Seq(Item(0, name, price))
    val future1 = db.run(action)
    val future2 = future1 map {result => 
      result map {x => x}
    } …

我正在尝试Slick 3.0.0-RC1而且我遇到了一个奇怪的问题.

这是我的代码:

import slick.driver.SQLiteDriver.api._
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Await
import scala.concurrent.duration.Duration

lazy val db = Database.forURL(
  url = "jdbc:sqlite:thebase.db",
  driver = "org.sqlite.JDBC"
)

case class Issue(id: Option[Int], name: String)     

class IssueTable(tag: Tag) extends Table[Issue](tag, "issue"){
  def id = column[Int]("issue_id", O.PrimaryKey)
  def name = column[String]("name")
  def * = (id.?, name) <> (Issue.tupled, Issue.unapply _)
}

val issueQuery = TableQuery[IssueTable]

Await.result(db.run(issueQuery.result), Duration.Inf) // This does not compile

错误是:

"无法解析符号结果"

阅读文档我不能真正理解为什么这会失败.我在这里错过了什么吗？

解析度

szeiger指出,这可能是"IntelliJ的演示编译器"中的一个错误,而且这一点很明显.

我无法理解新的Slick DBIOActionAPI,它在文档中似乎没有很多例子.我正在使用Slick 3.0.0,我需要执行一些数据库操作以及从数据库接收的数据的一些计算,但所有这些操作都必须在单个事务中完成.我正在尝试执行以下操作:

1. 对数据库(types表)执行查询.
2. 对查询结果进行一些聚合和过滤(无法在数据库上进行此计算).
3. 根据步骤2中的计算执行另一个查询(该messages表 - 由于某些限制,此查询必须在原始SQL中).
4. 将步骤2和3中的数据加入内存中.

我希望步骤1和3中的查询在事务内执行,因为结果集中的数据必须一致.

我试图用monadic join样式做到这一点.这是我的代码的过度简化版本,但我甚至无法编译:

  val compositeAction = (for {
    rawTypes <- TableQuery[DBType].result
    (projectId, types) <- rawTypes.groupBy(_.projectId).toSeq.map(group => (group._1, group._2.slice(0, 10)))
    counts <- DBIO.sequence(types.map(aType => sql"""select count(*) from messages where type_id = ${aType.id}""".as[Int]))
  } yield (projectId, types.zip(counts))).transactionally

1. 第一行for理解选择types表中的数据.
2. for理解的第二行应该对结果进行一些分组和切片,从而产生一个Seq[(Option[String], Seq[String])]
3. 第三行for理解必须为上一步中的每个元素执行一组查询,特别是,它必须为每个内部值执行单个SQL查询Seq[String].所以在第三行我构建了一个DBIOActions 序列.
4. 该yield子句zip小号types从第二步骤和counts从所述第三步.

但是,这种结构不起作用,并且会产生两个编译时错误:

Error:(129, 16) type mismatch; …

我使用了一个由光滑的代码生成器生成的代码.

我的表有超过22列,因此它使用 HList

它生成1种类型和1种功能:

type AccountRow
def AccountRow(uuid: java.util.UUID, providerid: String, email: Option[String], ...):AccountRow

如何从生成的代码中编写编译的插入代码？

我试过这个:

val insertAccountQueryCompiled = {

def q(uuid:Rep[UUID], providerId:Rep[String], email:Rep[Option[String]], ...) = Account += AccountRow(uuid, providerId, email, ...)

Compiled(q _)
}

我需要转换Rep[T]到T为AccountRow功能工作.我怎么做？

谢谢

基本上同样的问题大约一年前被问到光滑的2.x(scala光滑的一对多收藏).我想知道是否有任何进展与反应浮油的发布.

比方说我们有三张桌子.library,book和library_to_book其中一个图书馆有很多书.我想要的是带有书籍的图书馆清单.在scala中,这就像是Seq[(Library, Seq[Book])].我的查询如下:

val q = (for {
  l   <- libraries
  ltb <- libraryToBooks if l.id === ltb.libraryId
  b   <- books if ltb.bookId === b.id
} yield (l, b)
db.run(q.result).map( result => ??? )

results在这种情况下是类型Seq[(Library, Book)].如何更改查询以获取类型的结果Seq[(Library, Seq[Book])]？编写此类查询的"光滑方式"是什么？

我有一个非常简单的查询,其中SQL可以表示如下:

SELECT
  c.id,
  count(cp.product_id)
FROM cart c LEFT OUTER JOIN cart_product cp ON c.id = cp.cart_id
WHERE c.id = 3
GROUP BY c.id;

当Slick DSL用于表示上述查询时,我非常惊讶,该查询生成如下DSL:

Cart.joinLeft(CartProduct)
  .on { case (c, cp) => c.id === cp.cartId }
  .filter { case (c, cp) => c.id === 3 }
  .groupBy { case (c, cp) => c.id }
  .map { case (c, pr) => (c, pr.length)
}

看起来如下:

SELECT
  x2.x3,
  count(1)
FROM (SELECT
        x4.x5  AS x3,
        x4.x6  AS …

我正在使用Slick 3.1.1,问题是在某些情况下我想省略一些相当重的列,并且仍然将列的子集实现为案例类.

请考虑以下表定义:

class AuditResultTable(tag: Tag) extends Table[AuditResult](tag, AuditResultTableName) {
    def auditResultId: Rep[Long] = column[Long]("AuditResultId", O.PrimaryKey, O.AutoInc)
    def processorId: Rep[Long] = column[Long]("ProcessorId")
    def dispatchedTimestamp: Rep[Timestamp] = column[Timestamp]("DispatchedTimestamp", O.SqlType("timestamp(2)"))
    def SystemAOutput: Rep[Array[Byte]] = column[Array[Byte]]("SystemAOutput", O.SqlType("LONGBLOB"))
    def SystemBOutput: Rep[Array[Byte]]  = column[Array[Byte]]("SystemBOutput", O.SqlType("LONGBLOB"))
    def isSuccessful: Rep[Boolean] = column[Boolean]("IsSuccessful")


def * : ProvenShape[AuditResult] = (processorId, dispatchedTimestamp, systemAOutput, systemBOutput, isSuccessful, auditResultId) <>
  (AuditResult.tupled, AuditResult.unapply) 

}  

val auditResults = TableQuery[AuditResultTable]  

相应的案例类:

case class AuditResult (
   ProcessorId: Long,
   DispatchedTimestamp: Timestamp,
   SystemAOutput: Array[Byte],
   SystemBOutput: Array[Byte],
   IsSuccessful: Boolean,
   AuditResultId: …

我是Play Scala和Slick的新手.我试图在Scala上的Enumeration和Slick上的String/Int之间进行映射.我写了下面的代码但是我收到了一个错误.能不能让我知道如何解决这个问题.

我正在使用Scala 2.11.6,Slick 3.1.0,Play 2.4.4,play-slick 1.1.1.

package models

import javax.inject.{Inject, Singleton}

import play.api.db.slick.DatabaseConfigProvider
import slick.driver.JdbcProfile

import scala.concurrent.ExecutionContext

class Color extends Enumeration {
  type Color = Value
  val Blue = Value("Blue")
  val Red = Value("Red")
  val Green = Value("Green")
}
object Color extends Color

case class Sample(name:String, id:Int, c:Color)

@Singleton
class ColorDao @Inject()(dbConfigProvider: DatabaseConfigProvider)(implicit ec: ExecutionContext) {
  val dbConfig = dbConfigProvider.get[JdbcProfile]
  import dbConfig._
  import driver.api._

  class SampleTable(tag: Tag) extends Table[Sample](tag, "Sample") {
    def name  = column[String]("NAME")
    def id    = column[Int]("ID") …

如何检查表格是否存在光滑的3.0？

在以前版本的光滑中有一种方法可以使用:

MTable.getTables.list()

但这不再编译了.

这个问题背后的想法是在它不存在时动态创建一个表,非常像这样:

if (Tables.contains("USERS") == false)
    Users.createTable()

我想弄清楚如何使用光滑的流媒体.我使用带有postgres驱动程序的光滑3.0.0

情况如下:服务器必须将客户端数据序列拆分为大小(以字节为单位)限制的块.所以,我写了以下光滑的查询:

val sequences = TableQuery[Sequences]
def find(userId: Long, timestamp: Long) = sequences.filter(s ? s.userId === userId && s.timestamp > timestamp).sortBy(_.timestamp.asc).result
val seq = db.stream(find(0L, 0L))

我将seq与akka-streams结合起来Source,编写自定义PushPullStage,限制数据大小(以字节为单位),并在达到大小限制时完成上游.它工作得很好.问题是 - 当我查看postgres日志时,我看到这样的查询 select * from sequences where user_id = 0 and timestamp > 0 order by timestamp;

因此,乍一看似乎有很多(并且不必要的)数据库查询正在进行,只是在每个查询中使用几个字节.使用Slick进行流式传输的正确方法是什么,以便最大限度地减少数据库查询并充分利用每个查询中传输的数据？