public partial class DomainAggregateRow : IEquatable<DomainAggregateRow>
{
    [Relation]
    public SubContainerRow SubContainer { get; set; }

    [Relation]
    public AggregateOptionRow AggregateOption { get; set; }

    [Relation]
    public TemplateRow Template { get; set; }

    [Relation]
    public CategoryAttributeRow CategoryAttribute { get; set; }

    [Relation]
    public DomainIdentityRow CreatedBy { get; set; }

    [Relation]
    public DomainIdentityRow LastModifiedBy { get; set; }

    [Relation]
    public OtherAggregateRow OtherAggregate { get; set; }
}

public partial class SubContainerRow : IEquatable<SubContainerRow>
{
    [Relation]
    public TopContainerRow TopContainer { get; set; }
}

var connectionString = ConfigurationRoot.GetConnectionString("MasterDatabase");
var definitionProvider = new DataAnnotationsDefinitionProvider();
var repositoryAdapter = new TransactSqlAdapter(definitionProvider);

using (var target = new DatabaseContext(connectionString, providerName, repositoryAdapter))
{
    var tables = target.Query<dynamic>("SELECT * FROM sys.tables WHERE [type] = @0", 'U').ToList();
    Assert.IsTrue(tables.Any());
    Assert.IsNotNull(tables.FirstOrDefault()?.name);
    Assert.IsTrue(tables.FirstOrDefault()?.object_id > 0);

    var tableCount = target.ExecuteScalar<int>("SELECT COUNT(1) FROM sys.tables WHERE [type] = @0", 'U');
    Assert.AreNotEqual(0, tableCount);
}

List<DomainAggregateRow> expectedPage1;
List<DomainAggregateRow> expectedPage2;

var providerFactory = new SqlClientProviderFactory(new DataAnnotationsDefinitionProvider());

using (var target = providerFactory.Create(ConfigurationRoot.GetConnectionString("OrmTestDb")))
{
    var topContainer2 = new TopContainerRow
    {
        Name = $"UNIT_TEST:TopContainer2-{Generator.Next(int.MaxValue)}"
    };

    target.Insert(topContainer2);

    var subContainerA = new SubContainerRow
    {
        Name = $"UNIT_TEST:SubContainerA-{Generator.Next(int.MaxValue)}",
        TopContainer = topContainer2,
        TopContainerId = topContainer2.TopContainerId
    };

    target.Insert(subContainerA);

    var categoryAttribute20 = new CategoryAttributeRow
    {
        Name = $"UNIT_TEST:CatAttr20-{Generator.Next(int.MaxValue)}",
        IsActive = true,
        IsSystem = false
    };

    target.Insert(categoryAttribute20);

    var timBobIdentity = new DomainIdentityRow
    {
        FirstName = "Tim",
        LastName = "Bob",
        UniqueIdentifier = $"UNIT_TEST:timbob@unittest.com-{Generator.Next(int.MaxValue)}"
    };

    target.Insert(timBobIdentity);

    var fooBarIdentity = new DomainIdentityRow
    {
        FirstName = "Foo",
        LastName = "Bar",
        UniqueIdentifier = $"UNIT_TEST:foobar@unittest.com-{Generator.Next(int.MaxValue)}"
    };

    target.Insert(fooBarIdentity);

    var otherAggregate10 = new OtherAggregateRow
    {
        Name = $"UNIT_TEST:OtherAggregate10-{Generator.Next(int.MaxValue)}",
        AggregateOptionTypeId = 3
    };

    target.Insert(otherAggregate10);

    var template23 = new TemplateRow
    {
        Name = $"UNIT_TEST:Template23-{Generator.Next(int.MaxValue)}"
    };

    target.Insert(template23);

    var aggregateOption1 = new AggregateOptionRow
    {
        Name = $"UNIT_TEST:AgOption1-{Generator.Next(int.MaxValue)}",
        AggregateOptionTypeId = 2,
        Value = 439034.0332m
    };

    var aggregateOption2 = new AggregateOptionRow
    {
        Name = $"UNIT_TEST:AgOption2-{Generator.Next(int.MaxValue)}",
        AggregateOptionTypeId = 4,
        Value = 32453253
    };

    var domainAggregate1 = new DomainAggregateRow
    {
        AggregateOption = aggregateOption1,
        CategoryAttribute = categoryAttribute20,
        CategoryAttributeId = categoryAttribute20.CategoryAttributeId,
        Name = $"UNIT_TEST:Aggregate1-{Generator.Next(int.MaxValue)}",
        Description = "My First Domain Aggregate",
        CreatedBy = timBobIdentity,
        CreatedByDomainIdentityId = timBobIdentity.DomainIdentityId,
        CreatedTime = DateTimeOffset.Now.AddMonths(-1),
        LastModifiedBy = fooBarIdentity,
        LastModifiedByDomainIdentityId = fooBarIdentity.DomainIdentityId,
        LastModifiedTime = DateTimeOffset.Now,
        SubContainer = subContainerA,
        SubContainerId = subContainerA.SubContainerId,
        Template = template23,
        TemplateId = template23.TemplateId
    };

    target.Insert(domainAggregate1);

    var domainAggregate2 = new DomainAggregateRow
    {
        AggregateOption = aggregateOption2,
        CategoryAttribute = categoryAttribute20,
        CategoryAttributeId = categoryAttribute20.CategoryAttributeId,
        Name = $"UNIT_TEST:Aggregate2-{Generator.Next(int.MaxValue)}",
        Description = "My Second Domain Aggregate",
        CreatedBy = timBobIdentity,
        CreatedByDomainIdentityId = timBobIdentity.DomainIdentityId,
        CreatedTime = DateTimeOffset.Now.AddMonths(-1),
        LastModifiedBy = fooBarIdentity,
        LastModifiedByDomainIdentityId = fooBarIdentity.DomainIdentityId,
        LastModifiedTime = DateTimeOffset.Now,
        OtherAggregate = otherAggregate10,
        SubContainer = subContainerA,
        SubContainerId = subContainerA.SubContainerId,
        Template = template23,
        TemplateId = template23.TemplateId
    };

    target.Insert(domainAggregate2);

    var domainAggregate3 = new DomainAggregateRow
    {
        CategoryAttribute = categoryAttribute20,
        CategoryAttributeId = categoryAttribute20.CategoryAttributeId,
        Name = $"UNIT_TEST:Aggregate3-{Generator.Next(int.MaxValue)}",
        Description = "My Third Domain Aggregate",
        CreatedBy = timBobIdentity,
        CreatedByDomainIdentityId = timBobIdentity.DomainIdentityId,
        CreatedTime = DateTimeOffset.Now.AddMonths(-1),
        LastModifiedBy = timBobIdentity,
        LastModifiedByDomainIdentityId = timBobIdentity.DomainIdentityId,
        LastModifiedTime = DateTimeOffset.Now,
        SubContainer = subContainerA,
        SubContainerId = subContainerA.SubContainerId,
        Template = template23,
        TemplateId = template23.TemplateId
    };

    target.Insert(domainAggregate3);

    var domainAggregate4 = new DomainAggregateRow
    {
        CategoryAttribute = categoryAttribute20,
        CategoryAttributeId = categoryAttribute20.CategoryAttributeId,
        Name = $"UNIT_TEST:Aggregate4-{Generator.Next(int.MaxValue)}",
        Description = "My Fourth Domain Aggregate",
        CreatedBy = timBobIdentity,
        CreatedByDomainIdentityId = timBobIdentity.DomainIdentityId,
        CreatedTime = DateTimeOffset.Now.AddMonths(-1),
        LastModifiedBy = timBobIdentity,
        LastModifiedByDomainIdentityId = timBobIdentity.DomainIdentityId,
        LastModifiedTime = DateTimeOffset.Now,
        SubContainer = subContainerA,
        SubContainerId = subContainerA.SubContainerId,
        Template = template23,
        TemplateId = template23.TemplateId
    };

    target.Insert(domainAggregate4);

    var domainAggregate5 = new DomainAggregateRow
    {
        CategoryAttribute = categoryAttribute20,
        CategoryAttributeId = categoryAttribute20.CategoryAttributeId,
        Name = $"UNIT_TEST:Aggregate5-{Generator.Next(int.MaxValue)}",
        Description = "My Fifth Domain Aggregate",
        CreatedBy = timBobIdentity,
        CreatedByDomainIdentityId = timBobIdentity.DomainIdentityId,
        CreatedTime = DateTimeOffset.Now.AddMonths(-1),
        LastModifiedBy = timBobIdentity,
        LastModifiedByDomainIdentityId = timBobIdentity.DomainIdentityId,
        LastModifiedTime = DateTimeOffset.Now,
        SubContainer = subContainerA,
        SubContainerId = subContainerA.SubContainerId,
        Template = template23,
        TemplateId = template23.TemplateId
    };

    target.Insert(domainAggregate5);

    aggregateOption1.AggregateOptionId = domainAggregate1.DomainAggregateId;
    target.Insert(aggregateOption1);

    aggregateOption2.AggregateOptionId = domainAggregate2.DomainAggregateId;
    target.Insert(aggregateOption2);

    var associationRow = new AssociationRow
    {
        DomainAggregateId = domainAggregate2.DomainAggregateId,
        OtherAggregateId = otherAggregate10.OtherAggregateId
    };

    target.Insert(associationRow);

    expectedPage1 = new List<DomainAggregateRow>
                        {
                            domainAggregate1,
                            domainAggregate2,
                            domainAggregate3
                        };

    expectedPage2 = new List<DomainAggregateRow>
                        {
                            domainAggregate4,
                            domainAggregate5
                        };
}

using (var target = providerFactory.Create(ConfigurationRoot.GetConnectionString("OrmTestDb")))
{
    var countQuery = Query.SelectEntities<DomainAggregateRow>(
        select => select.Count(row => row.DomainAggregateId)
            .From(set => set.InnerJoin(row => row.SubContainerId, row => row.SubContainer.SubContainerId))
            .Where(set => set.AreEqual(row => row.SubContainerId, expectedPage1.First().SubContainerId)));

    // TODO: How will we label our aggregate columns?
    var count = target.GetScalar<int>(countQuery);

    Assert.AreEqual(5, count);

    var tableExpression = Query.SelectEntities<DomainAggregateRow>(
        select => select.Select(row => row.DomainAggregateId)
            .From(
                set => set.LeftJoin<AssociationRow>(row => row.DomainAggregateId, row => row.DomainAggregateId)
                    .LeftJoin<AssociationRow, OtherAggregateRow>(row => row.OtherAggregateId, row => row.OtherAggregateId)
                    .InnerJoin(row => row.CategoryAttributeId, row => row.CategoryAttribute.CategoryAttributeId)
                    .InnerJoin(row => row.CreatedByDomainIdentityId, row => row.CreatedBy.DomainIdentityId)
                    .LeftJoin(row => row.DomainAggregateId, row => row.AggregateOption.AggregateOptionId)
                    .InnerJoin(row => row.LastModifiedByDomainIdentityId, row => row.LastModifiedBy.DomainIdentityId)
                    .InnerJoin(row => row.SubContainerId, row => row.SubContainer.SubContainerId)
                    .InnerJoin(row => row.SubContainer.TopContainerId, row => row.SubContainer.TopContainer.TopContainerId)
                    .InnerJoin(row => row.TemplateId, row => row.Template.TemplateId))
            .Where(set => set.AreEqual(row => row.SubContainerId, expectedPage1.First().SubContainerId))
            .Sort(set => set.OrderBy(row => row.Name))
            .Seek(subset => subset.Skip(0).Take(3)));

    var selection = Query.With(tableExpression, "pgCte")
        .ForSelection<DomainAggregateRow>(matches => matches.On(row => row.DomainAggregateId, row => row.DomainAggregateId))
        .From(
            set => set.LeftJoin<AssociationRow>(row => row.DomainAggregateId, row => row.DomainAggregateId)
                .LeftJoin<AssociationRow, OtherAggregateRow>(row => row.OtherAggregateId, row => row.OtherAggregateId)
                .InnerJoin(row => row.CategoryAttributeId, row => row.CategoryAttribute.CategoryAttributeId)
                .InnerJoin(row => row.CreatedByDomainIdentityId, row => row.CreatedBy.DomainIdentityId)
                .LeftJoin(row => row.DomainAggregateId, row => row.AggregateOption.AggregateOptionId)
                .InnerJoin(row => row.LastModifiedByDomainIdentityId, row => row.LastModifiedBy.DomainIdentityId)
                .InnerJoin(row => row.SubContainerId, row => row.SubContainer.SubContainerId)
                .InnerJoin(row => row.SubContainer.TopContainerId, row => row.SubContainer.TopContainer.TopContainerId)
                .InnerJoin(row => row.TemplateId, row => row.Template.TemplateId))
        .Where(set => set.AreEqual(row => row.SubContainerId, expectedPage1.First().SubContainerId))
        .Sort(set => set.OrderBy(row => row.Name));

    var actualPage1 = target.SelectEntities(selection).ToList();
    Assert.AreEqual(
        expectedPage1.First(),
        actualPage1.First(),
        string.Join(Environment.NewLine, expectedPage1.First().GetDifferences(actualPage1.First())));

    CollectionAssert.AreEqual(expectedPage1, actualPage1);

    // Advance the number of rows
    selection.ParentExpression.Expression.Page.SetPage(2);

    var actualPage2 = target.SelectEntities(selection).ToList();
    Assert.AreEqual(
        expectedPage2.First(),
        actualPage2.First(),
        string.Join(Environment.NewLine, expectedPage2.First().GetDifferences(actualPage2.First())));

    CollectionAssert.AreEqual(expectedPage2, actualPage2);
}

/// <summary>
/// Represents a user-defined table type for the <see cref="FieldRow"/> entity.
/// </summary>
[TableType("FieldTableType")]
[Table("Field", Schema = "dbo")]
public class FieldTableTypeRow
{
    /// <summary>
    /// Gets or sets the field ID.
    /// </summary>
    [Column(Order = 1)]
    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
    public int? FieldId { get; set; }

    /// <summary>
    /// Gets or sets the name.
    /// </summary>
    [Column(Order = 2)]
    public string Name { get; set; }

    /// <summary>
    /// Gets or sets the description.
    /// </summary>
    [Column(Order = 3)]
    public string Description { get; set; }
}

var internalId = new Field
{
    Name = "INS_Internal ID",
    Description = "Unique ID used internally"
};

var firstName = new Field
{
    Name = "INS_First Name",
    Description = "The person's first name"
};

var lastName = new Field
{
    Name = "INS_Last Name",
    Description = "The person's last name"
};

var yearlyWage = new Field
{
    Name = "INS_Yearly Wage",
    Description = "The base wage paid year over year."
};

var hireDate = new Field
{
    Name = "INS_Hire Date",
    Description = "The date and time of hire for the person"
};

var bonusTarget = new Field
{
    Name = "INS_Bonus Target",
    Description = "The target bonus for the person"
};

var contactNumbers = new Field
{
    Name = "INS_Contact Numbers",
    Description = "A list of contact numbers for the person in order of preference"
};

var expected = new List<Field>
                {
                    internalId,
                    firstName,
                    lastName,
                    yearlyWage,
                    hireDate,
                    bonusTarget,
                    contactNumbers
                };

var providerFactory = new SqlClientProviderFactory(new DataAnnotationsDefinitionProvider());

using (var provider = providerFactory.Create(ConfigurationRoot.GetConnectionString("OrmTestDb")))
using (var transaction = provider.BeginTransaction())
{
    var fieldRepository = new SqlClientRepository<Field, FieldRow>(provider, this.mapper);
    var fieldValueRepository = new SqlClientRepository<FieldValue, FieldValueRow>(provider, this.mapper);

    var fieldSelection = Query.SelectEntities<FieldRow>(
        select => select.Select(row => row.FieldId).Where(set => set.AreEqual(row => row.Name, "INS_%")));

    var fieldValuesToDelete = fieldRepository.DynamicSelect(fieldSelection);
    fieldValueRepository.DeleteSelection(
        Query.Select<FieldValueRow>()
            .Where(set => set.Include(row => row.FieldId, fieldValuesToDelete.Select(o => (int)o.FieldId).ToArray())));

    fieldRepository.DeleteSelection(fieldSelection);

    var fieldRows = from f in expected
                    select new FieldTableTypeRow
                    {
                        Name = f.Name,
                        Description = f.Description
                    };

    // Select results = by name because the TVP won't have the IDs
    // TODO: See if we can simplify this process to just pull inserted items without joins
    var results = fieldRepository.InsertForResults(fieldRows, insert => insert.SelectResults(row => row.Name)).ToList();

    transaction.Commit();

    var actual = this.mapper.Map<List<Field>>(results);
    CollectionAssert.AreEquivalent(expected, actual);
}

var internalId = new Field
{
    Name = "MERGE_Existing_Internal ID",
    Description = "Unique ID used internally"
};

var firstName = new Field
{
    Name = "MERGE_Existing_First Name",
    Description = "The person's first name"
};

var lastName = new Field
{
    Name = "MERGE_Existing_Last Name",
    Description = "The person's last name"
};

var yearlyWage = new Field
{
    Name = "MERGE_Existing_Yearly Wage",
    Description = "The base wage paid year over year."
};

var hireDate = new Field
{
    Name = "MERGE_NonExisting_Hire Date",
    Description = "The date and time of hire for the person"
};

var bonusTarget = new Field
{
    Name = "MERGE_NonExisting_Bonus Target",
    Description = "The target bonus for the person"
};

var contactNumbers = new Field
{
    Name = "MERGE_NonExisting_Contact Numbers",
    Description = "A list of contact numbers for the person in order of preference"
};

var fields = new List<Field>
                {
                    internalId,
                    firstName,
                    lastName,
                    yearlyWage,
                    hireDate,
                    bonusTarget,
                    contactNumbers
                };

var providerFactory = new SqlClientProviderFactory(new DataAnnotationsDefinitionProvider());

using (var provider = providerFactory.Create(ConfigurationRoot.GetConnectionString("OrmTestDb")))
using (var transaction = provider.BeginTransaction())
{
    var fieldRepository = new SqlClientRepository<Field, FieldRow>(provider, this.mapper);
    fieldRepository.Merge(
        from f in fields
        select new FieldTableTypeRow
        {
            Name = f.Name,
            Description = f.Description
        },
        merge => merge.On<FieldTableTypeRow>(row => row.Name, row => row.Name));

    transaction.Commit();
}

var providerFactory = new PostgreSqlProviderFactory(new DataAnnotationsDefinitionProvider());

using (var provider = providerFactory.Create(ConfigurationRoot.GetConnectionString("OrmTestDbPg")))
{
    var identityRepository = new PostgreSqlRepository<DomainIdentity, DomainIdentityRow>(provider, this.mapper);

    var domainIdentity = identityRepository.FirstOrDefault(
                                Query.From<DomainIdentity>()
                                    .Where(set => set.AreEqual(identity => identity.UniqueIdentifier, Environment.UserName)))
                            ?? identityRepository.Save(
                                new DomainIdentity(Environment.UserName)
                                {
                                    FirstName = "King",
                                    MiddleName = "T.",
                                    LastName = "Animal"
                                });

    var expected = new GenericSubmission("My Submission", domainIdentity);
    var internalId = new Field
    {
        Name = "Internal ID",
        Description = "Unique ID used internally"
    };

    var firstName = new Field
    {
        Name = "First Name",
        Description = "The person's first name"
    };

    var lastName = new Field
    {
        Name = "Last Name",
        Description = "The person's last name"
    };

    var yearlyWage = new Field
    {
        Name = "Yearly Wage",
        Description = "The base wage paid year over year."
    };

    var hireDate = new Field
    {
        Name = "Hire Date",
        Description = "The date and time of hire for the person"
    };

    var bonusTarget = new Field
    {
        Name = "Bonus Target",
        Description = "The target bonus for the person"
    };

    var contactNumbers = new Field
    {
        Name = "Contact Numbers",
        Description = "A list of contact numbers for the person in order of preference"
    };

    expected.SetValue(internalId, 9234);
    expected.SetValue(firstName, "Dan");
    expected.SetValue(lastName, "The Man");
    expected.SetValue(yearlyWage, 75100.35m);
    expected.SetValue(hireDate, DateTimeOffset.Now);
    expected.SetValue(bonusTarget, 1.59834578934);
    expected.SetValue(
        contactNumbers,
        new List<string>
            {
                "423-222-2252",
                "615-982-0012",
                "+1-555-252-5521"
            });

    expected.Submit();

    var fieldRepository = new PostgreSqlRepository<Field, FieldRow>(provider, this.mapper);

    var fields = expected.SubmissionValues.Select(value => value.Field).Distinct().ToDictionary(field => field.Name, field => field);
    var inclusionValues = fields.Keys.ToArray();
    var existingFields = fieldRepository.SelectEntities(
        new EntitySelection<Field>().Where(set => set.Include(field => field.Name, inclusionValues)));

    foreach (var field in existingFields)
    {
        var output = fields[field.Name];
        this.mapper.MapTo(field, output);
    }

    foreach (var field in fields.Values.Where(field => field.FieldId.HasValue == false))
    {
        fieldRepository.Save(field);
    }

    var submissionRepository = new PostgreSqlRepository<GenericSubmission, GenericSubmissionRow>(provider, this.mapper);

    using (var transaction = provider.BeginTransaction())
    {
        submissionRepository.Save(expected);

        var submissionId = expected.GenericSubmissionId.GetValueOrDefault();
        Assert.AreNotEqual(0, submissionId);

        var fieldValueRepository = new PostgreSqlRepository<FieldValue, FieldValueRow>(provider, this.mapper);

        // Do the field values
        var valuesList = from v in expected.SubmissionValues
                            select new FieldValueRow
                                {
                                    FieldId = v.Field.FieldId.GetValueOrDefault(),
                                    LastModifiedByDomainIdentifierId = domainIdentity.DomainIdentityId.GetValueOrDefault(),
                                    LastModifiedTime = expected.SubmittedTime
                                };

        var insertedValues = fieldValueRepository.InsertForResults(
                valuesList,
                insert => insert.Returning(
                    row => row.FieldValueId,
                    row => row.FieldId,
                    row => row.LastModifiedByDomainIdentifierId,
                    row => row.LastModifiedTime))
            .ToDictionary(row => row.FieldId, row => row);

        // Map back to the domain object if needed.
        foreach (var value in expected.SubmissionValues.Where(value => value.FieldValueId.HasValue == false))
        {
            var input = insertedValues[value.Field.FieldId.GetValueOrDefault()];
            this.mapper.MapTo(input, value);
        }

        var fieldValueElementRepository = new PostgreSqlRepository<FieldValueElement, FieldValueElementRow>(provider, this.mapper);

        // Do the field value elements
        var elementsList = (from e in expected.SubmissionValues.SelectMany(value => value.Elements)
                            select new FieldValueElementTableTypeRow
                                    {
                                        FieldValueElementId = e.FieldValueElementId,
                                        FieldValueId = e.FieldValue.FieldValueId.GetValueOrDefault(),
                                        Order = e.Order,
                                        DateElement = e.Element as DateTimeOffset? ?? e.Element as DateTime?,
                                        FloatElement = e.Element as double? ?? e.Element as float?,
                                        IntegerElement =
                                            e.Element as long? ?? e.Element as int? ?? e.Element as short? ?? e.Element as byte?,
                                        MoneyElement = e.Element as decimal?,
                                        TextElement = e.Element as string // here we actually want it to be null if it is not a string
                                    }).ToDictionary(row => new Tuple<long, int>(row.FieldValueId, row.Order));

        var insertedElements = fieldValueElementRepository.InsertForResults(
                elementsList.Values,
                insert => insert.Returning(row => row.FieldValueElementId, row => row.FieldValueId, row => row.Order))
            .ToDictionary(row => new Tuple<long, int>(row.FieldValueId, row.Order));

        foreach (var element in expected.SubmissionValues.SelectMany(value => value.Elements))
        {
            var key = new Tuple<long, int>(element.FieldValue.FieldValueId.GetValueOrDefault(), element.Order);
            var input = insertedElements[key];
            this.mapper.MapTo(input, element);
            elementsList[key].FieldValueElementId = input.FieldValueElementId;
        }

        var dateElementRepository = new PostgreSqlRepository<FieldValueElement, DateElementRow>(provider, this.mapper);
        dateElementRepository.Insert(
            elementsList.Values.Where(row => row.DateElement.HasValue),
            insert => insert.InsertInto(row => row.DateElementId, row => row.Value)
                .From<FieldValueElementTableTypeRow>(row => row.FieldValueElementId, row => row.DateElement));

        var floatElementRepository = new PostgreSqlRepository<FieldValueElement, FloatElementRow>(provider, this.mapper);
        floatElementRepository.Insert(
            elementsList.Values.Where(row => row.FloatElement.HasValue),
            insert => insert.InsertInto(row => row.FloatElementId, row => row.Value)
                .From<FieldValueElementTableTypeRow>(row => row.FieldValueElementId, row => row.FloatElement));

        var integerElementRepository = new PostgreSqlRepository<FieldValueElement, IntegerElementRow>(provider, this.mapper);
        integerElementRepository.Insert(
            elementsList.Values.Where(row => row.IntegerElement.HasValue),
            insert => insert.InsertInto(row => row.IntegerElementId, row => row.Value)
                .From<FieldValueElementTableTypeRow>(row => row.FieldValueElementId, row => row.IntegerElement));

        var moneyElementRepository = new PostgreSqlRepository<FieldValueElement, MoneyElementRow>(provider, this.mapper);
        moneyElementRepository.Insert(
            elementsList.Values.Where(row => row.MoneyElement.HasValue),
            insert => insert.InsertInto(row => row.MoneyElementId, row => row.Value)
                .From<FieldValueElementTableTypeRow>(row => row.FieldValueElementId, row => row.MoneyElement));

        var textElementRepository = new PostgreSqlRepository<FieldValueElement, TextElementRow>(provider, this.mapper);
        textElementRepository.Insert(
            elementsList.Values.Where(row => row.TextElement != null),
            insert => insert.InsertInto(row => row.TextElementId, row => row.Value)
                .From<FieldValueElementTableTypeRow>(row => row.FieldValueElementId, row => row.TextElement));

        // Attach the values to the submission
        var genericValueSubmissions = from v in insertedValues.Values
                                        select new GenericSubmissionValueRow
                                                {
                                                    GenericSubmissionId = submissionId,
                                                    GenericSubmissionValueId = v.FieldValueId
                                                };

        var genericSubmissionValueRepository = new PostgreSqlRepository<FieldValue, GenericSubmissionValueRow>(provider, this.mapper);
        genericSubmissionValueRepository.Insert(genericValueSubmissions, null);
        transaction.Commit();
    }
}