CQL Tuples in C#

[baseTwo]

Intro

A CQL Value Tuple is basically a name-value dictionary. One would be tempted to use the dynamic ExpandoObject as a candicate for tuple types, however, the architectural decision is to avoid dynamic code in generated C#, since statically compiled code will always be more performant.

Value Tuples

C# value tuples is a good candidate, but the names of the properties are only available at compile-time. During runtime, their names are always Item1, Item2, .... etc. So this would not be idea for serialization.

Three proposals were considered and they are available in #599 .

An option is to keep the item names as part of the value tuple. The item names would have to be stored as a static property on the library, so that memory is not wasted.

Here is a code snippet demonstrating the concept

internal record CqlTupleMetadata(string[] PropertyNames)
{
	public string[] PropertyNames { get; } = PropertyNames;
	private readonly int _hashCode = PropertyNames.Aggregate(0, HashCode.Combine);
	private readonly string _toString = $"[{string.Join(", ", PropertyNames.Select(pn => $"\"{pn}\""))}]";

	public virtual bool Equals(CqlTupleMetadata? other)
	{
		if (other is null) return false;
		if (ReferenceEquals(this, other)) return true;
		if (_hashCode != other._hashCode) return false;
		return PropertyNames.SequenceEqual(other.PropertyNames);
	}

	public override int GetHashCode() => _hashCode;

	public override string ToString() => _toString;
}


	// Similar value tuples
	(string? name,DateTime? dob) vt1 = ("Paul", new DateTime(2000,12,31));
	(string? name,DateTime? dob) vt2 = ("Paul", new DateTime(2000,12,31));	
	Debug.Assert(vt1 == vt2);
	Debug.Assert(vt1.GetHashCode() == vt2.GetHashCode());
	
	// Similar CqlTupleMetadata
	CqlTupleMetadata meta1 = new(["name", "dob"]); // Assume these are static properties on a library
	CqlTupleMetadata meta2 = new(["name", "dob"]);
	Debug.Assert(meta1 == meta2);
	Debug.Assert(meta1.GetHashCode() == meta2.GetHashCode());
	
	// Value tuples with metadata
	(CqlTupleMetadata, string? name,DateTime? dob) mvt1 = (meta1, "Paul", new DateTime(2000,12,31));
	(CqlTupleMetadata, string? name, DateTime? dob) mvt2 = (meta2, "Paul", new DateTime(2000, 12, 31));
	Debug.Assert(mvt1 == mvt2);
	Debug.Assert(mvt1.GetHashCode() == mvt2.GetHashCode());
	Debug.Assert(mvt1.ToString() == """(["name", "dob"], Paul, 31-12-2000 00:00:00)""");

Serialization

Custom serialization is necessary, because value tuples don't serialize well as demonstrated here

	// Out of the box serialization does not work
	var json1 = JsonSerializer.Serialize(mvt1);
	Debug.Assert(json1 == "{}");

Adding custom json converter

public class ValueTupleJsonConverterFactory : JsonConverterFactory
{
	public override bool CanConvert(Type typeToConvert)
	{
		var canConvert = typeof(ITuple).IsAssignableFrom(typeToConvert)
						 && typeToConvert.IsGenericType
						 && typeToConvert.GenericTypeArguments[0] == typeof(CqlTupleMetadata);
		return canConvert;
	}

	public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options) =>
		ValueTupleJsonConverter.Default;
}

public class ValueTupleJsonConverter : JsonConverter<ITuple>
{
	public static ValueTupleJsonConverter Default { get; } = new();

	public override ITuple Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
	{
		throw new NotImplementedException();
	}

	public override void Write(Utf8JsonWriter writer, ITuple value, JsonSerializerOptions options)
	{
		writer.WriteStartObject();

		if (value[0] is CqlTupleMetadata { PropertyNames: { } properties })
		{
			for (int i = 1; i < value.Length; i++)
			{
				writer.WritePropertyName(properties[i - 1]);
				JsonSerializer.Serialize(writer, value[i], options);
			}
		}
		else throw new InvalidOperationException("Invalid tuple format");

		writer.WriteEndObject();
	}
}

	// With custom json converter
	var jsonOK1 = JsonSerializer.Serialize(mvt1, new JsonSerializerOptions { Converters = { new ValueTupleJsonConverterFactory() } }).Dump();
	Debug.Assert(jsonOK1 == """{"name":"Paul","dob":"2000-12-31T00:00:00"}""");

Nested Tuples

Testing more complex scenarios

public class Library1
{	
	public static Library1 Instance { get; } = new();
	
	public (
		CqlTupleMetadata, 
		int? Id, 
		string? Name, 
		(	CqlTupleMetadata, 
			string? AddressType, 
			string? Street, 
			string? City, 
			string? Country)?[] Addresses) GetPerson(int id, string name)
	{
		return (
			__TupleMetadata1,
			id,
			name,
			[
				(__TupleMetadata2, "Home", "2077 Sussex Court", "Gatesville", "USA"),
				(__TupleMetadata2, "Work", "964 Rogers Street", "Dallas", "USA"),
			]);
	}
	
	private static readonly CqlTupleMetadata __TupleMetadata1 = new(["Id", "Name", "Addresses"]);
	private static readonly CqlTupleMetadata __TupleMetadata2 = new(["AddressType", "Street", "City", "Country"]);
}

	// Complex example	
	var person1 = Library1.Instance.GetPerson(101, "Joe Smith");
	var person2 = Library1.Instance.GetPerson(101, "Joe Smith");
	Debug.Assert(person1 != person2); // The Addresses references differ	
	Debug.Assert(person1.GetHashCode() != person2.GetHashCode()); // The Addresses references differ	

	// Assume same Addresses reference
	person2 = person2 with { Addresses = person1.Addresses };
	Debug.Assert(person1 == person2);
	Debug.Assert(person1.GetHashCode() == person2.GetHashCode());
	
	// Serialize
	var person1Json = JsonSerializer.Serialize(person1, new JsonSerializerOptions { WriteIndented = true,  Converters = { new ValueTupleJsonConverterFactory() } });
	Debug.Assert(
		person1Json ==
		"""
		{
		  "Id": 101,
		  "Name": "Joe Smith",
		  "Addresses": [
		    {
		      "AddressType": "Home",
		      "Street": "2077 Sussex Court",
		      "City": "Gatesville",
		      "Country": "USA"
		    },
		    {
		      "AddressType": "Work",
		      "Street": "964 Rogers Street",
		      "City": "Dallas",
		      "Country": "USA"
		    }
		  ]
		}
		""");

[baseTwo]

Closing this discussion. Implementation will follow in PR #603 .