Class dc.demo Extends %Persistent
{
Property ChildPrice As %Library.Float;
ClassMethod Test()
{
  ;d ##class(dc.demo).Test()
  d ..%KillExtent()
  s obj=..%New()
  s obj.ChildPrice=2.56
  d obj.%Save()
  
  &sql(select ChildPrice into :ChildPrice from dc.demo where %ID=1)
  w ChildPrice,!
}
}
My result:
USER>d ##class(dc.demo).Test()
2.56

Synchronous and Asynchronous Methods

1. ClientMethod onunloadHandler() [ Language = javascript ]
   {
     this.SomeZenMethod();
   }
   
   ClassMethod SomeZenMethod() As %Status [ ZenMethod ]
   {
     // to do some work
     quit $$$OK
   }

2. ClientMethod onunloadHandler() [ Language = javascript ]
   {
     var old = zenSynchronousMode;
     zenSynchronousMode = true;
     this.SomeZenMethod();
     zenSynchronousMode = old;
   }
   
   ClassMethod SomeZenMethod() [ ZenMethod ]
   {
     // to do some work
   }

The following code has been tested on versions 2015.2 and 2017.2:

Class dc.demo Extends %RegisteredObject
{

Property f1 As %String;

Property f2 As %Integer;

Property f3 As %ListOfDataTypes;

Method GetTarget(
  ByRef pParms As %String,
  Output pObj As %RegisteredObject) As %Status
{
  s pObj = ..%New()
  
  i $g(pParms(1))="a" {
    s pObj.f1 = "Peter"
    s pObj.f2 = 21
  }else{
    s pObj.f1 = "Bob"
    s pObj.f2 = 12
    s pObj.f3 = ##class(%ListOfDataTypes).%New()
    d pObj.f3.InsertList($lb("a","b","c"))
  }
  q $$$OK
}

ClassMethod Obj2Json()
{
  ;d ##class(dc.demo).Obj2Json()
  
  s parms(1)="a"
  d ##class(%ZEN.Auxiliary.jsonProvider).%WriteJSONStreamFromObject(.stream,..%New(),"GetTarget",.parms,$$$YES,"aeloq")
  w "1) ",stream.Read($$$MaxLocalLength),!
  
  k parms
  d ##class(%ZEN.Auxiliary.jsonProvider).%WriteJSONStreamFromObject(.stream,..%New(),"GetTarget",.parms,$$$YES,"aeloq")
  w "2) ",stream.Read($$$MaxLocalLength),!
}

ClassMethod Json2Obj()
{
  ;d ##class(dc.demo).Json2Obj()
  
  d ##class(%ZEN.Auxiliary.jsonProvider).%ConvertJSONToObject("{""f1"":""Peter"",""f2"":21,""f3"":[]}",$classname(),.obj)
  w obj.f1," : ",obj.f3.Count(),!

  d ##class(%ZEN.Auxiliary.jsonProvider).%ConvertJSONToObject("{""f1"":""Bob"",""f2"":12,""f3"":[""a"",""b"",""c""]}",$classname(),.obj)
  w obj.f1," : ",obj.f3.Count(),!
}

}

Result:

USER>d ##class(dc.demo).Obj2Json()
1) {"f1":"Peter","f2":21,"f3":[]}
2) {"f1":"Bob","f2":12,"f3":["a","b","c"]}
 
USER>d ##class(dc.demo).Json2Obj()
Peter : 0
Bob : 3

Class dc.SomeClass
{
Parameter SOMENAME = "Name1";
Query SomeQuery(SOMENAME = {..#SOMENAME}) As %SQLQuery
{
  SELECT ID || :SOMENAME || Name FROM Table1
}
Query SomeQuery1() As %SQLQuery
{
  #define SOMENAME ##Expression("'"$parameter("dc.SomeClass","SOMENAME")"'")
  SELECT ID || $$$SOMENAME || Name FROM Table1
}
Query SomeQuery2() As %SQLQuery
{
  #define SOMENAME ##Expression("'"##class(dc.SomeClass).#SOMENAME"'")
  SELECT ID || $$$SOMENAME || Name FROM Table1
}
ClassMethod Test()
{
  ;d ##class(dc.SomeClass).Test()
  
  s rs=##class(%ResultSet).%New("dc.SomeClass:SomeQuery")
  s sc=rs.Execute()
  i $$$ISERR(sc) {
    d $System.Status.DisplayError(sc)
  } else {
    d rs.%Display()
  }
}
}

Client Side Callback Methods for the Page

///  This client event, if present, is fired when the page is unloaded.
///  If this method returns a string value, then that is used as the
///  return value of the HTML page's onbeforeunload handler (if more than
///  one component returns a string, the first one encountered is used).
ClientMethod onunloadHandler() [ Language = javascript ]
{
  return 'Are you sure you want to leave?';
}

The following query produces zero results:

select bar.name from foo join bar on bar.id %INLIST MyBars

This is because MyBars is stored as a $lb($lb(id1),$lb(id2),...,$lb(idN)), and you try to query the data stored in the form $lb(id1,id2,...,idN).

Your query need some change to make it work, namely:

select name from foo join bar b on $listbuild(b.%ID) %INLIST MyBars

For passing array by reference try to use the class $system.WorkMgr instead of job.

Sample:

Class demo.test [ Abstract ]
{

ClassMethod Test(array) As %Status
{
  k ^CacheTempUser.dbg
  m ^CacheTempUser.dbg($zp)=array
  s ^CacheTempUser.dbg($zp,"$j")=$j
  q $$$OK
}

}

demo()
  n queue,arr

  s arr(1)="qwe"
  s arr(2)="asd"
  
  w "$j = ",$j,!
  s queue=$system.WorkMgr.Initialize("/multicompile=1",,1)
  d queue.Queue("##class(demo.test).Test",.arr)
  d queue.WaitForComplete()
  
  zw ^CacheTempUser.dbg
  q

Result:

USER>d ^demo
$j = 7600
^CacheTempUser.dbg(8488,1)="qwe"
^CacheTempUser.dbg(8488,2)="asd"
^CacheTempUser.dbg(8488,"$j")=8348

Import data programmatically:

• %SQL.ExImData
• CSV()

In addition to the above.

Fill the array tArray can be charged a method %ListOfDataTypes:BuildValueArray(). But I still prefer the next option (unless you count every tick of CPU :) ):

s list=##class(%ListOfDataTypes).%New()
d list.InsertList(tInputList)
 
; method #1
s key="" d {s value=list.GetPrevious(.key)} while (key'="")
 
; method #2 (better way)
f key=list.Size:-1:1 s value=list.GetAt(key)

You can fix this error directly now, if you don't want to wait for the release of version 2018.1.1.

To do this, follow these steps:

1. make export the locale "deuw"

   %SYS>s Locales("deuw")="" d $system.OBJ.DisplayError(##class(Config.NLS.Locales).ExportList("loc_deuw.xml",.t,.Locales)) zw Locales,t

2. fix the file loc_deuw.xml (by default located in the folder %CACHEHOME%\Mgr)
   

   Add the following lines to the appropriate subtables:

   Name of subtable (Where to insert)	New lines (That to insert)
   COL-German3-Unicode	<FromToItem FromToKey="55,55,1">83,83;</FromToItem> <FromToItem FromToKey="55,55,2">7838;</FromToItem> <FromToItem FromToKey="55,55,3">83,7838;</FromToItem>
   COL-Unicode-German3	<FromToItem FromToKey="7838">55,55;2</FromToItem> <FromToItem FromToKey="83,83">55,55;1</FromToItem> <FromToItem FromToKey="83,7838">55,55;3</FromToItem>
   LowerCase-Unicode-Unicode	<FromToItem FromToKey="7838">223</FromToItem>
   UpperCase-Unicode-Unicode	<FromToItem FromToKey="223">7838</FromToItem>

3. import fixed loc_deuw.xml:
   

   %SYS>d $system.OBJ.DisplayError(##class(Config.NLS.Locales).ImportAll("loc_deuw.xml",.t,1+2+4)) zw t
   %SYS>d $system.OBJ.DisplayError(##class(Config.NLS.Locales).Compile("deuw"))
   %SYS>d Locale^NLSLOAD("deuw")

   Just in case, restart Caché.

Now, run a small test

#include %systemInclude
#include %occErrors
#include %syNLS
test() public {
  
  #dim ex As %Exception.AbstractException

  try {
    $$$AddAllRoleTemporaryInTry
    n $namespace
    s $namespace="%SYS"
    
    s oldLocale=$$$LOCALENAME
    w "Old locale = ",oldLocale,!
    d ##class(Config.NLS.Locales).Install("deuw")
    w "Current locale = ",$$$LOCALENAME,!!
    
    k ^||low,^||up

    f w="wei"_$c(223)_"er","weiter","weiser" {
      s ^||low($zcvt(w,"L"))=1
      s ^||up($zcvt(w,"U"))=1
    }
    zw ^||low,^||up
    
    s low=$c(223)
    s up=$zcvt(low,"U")
    zw low,up
    zzdump low,up
    
  }catch(ex) {
    w "Error ", ex.DisplayString(),!
  }
  d ##class(Config.NLS.Locales).Install(oldLocale)

}

My result:

USER>d ^test
Old locale = rusw
Current locale = deuw
 
^||low("weiser")=1
^||low("weißer")=1
^||low("weiter")=1
^||up("WEISER")=1
^||up("WEIẞER")=1
^||up("WEITER")=1
low="ß"
up="ẞ"
 
0000: DF                                                      ß
0000: 1E9E                                                    ẞ

Try this:

Property Amounts As %ArrayOfDataTypes [ SqlComputeCode = { set {*} = ##class(ContainerSize).GetTotalAmounts({ID})}, SqlComputed, Transient ];

ClassMethod GetTotalAmounts(thisID) As %List
{
  quit $lb(
           $lb("GBP",1.23),
           $lb("EUR",2.45)
          )
}

Possible do on-other, namely to write one "universal" query:

select * from person where 
(lastname=:lastname or :lastname is null) and
(age > :age or :age is null)

That is:
sql = "select * from person where (lastname=? or ? is null) and (age > ? or ? is null)"resultset = statement.%Execute(param1, param1, param2, param2)

s l=$lb("",,,,,"",,,"BOOLEAN","0",2,2,"1",,"bla",$lb(,,"bla","20050502123400"),"",1,"bla",,0)
s jsonStr=[(l)].%ToJSON()
w jsonStr,!!
   
s obj=[].%FromJSON(jsonStr)
s list=obj."0"
zw list
Result:
["\u0002\u0001\u0001\u0001\u0001\u0001\u0002\u0001\u0001\u0001\t\u0001BOOLEAN\u0003\u00010\u0003\u0004\u0002\u0003\u0004\u0002\u0003\u00011\u0001\u0005\u0001bla\u0019\u0001\u0001\u0001\u0005\u0001bla\u0010\u000120050502123400\u0002\u0001\u0003\u0004\u0001\u0005\u0001bla\u0001\u0002\u0004"]
list=$lb("",,,,,"",,,"BOOLEAN","0",2,2,"1",,"bla",$lb(,,"bla","20050502123400"),"",1,"bla",,0)

Hi Uri.

In my opinion, this possible hear only empirically through load testing on specific hardware. It is also important and the interface between Caché and the world .NET, namely the number of calls made to a DLL^{Better performance}.

Sometimes the performance gain is observed when .NET refers to Caché (ADO.NET, eXTreme .NET Provider), and not vice versa (.NET Gateway). But it always requires a revision of the architecture.

By the way, for .NET Provider/ADO.NET there is Connection Pooling