Merge pull request #191 from AkosLukacs/postgres_bytea

Problem with PostgreSQL byte[] serialization/deserialization

Author: tomaszkubacki

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

@@ -4,11 +4,19 @@
 namespace ServiceStack.OrmLite.PostgreSQL.Tests
 {
     public class TypeWithByteArrayFieldTests : OrmLiteTestBase
-    {
+    {
+        TypeWithByteArrayField getSampleObject()
+        {
+            var testByteArray = new byte[256];
+            for(int i = 0; i < 256; i++) { testByteArray[i] = (byte)i; }
+            
+            return new TypeWithByteArrayField { Id = 1, Content = testByteArray };
+        }
+
         [Test]
         public void CanInsertAndSelectByteArray()
         {
-            var orig = new TypeWithByteArrayField { Id = 1, Content = new byte[] { 0, 17, 0, 17, 0, 7 } };
+            var orig = getSampleObject();
 
             using (var db = ConnectionString.OpenDbConnection())
             {
@@ -21,6 +29,116 @@ public void CanInsertAndSelectByteArray()
                 Assert.AreEqual(orig.Id, target.Id);
                 Assert.AreEqual(orig.Content, target.Content);
             }
+        }
+
+        [Test]
+        public void CanInsertAndSelectByteArray__manual_insert__manual_select()
+        {
+            var orig = getSampleObject();
+
+            using(var db = ConnectionString.OpenDbConnection()) {
+                //insert and select manually - ok
+                db.CreateTable<TypeWithByteArrayField>(true);
+                _insertManually(orig, db);
+
+                _selectAndVerifyManually(orig, db);
+            }
+        }
+
+        [Test]
+        public void CanInsertAndSelectByteArray__InsertParam_insert__manual_select()
+        {
+            var orig = getSampleObject();
+
+            using(var db = ConnectionString.OpenDbConnection()) {
+                //insert using InsertParam, and select manually - ok
+                db.CreateTable<TypeWithByteArrayField>(true);
+                db.InsertParam(orig);
+
+                _selectAndVerifyManually(orig, db);
+            }
+        }
+
+        [Test]
+        public void CanInsertAndSelectByteArray__InsertParam_insert__GetById_select()
+        {
+            var orig = getSampleObject();
+
+            using(var db = ConnectionString.OpenDbConnection()) {
+                //InsertParam + GetByID - fails
+                db.CreateTable<TypeWithByteArrayField>(true);
+                db.InsertParam(orig);
+
+                var target = db.GetById<TypeWithByteArrayField>(orig.Id);
+
+                Assert.AreEqual(orig.Id, target.Id);
+                Assert.AreEqual(orig.Content, target.Content);
+            }
+        }
+
+        [Test]
+        public void CanInsertAndSelectByteArray__Insert_insert__GetById_select()
+        {
+            var orig = getSampleObject();
+
+            using(var db = ConnectionString.OpenDbConnection()) {
+                //InsertParam + GetByID - fails
+                db.CreateTable<TypeWithByteArrayField>(true);
+                db.Insert(orig);
+
+                var target = db.GetById<TypeWithByteArrayField>(orig.Id);
+
+                Assert.AreEqual(orig.Id, target.Id);
+                Assert.AreEqual(orig.Content, target.Content);
+            }
+        }
+
+        [Test]
+        public void CanInsertAndSelectByteArray__Insert_insert__manual_select()
+        {
+            var orig = getSampleObject();
+
+            using(var db = ConnectionString.OpenDbConnection()) {
+                //InsertParam + GetByID - fails
+                db.CreateTable<TypeWithByteArrayField>(true);
+                db.Insert(orig);
+
+                _selectAndVerifyManually(orig, db);
+            }
+        }
+
+        private static void _selectAndVerifyManually(TypeWithByteArrayField orig, System.Data.IDbConnection db)
+        {
+            using(var cmd = db.CreateCommand()) {
+                cmd.CommandText = @"select ""Content"" from ""TypeWithByteArrayField"" where ""Id"" = 1 --manual select";
+                using(var reader = cmd.ExecuteReader()) {
+                    reader.Read();
+                    var ba = reader["Content"] as byte[];
+                    Assert.AreEqual(orig.Content.Length, ba.Length);
+                    Assert.AreEqual(orig.Content, ba);
+                }
+            }
+        }
+
+        private static void _insertManually(TypeWithByteArrayField orig, System.Data.IDbConnection db)
+        {
+            using(var cmd = db.CreateCommand()) {
+                cmd.CommandText = @"INSERT INTO ""TypeWithByteArrayField"" (""Id"",""Content"") VALUES (@Id, @Content) --manual parameterized insert";
+
+                var p_id = cmd.CreateParameter();
+                p_id.ParameterName = "@Id";
+                p_id.Value = orig.Id;
+
+                cmd.Parameters.Add(p_id);
+
+                var p_content = cmd.CreateParameter();
+                p_content.ParameterName = "@Content";
+                p_content.Value = orig.Content;
+
+                cmd.Parameters.Add(p_content);
+
+                cmd.ExecuteNonQuery();
+            }
         }
     }
 

src/ServiceStack.OrmLite.PostgreSQL/PostgreSQLDialectProvider.cs

@@ -120,14 +120,20 @@ public override string GetQuotedValue(object value, Type fieldType)
 				var guidValue = (Guid)value;
 				return base.GetQuotedValue(guidValue.ToString("N"), typeof(string));
 			}
+			if(fieldType == typeof(byte[]))
+			{
+				return "E'" + ToBinary(value) + "'";
+			}
 
 			return base.GetQuotedValue(value, fieldType);
 		}
 
 		public override object ConvertDbValue(object value, Type type)
 		{
 			if (value == null || value is DBNull) return null;
-		
+			
+			if(type == typeof(byte[])) { return value; }
+
 			return base.ConvertDbValue(value, type);
 		}
 
@@ -194,5 +200,27 @@ public override string GetQuotedTableName(ModelDefinition modelDef)
             string escapedSchema = modelDef.Schema.Replace(".", "\".\"");
             return string.Format("\"{0}\".\"{1}\"", escapedSchema, base.NamingStrategy.GetTableName(modelDef.ModelName));
         }
+
+		/// <summary>
+		/// based on Npgsql2's source: Npgsql2\src\NpgsqlTypes\NpgsqlTypeConverters.cs
+		/// </summary>
+		/// <param name="TypeInfo"></param>
+		/// <param name="NativeData"></param>
+		/// <param name="ForExtendedQuery"></param>
+		/// <returns></returns>
+		internal static String ToBinary(Object NativeData)
+		{
+			Byte[] byteArray = (Byte[])NativeData;
+			StringBuilder res = new StringBuilder(byteArray.Length * 5);
+			foreach(byte b in byteArray)
+				if(b >= 0x20 && b < 0x7F && b != 0x27 && b != 0x5C)
+					res.Append((char)b);
+				else
+					res.Append("\\\\")
+						.Append((char)('0' + (7 & (b >> 6))))
+						.Append((char)('0' + (7 & (b >> 3))))
+						.Append((char)('0' + (7 & b)));
+			return res.ToString();
+		}
 	}
 }