Add support for remaining pgsql array types

Author: mythz

src/ServiceStack.OrmLite.PostgreSQL.Tests/PostgreSqlJsonTests.cs

@@ -35,17 +35,69 @@ public class PgsqlData
         [PrimaryKey]
         public Guid Id { get; set; }
 
-        [PgSqlIntArray]
         public int[] Ints { get; set; }
+        public long[] Longs { get; set; }
+        public float[] Floats { get; set; }
+        public double[] Doubles { get; set; }
+        public decimal[] Decimals { get; set; }
+        public string[] Strings { get; set; }
+        public DateTime[] DateTimes { get; set; }
+        public DateTimeOffset[] DateTimeOffsets { get; set; }
+        
+        public List<int> ListInts { get; set; }
+        public List<long> ListLongs { get; set; }
+        public List<float> ListFloats { get; set; }
+        public List<double> ListDoubles { get; set; }
+        public List<decimal> ListDecimals { get; set; }
+        public List<string> ListStrings { get; set; }
+        public List<DateTime> ListDateTimes { get; set; }
+        public List<DateTimeOffset> ListDateTimeOffsets { get; set; }
+    }
 
+    public class PgsqlDataAnnotated
+    {
+        [PrimaryKey]
+        public Guid Id { get; set; }
+
+        [PgSqlIntArray]
+        public int[] Ints { get; set; }
+        [PgSqlBigIntArray]
+        public long[] Longs { get; set; }
+        [PgSqlFloatArray]
+        public float[] Floats { get; set; }
+        [PgSqlDoubleArray]
+        public double[] Doubles { get; set; }
+        [PgSqlDecimalArray]
+        public decimal[] Decimals { get; set; }
         [PgSqlTextArray]
         public string[] Strings { get; set; }
 
+//        [PgSqlTimestamp]
+        [CustomField("timestamp[]")]
+        public DateTime[] DateTimes { get; set; }
+        
+//        [PgSqlTimestampTz]
+        [CustomField("timestamp with time zone[]")]
+        public DateTimeOffset[] DateTimeOffsets { get; set; }
+
         [PgSqlIntArray]
         public List<int> ListInts { get; set; }
-
+        [PgSqlBigIntArray]
+        public List<long> ListLongs { get; set; }
+        [PgSqlFloatArray]
+        public List<float> ListFloats { get; set; }
+        [PgSqlDoubleArray]
+        public List<double> ListDoubles { get; set; }
+        [PgSqlDecimalArray]
+        public List<decimal> ListDecimals { get; set; }
         [PgSqlTextArray]
         public List<string> ListStrings { get; set; }
+//        [PgSqlTimestamp]
+        [CustomField("timestamp[]")]
+        public List<DateTime> ListDateTimes { get; set; }
+//        [PgSqlTimestampTz]
+        [CustomField("timestamp with time zone[]")]
+        public List<DateTimeOffset> ListDateTimeOffsets { get; set; }
     }
 
     [TestFixture]
@@ -98,27 +150,114 @@ public void Can_save_complex_types_as_JSON()
         [Test]
         public void Does_save_PgSqlData()
         {
+            OrmLiteUtils.PrintSql();
+            
             using (var db = OpenDbConnection())
             {
                 db.DropAndCreateTable<PgsqlData>();
+                long UnixEpoch = 621355968000000000L;
+                var dateTimes = new DateTime[] {
+                    new DateTime(UnixEpoch, DateTimeKind.Utc),
+                    new DateTime(2001, 01, 01, 1, 1, 1, 1, DateTimeKind.Utc),
+                };
+                var dateTimeOffsets = dateTimes.Select(x => new DateTimeOffset(x, TimeSpan.Zero)).ToArray();
 
                 var data = new PgsqlData
                 {
                     Id = Guid.NewGuid(),
                     Ints = new[] { 2, 4, 1 },
-                    ListInts = new[] { 2, 4, 1 }.ToList(),
+                    Longs = new long[] { 2, 4, 1 },
+                    Floats = new float[] { 2, 4, 1 },
+                    Doubles = new double[] { 2, 4, 1 },
                     Strings = new[] { "test string 1", "test string 2" },
+                    Decimals = new decimal[] { 2, 4, 1 },
+                    DateTimes = dateTimes,
+                    DateTimeOffsets = dateTimeOffsets,
+                    
+                    ListInts = new[] { 2, 4, 1 }.ToList(),
+                    ListLongs = new long[] { 2, 4, 1 }.ToList(),
+                    ListFloats = new float[] { 2, 4, 1 }.ToList(),
+                    ListDoubles = new double[] { 2, 4, 1 }.ToList(),
                     ListStrings = new[] { "test string 1", "test string 2" }.ToList(),
+                    ListDecimals = new decimal[] { 2, 4, 1 }.ToList(),
+                    ListDateTimes = dateTimes.ToList(),
+                    ListDateTimeOffsets = dateTimeOffsets.ToList(),
                 };
 
                 db.Save(data);
 
                 var row = db.Select<PgsqlData>()[0];
                 Assert.That(row.Ints.EquivalentTo(data.Ints));
+                Assert.That(row.Longs.EquivalentTo(data.Longs));
+                Assert.That(row.Floats.EquivalentTo(data.Floats));
+                Assert.That(row.Doubles.EquivalentTo(data.Doubles));
+                Assert.That(row.Decimals.EquivalentTo(data.Decimals));
+                Assert.That(row.ListInts.EquivalentTo(data.ListInts));
+                Assert.That(row.ListLongs.EquivalentTo(data.ListLongs));
+                Assert.That(row.ListFloats.EquivalentTo(data.ListFloats));
+                Assert.That(row.ListDoubles.EquivalentTo(data.ListDoubles));
+                Assert.That(row.ListDecimals.EquivalentTo(data.ListDecimals));
+                Assert.That(row.Strings.EquivalentTo(data.Strings));
+                Assert.That(row.ListStrings.EquivalentTo(data.ListStrings));
+            }
+
+            OrmLiteUtils.UnPrintSql();
+        }
+        [Test]
+        public void Does_save_PgSqlDataAnnotated()
+        {
+            OrmLiteUtils.PrintSql();
+            
+            using (var db = OpenDbConnection())
+            {
+                db.DropAndCreateTable<PgsqlDataAnnotated>();
+                long UnixEpoch = 621355968000000000L;
+                var dateTimes = new DateTime[] {
+                    new DateTime(UnixEpoch, DateTimeKind.Utc),
+                    new DateTime(2001, 01, 01, 1, 1, 1, 1, DateTimeKind.Utc),
+                };
+                var dateTimeOffsets = dateTimes.Select(x => new DateTimeOffset(x, TimeSpan.Zero)).ToArray();
+
+                var data = new PgsqlDataAnnotated
+                {
+                    Id = Guid.NewGuid(),
+                    Ints = new[] { 2, 4, 1 },
+                    Longs = new long[] { 2, 4, 1 },
+                    Floats = new float[] { 2, 4, 1 },
+                    Doubles = new double[] { 2, 4, 1 },
+                    Strings = new[] { "test string 1", "test string 2" },
+                    Decimals = new decimal[] { 2, 4, 1 },
+                    DateTimes = dateTimes,
+                    DateTimeOffsets = dateTimeOffsets,
+                    
+                    ListInts = new[] { 2, 4, 1 }.ToList(),
+                    ListLongs = new long[] { 2, 4, 1 }.ToList(),
+                    ListFloats = new float[] { 2, 4, 1 }.ToList(),
+                    ListDoubles = new double[] { 2, 4, 1 }.ToList(),
+                    ListStrings = new[] { "test string 1", "test string 2" }.ToList(),
+                    ListDecimals = new decimal[] { 2, 4, 1 }.ToList(),
+                    ListDateTimes = dateTimes.ToList(),
+                    ListDateTimeOffsets = dateTimeOffsets.ToList(),
+                };
+
+                db.Save(data);
+
+                var row = db.Select<PgsqlDataAnnotated>()[0];
+                Assert.That(row.Ints.EquivalentTo(data.Ints));
+                Assert.That(row.Longs.EquivalentTo(data.Longs));
+                Assert.That(row.Floats.EquivalentTo(data.Floats));
+                Assert.That(row.Doubles.EquivalentTo(data.Doubles));
+                Assert.That(row.Decimals.EquivalentTo(data.Decimals));
                 Assert.That(row.ListInts.EquivalentTo(data.ListInts));
+                Assert.That(row.ListLongs.EquivalentTo(data.ListLongs));
+                Assert.That(row.ListFloats.EquivalentTo(data.ListFloats));
+                Assert.That(row.ListDoubles.EquivalentTo(data.ListDoubles));
+                Assert.That(row.ListDecimals.EquivalentTo(data.ListDecimals));
                 Assert.That(row.Strings.EquivalentTo(data.Strings));
                 Assert.That(row.ListStrings.EquivalentTo(data.ListStrings));
             }
+
+            OrmLiteUtils.UnPrintSql();
         }
     }
 }

src/ServiceStack.OrmLite.PostgreSQL/Converters/PostgreSqlArrayConverters.cs

@@ -43,37 +43,56 @@ public override object ToDbValue(Type fieldType, object value)
 
         public override object FromDbValue(Type fieldType, object value)
         {
-            var strVal = value as string;
-            return strVal != null
+            return value is string strVal
                 ? strVal.FromJson<string[]>()
                 : value;
         }
     }
 
-    public class PostgreSqlIntArrayConverter : NativeValueOrmLiteConverter
+    public abstract class PostgreSqlArrayConverterBase<T> : NativeValueOrmLiteConverter
     {
-        public override string ColumnDefinition => "integer[]";
-
         public override DbType DbType => DbType.Object;
 
         public override string ToQuotedString(Type fieldType, object value)
         {
-            var integerArray = (int[])value;
+            var integerArray = (T[])value;
             return this.ToArray(integerArray);
         }
     }
 
-    public class PostgreSqlLongArrayConverter : NativeValueOrmLiteConverter
+    public class PostgreSqlIntArrayConverter : PostgreSqlArrayConverterBase<int>
+    {
+        public override string ColumnDefinition => "integer[]";
+    }
+
+    public class PostgreSqlLongArrayConverter : PostgreSqlArrayConverterBase<long>
     {
         public override string ColumnDefinition => "bigint[]";
+    }
 
-        public override DbType DbType => DbType.Object;
+    public class PostgreSqlFloatArrayConverter : PostgreSqlArrayConverterBase<float>
+    {
+        public override string ColumnDefinition => "real[]";
+    }
 
-        public override string ToQuotedString(Type fieldType, object value)
-        {
-            var longArray = (long[])value;
-            return this.ToArray(longArray);
-        }
+    public class PostgreSqlDoubleArrayConverter : PostgreSqlArrayConverterBase<double>
+    {
+        public override string ColumnDefinition => "double precision[]";
+    }
+
+    public class PostgreSqlDecimalArrayConverter : PostgreSqlArrayConverterBase<decimal>
+    {
+        public override string ColumnDefinition => "numeric[]";
+    }
+
+    public class PostgreSqlDateTimeTimeStampArrayConverter : PostgreSqlArrayConverterBase<DateTime>
+    {
+        public override string ColumnDefinition => "timestamp[]";
+    }
+
+    public class PostgreSqlDateTimeOffsetTimeStampTzArrayConverter : PostgreSqlArrayConverterBase<DateTimeOffset>
+    {
+        public override string ColumnDefinition => "timestamp with time zone[]";
     }
 
 

src/ServiceStack.OrmLite.PostgreSQL/Converters/PostgreSqlDateTimeConverter.cs

@@ -4,9 +4,6 @@ namespace ServiceStack.OrmLite.PostgreSQL.Converters
 {
     public class PostgreSqlDateTimeConverter : DateTimeConverter
     {
-        public override string ColumnDefinition
-        {
-            get { return "timestamp"; }
-        }
+        public override string ColumnDefinition => "timestamp";
     }
 }

src/ServiceStack.OrmLite.PostgreSQL/PostgreSQLDialectProvider.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Data;
 using System.Linq;
@@ -61,6 +62,11 @@ public PostgreSqlDialectProvider()
             RegisterConverter<string[]>(new PostgreSqlStringArrayConverter());
             RegisterConverter<int[]>(new PostgreSqlIntArrayConverter());
             RegisterConverter<long[]>(new PostgreSqlLongArrayConverter());
+            RegisterConverter<float[]>(new PostgreSqlFloatArrayConverter());
+            RegisterConverter<double[]>(new PostgreSqlDoubleArrayConverter());
+            RegisterConverter<decimal[]>(new PostgreSqlDecimalArrayConverter());
+            RegisterConverter<DateTime[]>(new PostgreSqlDateTimeTimeStampArrayConverter());
+            RegisterConverter<DateTimeOffset[]>(new PostgreSqlDateTimeOffsetTimeStampTzArrayConverter());
 
             this.Variables = new Dictionary<string, string>
             {
@@ -511,56 +517,44 @@ public override string GetLastInsertIdSqlSuffix<T>()
             return "; " + SelectIdentitySql;
         }
 
+        public static Dictionary<string, NpgsqlDbType> NativeTypes = new Dictionary<string, NpgsqlDbType> {
+            { "json", NpgsqlDbType.Json },
+            { "jsonb", NpgsqlDbType.Jsonb },
+            { "hstore", NpgsqlDbType.Hstore },
+            { "text[]", NpgsqlDbType.Array | NpgsqlDbType.Text },
+            { "integer[]", NpgsqlDbType.Array | NpgsqlDbType.Integer },
+            { "bigint[]", NpgsqlDbType.Array | NpgsqlDbType.Bigint },
+            { "real[]", NpgsqlDbType.Array | NpgsqlDbType.Real },
+            { "double precision[]", NpgsqlDbType.Array | NpgsqlDbType.Double },
+            { "numeric[]", NpgsqlDbType.Array | NpgsqlDbType.Numeric },
+            { "timestamp[]", NpgsqlDbType.Array | NpgsqlDbType.Timestamp },
+            { "timestamp with time zone[]", NpgsqlDbType.Array | NpgsqlDbType.TimestampTz },
+        };
+        
         public override void SetParameter(FieldDefinition fieldDef, IDbDataParameter p)
         {
-            if (fieldDef.CustomFieldDefinition == "json")
+            if (fieldDef.CustomFieldDefinition != null &&
+                NativeTypes.TryGetValue(fieldDef.CustomFieldDefinition, out var npgsqlDbType))
             {
                 p.ParameterName = this.GetParam(SanitizeFieldNameForParamName(fieldDef.FieldName));
-                ((NpgsqlParameter) p).NpgsqlDbType = NpgsqlDbType.Json;
-                return;
+                ((NpgsqlParameter) p).NpgsqlDbType = npgsqlDbType;
             }
-            if (fieldDef.CustomFieldDefinition == "jsonb")
-            {
-                p.ParameterName = this.GetParam(SanitizeFieldNameForParamName(fieldDef.FieldName));
-                ((NpgsqlParameter)p).NpgsqlDbType = NpgsqlDbType.Jsonb;
-                return;
-            }
-            if (fieldDef.CustomFieldDefinition == "hstore")
-            {
-                p.ParameterName = this.GetParam(SanitizeFieldNameForParamName(fieldDef.FieldName));
-                ((NpgsqlParameter)p).NpgsqlDbType = NpgsqlDbType.Hstore;
-                return;
-            }
-            if (fieldDef.CustomFieldDefinition == "text[]")
-            {
-                p.ParameterName = this.GetParam(SanitizeFieldNameForParamName(fieldDef.FieldName));
-                ((NpgsqlParameter)p).NpgsqlDbType = NpgsqlDbType.Array | NpgsqlDbType.Text;
-                return;
-            }
-            if (fieldDef.CustomFieldDefinition == "integer[]")
-            {
-                p.ParameterName = this.GetParam(SanitizeFieldNameForParamName(fieldDef.FieldName));
-                ((NpgsqlParameter) p).NpgsqlDbType = NpgsqlDbType.Array | NpgsqlDbType.Integer;
-                return;
-            }
-            if (fieldDef.CustomFieldDefinition == "bigint[]")
+            else
             {
-                p.ParameterName = this.GetParam(SanitizeFieldNameForParamName(fieldDef.FieldName));
-                ((NpgsqlParameter) p).NpgsqlDbType = NpgsqlDbType.Array | NpgsqlDbType.Bigint;
-                return;
+                base.SetParameter(fieldDef, p);
             }
-            base.SetParameter(fieldDef, p);
         }
 
+        public virtual bool UseRawValue(string columnDef) => columnDef?.EndsWith("[]") == true;
+
         protected override object GetValue<T>(FieldDefinition fieldDef, object obj)
         {
-            switch (fieldDef.CustomFieldDefinition)
+            if (fieldDef.CustomFieldDefinition != null && NativeTypes.ContainsKey(fieldDef.CustomFieldDefinition)
+                && UseRawValue(fieldDef.CustomFieldDefinition))
             {
-                case "text[]":
-                case "integer[]":
-                case "bigint[]":
-                    return fieldDef.GetValue(obj);
+                return fieldDef.GetValue(obj);
             }
+
             return base.GetValue<T>(fieldDef, obj);
         }