[#1773] Add a new jOOQ-Scala project and jooq-scala artefactId, to
contain jOOQ extensions in the Scala language - Added support for bitwise operations
This commit is contained in:
Lukas Eder
parent
6194e189d7
commit
db728ae1e4
@ -77,20 +77,155 @@ import org.jooq.impl.Factory._
|
||||
*/
|
||||
object Conversions {
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Traits
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* A Scala-esque representation of {@link org.jooq.Field}, adding overloaded
|
||||
* operators for common jOOQ operations to arbitrary fields
|
||||
*/
|
||||
trait SAnyField[T] extends QueryPartInternal {
|
||||
|
||||
// String operations
|
||||
// -----------------
|
||||
|
||||
def ||(value : String) : Field[String]
|
||||
def ||(value : Field[_]) : Field[String]
|
||||
|
||||
// Comparison predicates
|
||||
// ---------------------
|
||||
|
||||
def ===(value : T) : Condition
|
||||
def ===(value : Field[T]) : Condition
|
||||
|
||||
def !==(value : T) : Condition
|
||||
def !==(value : Field[T]) : Condition
|
||||
|
||||
def <>(value : T) : Condition
|
||||
def <>(value : Field[T]) : Condition
|
||||
|
||||
def >(value : T) : Condition
|
||||
def >(value : Field[T]) : Condition
|
||||
|
||||
def >=(value : T) : Condition
|
||||
def >=(value : Field[T]) : Condition
|
||||
|
||||
def <(value : T) : Condition
|
||||
def <(value : Field[T]) : Condition
|
||||
|
||||
def <=(value : T) : Condition
|
||||
def <=(value : Field[T]) : Condition
|
||||
|
||||
def <=>(value : T) : Condition
|
||||
def <=>(value : Field[T]) : Condition
|
||||
}
|
||||
|
||||
/**
|
||||
* A Scala-esque representation of {@link org.jooq.Field}, adding overloaded
|
||||
* operators for common jOOQ operations to numeric fields
|
||||
*/
|
||||
trait SNumberField[T <: Number] extends SAnyField[T] {
|
||||
|
||||
// Arithmetic operations
|
||||
// ---------------------
|
||||
|
||||
def +(value : Number) : Field[T]
|
||||
def +(value : Field[_ <: Number]) : Field[T]
|
||||
|
||||
def -(value : Number) : Field[T]
|
||||
def -(value : Field[_ <: Number]) : Field[T]
|
||||
|
||||
def *(value : Number) : Field[T]
|
||||
def *(value : Field[_ <: Number]) : Field[T]
|
||||
|
||||
def /(value : Number) : Field[T]
|
||||
def /(value : Field[_ <: Number]) : Field[T]
|
||||
|
||||
def %(value : Number) : Field[T]
|
||||
def %(value : Field[_ <: Number]) : Field[T]
|
||||
|
||||
// Bitwise operations
|
||||
// ------------------
|
||||
|
||||
def unary_~ : Field[T]
|
||||
|
||||
def &(value : T) : Field[T]
|
||||
def &(value : Field[T]) : Field[T]
|
||||
|
||||
def |(value : T) : Field[T]
|
||||
def |(value : Field[T]) : Field[T]
|
||||
|
||||
def ^(value : T) : Field[T]
|
||||
def ^(value : Field[T]) : Field[T]
|
||||
|
||||
def <<(value : T) : Field[T]
|
||||
def <<(value : Field[T]) : Field[T]
|
||||
|
||||
def >>(value : T) : Field[T]
|
||||
def >>(value : Field[T]) : Field[T]
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------
|
||||
// Trait implementations
|
||||
// ------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* A Scala-esque representation of {@link org.jooq.Field}, implementing
|
||||
* overloaded operators for common jOOQ operations
|
||||
* overloaded operators for common jOOQ operations to arbitrary fields
|
||||
*/
|
||||
case class JFieldWrapper[T](val underlying: Field[T])
|
||||
abstract class AnyFieldBase[T](val underlying: Field[T])
|
||||
extends CustomField[T] (underlying.getName(), underlying.getDataType())
|
||||
with SField[T] {
|
||||
// ------------------------------------------------------------------------
|
||||
with SAnyField[T] {
|
||||
|
||||
// QueryPart API
|
||||
// ------------------------------------------------------------------------
|
||||
// -------------
|
||||
|
||||
def toSQL(context : RenderContext) = underlying.toSQL(context)
|
||||
def bind (context : BindContext) = underlying.bind(context)
|
||||
|
||||
// String operations
|
||||
// -----------------
|
||||
|
||||
def ||(value : String) = underlying.concat(value)
|
||||
def ||(value : Field[_]) = underlying.concat(value)
|
||||
|
||||
// Comparison predicates
|
||||
// ---------------------
|
||||
|
||||
def ===(value : T) = underlying.equal(value)
|
||||
def ===(value : Field[T]) = underlying.equal(value)
|
||||
|
||||
def !==(value : T) = underlying.notEqual(value)
|
||||
def !==(value : Field[T]) = underlying.notEqual(value)
|
||||
|
||||
def <>(value : T) = underlying.notEqual(value)
|
||||
def <>(value : Field[T]) = underlying.notEqual(value)
|
||||
|
||||
def >(value : T) = underlying.greaterThan(value)
|
||||
def >(value : Field[T]) = underlying.greaterThan(value)
|
||||
|
||||
def >=(value : T) = underlying.greaterOrEqual(value)
|
||||
def >=(value : Field[T]) = underlying.greaterOrEqual(value)
|
||||
|
||||
def <(value : T) = underlying.lessThan(value)
|
||||
def <(value : Field[T]) = underlying.lessThan(value)
|
||||
|
||||
def <=(value : T) = underlying.lessOrEqual(value)
|
||||
def <=(value : Field[T]) = underlying.lessOrEqual(value)
|
||||
|
||||
def <=>(value : T) = underlying.isNotDistinctFrom(value)
|
||||
def <=>(value : Field[T]) = underlying.isNotDistinctFrom(value)
|
||||
}
|
||||
|
||||
/**
|
||||
* A Scala-esque representation of {@link org.jooq.Field}, implementing
|
||||
* overloaded operators for common jOOQ operations to numeric fields
|
||||
*/
|
||||
abstract class NumberFieldBase[T <: Number](override val underlying: Field[T])
|
||||
extends AnyFieldBase[T] (underlying)
|
||||
with SNumberField[T] {
|
||||
|
||||
// ------------------------------------------------------------------------
|
||||
// Arithmetic operations
|
||||
// ------------------------------------------------------------------------
|
||||
@ -110,98 +245,54 @@ object Conversions {
|
||||
def %(value : Number) = underlying.mod(value)
|
||||
def %(value : Field[_ <: Number]) = underlying.mod(value)
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Bitwise operations
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
def ||(value : String) = underlying.concat(value)
|
||||
//def ||(value : Field[_]) : underlying.concat(value)
|
||||
def unary_~ = bitNot(underlying)
|
||||
|
||||
// ------------------------------------------------------------------------
|
||||
// Comparison predicates
|
||||
// ------------------------------------------------------------------------
|
||||
def &(value : T) = bitAnd(underlying, value)
|
||||
def &(value : Field[T]) = bitAnd(underlying, value)
|
||||
|
||||
def ===(value : T) : Condition = underlying.equal(value)
|
||||
def ===(value : Field[T]) : Condition = underlying.equal(value)
|
||||
def |(value : T) = bitOr (underlying, value)
|
||||
def |(value : Field[T]) = bitOr (underlying, value)
|
||||
|
||||
def !==(value : T) : Condition = underlying.notEqual(value)
|
||||
def !==(value : Field[T]) : Condition = underlying.notEqual(value)
|
||||
def ^(value : T) = bitXor(underlying, value)
|
||||
def ^(value : Field[T]) = bitXor(underlying, value)
|
||||
|
||||
def <>(value : T) : Condition = underlying.notEqual(value)
|
||||
def <>(value : Field[T]) : Condition = underlying.notEqual(value)
|
||||
def <<(value : T) = shl(underlying, value)
|
||||
def <<(value : Field[T]) = shl(underlying, value)
|
||||
|
||||
def >(value : T) : Condition = underlying.greaterThan(value)
|
||||
def >(value : Field[T]) : Condition = underlying.greaterThan(value)
|
||||
|
||||
def >=(value : T) : Condition = underlying.greaterOrEqual(value)
|
||||
def >=(value : Field[T]) : Condition = underlying.greaterOrEqual(value)
|
||||
|
||||
def <(value : T) : Condition = underlying.lessThan(value)
|
||||
def <(value : Field[T]) : Condition = underlying.lessThan(value)
|
||||
|
||||
def <=(value : T) : Condition = underlying.lessOrEqual(value)
|
||||
def <=(value : Field[T]) : Condition = underlying.lessOrEqual(value)
|
||||
|
||||
def <=>(value : T) : Condition = underlying.isNotDistinctFrom(value)
|
||||
def <=>(value : Field[T]) : Condition = underlying.isNotDistinctFrom(value)
|
||||
def >>(value : T) = shr(underlying, value)
|
||||
def >>(value : Field[T]) = shr(underlying, value)
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------
|
||||
// Implicit conversions
|
||||
// ------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* A Scala-esque representation of {@link org.jooq.Field}, adding overloaded
|
||||
* operators for common jOOQ operations
|
||||
* A Scala-esque representation of {@link org.jooq.Field}, implementing
|
||||
* overloaded operators for common jOOQ operations to arbitrary fields
|
||||
*/
|
||||
trait SField[T] extends QueryPartInternal {
|
||||
case class AnyFieldWrapper[T] (override val underlying: Field[T])
|
||||
extends AnyFieldBase[T] (underlying) {}
|
||||
|
||||
// ------------------------------------------------------------------------
|
||||
// Arithmetic operations
|
||||
// ------------------------------------------------------------------------
|
||||
/**
|
||||
* A Scala-esque representation of {@link org.jooq.Field}, implementing
|
||||
* overloaded operators for common jOOQ operations to numeric fields
|
||||
*/
|
||||
case class NumberFieldWrapper[T <: Number](override val underlying: Field[T])
|
||||
extends NumberFieldBase[T] (underlying) {}
|
||||
|
||||
def +(value : Number) : Field[T]
|
||||
def +(value : Field[_ <: Number]) : Field[T]
|
||||
|
||||
def -(value : Number) : Field[T]
|
||||
def -(value : Field[_ <: Number]) : Field[T]
|
||||
|
||||
def *(value : Number) : Field[T]
|
||||
def *(value : Field[_ <: Number]) : Field[T]
|
||||
|
||||
def /(value : Number) : Field[T]
|
||||
def /(value : Field[_ <: Number]) : Field[T]
|
||||
|
||||
def %(value : Number) : Field[T]
|
||||
def %(value : Field[_ <: Number]) : Field[T]
|
||||
|
||||
def ||(value : String) : Field[String]
|
||||
//def ||(value : Field[_]) : Field[String]
|
||||
|
||||
// ------------------------------------------------------------------------
|
||||
// Comparison predicates
|
||||
// ------------------------------------------------------------------------
|
||||
|
||||
def ===(value : T) : Condition
|
||||
def ===(value : Field[T]) : Condition
|
||||
|
||||
def !==(value : T) : Condition
|
||||
def !==(value : Field[T]) : Condition
|
||||
|
||||
def <>(value : T) : Condition
|
||||
def <>(value : Field[T]) : Condition
|
||||
|
||||
def >(value : T) : Condition
|
||||
def >(value : Field[T]) : Condition
|
||||
|
||||
def >=(value : T) : Condition
|
||||
def >=(value : Field[T]) : Condition
|
||||
|
||||
def <(value : T) : Condition
|
||||
def <(value : Field[T]) : Condition
|
||||
|
||||
def <=(value : T) : Condition
|
||||
def <=(value : Field[T]) : Condition
|
||||
|
||||
def <=>(value : T) : Condition
|
||||
def <=>(value : Field[T]) : Condition
|
||||
implicit def asSNumberField[T <: Number](f : Field[T]): SNumberField[T] = f match {
|
||||
case AnyFieldWrapper(f) => f
|
||||
case NumberFieldWrapper(f) => f
|
||||
case _ => new NumberFieldWrapper(f)
|
||||
}
|
||||
|
||||
implicit def asScalaField[T](f : Field[T]): SField[T] = f match {
|
||||
case JFieldWrapper(f) => f
|
||||
case _ => new JFieldWrapper(f)
|
||||
implicit def asSAnyField[T](f : Field[T]): SAnyField[T] = f match {
|
||||
case AnyFieldWrapper(f) => f
|
||||
case _ => new AnyFieldWrapper(f)
|
||||
}
|
||||
}
|
||||
|
||||
@ -4,11 +4,9 @@ import collection.JavaConversions._
|
||||
import org.scalatest.FunSuite
|
||||
import org.jooq._
|
||||
import org.jooq.impl._
|
||||
import org.jooq.impl.Factory._
|
||||
import org.jooq.scala.example.h2.Tables._
|
||||
import org.jooq.scala.Conversions._
|
||||
import org.jooq.conf.Settings
|
||||
import javax.xml.bind.JAXB
|
||||
import org.jooq.conf.SettingsTools
|
||||
|
||||
class ArithmeticExpressionTest extends FunSuite {
|
||||
|
||||
@ -42,4 +40,40 @@ class ArithmeticExpressionTest extends FunSuite {
|
||||
assert("(t_book.id + (t_book.author_id * 2))" == combined1.toString(), combined1.toString())
|
||||
assert("((t_book.id * t_book.author_id) + 2)" == combined2.toString(), combined2.toString())
|
||||
}
|
||||
}
|
||||
|
||||
test("concat") {
|
||||
val cat1 = T_BOOK.TITLE || T_BOOK.TITLE
|
||||
val cat2 = T_BOOK.TITLE || " part 2"
|
||||
val cat3 = T_BOOK.TITLE || " part 2" || " and 3"
|
||||
|
||||
assert("(t_book.title || t_book.title)" == cat1.toString(), cat1.toString())
|
||||
assert("(t_book.title || ' part 2')" == cat2.toString(), cat2.toString())
|
||||
assert("((t_book.title || ' part 2') || ' and 3')" == cat3.toString(), cat3.toString())
|
||||
}
|
||||
|
||||
test("bitwise") {
|
||||
val and1 = T_BOOK.ID & T_BOOK.AUTHOR_ID
|
||||
val and2 = T_BOOK.ID & 1
|
||||
val or1 = T_BOOK.ID | T_BOOK.AUTHOR_ID
|
||||
val or2 = T_BOOK.ID | 1
|
||||
val xor1 = T_BOOK.ID ^ T_BOOK.AUTHOR_ID
|
||||
val xor2 = T_BOOK.ID ^ 1
|
||||
val shl1 = T_BOOK.ID << T_BOOK.AUTHOR_ID
|
||||
val shl2 = T_BOOK.ID << 1
|
||||
val shr1 = T_BOOK.ID >> T_BOOK.AUTHOR_ID
|
||||
val shr2 = T_BOOK.ID >> 1
|
||||
val not1 = ~T_BOOK.ID
|
||||
|
||||
assert("(t_book.id & t_book.author_id)" == and1.toString(), and1.toString())
|
||||
assert("(t_book.id & 1)" == and2.toString(), and2.toString())
|
||||
assert("(t_book.id | t_book.author_id)" == or1.toString(), or1.toString())
|
||||
assert("(t_book.id | 1)" == or2.toString(), or2.toString())
|
||||
assert("(t_book.id ^ t_book.author_id)" == xor1.toString(), xor1.toString())
|
||||
assert("(t_book.id ^ 1)" == xor2.toString(), xor2.toString())
|
||||
assert("(t_book.id << t_book.author_id)" == shl1.toString(), shl1.toString())
|
||||
assert("(t_book.id << 1)" == shl2.toString(), shl2.toString())
|
||||
assert("(t_book.id >> t_book.author_id)" == shr1.toString(), shr1.toString())
|
||||
assert("(t_book.id >> 1)" == shr2.toString(), shr2.toString())
|
||||
assert("~(t_book.id)" == not1.toString(), not1.toString())
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user