阶隐式标识

Question

以一个数据库事务：

def create(model: Model, orderNum: String) = { 
    db.handle withSession { implicit ss: Session=> 
    ss.withTransaction { // auto commit now set to false 
     val result = for { 
     uid <- repo.user.create(model) 
     mid <- repo.membership.create(uid) 
     oid <- repo.orders.create(model, uid, orderNum) 
     } yield uid 
     result fold( 
     e=> { ss.rollback; Left(e) }, 
     s=> { Cache.remove("member.directory"); Right(s) } 
    ) 
    } 
    } 
} 

如果库用户创建的实现需要一个隐含的会议，是相同会议的withTransaction启用会议上面，或者是隐含价值“是一个“而不是”身份？“

def create[T <: User](t: T)(implicit ss: Session) = // what Session is this? 
    for { 
    uid <- either(Users.insert(Users(t)), i18n("user not created")) 
    ur <- either(UserRoles.insert(UserRole(uid, t.role)), i18n("user role not created")) 
    } yield uid 

我能通过在会议明确repo.user.create(model)(ss)和具有创造采取明确的会议，但我想知道是否更简洁/便利隐含的方式提供了相同的结果，的交易启用会话。

Answer 1

不知道下面是什么你正在尝试做一个忠实的抽象，但我希望它能帮助：

class Store(var x: Int) { 
    def flip() { x = -x } 
} 

object M1 { 
    implicit val store2 = new Store(2) 

    def create(s: String) = { 
    implicit val store3 = new Store(3) 

    { implicit store: Store => 
     println("[M1.create] store.x = " + store.x) 
     store.flip() 
     M2.create("tummy") 
     println("[M1.create] store.x = " + store.x) 
    } 
    } 
} 

object M2 { 
    implicit val store4 = new Store(4) 

    def create(s: String)(implicit store: Store) = { 
    println("[M2.create] store.x = " + store.x) 
    store.flip() 
    } 
} 

M1.create("dummy")(new Store(1)) 

输出是：

[M1.create] store.x = 1 
[M2.create] store.x = -1 
[M1.create] store.x = 1 

• 的new Store(1)明确转交给M1.create转发给M2.create

• 编译器明显忽略了其他隐式存储库store2, store3, store4。

Answer 2

如果我正确地理解了你，你正在使用ScalaQuery，并且你想让你的方法也在用户从外部提供会话时工作。

DEF withSession [T]（F：⇒T）：T运行所提供的thunk用一个新的会话和 在结束时自动关闭会话。

def withSession [T]（f： （Session）⇒T）：T用新会话运行提供的功能，并在最后自动关闭会话。

这些都正在创造一个新的事务，所以我会去的方式是使用一个可选[会议]作为隐含的而且默认为无

def onProvidedOrCreatedSession[K](f: Session => K)(session:Option[Session]) = { 
    session match { 
     case Some(s) => f(s) 
     case None => db.withSession { f } 
    } 
    } 

    def create(model: Model, orderNum: String)(implicit session:Option[Session]=None){ 
    onProvidedOrCreatedSession( 
     implicit s => s.withTransaction { val x = 10 } 
    )(session) 

    }