The attached class should provide what you are looking for based on my testing.  This follows work I did while at a prior position.

Some things to note about this class

• I'm declaring  SqlRowIdName = Id so that I don't end up with an Id1 column in the SQL view of the table
• I've set  Parameter STORAGEDELIMITERCHECK = 1; so that when an Save/Insert/Update is done it ensures that the data fields do not contain a delimiter and then "throw off" the piecing strategy, if you aren using delimited data but instead using $list data then you wouldn't need this.
• I've overridden %OnNew so as to establish an array of namespaces where the data lives
• You would also want to call SetServerInitCode in %SYSTEM.SQL or the corresponding SetOption in %SYSTEM.SQL.Util  so as to build up the namespaces array.
• My usage of the namespaces array is for demonstration purposes only, your application probably already has some array that defines where the CB global is defined.
• If you want to only provide read access thru objects and SQL you could set the class Parameter READONLY=1;

seems like uploading a file doesn't work.. here's the class definition .. this will work on Cache or IRIS although on a Cache based system you would have to change <Type>%Storage.SQL</Type> to the proper Cache type.

Class Mapping.Test1 Extends %Persistent [ SqlRowIdName = Id, StorageStrategy = SQLStorage ]
{

/// Namespace
Property NS As %String [ Required ];

/// Contact Row ID
Property RowID As %Library.String(SELECTIVITY = 1, TRUNCATE = 1) [ Required ];

Property Field1 As %String;

Property Field2 As %String;

Index RowIDBasedIDKeyIndex On (NS, RowID) [ IdKey ];

/// <Example>
/// Set tSC=##class(Mappting.Test1).Populate()
/// </example>
ClassMethod Populate() As %Status
{
    #dim tSC 			As %Status=$$$OK
    #dim eException  	As %Exception.AbstractException
    try {
        Set tObject=..%New()
        Set tObject.NS="LAB"
        Set tObject.RowID=1
        $$$THROWONERROR(tSC,tObject.%Save())
        Write !,tObject.NS,": ",tObject.RowID
        
        Set tObject=..%New()
        Set tObject.NS="ARK"
        Set tObject.RowID=1
        $$$THROWONERROR(tSC,tObject.%Save())
        Write !,tObject.NS,": ",tObject.RowID
        
        &SQL(insert into Mapping.Test1 (NS,Rowid) values ('LAB',2))
        If SQLCODE $$$ThrowStatus(##class(%Exception.SQL).CreateFromSQLCODE(SQLCODE,%msg))
        
    }
    catch eException {
        Set tSC=eException.AsStatus()
    }
    Quit tSC
}

Storage SQLStorage
{
<SQLMap name="Map1">
<Data name="Field1">
<Delimiter>"^"</Delimiter>
<Piece>1</Piece>
</Data>
<Data name="Field2">
<Delimiter>"^"</Delimiter>
<Piece>2</Piece>
</Data>
<Global>namespaces</Global>
<Subscript name="1">
<Expression>{NS}</Expression>
</Subscript>
<Subscript name="2">
<Expression>1</Expression>
</Subscript>
<Subscript name="3">
<DataAccess>^[{L1}]CB({L2})</DataAccess>
<Expression>{RowID}</Expression>
</Subscript>
<Type>data</Type>
</SQLMap>
<StreamLocation>^Mappting.Test1S</StreamLocation>
<Type>%Storage.SQL</Type>
}

/// This callback method is invoked by the <METHOD>%New</METHOD> method to 
/// provide notification that a new instance of an object is being created.
/// 
/// <P>If this method returns an error then the object will not be created.
/// <p>It is passed the arguments provided in the %New call.
/// When customizing this method, override the arguments with whatever variables and types you expect to receive from %New().
/// For example, if you're going to call %New, passing 2 arguments, %OnNew's signature could be:
/// <p>Method %OnNew(dob as %Date = "", name as %Name = "") as %Status
/// If instead of returning a %Status code this returns an oref and this oref is a subclass of the current
/// class then this oref will be the one returned to the caller of %New method.
Method %OnNew() As %Status [ Private, PublicList = namespaces, ServerOnly = 1 ]
{
    
    #dim tSC		As %Status=$$$OK
    #dim eException	As %Exception.AbstractException
    Try {
        Set namespaces("LAB")=""
        Set namespaces("ARK")=""
    }
    Catch eException {
        Set tSC=eException.AsStatus()
    }
    Quit tSC
}

Parameter STORAGEDELIMITERCHECK = 1;

}

With the discussion of Intersystem IRIS Studio or VS Code, I understand the initial reaction to think you are losing something using VS Code.  Will you miss some things, I'm sure you will, but measured on the whole I feel like VS Code is a much better environment even if all you ever do is objectscript work.  I feel like that's the critical thing to remember, there may be some differences but measured on the whole it is better, give it a try and give it a chance, especially learning the full capabilities.

when you call the compiler did you call

Set tSC=##class(%SYSTEM.OBJ).Compile(ClassName,"cuk",.errorFile)

and was anything contained in the output array errorFile?

I've integrated in the past with 

• twilio.com
• bandwidth.com

The Athena IDX data is mapped/described by class definitions.  Documatic would be a good place to start.  The class definitions come with a rich set of meta-data including

• proper Foreign Key declarations to assist in describing the relationships between tables
• Example Class queries/SQL Procs which can be referenced as examples to join tables as well as other special cases.
• A number of SQLProces to facilitate more complex joins such as the ones founding MCA_Enrollment.

Many of the tables support bitmap indices.

somewhat related, I commonly used in the past in IRIS Studio CRTL-G (goto) to jump to an entity within a class or routine.  This dialog 

allow you to goto either a Line Number or Tag or Label.

I wanted to be able to do the same in VS Code and found by looking at

https://code.visualstudio.com/shortcuts/keyboard-shortcuts-windows.pdf

in VS Code you can use CTRL-SHIFT-O.

This isn't exactly your question but the link to the shortcuts is useful and for me, CTRL-SHIFT-O is what I was looking for as I wanted to jump around without using my mouse.

Without additional details it may be hard to tell for certain.  If it's an issue on Cache side you might consider using $Sequence in your storage model

$SEQUENCE provides a fast way for multiple processes to obtain unique (non-duplicate) integer indices for the same global variable. For each process, $SEQUENCE allocates a sequence (range) of integer values. $SEQUENCE uses this allocated sequence to assign a value to gvar and returns this gvar value. Subsequent calls to $SEQUENCE increment to the next value in the allocated sequence for that process. When a process consumes all of the integer values in its allocated sequence, its next call to $SEQUENCE automatically allocates a new sequence of integer values. $SEQUENCE automatically determines the size of the sequence of integer values to allocate. It determines the size of the allocated sequence separately for each sequence allocation. In some cases, this allocated sequence may be a single integer.

$SEQUENCE is intended to be used when multiple processes concurrently increment the same global. $SEQUENCE allocates to each concurrent process a unique range of values for the gvar global. Each process can then call $SEQUENCE to assign sequential values from its allocated range of values.

In your class definition within the you could consider changing the IdFunction from the default which is Increment to sequence

but again more detail is needed.

Nicely done.  while I haven't contributed to the project I do have a User Snippet

"Create Status Method": {
		  "prefix": "Method Create ClassMethod Returning %Status",
		  "body": [
			"///${1:Description}",
			"///<example>",
			"/// Set tSC=##class($TM_FILENAME_BASE).${2:MethodName}()",
			"///</example>",
			"ClassMethod ${2:MethodName}(${3:parameters}) As %Status",
			" {",
			"  #dim tSC \t\t\t As %Status=\\$\\$\\$OK",
			"  #dim eException \t As %Exception.AbstractException",
			"  try {",
			"   $0",
			"  }",
			"  catch eException {",
			"   Set tSC=eException.AsStatus()",
			"  }",
			" Quit tSC",
			" }"
		  ],
		  "description": "Method Create ClassMethod Returning %Status"
		}

that utilizes the <example> Documatic special tag as I too was tired typing the ##class when testing methods.  My approach is different and it's not perfect but it works for me.  It also produces a class method with a consistent pattern/structure.

I've run into something similar but with a different streamlet type.  The subscript error indicates that it is getting a null value which it expects to be non-null.  I would suggest looking at the medication streamlet and ensuring that all of the required fields are defined.  It might be the Medication.OrderItem.Code is null.

I cant speak for Templates but in the same area I do have Studio Add-Ins in use in VS Code.

I too am not entirely sure what your issue is but when I have particularly complex reports I leverage the ability to define in the ReportDefinition multiple <group> entities.  Consider for example you have a data model that has

• Batch
• Claim
• ClaimLine
• ClaimLineAdjudication

while you could define a single entity <group> which calls a single query, in my case I prefer to use Class Queries and then leverage breakOnField and create multiple <groups>, I find it makes more sense to have something like this, albeit this is psuedo code and not 100% what is entered in a Report Definition.

In this manner each level/group is responsible for doing one thing.  If needed I've also added to the <group> tag a filter element.  An actual example I have is this

fields="ClassName,LocalTimeChanged,RemoteTimeChanged,Description,LocalFkeys,RemoteFkeys,LocalIndices,RemoteIndices,LocalMethods,RemoteMethods,LocalProperties,RemoteProperties,LocalQueries,RemoteQueries,LocalParameters,RemoteParameters,LocalTriggers,RemoteTrigger" filter="..Filter(..FilterSpec)">

whereby I send to my method Filter the field values specified in the attribute fields as well as a FilterSpecification to test the filter.  You don't have to do it this way, its just an example of using the fields attribute and the filter attribute which is any valid objectscript expression.

Based on 

it looks like History.Views may not have indices or at least doesn't have a bitmap index.  If the table had a bitmap index it shouldn't take 30 seconds to count the rows. ... but maybe I'm incorrect.... seeing the query plan would have provided that insight.

You report that the now generates in 60 seconds and previously it 28 minutes for a twelve-page report.  Was the primary problem /time consumed in gathering the data or something else?

In the past, I have utilized %CSP.StreamServer to accomplish this.  While this may have a %CSP package name its perfectly usable in a ZEN context.