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

What will be the result you have?
Also check the settings for the format of the data types in your tool (DbVisualizer, Caché Monitor, WinSQL, SQuirreL SQL, etc.), in which you make a selection.

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()

There a sample of the code is brought.

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)
          )
}

There is a method $system.Memory.Clean(<cleancache>, <defragment>), but unfortunately it appeared only with version 2011.1.

Try this code (consider that LONGVARCHAR = %Stream.GlobalCharacter) ^{Read a CLOB through JDBC}: