我目前正在使用Casbah和MongoDB来实现Web服务.到目前为止我没有遇到任何问题.我也在使用
Scala.
但是,我只是想知道是否有比Casbah更好的东西来做很多find / findOne类型的查询.
我遇到了Rogue,这是一种基于类型安全的基于Scala的DSL,它可以使查询更容易,更易读.
所以,我想知道转移到Rogue是否有用,这样随着Web服务项目变得更大,更复杂,Rogue对查询的支持可能会有所帮助？
只是想知道我是否应该继续或转向更好的东西.
解决方法
目前,Rogue仅针对
Lift’s MongoDB-Record系统.
它提供完全类型安全性的部分原因是它使用强大,定义明确的Lift-Record对象结构.由于您拥有完整的结构,因此您执行“自由格式”查询的能力要低得多.以下是我最近为Scala网络研讨会做的Lift-Record Rogue演示的意思. Lift& amp;和Rogue自从我这样做以后代码可能会稍微过时但仍然具有代表性.这是MongoDB的Lift-Record模型：
object LiftRecordDemo extends Application {
// We'll use enums for Type and Subtype
object EventType extends Enumeration {
type EventType = Value
val Conference,Webinar = Value
}
object EventSubType extends Enumeration {
type EventSubType = Value
val FullDay = Value("Full Day")
val HalfDay = Value("Half Day")
}
class MongoEvent extends MongoRecord[MongoEvent] with MongoId[MongoEvent] {
def meta = MongoEvent
object name extends StringField(this,255)
object eventType extends EnumField(this,EventType)
object eventSubType extends OptionalEnumField(this,EventSubType)
object location extends JsonObjectField[MongoEvent,EventLocation](this,EventLocation) {
def defaultValue = EventLocation(None,None,None)
}
object hashtag extends OptionalStringField(this,32)
object language extends OptionalStringField(this,32)
object date extends JsonObjectField[MongoEvent,EventDate](this,EventDate) {
def defaultValue = EventDate(new DateTime,None)
}
object url extends OptionalStringField(this,255)
object presenter extends OptionalStringField(this,255)
}
object MongoEvent extends MongoEvent with MongoMetaRecord[MongoEvent] {
override def collectionName = "mongoEvents"
override def formats = super.formats + new EnumSerializer(EventType) + new EnumSerializer(EventSubType)
}
case class EventLocation(val venueName: Option[String],val url: Option[String],val address: Option[String],val city: Option[String],val state: Option[String],val zip: Option[String],val country: Option[String]) extends JsonObject[EventLocation] {
def meta = EventLocation
}
object EventLocation extends JsonObjectMeta[EventLocation]
case class EventDate(start: DateTime,end: Option[DateTime]) extends JsonObject[EventDate] {
def meta = EventDate
}
object EventDate extends JsonObjectMeta[EventDate]
}
正如您所看到的,您需要提前定义MongoDB数据模型,以获得强类型,安全查询的好处…… Rogue在编译时强制执行大部分内容.以下是针对此模型的一些Rogue示例：
// Tell Lift about our DB
val mongoAddr = MongoAddress(MongoHost("127.0.0.1",27017),"scalaWebinar")
MongoDB.defineDb(DefaultMongoIdentifier,mongoAddr)
// Rogue gives us a saner approach,although still hobbled by some
// of Lift-MongoDB-Record's limits on embedded docs
val q = MongoEvent where (_.eventType eqs EventType.Webinar)
println("Rogue created a Query '%s'\n\n".format(q))
for (x <- MongoEvent where (_.eventType eqs EventType.Webinar)) {
println("Name: %s Presenter: %s\n".format(x.name,x.presenter))
}
// Rogue can also do sorting for you,which is useful
println("\n\n\n")
for (x <- MongoEvent where (_.eventType eqs EventType.Conference)
orderAsc(_.language) andDesc(_.name)) {
println("Name: %s Language: %s\n".format(x.name,x.language))
}
val start = new DateTime(2011,2,1,0)
val end = new DateTime(2011,3,0)
/** The following would be nice but unfortunately,doesn't work because of lift's current embedded doc
implementation
*/
//val dateQ = MongoEvent where (_.date.start after start)
//and (_.date.end before end)
请注意,我并不是说Rogue和Lift-Record不是很棒,只是说它们使用了强大定义的编译时数据模型.
如果您想使用与Casbah类似的上下文,我们确实有一个内置DSL,旨在尽可能地模仿MongoDB的内置Query模型.它适用于任何任意底层模型,但是尽可能强制执行类型安全级别.这是Casbah的查询的一个例子(在同一个演示文稿中有点过时)：
// What about querying? Lets find all the non-US events
for (x <- mongo.find(MongoDBObject("location.country" ->
MongoDBObject("$ne" -> "USA")))) println(x)
/* There's a problem here: We got back the Webinars too because
They don't have a country at all,so they aren't "USA"
*/
println("\n\nTesting for existence of Location.Country:")
for (x <- mongo.find(MongoDBObject("location.country" -> MongoDBObject(
"$ne" -> "USA","$exists" -> true
)))) println(x)
// This is getting a bit unwieldy. Thankfully,Casbah offers a DSL
val q = $or ("location.country" -> "USA","location.country" -> "Japan")
println("\n Created a DBObject: %s".format(q))
println("\n Querying using DSL Object...")
for (x <- mongo.find(q)) println(x)
// It's possible to construct more complex queries too.
// Lets find everything in February
println("\n February Events...")
val start = new DateTime(2011,0)
val dateQ = "date.start" $gte start $lt end
println("\n Date Query: %s".format(dateQ))
for (x <- mongo.find(dateQ,MongoDBObject("name" -> true,"date" -> true))) println(x)
值得注意的是,我们正在查询自由格式模型,但使用DSL运算符而不是嵌套的MongoDB定义.运算符有很多奇妙的映射,直到$type运算符,使用类清单来测试类型以确保编译时的安全性：
"Casbah's $type operator" should {
"Accept raw Byte indicators (e.g. from org.bson.BSON)" in {
// Don't need to test every value here since it's just a byte
val typeOper = "foo" $type org.bson.BSON.NUMBER_LONG
typeOper must notBeNull
typeOper.toString must notBeNull
typeOper must haveSuperClass[DBObject]
typeOper must beEqualTo(nonDSL("foo","$type",org.bson.BSON.NUMBER_LONG))
}
"Accept manifested Type arguments" in {
"Doubles" in {
val typeOper = "foo".$type[Double]
typeOper must notBeNull
typeOper.toString must notBeNull
typeOper must haveSuperClass[DBObject]
typeOper must beEqualTo(nonDSL("foo",org.bson.BSON.NUMBER))
}
"Strings" in {
val typeOper = "foo".$type[String]
typeOper must notBeNull
typeOper.toString must notBeNull
typeOper must haveSuperClass[DBObject]
typeOper must beEqualTo(nonDSL("foo",org.bson.BSON.STRING))
}
"Object" in {
"via BSONObject" in {
val typeOper = "foo".$type[org.bson.BSONObject]
typeOper must notBeNull
typeOper.toString must notBeNull
typeOper must haveSuperClass[DBObject]
typeOper must beEqualTo(nonDSL("foo",org.bson.BSON.OBJECT))
}
"via DBObject" in {
val typeOper = "foo".$type[DBObject]
typeOper must notBeNull
typeOper.toString must notBeNull
typeOper must haveSuperClass[DBObject]
typeOper must beEqualTo(nonDSL("foo",org.bson.BSON.OBJECT))
}
}
"Array" in {
"via BasicDBList" in {
val typeOper = "foo".$type[BasicDBList]
typeOper must notBeNull
typeOper.toString must notBeNull
typeOper must haveSuperClass[DBObject]
typeOper must beEqualTo(nonDSL("foo",org.bson.BSON.ARRAY))
}
"via BasicBSONList" in {
val typeOper = "foo".$type[org.bson.types.BasicBSONList]
typeOper must notBeNull
typeOper.toString must notBeNull
typeOper must haveSuperClass[DBObject]
typeOper must beEqualTo(nonDSL("foo",org.bson.BSON.ARRAY))
}
}
"OID" in {
val typeOper = "foo".$type[ObjectId]
typeOper must notBeNull
typeOper.toString must notBeNull
typeOper must haveSuperClass[DBObject]
typeOper must beEqualTo(nonDSL("foo",org.bson.BSON.OID))
}
"Boolean" in {
val typeOper = "foo".$type[Boolean]
typeOper must notBeNull
typeOper.toString must notBeNull
typeOper must haveSuperClass[DBObject]
typeOper must beEqualTo(nonDSL("foo",org.bson.BSON.BOOLEAN))
}
"Date" in {
"via JDKDate" in {
val typeOper = "foo".$type[java.util.Date]
typeOper must notBeNull
typeOper.toString must notBeNull
typeOper must haveSuperClass[DBObject]
typeOper must beEqualTo(nonDSL("foo",org.bson.BSON.DATE))
}
"via Joda DateTime" in {
val typeOper = "foo".$type[org.joda.time.DateTime]
typeOper must notBeNull
typeOper.toString must notBeNull
typeOper must haveSuperClass[DBObject]
typeOper must beEqualTo(nonDSL("foo",org.bson.BSON.DATE))
}
}
"None (null)" in {
// For some reason you can't use NONE
val typeOper = "foo".$type[Option[Nothing]]
typeOper must notBeNull
typeOper.toString must notBeNull
typeOper must haveSuperClass[DBObject]
typeOper must beEqualTo(nonDSL("foo",org.bson.BSON.NULL))
}
"Regex" in {
"Scala Regex" in {
val typeOper = "foo".$type[scala.util.matching.Regex]
typeOper must notBeNull
typeOper.toString must notBeNull
typeOper must haveSuperClass[DBObject]
typeOper must beEqualTo(nonDSL("foo",org.bson.BSON.REGEX))
}
}
"Symbol" in {
val typeOper = "foo".$type[Symbol]
typeOper must notBeNull
typeOper.toString must notBeNull
typeOper must haveSuperClass[DBObject]
typeOper must beEqualTo(nonDSL("foo",org.bson.BSON.SYMBOL))
}
"Number (integer)" in {
val typeOper = "foo".$type[Int]
typeOper must notBeNull
typeOper.toString must notBeNull
typeOper must haveSuperClass[DBObject]
typeOper must beEqualTo(nonDSL("foo",org.bson.BSON.NUMBER_INT))
}
"Number (Long)" in {
val typeOper = "foo".$type[Long]
typeOper must notBeNull
typeOper.toString must notBeNull
typeOper must haveSuperClass[DBObject]
typeOper must beEqualTo(nonDSL("foo",org.bson.BSON.NUMBER_LONG))
}
"Timestamp" in {
val typeOper = "foo".$type[java.sql.Timestamp]
typeOper must notBeNull
typeOper.toString must notBeNull
typeOper must haveSuperClass[DBObject]
typeOper must beEqualTo(nonDSL("foo",org.bson.BSON.TIMESTAMP))
}
"Binary" in {
val typeOper = "foo".$type[Array[Byte]]
typeOper must notBeNull
typeOper.toString must notBeNull
typeOper must haveSuperClass[DBObject]
typeOper must beEqualTo(nonDSL("foo",org.bson.BSON.BINARY))
}
}
(注意：您需要将casbah-query软件包及其相关的导入导入到您的代码中,或者使用预模块化的默认“casbah”导入).目前Casbah的规格已经覆盖了每个DSL操作符;目前这些文档落后了,但规范是对其使用的一个很好的介绍.注意Casbah中有两种运算符,就像在MongoDB中一样.
Bareword Operators,in which the leftmost part of the statement is the $Operator. Examples of this are
$set,$rename,etc. See 07001 for more.“Core” Operators,are operators that exist on the right hand side of the statement,such as
$type. See 07002 for more.
我知道这是一个相当详细的答案,但我想确保您了解您的选择,以及两种解决方案的局限性.卡斯巴会给你密切映射到MongoDB的,并删除了一些语法克鲁夫特的DSL(请记住,也卡斯巴提供DBOBJECT一个getAs [T]的方法,要求从DBOBJECT的值作为一个特定的类型,人们往往忽视);许多用户在寻求内容之前并不知道DSL存在.然而,Casbah的Query DSL在一些人的观点中看起来有点“狡猾”……作为它的作者我更喜欢它的简洁和优雅我只需要记住用于查询的** MONGODB *语法,而不是MongoDB和另一个DSL.它也基于自由格式查询,并且不提供相同的结构化编译时类型安全&意识到Rogue所做的设施.
相比之下,Rogue还需要一个完全定义的Record模型,它不适合每个应用程序.
我很乐意听到,如果有任何产品不能正常满足您需求的“中间地带”,那么任何产品都可以改进.
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。