SNOW-14887010 Structured types read for json result format

Snowflake.Data.Tests/Client/Address.cs

@@ -0,0 +1,20 @@
+namespace Snowflake.Data.Tests.Client
+{
+    public class Address
+    {
+        public string city { get; set; }
+        public string state { get; set; }
+        public Zip zip { get; set; }
+
+        public Address()
+        {
+        }
+
+        public Address(string city, string state, Zip zip)
+        {
+            this.city = city;
+            this.state = state;
+            this.zip = zip;
+        }
+    }
+}

Snowflake.Data.Tests/Client/AllNullableTypesClass.cs

@@ -0,0 +1,28 @@
+using System;
+
+namespace Snowflake.Data.Tests.Client
+{
+    public class AllNullableTypesClass
+    {
+        public string StringValue { get; set; }
+        public char? CharValue { get; set; }
+        public byte? ByteValue { get; set; }
+        public sbyte? SByteValue { get; set; }
+        public short? ShortValue { get; set; }
+        public ushort? UShortValue { get; set; }
+        public int? IntValue { get; set; }
+        public int? UIntValue { get; set; }
+        public long? LongValue { get; set; }
+        public long? ULongValue { get; set; }
+        public float? FloatValue { get; set; }
+        public double? DoubleValue { get; set; }
+        public decimal? DecimalValue { get; set; }
+        public bool? BooleanValue { get; set; }
+        public Guid? GuidValue { get; set; }
+        public DateTime? DateTimeValue { get; set; }
+        public DateTimeOffset? DateTimeOffsetValue { get; set; }
+        public TimeSpan? TimeSpanValue { get; set; }
+        public byte[] BinaryValue { get; set; }
+        public string SemiStructuredValue { get; set; }
+    }
+}

Snowflake.Data.Tests/Client/AllTypesClass.cs

@@ -0,0 +1,28 @@
+using System;
+
+namespace Snowflake.Data.Tests.Client
+{
+    public class AllTypesClass
+    {
+        public string StringValue { get; set; }
+        public char CharValue { get; set; }
+        public byte ByteValue { get; set; }
+        public sbyte SByteValue { get; set; }
+        public short ShortValue { get; set; }
+        public ushort UShortValue { get; set; }
+        public int IntValue { get; set; }
+        public int UIntValue { get; set; }
+        public long LongValue { get; set; }
+        public long ULongValue { get; set; }
+        public float FloatValue { get; set; }
+        public double DoubleValue { get; set; }
+        public decimal DecimalValue { get; set; }
+        public bool BooleanValue { get; set; }
+        public Guid GuidValue { get; set; }
+        public DateTime DateTimeValue { get; set; }
+        public DateTimeOffset DateTimeOffsetValue { get; set; }
+        public TimeSpan TimeSpanValue { get; set; }
+        public byte[] BinaryValue { get; set; }
+        public string SemiStructuredValue { get; set; }
+    }
+}

Snowflake.Data.Tests/Client/AnnotatedClassForConstructorConstruction.cs

@@ -0,0 +1,22 @@
+using Snowflake.Data.Client;
+
+namespace Snowflake.Data.Tests.Client
+{
+    [SnowflakeObject(ConstructionMethod = SnowflakeObjectConstructionMethod.CONSTRUCTOR)]
+    public class AnnotatedClassForConstructorConstruction
+    {
+        public string StringValue { get; set; }
+        public int? IgnoredValue { get; set; }
+        public int IntegerValue { get; set; }
+
+        public AnnotatedClassForConstructorConstruction()
+        {
+        }
+
+        public AnnotatedClassForConstructorConstruction(string stringValue, int integerValue)
+        {
+            StringValue = stringValue;
+            IntegerValue = integerValue;
+        }
+    }
+}

Snowflake.Data.Tests/Client/AnnotatedClassForPropertiesNamesConstruction.cs

@@ -0,0 +1,13 @@
+using Snowflake.Data.Client;
+
+namespace Snowflake.Data.Tests.Client
+{
+    [SnowflakeObject(ConstructionMethod = SnowflakeObjectConstructionMethod.PROPERTIES_NAMES)]
+    public class AnnotatedClassForPropertiesNamesConstruction
+    {
+        [SnowflakeColumn(Name = "x")]
+        public string StringValue { get; set; }
+        public int? IgnoredValue { get; set; }
+        public int IntegerValue { get; set; }
+    }
+}

Snowflake.Data.Tests/Client/AnnotatedClassForPropertiesOrderConstruction.cs

@@ -0,0 +1,13 @@
+using Snowflake.Data.Client;
+
+namespace Snowflake.Data.Tests.Client
+{
+    [SnowflakeObject(ConstructionMethod = SnowflakeObjectConstructionMethod.PROPERTIES_ORDER)]
+    public class AnnotatedClassForPropertiesOrderConstruction
+    {
+        public string StringValue { get; set; }
+        [SnowflakeColumn(IgnoreForPropertyOrder = true)]
+        public int? IgnoredValue { get; set; }
+        public int IntegerValue { get; set; }
+    }
+}

Snowflake.Data.Tests/Client/DateTimeOffsetWrapper.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace Snowflake.Data.Tests.Client
+{
+    public class DateTimeOffsetWrapper
+    {
+        public DateTimeOffset Value { get; set; }
+    }
+}

Snowflake.Data.Tests/Client/DateTimeWrapper.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace Snowflake.Data.Tests.Client
+{
+    public class DateTimeWrapper
+    {
+        public DateTime Value { get; set; }
+    }
+}

Snowflake.Data.Tests/Client/Grades.cs

@@ -0,0 +1,46 @@
+using System.Collections.Generic;
+
+namespace Snowflake.Data.Tests.Client
+{
+    public class Grades
+    {
+        public string[] Names { get; set; }
+
+        public Grades()
+        {
+        }
+
+        public Grades(string[] names)
+        {
+            Names = names;
+        }
+    }
+
+    public class GradesWithList
+    {
+        public List<string> Names { get; set; }
+
+        public GradesWithList()
+        {
+        }
+
+        public GradesWithList(List<string> names)
+        {
+            Names = names;
+        }
+    }
+
+    public class GradesWithMap
+    {
+        public Dictionary<string, string> Names { get; set; }
+
+        public GradesWithMap()
+        {
+        }
+
+        public GradesWithMap(Dictionary<string, string> names)
+        {
+            Names = names;
+        }
+    }
+}

Snowflake.Data.Tests/Client/Identity.cs

@@ -0,0 +1,34 @@
+namespace Snowflake.Data.Tests.Client
+{
+    public class Identity
+    {
+        public string Name { get; set; }
+
+        public Identity()
+        {
+        }
+
+        public Identity(string name)
+        {
+            Name = name;
+        }
+
+        protected bool Equals(Identity other)
+        {
+            return Name == other.Name;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((Identity)obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return (Name != null ? Name.GetHashCode() : 0);
+        }
+    }
+}

Snowflake.Data.Tests/Client/ObjectArrayMapWrapper.cs

@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+
+namespace Snowflake.Data.Tests.Client
+{
+    public class ObjectArrayMapWrapper
+    {
+        public Identity ObjectValue { get; set; }
+        public List<string> ListValue { get; set; }
+        public string[] ArrayValue { get; set; }
+        public IList<string> IListValue { get; set; }
+        public Dictionary<int, int> MapValue { get; set; }
+        public IDictionary<int, int> IMapValue { get; set; }
+    }
+}

Snowflake.Data.Tests/Client/StringWrapper.cs

@@ -0,0 +1,7 @@
+namespace Snowflake.Data.Tests.Client
+{
+    public class StringWrapper
+    {
+        public string Value { get; set; }
+    }
+}

Snowflake.Data.Tests/Client/Zip.cs

@@ -0,0 +1,40 @@
+namespace Snowflake.Data.Tests.Client
+{
+    public class Zip
+    {
+        public string prefix { get; set; }
+        public string postfix { get; set; }
+
+        public Zip()
+        {
+        }
+
+        public Zip(string prefix, string postfix)
+        {
+            this.prefix = prefix;
+            this.postfix = postfix;
+        }
+
+        protected bool Equals(Zip other)
+        {
+            return prefix == other.prefix && postfix == other.postfix;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((Zip)obj);
+        }
+
+        public override int GetHashCode()
+        {
+#if NETFRAMEWORK
+            return prefix.GetHashCode() * 177 + postfix.GetHashCode();
+#else
+            return System.HashCode.Combine(prefix, postfix);
+#endif
+        }
+    }
+}

Snowflake.Data.Tests/IntegrationTests/ConnectionMultiplePoolsIT.cs

@@ -8,6 +8,7 @@
 using NUnit.Framework;
 using Snowflake.Data.Client;
 using Snowflake.Data.Core.Session;
+using Snowflake.Data.Log;
 using Snowflake.Data.Tests.Mock;
 using Snowflake.Data.Tests.Util;
 
@@ -17,6 +18,7 @@ namespace Snowflake.Data.Tests.IntegrationTests
     [NonParallelizable]
     public class ConnectionMultiplePoolsIT: SFBaseTest
     {
+        private static readonly SFLogger s_logger = SFLoggerFactory.GetLogger<ConnectionPoolManager>();
         private readonly PoolConfig _previousPoolConfig = new PoolConfig();
 
         [SetUp]
@@ -337,6 +339,7 @@ public void TestConnectionPoolExpirationWorks()
 
             // act
             WaitUntilAllSessionsCreatedOrTimeout(pool);
+            LogState(pool, "expecting 4 sections to be busy");
             var beforeSleepMillis = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
             Thread.Sleep(TimeSpan.FromSeconds(ExpirationTimeoutInSeconds));
             conn1.Close();
@@ -345,21 +348,30 @@ public void TestConnectionPoolExpirationWorks()
             conn4.Close();
 
             // assert
+            LogState(pool, "expecting 2 sections to be idle after closing all sessions");
             Assert.AreEqual(2, pool.GetCurrentPoolSize()); // 2 idle sessions, but expired because close doesn't remove expired sessions
 
             // act
             WaitUntilAllSessionsCreatedOrTimeout(pool);
+            LogState(pool, "before opening the next connection");
             var conn5 = OpenConnection(connectionString);
             WaitUntilAllSessionsCreatedOrTimeout(pool);
 
             // assert
+            LogState(pool, "after opening the next connection");
             Assert.AreEqual(2, pool.GetCurrentPoolSize()); // 1 idle session and 1 busy
             var sessionStartTimes = pool.GetIdleSessionsStartTimes();
             Assert.AreEqual(1, sessionStartTimes.Count);
             Assert.That(sessionStartTimes.First(), Is.GreaterThan(beforeSleepMillis));
             Assert.That(conn5.SfSession.GetStartTime(), Is.GreaterThan(beforeSleepMillis));
         }
 
+        private void LogState(SessionPool pool, string context)
+        {
+            var state = pool.GetCurrentState();
+            s_logger.Warn($"{context}: {state}");
+        }
+
         [Test]
         public void TestMinPoolSize()
         {