Refactored code, and added support for long and double arrays (with tests)

Author: Tony Kay

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

@@ -36,12 +36,16 @@ class PostgreSqlAdapter extends DatabaseAdapter {
   override def booleanTypeDeclaration = "boolean"
   override def doubleTypeDeclaration = "double precision"
   override def longTypeDeclaration = "bigint"
-  override def arrayIntTypeDeclaration = "integer[]"
   override def bigDecimalTypeDeclaration = "numeric"
   override def bigDecimalTypeDeclaration(precision:Int, scale:Int) = "numeric(" + precision + "," + scale + ")"
   override def binaryTypeDeclaration = "bytea"
   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

@@ -65,11 +65,15 @@ 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

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

@@ -17,10 +17,11 @@ abstract class ArrayTEF[P, TE] extends TypedExpressionFactory[Array[P], TE] with
     val s = Session.currentSession
     val con = s.connection
     var rv: java.sql.Array = null
-    try {
-      rv = con.createArrayOf(s.databaseAdapter.arrayCreationType(sample(0).getClass), content)
+    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());
+      case e: Exception => s.log("Cannot create JDBC array: " + e.getMessage)
     }
     rv
   }

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

@@ -177,24 +177,26 @@ trait DatabaseAdapter {
   def longTypeDeclaration = "bigint"
   def floatTypeDeclaration = "real"
   def bigDecimalTypeDeclaration = "decimal"
-  def arrayIntTypeDeclaration = "int array"
   def bigDecimalTypeDeclaration(precision:Int, scale:Int) = "decimal(" + precision + "," + scale + ")"
   def timestampTypeDeclaration = "timestamp"
   def binaryTypeDeclaration = "binary"
   def uuidTypeDeclaration = "char(36)"
-    
-  // These are needed by the jdbc connection when creating arrays
-  def intArrayCreationType = "integer"
-  def doubleArrayCreationType = "double"
-  def longArrayCreationType = "bigint"
+  def intArrayTypeDeclaration = intTypeDeclaration + "[]"
+  def longArrayTypeDeclaration = longTypeDeclaration + "[]"
+  def doubleArrayTypeDeclaration = doubleTypeDeclaration + "[]"
+    
+  def jdbcIntArrayCreationType = intTypeDeclaration
+  def jdbcLongArrayCreationType = longTypeDeclaration
+  def jdbcDoubleArrayCreationType = doubleTypeDeclaration
 
   final def arrayCreationType(ptype : Class[_]) : String = {
-    ptype.getName() match {
-      case "java.lang.Integer" => intArrayCreationType
-      case "java.lang.Double" => doubleArrayCreationType
-      case "java.lang.Long" => longArrayCreationType
-      case _ => throw new SQLException("Unable to create an sql array for " + ptype.getName())
-    }
+    val rv = ptype.getName() match {
+      case "java.lang.Integer" => jdbcIntArrayCreationType
+      case "java.lang.Double" => jdbcDoubleArrayCreationType
+      case "java.lang.Long" => jdbcLongArrayCreationType
+      case _ => ""
+    }
+    rv
   }
 
 /*
@@ -813,10 +815,14 @@ trait DatabaseAdapter {
       else if(classOf[BigDecimal].isAssignableFrom(c))
         bigDecimalTypeDeclaration                  
       else if(classOf[scala.Array[Int]].isAssignableFrom(c))
-        arrayIntTypeDeclaration
+        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

@@ -114,6 +114,19 @@ trait FieldMapper {
       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: Get this to work...
     //val optionIntArrayTEF = new TypedExpressionFactory[Option[Array[Int]],TOptionIntArray] with DeOptionizer[Array[Int], Array[Int], TIntArray, Option[Array[Int]], TOptionIntArray] {
       //val deOptionizer = intArrayTEF
     //}
@@ -235,6 +248,8 @@ trait FieldMapper {
     register(dateTEF)  
     register(uuidTEF)
     register(intArrayTEF)
+    register(longArrayTEF)
+    register(doubleArrayTEF)
 
     val re = enumValueTEF(DummyEnum.DummyEnumerationValue)    
 

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

@@ -14,18 +14,26 @@ abstract class PrimitiveArrayTest extends SchemaTester with RunTestsInsideTransa
     transaction {
       schema.drop
       schema.create
-      swimmers.insert(new Swimmer(1, Array(1055, 1299, 1532)))
+      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))
-    println(query.toString)
     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(1055)
-    res(0).lap_times(1) should equal(1299)
-    res(0).lap_times(2) should equal(1532)
+    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)
   }
 }
 
@@ -39,4 +47,4 @@ object PrimitiveArraySchema extends Schema {
   override def drop = super.drop
 }
 
-class Swimmer(val id: Int, val lap_times: Array[Int])
+class Swimmer(val id: Int, val lap_times: Array[Double], val scores : Array[Int], val orgids : Array[Long])