$SYSTEM.SQL.QueryToTable

Still can be so:

Class dc.test [ Abstract ]
{

ClassMethod Test(s = "#")
{
  w "Test_",s
}

ClassMethod mac() [ ProcedureBlock = 0 ]
{
sub1(s=1)
  w "sub1_",s
  q
sub2(s=2)
  w "sub2_",s
  q
procPrivate(s=3) {
  w "procPrivate_",s
}
procPublic(s=3) public {
  w "procPublic_",s
}
}

}

Result:

USER>d zTest^dc.test.1(1)
Test_1
USER>d sub1^dc.test.1
sub1_1
USER>d sub2^dc.test.1
sub2_2
USER>d sub1^dc.test.1(10)
sub1_10
USER>d sub2^dc.test.1(10)
sub2_10
USER>d procPrivate^dc.test.1(10)
 
D procPrivate^dc.test.1(10)
^

USER>d procPublic^dc.test.1(10)
procPublic_10
USER>

This can be done also in the CLS.

TEST(invar) [outvar] public {

}

=>

ClassMethod TEST(invar) [PublicList=outvar] {

}

PublicList

my code is disclosed above

Upd: 67

Upd: 72

Fixed bugs/typos and added new types.

#include %PVA
types ; Show COS-Datatypes ; kav ; 2018-03-04
 n array,i,bitstring
 
 s $bit(bitstring,1) = 1

 w "№",?4,"VALUE",?30,"JSON",?45,"$LISTBUILD",!,$TR($J("",55)," ","-"),!
 
 s array=[
          (bitstring),
          ($ZBITSET($ZBITSTR(4,1),2,0)),
          ($lb("")),
          null,
          true,
          false,
          (##class(%ZEN.proxyObject).%New()),
          [],
          {},
          "abcd",
          ($wc(35222)),
          "2",
          2,
          -2,
          2.1,
          -2.1,
          ($double(2.1))
          ]
 s array."18"=2
 s array."19"=-2
          
 f i=0:1:array.%Size() {
   w i,")",?4,array.%Get(i),?30,$$TypeOf1(.array,i),?45,$$TypeOf2(array.%Get(i)),!
 }
 
 // Return JSON datatype by the documented way
 //
TypeOf1(&array,key)
{
  s typ=array.%GetTypeCodeOf(key)
  q typ_" "_$case(typ,
    $$$PVVALUENULL:"null",
    $$$PVVALUETRUE:"boolTrue",
    $$$PVVALUEFALSE:"boolFalse",
    $$$PVVALUEINTEGERPOS:"+int",
    $$$PVVALUEINTEGERNEG:"-int",
    $$$PVVALUEUNUSED1:"unused",
    $$$PVVALUEARRAY:"array",
    $$$PVVALUEOBJECT:"object",
    $$$PVVALUETEXT:"text",
    $$$PVVALUENUMBER:"number",
    $$$PVVALUEOVERFLOW:"overflow",
    $$$PVVALUECACHENUMERIC:"cacheNumeric",
    $$$PVVALUEOREF:"oref",
    $$$PVVALUEUNASSIGNED:"unassigned",
    $$$PVVALUELONGPOS:"+long",
    $$$PVVALUELONGNEG:"-long",
    $$$PVVALUEBYTE:"byte[]",
    $$$PVVALUEDATETIME:"dateTime",
    $$$PVVALUEDOUBLE:"double",
    $$$PVVALUESINGLE:"single",
    $$$PVVALUEUTF8:"utf8",
    $$$PVVALUENESTED:"nested",
    $$$PVVALUEEOF:"eof",
    :"unknown")
}
   
 // Return datatype by the undocumented $LB() way
 //
TypeOf2(val)
 {
  i $l(val)>253 {
    s typ=$ziswide(val)+1
  } else {
    s typ=$a($lb(val),2)
  }
  q typ_" "_$case(typ
    ,1:"8bitString"
    ,2:"16bitString"
    ,4:"nonNegativeInteger"
    ,5:"negativeInteger"
    ,6:"nonNegativeFloat"
    ,7:"negativeFloat"
    ,8:"double"
    , :"??? never seen before")
}

Result:

USER>d ^types
№   VALUE                     JSON           $LISTBUILD
-------------------------------------------------------
0)  Ÿ                          8 text         1 8bitString
                              8 text         1 8bitString
2)                            8 text         1 8bitString
3)                            0 null         1 8bitString
4)  1                         1 boolTrue     1 8bitString
5)  0                         2 boolFalse    1 8bitString
6)  4@%ZEN.proxyObject        12 oref        1 8bitString
7)  2@%Library.DynamicArray   6 array        1 8bitString
8)  1@%Library.DynamicObject  7 object       1 8bitString
9)  abcd                      8 text         1 8bitString
10) 視                         8 text         2 16bitString
11) 2                         8 text         1 8bitString
12) 2                         9 number       4 nonNegativeInteger
13) -2                        9 number       5 negativeInteger
14) 2.1                       9 number       6 nonNegativeFloat
15) -2.1                      9 number       7 negativeFloat
16) 2.1000000000000000888     18 double      8 double
17)                           13 unassigned  1 8bitString
18) 2                         3 +int         4 nonNegativeInteger
19) -2                        4 -int         5 negativeInteger
20)                           31 eof         1 8bitString

On my desktop quite other results.

  n N,j,time

  s N=1e8

  f j=1,2/*,3,4,5*/ {
    w j,") "

    s time=$zh
    d @("j"_j)(N)
    w $zh-time," s.",!
  }
  q
j1(N) public {
  f i=1:1:N {s (a,b,c,d,e,f)=0}
}
j2(N) public {
  f i=1:1:N {s a=0,b=0,c=0,d=0,e=0,f=0}
}
j3(N) public {
  f i=1:1:N {s a=0,b=1,c=2,d=3,e=4,f=5}
}
j4(N) public {
  f i=1:1:N {s a=0 s b=1 s c=2 s d=3 s e=4 s f=5}
}
j5(N) public {
  f i=1:1:N {s $lb(a,b,c,d,e,f)=$lb(0,1,2,3,4,5)}
}

Results:

USER>d ^perf
1) 11.814189 s.
2) 4.683832 s.

As you can see the difference is almost 2.5 times.

I also want to note that
s (a,b,c)=0
is slower than
s a=0,b=0,c=0

Please note that the option with %INLIST does not yet use “collection” indexes, and will therefore be slower than the one provided above ^proof

Using Caché System Monitor

You are right, the macro $$$NULL present only in %sqlMigration.inc and this is not the file that developers often include to its project.
I prefer to use the macro $$$NULLOREF/$$$NULLOID from %occExtent.inc, which is available by default in the class that inherits from %Library.Base, and for routines is enough to include %systemInclude.inc.

Why so difficult?
This similarly following condition:

WHERE 
(
year(current_date) - year(DOB)
) >= 13

It Besides above was already indicated, why does not follow to use such a code, for example:

select datediff(year,
todate(to_char({d '1990-12-31'},'YYYY')||':1','YYYY:MM'), -- birthday
todate(to_char({d '2003-01-01'},'YYYY')||':1','YYYY:MM') -- report date
)

This gives an incorrect result - 13, although it should be 12.

The key difference of $classmethod is runtime:

$CLASSMETHOD permits a ObjectScript program to invoke an arbitrary class method in an arbitrary class. Both the class name and the method name may be computed at runtime or supplied as string constants.^proof