If you have access to Caché database you can create custom query that accepts date as an argument and based on that returns specific table. It can be used via ODBC like this:

SELECT * FROM Package.Class.MyQuery(DATE)

or

Call Package.Class.MyQuery(DATE)

Here's a sample query that returns Ids from a table or a class and has an argument - class name (or table name):

Class Utils.CustomQuery2
{

/// Return ids from a table or a class
Query GetTable(Table) As %Query(CONTAINID = 1, ROWSPEC = "Id:%String") [ SqlProc ]
{
}

ClassMethod GetTableExecute(ByRef qHandle As %Binary, Table) As %Status
{
    #Dim Status As %Status = $$$OK

    If ##class(%Dictionary.ClassDefinition).%ExistsId(Table) {
        // Got a class, we need to calculate a table name and quote it
        #define ClassSQLTable(%c)    ($$$comClassKeyGet(%c,$$$cCLASSsqlschemaname)_"."_$$$comClassKeyGet(%c,$$$cCLASSsqltablename))
        Set Table = ##class(%CSP.UI.Portal.SQL.Home).Quoter2($$$ClassSQLTable(Table))
    }
    

    Set qHandle = ##class(%SQL.Statement).%ExecDirect(,"SELECT ID FROM " _ Table)
    If qHandle.%SQLCODE'=0 {
        Set Status = $$$ERROR($$$SQLError, qHandle.%SQLCODE, qHandle.%Message)
    }
    Quit Status
}

ClassMethod GetTableFetch(ByRef qHandle As %Binary, ByRef Row As %List, ByRef AtEnd As %Integer = 0) As %Status
{
    If qHandle.%Next() {
        // Same as in ROWSPEC
        Set Row = $Lb(qHandle.ID)
    } Else {
        /// No more data
        Set AtEnd = 1
        Set Row = ""
    }
    Quit $$$OK
}

ClassMethod GetTableClose(ByRef qHandle As %Binary) As %Status
{
    Kill qHandle
    Quit $$$OK
}

}

Call samples from ODBC:

SELECT * FROM Utils.CustomQuery2_GetTable('Cube.Cube.Fact')
Call Utils.CustomQuery2_GetTable('Cube_Cube.Fact')

Code on GitHub.

You can use %Dictionary package to do that. Here's a method that sets selectivity of a specified class/property (assuming Default storage) to an arbitrary value:

/// w $system.Status.DisplayError(##class(User.Selectivity).ModifySelectuvity())
ClassMethod ModifySelectuvity(class As %Dictionary.CacheClassname = {$classname()}, property As %String = "field1", selectivity As %Integer(MINVAL=0,MAXVAL=100) = {$random(101)}) As %Status
{
    #dim sc As %Status = $$$OK
    set id = $lts($lb(class, "Default", property), "||")
    set strategy = ##class(%Dictionary.StoragePropertyDefinition).%OpenId(id)
    set strategy.Selectivity = selectivity _ ".0000%"
    set sc = strategy.%Save()
    quit:$$$ISERR(sc) sc
    
    set sc = $system.OBJ.Compile(class)
    quit sc
}

You can use method generators:

ClassMethod OnCompile() [ CodeMode = objectgenerator ]
{
    do $system.OBJ.Compile("class")
    quit $$$OK
}

If method generator produces no code, then it would not be created, only ran at compile time.

To convert to Big Endian and Little Endian you can use $zcvt:

>zzdump $zcvt("12","O","UnicodeBig")
0000: 00 31 00 32                                             .1.2
>zzdump $zcvt("12","O","UnicodeLittle")
0000: 31 00 32 00                                             1.2.

It depends on a queries you want to run. For example you want to get all parents' ids which have a child with a specific property value. In a child class you can index for one or several properties, and execute this query:

SELECT parentId
FROM child
WHERE propertyA = 'value'

Documentation on indexes.

Or you can define a computed property in your parent class and index that.

I thought you needed an alphabetical consumption. What order do you need?

You can get one of these fairly easy:

• Name - the name of the file (the default)
• Type - file type
• DateCreated - the date the file was created
• DateModified - the date the file was last modified
• Size - the file size

Code should be stored in source control and there should be some sort of installer that does all required steps to get an application running.

That said,  ^%qCacheMsg is stored in CACHELIB, which is Read-Only by default. <PROTECT>  means either read or write error, so you need to add roles to your current user and/or make  CACHELIB writable temporaly.

When you define a query:

Query MyQuery() As %Query
{
  QUERY TEXT
}

Or

Query MyQuery() As %SQLQuery
{
  QUERY TEXT
}

That means that this query implements an interface provided by %Library.Query or %Library.SQLQuery respectively. They define method generators for Fetch/Execute/Func methods (more on them). Each method of the interface class gets called during compilation

You can subclass %Library.Query or %Library.SQLQuery to define your own methods. Here's custom query interface that does 2 things:

• Changes ROWSPEC to Id123:%String
  • It can be seen in class definition after compilation
  • <QueryName>GetInfo and <QueryName>GetODBCInfo methods also reflect new ROWSPEC properly
• Generates <QueryName>GetText method that returns query text

Class Utils.MyQuery Extends %SQLQuery
{

/// This method would be ran before others and changes ROWSPEC to "Id123:%String"
ClassMethod %ChangeRowspec() [ CodeMode = objectgenerator, ServerOnly = 1 ]
{
    // quit if we're not compiling a query
    if %mode="method" quit $$$OK
    
    set class = %class.Name
    set query = %compiledmethod.parent.Name        
    set rowspec = "Id123:%String"
    
    // Modify query definition
    $$$defSubMemberSet(class,$$$cCLASSquery,query,$$$cQUERYparameter,"ROWSPEC",rowspec)
    
    // Modify compiled query definition
    $$$comSubMemberSet(class,$$$cCLASSquery,query,$$$cQUERYparameter,"ROWSPEC",rowspec)
    
    // Update compile-time parameter value
    set %parameter("ROWSPEC") = rowspec
    
    // Update class definition
    do UpdClsDef^%occLibrary(class)
    
    quit $$$OK
}

/// GetText is a method that is used to get query text as a %String
ClassMethod GetText() As %String [ CodeMode = objectgenerator, ServerOnly = 1 ]
{
    if %mode="method" quit $$$OK
    $$$comMemberKeyGetLvar(query,%classname,$$$cCLASSquery,%property,$$$cQUERYsqlquery)
    do %code.WriteLine("    quit " _ $$$quote(query))
    quit $$$OK
}

}

And here's a test class with our new query:

Class Utils.MyQueryTest
{
Query ABC() As Utils.MyQuery
{
SELECT 1
}
}

After Utils.MyQueryTest is compiled it looks like this:

Class Utils.MyQueryTest
{
Query ABC() As Utils.MyQuery(ROWSPEC = "Id123:%String")
{
SELECT 1
}
}

You can modify this interface to get any behavior you want.

Code is available on GitHub.