github/jooq
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[#4271] Add implicit ScalaResultQuery type to add additional functionality to ResultQuery for Scala users

Browse Source
This commit is contained in:
lukaseder 2015-05-06 11:59:18 +02:00
parent a681e671a9
commit 7279f068b9
2 changed files with 54 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
jOOQ-scala/src/main/scala/org/jooq/scala/Conversions.scala
View File

@ -44,6 +44,9 @@ import org.jooq._
import org.jooq.impl._
import org.jooq.impl.DSL._
import _root_.scala.collection.convert.WrapAsScala
import _root_.scala.collection.convert.Wrappers.JMapWrapper
/**
* jOOQ type conversions used to enhance the jOOQ Java API with Scala Traits
* <p>
@ -83,6 +86,46 @@ import org.jooq.impl.DSL._
*/
object Conversions {
// -------------------------------------------------------------------------
// Enhanced jOOQ types
// -------------------------------------------------------------------------
implicit class ScalaResultQuery[R <: Record](val query: ResultQuery[R]) {
import _root_.scala.collection.mutable._
def fetchAnyOption () : Option[R] = Option(query.fetchAny)
def fetchAnyOption[E] (mapper : RecordMapper[_ >: R, E]) : Option[E] = Option(query.fetchAny(mapper))
def fetchAnyOption[T] (field : Field[T]) : Option[T] = Option(query.fetchAny(field))
def fetchAnyOption[T] (field : Field[_], newType : Class[_ <: T]) : Option[T] = Option(query.fetchAny(field, newType))
def fetchAnyOption[T, U] (field : Field[T], converter : Converter[_ >: T, U]) : Option[U] = Option(query.fetchAny[T, U](field, converter))
def fetchAnyOption (fieldIndex : Int) : Option[_] = Option(query.fetchAny(fieldIndex))
def fetchAnyOption[T] (fieldIndex : Int, newType : Class[_ <: T]) : Option[_] = Option(query.fetchAny(fieldIndex, newType))
def fetchAnyOption[T, U] (fieldIndex : Int, converter : Converter[_ >: T, U]) : Option[_] = Option(query.fetchAny(fieldIndex, converter))
def fetchAnyOption (fieldName : String) : Option[_] = Option(query.fetchAny(fieldName))
def fetchAnyOption[T] (fieldName : String, newType : Class[_ <: T]) : Option[_] = Option(query.fetchAny(fieldName, newType))
def fetchAnyOption[U] (fieldName : String, converter : Converter[_, U]) : Option[_] = Option(query.fetchAny(fieldName, converter))
def fetchAnyOptionArray () : Option[Array[AnyRef]] = Option(query.fetchAnyArray)
def fetchAnyOptionInto[E] (newType : Class[_ <: E]) : Option[E] = Option(query.fetchAnyInto(newType))
def fetchAnyOptionInto[Z <: Record](table : Table[Z]) : Option[Z] = Option(query.fetchAnyInto(table))
def fetchAnyOptionMap () : Option[Map[String, AnyRef]] = Option(query.fetchAnyMap).map(m => WrapAsScala.mapAsScalaMap(m))
def fetchOneOption () : Option[R] = Option(query.fetchOne)
def fetchOneOption[E] (mapper : RecordMapper[_ >: R, E]) : Option[E] = Option(query.fetchOne(mapper))
def fetchOneOption[T] (field : Field[T]) : Option[T] = Option(query.fetchOne(field))
def fetchOneOption[T] (field : Field[_], newType : Class[_ <: T]) : Option[T] = Option(query.fetchOne(field, newType))
def fetchOneOption[T, U] (field : Field[T], converter : Converter[_ >: T, U]) : Option[U] = Option(query.fetchOne[T, U](field, converter))
def fetchOneOption (fieldIndex : Int) : Option[_] = Option(query.fetchOne(fieldIndex))
def fetchOneOption[T] (fieldIndex : Int, newType : Class[_ <: T]) : Option[_] = Option(query.fetchOne(fieldIndex, newType))
def fetchOneOption[T, U] (fieldIndex : Int, converter : Converter[_ >: T, U]) : Option[_] = Option(query.fetchOne(fieldIndex, converter))
def fetchOneOption (fieldName : String) : Option[_] = Option(query.fetchOne(fieldName))
def fetchOneOption[T] (fieldName : String, newType : Class[_ <: T]) : Option[_] = Option(query.fetchOne(fieldName, newType))
def fetchOneOption[U] (fieldName : String, converter : Converter[_, U]) : Option[_] = Option(query.fetchOne(fieldName, converter))
def fetchOneOptionArray () : Option[Array[AnyRef]] = Option(query.fetchOneArray)
def fetchOneOptionInto[E] (newType : Class[_ <: E]) : Option[E] = Option(query.fetchOneInto(newType))
def fetchOneOptionInto[Z <: Record](table : Table[Z]) : Option[Z] = Option(query.fetchOneInto(table))
def fetchOneOptionMap () : Option[Map[String, AnyRef]] = Option(query.fetchOneMap).map(m => WrapAsScala.mapAsScalaMap(m))
}
// -------------------------------------------------------------------------
// Traits
// -------------------------------------------------------------------------

11
jOOQ-scala/src/test/scala/org/jooq/scala/example/Test.scala
View File

@ -108,5 +108,16 @@ object Test {
ORDER BY a.id, b.id
""")
)
// Option conversions
for (i <- 1 to 3) {
f.select (T_AUTHOR.FIRST_NAME, T_AUTHOR.LAST_NAME)
.from (T_AUTHOR)
.where (T_AUTHOR.ID === i)
.fetchOneOption() match {
case Some(author) => println("Author found: " + author.getValue(T_AUTHOR.FIRST_NAME) + " " + author.getValue(T_AUTHOR.LAST_NAME))
case None => println("No author found for ID: " + i)
}
}
}
}