public async Task<Address> GetAddressResult(Guid id, TraceTree parentTraceTree)
{
    var traceTree = parentTraceTree.AddChild();
    traceTree.RecordCodeMethodExecution(MethodBase.GetCurrentMethod());

    return await _addressRepository.GetById(id, parentTraceTree);
}

public async Task<TItem> GetById(Guid entityId, TraceTree parentTraceTree)
{
    var traceTree = parentTraceTree.AddChild();
    traceTree.RecordCodeMethodExecution(MethodBase.GetCurrentMethod());

    /*
     * _createSelectById gets passed on, by for example the AddressRepository
     * (that inherits from RepositoryBase<AddressTable, AddressSubselect, Address>),
     * like so: (parentTraceTree, id) => new AddressSubselect(parentTraceTree, id: id))
     */
    TSelect selectById = _createSelectById(parentTraceTree, entityId);

    return await GetSingle(selectById, parentTraceTree);
}

/*
 * ItemSubselectBase is the Framework Demo base class for all subselects used in
 * repositories and other dynamic query building.
 * This class inherits from WYSE's convertable subselect that enables query result row 
 * conversion (extending DbDataReader) and (Hierarchical) Object Relational Mapping.
 * Usage examples (different overloads):
 * - var select = new AddressSelect()  // Gets all addresses
 * - var select = new AddressSelect(id: new Guid("11111111-1111-1111-1111-111111111111"))  // Get a single address by id
 * - var select = new AddressSelect(isDeleted: true)  // Only gets the deleted addresses
 * - var select = new AddressSelect(new PagingSettings { PageNumber = 3, PageSize = 20 })
 * So a Select with WYSE can be used to encapsulate SQL logic,
 * making it kind of like a coded version of a SqlServer function or view,
 * but much more flexible!
 */
protected ItemSubselectBase(
    ItemTableBase<TItem> sourceTable,
    TraceTree parentTraceTree,
    PagingSettings? pagingSettings,  /* If not null then paging is added to the query */
    Guid? id,  /* If not null then a select by id is done */
    bool? isDeleted)  /* If 'null' then both deleted and not deleted */
{
    var traceTree = parentTraceTree?.AddChild();
    traceTree?.RecordCodeConstructorExecution(typeof(ItemSubselectBase<TSelect, TItem>));

    _sourceListConvert = sourceTable.Convert;

    // Funneling is a concept used in WYSE to expose the columns of a (nested)
    // subselect one level higher in a query, so it can be used in a From or in
    // Where/Join expressions for example.
    Id = /*WYSE*/Funnel(sourceTable.Id);
    Created = /*WYSE*/Funnel(sourceTable.Created);
    LastModified = /*WYSE*/Funnel(sourceTable.LastModified);
    IsDeleted = /*WYSE*/Funnel(sourceTable.IsDeleted);

    var columnExpressions = new List</*WYSE*/IExpression>(
        sourceTable./*WYSE*/ListColumns());

    if (pagingSettings is not null)
    {
        // Add SqlServer's 'COUNT(Id) OVER()' to selected columns.
        // The modifying of the Where clause for row selection is done in
        // the query backbone. Check the traces below.
        sourceTable.CountUnpaged = new /*WYSE*/Count(sourceTable.Id).Over();
        CountUnpaged = /*WYSE*/Funnel(sourceTable.CountUnpaged);

        columnExpressions.Add(sourceTable.CountUnpaged);
    }

    // This makes the statement: SELECT [columnExpressions] FROM [sourceList]
    /*WYSE*/From from = this./*WYSE*/Columns(columnExpressions).From(sourceTable);

    // Determine the applicable where clause sub expressions (based on SQL parameters)
    var whereExpressions = new List</*WYSE*/BooleanExpression>();

    if (id.HasValue)
    {
        whereExpressions.Add(
            sourceTable.Id == new /*WYSE*/UniqueIdentifierParam("Id", id));
    }
    if (isDeleted.HasValue)
    {
        whereExpressions.Add(
            sourceTable.IsDeleted == new /*WYSE*/BitParam("IsDeleted", isDeleted));
    }

    if (whereExpressions.Count > 0)
    {
        // Append a Where clause with a condition that is all the
        // sub expressions 'AND'-ed together
        from.Where(whereExpressions./*WYSE*/And());
    }
}

public AddressSubselect(
    AddressTable addressTable,
    TraceTree parentTraceTree,
    PagingSettings? pagingSettings = null,
    Guid? id = null,
    bool? isDeleted = false)
    : base(addressTable ?? throw new ArgumentNullException(nameof(addressTable)),
          parentTraceTree,
          pagingSettings,
          id,
          isDeleted)
{
    var traceTree = parentTraceTree?.AddChild();
    traceTree?.RecordCodeConstructorExecution(typeof(AddressSubselect));

    Town = Funnel(addressTable.Town);
}

private async Task<TItem> GetSingle(TSelect select, TraceTree parentTraceTree)
{
    var traceTree = parentTraceTree.AddChild();
    traceTree.RecordCodeMethodExecution(MethodBase.GetCurrentMethod());

    // A scriptable can be anything in the WYSE language that can be part of a script:
    // - Executables; like Selects, Inserts, Updates, Deletes, Merges (SqlServer only)
    // - Variable and Temp table declarations
    // - If/Elses
    // ...and more.
    var scriptables = new List</*WYSE*/IScriptable>();

    // The Framework has one centralized place where the select statements are
    // dynamically decorated to apply business rules, encapsulated.
    // In some cases this means that select becomes a grander script with inital SQL
    // 'Scriptables', prefixing the initial Select statement.
    _queryBackbone.Using(traceTree).Modify(select, scriptables);

    // Create a script containing the scriptables (if any) plus the modified Select
    return await _sqlExecuter.GetScriptItemAsync(
        // Merge Script with the Select into total Script
        new /*WYSE*/Script(scriptables) + select,
        select.SourceListConvert,
        traceTree);
}