Slick 编程(6): 查询(一)

本篇介绍Slick的基本查询,比如选择,插入,更新,删除记录等。
排序和过滤
Slick提供了多种方法可以用来排序和过滤,比如:

val q = Album.filter(_.albumid === 101)

//select `AlbumId`, `Title`, `ArtistId` 
//from `Album` where `AlbumId` = 101


val q = Album.drop(10).take(5)
//select .`AlbumId` as `AlbumId`, .`Title` as `Title`,
// .`ArtistId` as `ArtistId` from `Album`  limit 10,5


val q = Album.sortBy(_.title.desc)
//select `AlbumId`, `Title`, `ArtistId` 
//from `Album` order by `Title` desc

Join和Zipping
Join指多表查询,可以有两种不同的方法来实现多表查询,一种是通过明确调用支持多表连接的方法(比如innerJoin方法)返回一个多元组,另外一种为隐含连接(implicit join),它不直接使用这些连接方法(比如LeftJoin方法)。
一个隐含的cross-Join 为Query的flatMap操作(在for表达式中使用多个生成式),例如:

val q = for{a <- Album
			b <- Artist
		} yield( a.title, b.name)

//select x2.`Title`, x3.`Name` from `Album` x2, `Artist` x3

如果添加一个条件过滤表达式,它就变成隐含的inner join,例如:

val q = for{a <- Album
			b <- Artist
		    if a.artistid === b.artistid
		} yield( a.title, b.name)

//select x2.`Title`, x3.`Name` from `Album` x2, `Artist` x3 
//where x2.`ArtistId` = x3.`ArtistId`

明确的多表连接则使用innerJoin , leftJoin ,rightJoin,outerJoin 方法,例如:

val explicitCrossJoin = = for {
			 (a,b) <- Album innerJoin Artist  
			 } yield( a.title, b.name)


//select x2.x3, x4.x5 from (select x6.`Title` as x3 from `Album` x6) 
//x2 inner join (select x7.`Name` as x5 from `Artist` x7) x4 on 1=1


 val explicitInnerJoin  = for {
		 (a,b) <- Album innerJoin Artist on (_.artistid === _.artistid)
		 } yield( a.title, b.name)
//select x2.x3, x4.x5 from (select x6.`Title` as x3, x6.`ArtistId` as x7 from `Album` x6) x2 
//inner join (select x8.`ArtistId` as x9, x8.`Name` as x5 from `Artist` x8) x4 on x2.x7 = x4.x9


val explicitLeftOuterJoin   = for {
		 (a,b) <- Album leftJoin Artist on (_.artistid === _.artistid)
		 } yield( a.title, b.name.?)
//select x2.x3, x4.x5 from (select x6.`Title` as x3, x6.`ArtistId` as x7 from `Album` x6) x2 
//left outer join (select x8.`ArtistId` as x9, x8.`Name` as x5 from `Artist` x8) x4 on x2.x7 = x4.x9


val explicitRightOuterJoin   = for {
		 (a,b) <- Album rightJoin Artist on (_.artistid === _.artistid)
		 } yield( a.title.?, b.name)
//select x2.x3, x4.x5 from (select x6.`Title` as x3, x6.`ArtistId` as x7 from `Album` x6) x2 
//right outer join (select x8.`ArtistId` as x9, x8.`Name` as x5 from `Artist` x8) x4 on x2.x7 = x4.x9

注意leftJoin 和 rightJoin中的 b.name.?和 a.title.? 的”.?” 这是因为外部查询时会产生额外的NULL值,你必须保证返回Option类型的值。
除了通常的InnerJoin ,LeftJoin,RightJoin之外,Scala还提供了Zip 方法,它的语法类似于Scala的集合类型,比如:

val zipJoinQuery  = for {
	   (a,b) <- Album zip Artist
	 } yield( a.title.?, b.name)

此外,还有一个zipWithIndex,可以把一个表的行和一个从0开始的整数序列Zip操作,相当于给行添加序号,比如

val zipWithIndexJoin  = for {
	   (a,idx) <- Album.zipWithIndex 
	 } yield( a.title, idx)

Scala 专题教程-参数化类型(1): 概述和例子说明

本专题介绍Scala的参数化类型,在介绍的过程中同时演示了信息隐藏的技术,这里我们通过实现一个纯函数化实现的队列来举例说明。
参数化类型帮助你实现通用的类型和Trait。比如通用的集合类Set,该通用集合类可以通过制定类型参数T,Set[T],它通过实例化参数类型,可以定义Set[String],Set[Int]等等。
此外,一般来说 String是AnyRef,但在其它一些语言中,Set[String]并一定是Set[AnyRef]的子类。在Scala中可以通过制定参数化类型之间的继承属性的Variance特性,来说明该参数化类型中使用不同的参数类型后的类型之间是否也存在继承关系。
首先我们定义一些我们要实现的这个简单的对象的一些基本需求:
这个函数化队列要求支持下面三个基本操作:
head 返回队列的首元素
tail 返回队列的除首元素之外的其余元素(也是一个队列)
enqueue 把新元素添加到队列尾部后返回一个新队列。

和一般队列实现不同的是,函数化队列实现时不改变队列的内容,当需要修改队列时构造一个新队列。
如何构造一个效率高的队列呢?也就是head,tail ,enqueue所花费的时间不应当随队列的大小而改变,一个简单的实现可以使用List类来实现,但enqueue操作的时间和队列的长度成正比,这里给出一个使用两个List对象的队列实现,具体算法不解释了(本专题侧重点不在算法本身)可以实现一个高效的队列操作。

class Queue[T](
  private val leading:List[T],
  private val trailing:List[T]
 ){
  private def mirror =
    if(leading.isEmpty)
      new Queue(trailing.reverse,Nil)
    else
       this

  def head=mirror.leading.head
  def tail={
    val q= mirror
      new Queue(q.leading.tail,q.trailing)
  }

  def enqueue(x:T)=
    new Queue(leading,x::trailing)
}

使用这个实现,进行一些基本的队列操作:

scala> val q = new Queue(List(1,2,3),Nil)
q: Queue[Int] = Queue@24cc40b6

scala> val q1 = q enqueue 4
q1: Queue[Int] = Queue@67825189

scala> q
res0: Queue[Int] = Queue@24cc40b6

scala> val p = q1 head
p: Int = 1

scala> q1
res1: Queue[Int] = Queue@67825189

这个实现满足功能需求,但我们希望可以实现如下的形式:

scala> val q = Queue(1,2,3)
q: Queue[Int] = Queue(1,2,3)

scala> val q1 = q enqueue 4
q1: Queue[Int] = Queue(1,2,3,4)

scala> q
q: Queue[Int] = Queue(1,2,3)

在之后的文章我们逐步的优化这个实现。

休假归来

一个多月没有更新博客了,休了五个星期的假,行程绕地球一圈半还多,八年之后重游美国,回顾了一下迪斯尼,不同的是这次是全家一起重游Disney World。
20130801001

将尽快更新博客,敬请关注