Merge pull request squeryl#157 from awkay/arrays

Adds basic support for Arrays

Author: max-l

org.squeryl.tests.cfg

@@ -3,9 +3,9 @@ h2.connectionString=jdbc:h2:~/test
 h2.user=sa
 h2.password=
 
-#postgresql.connectionString=jdbc:postgresql://localhost:5432/squeryl
-#postgresql.user=squeryl
-#postgresql.password=squeryl
+postgresql.connectionString=jdbc:postgresql://localhost:5432/test
+postgresql.user=test
+postgresql.password=test
 
 #derby.connectionString=jdbc:derby:memory:test;create=true
 #derby.user=app

src/main/scala/org/squeryl/PrimitiveTypeMode.scala

@@ -38,6 +38,9 @@ trait PrimitiveTypeMode extends QueryDsl with FieldMapper {
   implicit val optionDateTEF = PrimitiveTypeSupport.optionDateTEF    
   implicit val timestampTEF = PrimitiveTypeSupport.timestampTEF
   implicit val optionTimestampTEF = PrimitiveTypeSupport.optionTimestampTEF
+  implicit val doubleArrayTEF = PrimitiveTypeSupport.doubleArrayTEF
+  implicit val intArrayTEF = PrimitiveTypeSupport.intArrayTEF
+  implicit val longArrayTEF = PrimitiveTypeSupport.longArrayTEF
 
   // =========================== Numerical Integral =========================== 
   implicit val byteTEF = PrimitiveTypeSupport.byteTEF
@@ -97,5 +100,9 @@ trait PrimitiveTypeMode extends QueryDsl with FieldMapper {
 
   implicit def bigDecimalToTE(f: BigDecimal) = bigDecimalTEF.create(f)    
   implicit def optionBigDecimalToTE(f: Option[BigDecimal]) = optionBigDecimalTEF.create(f)
+  
+  implicit def doubleArrayToTE(f : Array[Double]) = doubleArrayTEF.create(f)
+  implicit def intArrayToTE(f : Array[Int]) = intArrayTEF.create(f)
+  implicit def longArrayToTE(f : Array[Long]) = longArrayTEF.create(f)
 
 }

src/main/scala/org/squeryl/adapters/PostgreSqlAdapter.scala

@@ -39,8 +39,13 @@ class PostgreSqlAdapter extends DatabaseAdapter {
   override def bigDecimalTypeDeclaration = "numeric"
   override def bigDecimalTypeDeclaration(precision:Int, scale:Int) = "numeric(" + precision + "," + scale + ")"
   override def binaryTypeDeclaration = "bytea"
-  override def uuidTypeDeclaration = "uuid"
-
+  override def uuidTypeDeclaration = "uuid"
+    
+    
+  override def jdbcIntArrayCreationType = "int4"
+  override def jdbcLongArrayCreationType = "int8"
+  override def jdbcDoubleArrayCreationType = "float8"
+    
   override def foreignKeyConstraintName(foreignKeyTable: Table[_], idWithinSchema: Int) =
     foreignKeyTable.name + "FK" + idWithinSchema
 

src/main/scala/org/squeryl/dsl/TypedExpression.scala

@@ -64,10 +64,16 @@ sealed trait TString extends TOptionString with TNonOption
 sealed trait TDate extends TOptionDate with TNonOption
 sealed trait TTimestamp extends TOptionTimestamp with TNonOption
 sealed trait TByteArray extends TOptionByteArray  with TNonOption
+sealed trait TIntArray extends TOptionIntArray  with TNonOption
+sealed trait TLongArray extends TOptionLongArray  with TNonOption
+sealed trait TDoubleArray extends TOptionDoubleArray  with TNonOption
 sealed trait TOptionString 
 sealed trait TOptionDate
 sealed trait TOptionTimestamp
 sealed trait TOptionByteArray  
+sealed trait TOptionIntArray  
+sealed trait TOptionLongArray  
+sealed trait TOptionDoubleArray  
 sealed trait TBoolean extends TOptionBoolean  with TNonOption
 sealed trait TOptionBoolean
 sealed trait TUUID extends TOptionUUID  with TNonOption
@@ -255,6 +261,10 @@ trait JdbcMapper[P,A] {
   def map(rs: ResultSet, i: Int): A = convertFromJdbc(extractNativeJdbcValue(rs, i)) 
 }
 
+trait ArrayJdbcMapper[P,A] extends JdbcMapper[P,A] {
+  self: TypedExpressionFactory[A,_] =>
+  def nativeJdbcType = sample.asInstanceOf[AnyRef].getClass
+}
 
 trait PrimitiveJdbcMapper[A] extends JdbcMapper[A,A] {
   self: TypedExpressionFactory[A,_] =>

src/main/scala/org/squeryl/internals/ArrayTEF.scala

@@ -0,0 +1,39 @@
+package org.squeryl.internals
+
+import java.sql.ResultSet
+import org.squeryl.Session
+import org.squeryl.dsl.TypedExpressionFactory
+import org.squeryl.dsl.ArrayJdbcMapper
+
+abstract class ArrayTEF[P, TE] extends TypedExpressionFactory[Array[P], TE] with ArrayJdbcMapper[java.sql.Array, Array[P]] {
+  // must define "sample" that includes an element. e.g. Array[Int](0)
+  def sample : Array[P]
+  def toWrappedJDBCType(element: P) : java.lang.Object
+  def fromWrappedJDBCType(element: Array[java.lang.Object]) : Array[P]
+  val defaultColumnLength = 1
+  def extractNativeJdbcValue(rs: ResultSet, i: Int) = rs.getArray(i)
+  def convertToJdbc(v: Array[P]): java.sql.Array = {
+    val content: Array[java.lang.Object] = v.map(toWrappedJDBCType(_))
+    val s = Session.currentSession
+    val con = s.connection
+    var rv: java.sql.Array = null
+    try {
+      val typ = s.databaseAdapter.arrayCreationType(sample(0).getClass)
+      rv = con.createArrayOf(typ, content)
+    } catch {
+      case e: Exception => s.log("Cannot create JDBC array: " + e.getMessage)
+    }
+    rv
+  }
+  def convertFromJdbc(v: java.sql.Array): Array[P] = {
+    val s = Session.currentSession
+    var rv : Array[P] = sample.take(0)
+    try {
+      val obj = v.getArray();
+      rv = fromWrappedJDBCType(obj.asInstanceOf[Array[java.lang.Object]])
+    } catch {
+      case e: Exception => s.log("Cannot obtain array from JDBC: " + e.getMessage)
+    }
+    rv
+  }
+}

src/main/scala/org/squeryl/internals/DatabaseAdapter.scala

@@ -180,7 +180,25 @@ trait DatabaseAdapter {
   def bigDecimalTypeDeclaration(precision:Int, scale:Int) = "decimal(" + precision + "," + scale + ")"
   def timestampTypeDeclaration = "timestamp"
   def binaryTypeDeclaration = "binary"
-  def uuidTypeDeclaration = "char(36)"
+  def uuidTypeDeclaration = "char(36)"
+  def intArrayTypeDeclaration = intTypeDeclaration + "[]"
+  def longArrayTypeDeclaration = longTypeDeclaration + "[]"
+  def doubleArrayTypeDeclaration = doubleTypeDeclaration + "[]"
+    
+  def jdbcIntArrayCreationType = intTypeDeclaration
+  def jdbcLongArrayCreationType = longTypeDeclaration
+  def jdbcDoubleArrayCreationType = doubleTypeDeclaration
+    
+  final def arrayCreationType(ptype : Class[_]) : String = {
+    val rv = ptype.getName() match {
+      case "java.lang.Integer" => jdbcIntArrayCreationType
+      case "java.lang.Double" => jdbcDoubleArrayCreationType
+      case "java.lang.Long" => jdbcLongArrayCreationType
+      case _ => ""
+    }
+    rv
+  }
+    
 /*
   private val _declarationHandler = new FieldTypeHandler[String] {
 
@@ -796,9 +814,15 @@ trait DatabaseAdapter {
         binaryTypeDeclaration
       else if(classOf[BigDecimal].isAssignableFrom(c))
         bigDecimalTypeDeclaration                  
+      else if(classOf[scala.Array[Int]].isAssignableFrom(c))
+        intArrayTypeDeclaration
+      else if(classOf[scala.Array[Long]].isAssignableFrom(c))
+        longArrayTypeDeclaration
+      else if(classOf[scala.Array[Double]].isAssignableFrom(c))
+        doubleArrayTypeDeclaration
       else
-        Utils.throwError("unsupported type " + ar.getClass.getCanonicalName)
-                  
+        Utils.throwError("unsupported type " + ar.getClass.getCanonicalName)
+     
       decl    
   }
 

src/main/scala/org/squeryl/internals/FieldMapper.scala

@@ -22,7 +22,9 @@ import java.sql.Timestamp
 import java.util.Date
 import java.util.UUID
 import org.squeryl.dsl._
-
+import java.util.regex.Pattern
+import org.squeryl.Session
+import org.squeryl.dsl.ArrayJdbcMapper
 
 trait FieldMapper {
   outer =>
@@ -106,6 +108,29 @@ trait FieldMapper {
       val deOptionizer = binaryTEF
     }
 
+    val intArrayTEF = new ArrayTEF[Int, TIntArray] {
+      val sample = Array(0)
+      def toWrappedJDBCType(element: Int) : java.lang.Object = new java.lang.Integer(element)
+      def fromWrappedJDBCType(elements: Array[java.lang.Object]) : Array[Int] = elements.map(i => i.asInstanceOf[java.lang.Integer].toInt)
+    }
+    
+    val longArrayTEF = new ArrayTEF[Long, TLongArray] {
+      val sample = Array(0L)
+      def toWrappedJDBCType(element: Long) : java.lang.Object = new java.lang.Long(element)
+      def fromWrappedJDBCType(elements: Array[java.lang.Object]) : Array[Long] = elements.map(i => i.asInstanceOf[java.lang.Long].toLong)
+    }
+    
+    val doubleArrayTEF = new ArrayTEF[Double, TDoubleArray] {
+      val sample : Array[Double] = Array(0.0)
+      def toWrappedJDBCType(element: Double) : java.lang.Object = new java.lang.Double(element)
+      def fromWrappedJDBCType(elements: Array[java.lang.Object]) : Array[Double] = elements.map(i => i.asInstanceOf[java.lang.Double].toDouble)
+    }
+    
+    // FIXME: The type soup on this was beyond my patience for now...I think we'll need an ArrayDeOptionizer
+    //val optionIntArrayTEF = new TypedExpressionFactory[Option[Array[Int]],TOptionIntArray] with DeOptionizer[Array[Int], Array[Int], TIntArray, Option[Array[Int]], TOptionIntArray] {
+      //val deOptionizer = intArrayTEF
+    //}
+    
     def enumValueTEF[A >: Enumeration#Value <: Enumeration#Value](ev: Enumeration#Value) = 
       new JdbcMapper[Int,A] with TypedExpressionFactory[A,TEnumValue[A]] { 
 
@@ -222,6 +247,9 @@ trait FieldMapper {
     register(timestampTEF)
     register(dateTEF)  
     register(uuidTEF)
+    register(intArrayTEF)
+    register(longArrayTEF)
+    register(doubleArrayTEF)
 
     val re = enumValueTEF(DummyEnum.DummyEnumerationValue)    
 
@@ -323,6 +351,20 @@ trait FieldMapper {
       Utils.throwError("field type "+ z.clasz + " already registered, handled by " + m.getClass.getCanonicalName)
   }
 
+  private [squeryl] def register[S,J](m: ArrayJdbcMapper[S,J]) {
+    val f = m.thisTypedExpressionFactory
+    val z = new FieldAttributesBasedOnType(
+        makeMapper(m), 
+        m.defaultColumnLength, 
+        f.sample,
+        m.nativeJdbcType)
+    
+    val wasThere = registry.put(z.clasz, z)
+    
+    if(wasThere != None)
+      Utils.throwError("field type "+ z.clasz + " already registered, handled by " + m.getClass.getCanonicalName)
+  }
+  
   private def register[A](pm: PrimitiveJdbcMapper[A]) {
     val f = pm.thisTypedExpressionFactory
     val z = new FieldAttributesBasedOnType(
@@ -333,8 +375,8 @@ trait FieldMapper {
 
     registry.put(c, z)    
   }
-    
-  private def lookup(c: Class[_]): Option[FieldAttributesBasedOnType[_]] =
+  
+  private def lookup(c: Class[_]): Option[FieldAttributesBasedOnType[_]] = {
     if(!c.isPrimitive) 
       registry.get(c)
     else c.getName match {
@@ -346,4 +388,5 @@ trait FieldMapper {
       case "double" => lookup(classOf[java.lang.Double])
       case "void" => None
     }           
+  }
 }

src/test/scala/org/squeryl/postgres/PostgresTests.scala

@@ -2,11 +2,10 @@ package org.squeryl.postgres
 
 
 import org.squeryl.test._
-
 import org.squeryl.framework.DBConnector
 import org.squeryl.adapters.PostgreSqlAdapter
-
 import org.squeryl.Session
+import org.squeryl.test.arrays.PrimitiveArrayTest
 
 trait Postgresql_Connection extends DBConnector{
   def connectToDb() : Option[() => Session] = {
@@ -28,6 +27,7 @@ trait Postgresql_Connection extends DBConnector{
   }
 }
 
+class Postgresql_ArrayTests extends PrimitiveArrayTest with Postgresql_Connection
 class Postgresql_UuidTests extends UuidTests with Postgresql_Connection
 class Postgresql_NestedLeftOuterJoinTest extends NestedLeftOuterJoinTest with Postgresql_Connection
 class Postgresql_SchoolDbMutableRelations extends mutablerelations.SchoolDb2MetableRelations with Postgresql_Connection

src/test/scala/org/squeryl/test/arrays/PrimitiveArrayTest.scala

@@ -0,0 +1,83 @@
+package org.squeryl.test.arrays
+
+import _root_.org.squeryl.framework._
+
+abstract class PrimitiveArrayTest extends SchemaTester with RunTestsInsideTransaction {
+
+  import _root_.org.squeryl.PrimitiveTypeMode._
+
+  val schema = PrimitiveArraySchema
+
+  import PrimitiveArraySchema._
+
+  test("can insert and query integer, double, and long array values in database") {
+    transaction {
+      schema.drop
+      schema.create
+      swimmers.insert(new Swimmer(1, Array(10.55, 12.99, 15.32), Array(100, 110, 20), Array(9876543210L, 123456789L)))
+    }
+
+    val query = from(swimmers)((s) => select(s))
+    val res = transaction { query.toList }
+
+    res.size should equal(1)
+    res(0).lap_times.size should equal(3)
+    res(0).lap_times(0) should equal(10.55)
+    res(0).lap_times(1) should equal(12.99)
+    res(0).lap_times(2) should equal(15.32)
+
+    res(0).scores.size should equal(3)
+    res(0).scores(0) should equal(100)
+    res(0).scores(1) should equal(110)
+    res(0).scores(2) should equal(20)
+
+    res(0).orgids.size should equal(2)
+    res(0).orgids(0) should equal(9876543210L)
+    res(0).orgids(1) should equal(123456789L)
+  }
+  test("can update integer, double, and long array values in database") {
+    transaction {
+      schema.drop
+      schema.create
+      swimmers.insert(new Swimmer(1, Array(10.55, 12.99, 15.32), Array(100, 110, 20), Array(9876543210L, 123456789L)))
+    }
+
+    val query = from(swimmers)((s) => select(s))
+    val res = transaction { query.toList }
+
+    res.size should equal(1)
+    res(0).lap_times.size should equal(3)
+    res(0).scores.size should equal(3)
+    res(0).orgids.size should equal(2)
+
+    transaction {
+      update(swimmers)(s =>
+        where(s.id === 1)
+          set (s.lap_times := Array(11.69), s.scores := Array(1, 2, 3, 4, 5), s.orgids := Array(13L)))
+    }
+
+    val query2 = from(swimmers)((s) => select(s))
+    val res2 = transaction { query.toList }
+
+    res2.size should equal(1)
+    res2(0).lap_times.size should equal(1)
+    res2(0).scores.size should equal(5)
+    res2(0).orgids.size should equal(1)
+
+    res2(0).lap_times(0) should equal(11.69)
+    res2(0).scores(2) should equal(3)
+    res2(0).orgids(0) should equal(13L)
+  }
+}
+
+import _root_.org.squeryl.Schema
+import _root_.org.squeryl.PrimitiveTypeMode._
+
+object PrimitiveArraySchema extends Schema {
+
+  val swimmers = table[Swimmer]("swimmer")
+
+  override def drop = super.drop
+}
+
+class Swimmer(val id: Int, val lap_times: Array[Double], val scores: Array[Int], val orgids: Array[Long])