support encoding empty arrays, fixes #80

Author: tanner0101

Sources/PostgreSQL/Codable/PostgreSQLQueryEncoder.swift

@@ -26,7 +26,23 @@ public struct PostgreSQLDataEncoder {
             if let data = encoder.data {
                 return data
             } else {
-                let type = encoder.array.first?.type ?? .null
+                let type: PostgreSQLDataFormat
+                if let present = encoder.array.first?.type {
+                    type = present
+                } else if
+                    let array = Swift.type(of: encodable) as? AnyArray.Type,
+                    let psql = array.anyElementType as? PostgreSQLDataTypeStaticRepresentable.Type
+                {
+                    if let format = psql.postgreSQLDataType.dataFormat {
+                        type = format
+                    } else {
+                        WARNING("Could not determine PostgreSQL array data type: \(psql.postgreSQLDataType)")
+                        type = .null
+                    }
+                } else {
+                    WARNING("Could not determine PostgreSQL array data type: \(Swift.type(of: encodable))")
+                    type = .null
+                }
                 // encode array
                 var data = Data()
                 data += Data.of(Int32(1).bigEndian) // non-null
@@ -179,3 +195,13 @@ public struct PostgreSQLDataEncoder {
         }
     }
 }
+
+protocol AnyArray {
+    static var anyElementType: Any.Type { get }
+}
+
+extension Array: AnyArray {
+    static var anyElementType: Any.Type {
+        return Element.self
+    }
+}

Sources/PostgreSQL/Codable/PostgreSQLValueEncoder.swift

@@ -127,6 +127,30 @@ extension PostgreSQLDataFormat {
         case .float8: return ._float8
         case .uuid: return ._uuid
         case .jsonb: return ._jsonb
+        case .text: return ._text
+        default: return nil
+        }
+    }
+}
+
+extension PostgreSQLDataType {
+    internal var dataFormat: PostgreSQLDataFormat? {
+        switch primitive {
+        case .bigint, .bigserial: return .int8
+        case .bit, .char: return .char
+        case .boolean: return .bool
+        case .bytea: return .bytea
+        case .date: return .date
+        case .doublePrecision: return .float8
+        case .integer, .serial: return .int4
+        case .json: return .json
+        case .jsonb: return .jsonb
+        case .numeric: return .numeric
+        case .smallint, .smallserial: return .int2
+        case .text: return .text
+        case .time: return .time
+        case .timestamptz: return .timestamptz
+        case .uuid: return .uuid
         default: return nil
         }
     }

Sources/PostgreSQL/Column/PostgreSQLDataTypeCode.swift

@@ -88,6 +88,15 @@ extension PostgreSQLData: CustomStringConvertible {
             case .int4: override = data.as(Int32.self, default: 0).bigEndian.description
             case .int2: override = data.as(Int16.self, default: 0).bigEndian.description
             case .uuid: override = UUID.init(uuid: data.as(uuid_t.self, default: (0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0))).description
+            case ._text:
+                let strings = try? PostgreSQLDataDecoder().decode([String].self, from: self)
+                override = strings?.description
+            case ._int4:
+                let ints = try? PostgreSQLDataDecoder().decode([Int32].self, from: self)
+                override = ints?.description
+            case ._int8:
+                let ints = try? PostgreSQLDataDecoder().decode([Int64].self, from: self)
+                override = ints?.description
             default: break
             }
 

Sources/PostgreSQL/Data/PostgreSQLData.swift

@@ -338,15 +338,15 @@ public struct PostgreSQLDataType: SQLDataType, Equatable {
         return .init(dataType.primitive, isArray: true)
     }
 
-    private let primitive: Primitive
-    private let isArray: Bool
+    let primitive: Primitive
+    let isArray: Bool
 
     private init(_ primitive: Primitive, isArray: Bool = false) {
         self.primitive = primitive
         self.isArray = isArray
     }
 
-    private enum Primitive {
+    enum Primitive {
         /// signed eight-byte integer
         case bigint
 

Sources/PostgreSQL/SQL/PostgreSQLQuery+DataType.swift

@@ -1,4 +1,4 @@
-public struct PostgreSQLUpsert {
+public struct PostgreSQLUpsert: SQLSerializable {
     /// See `SQLUpsert`.
     public typealias Identifier = PostgreSQLIdentifier
 

Sources/PostgreSQL/SQL/PostgreSQLUpsert.swift

@@ -491,6 +491,32 @@ class PostgreSQLConnectionTests: XCTestCase {
         default: XCTFail("invalid row count")
         }
     }
+    
+    // https://github.com/vapor/postgresql/issues/80
+    func testEmptyArray() throws {
+        do {
+            var messages: [String] = []
+            let a = try PostgreSQLDataEncoder().encode(messages)
+            print(a)
+            messages.append("hello")
+            let b = try PostgreSQLDataEncoder().encode(messages)
+            print(b)
+            messages.append("world")
+            let c = try PostgreSQLDataEncoder().encode(messages)
+            print(c)
+        }
+        do {
+            var messages: [Int] = []
+            let a = try PostgreSQLDataEncoder().encode(messages)
+            print(a)
+            messages.append(42)
+            let b = try PostgreSQLDataEncoder().encode(messages)
+            print(b)
+            messages.append(1337)
+            let c = try PostgreSQLDataEncoder().encode(messages)
+            print(c)
+        }
+    }
 
     static var allTests = [
         ("testBenchmark", testBenchmark),
@@ -511,6 +537,7 @@ class PostgreSQLConnectionTests: XCTestCase {
         ("testSum", testSum),
         ("testOrderBy", testOrderBy),
         ("testInvalidDate", testInvalidDate),
+        ("testEmptyArray", testEmptyArray),
     ]
 }