If you want to compare two in-memory objects, you can use method generators, there are several related articles and discussions on that:

• Exploring Code Generation with Caché Method Generators
• Generic way to test if all the propertiers of an object are null
• Cheap object hashing?

Simple comparator on GiitHib - note that it's a runtime comparator, therefore slow. Better solution would be method generators.

If you're comparing objects of different classes you need to find their common ancestor class and compare using that.

If you're comparing stored objects you can calculate hashes and compare that.

All in all it's a very complex topic and you need to determine what requirements do you have:

• Streams?
• Lists? Arrays? Position change?
• Loops/relationships strategy
• How many levels to compare?
• Different classes? Do they have common superclass?
• Do you need to compare dynamic objects/objects from unrelated classes?

And design your comparator based on that.

Here's a simple hasher on GitHub.

That works only for CSP context and CSP pages. You can write a wrapper I suppose, but I think it would be easier to just write your own querybuilder code:

ClassMethod Link(server = "www.example.com")
{
    try {
        set cspContext = $data(%request)
        if 'cspContext {
          set %request = {} // ##class(%CSP.Request).%New()  
          set %response = ##class(%CSP.Response).%New()
          set %session = {} //##class(%CSP.Session).%New(-1,0)
        }
        set query("param") = 1
        set page = "/abcd.csp"
        set url = ##class(%CSP.Page).Link(page,.query)
        set url = $replace(url, page, server)
        write url
        kill:'cspContext %request,%response,%session
    } catch {
        kill:'$g(cspContext) %request,%response,%session
    }
}

With querybuilder:

ClassMethod Link(server = "www.example.com")
{
    set query("param") = 1

    set data = ""
    set param = $order(query(""),1,value)
    while (param'="") {
        set data=data _ $lb($$$URLENCODE(param)_"="_$$$URLENCODE(value))
        set param = $order(query(param),1,value)          
    }
    write server _ "?" _ $lts(data, "&")
}

For higher performance it's better to keep the data in InterSystems platform and sync it with remote db periodically.

To download the data via xDBC you have two main approaches:

• Interoperability (Ensemble) SQL inbound adapter
• "Raw" access via %SQLGatewayConnection or %Net.Remote.Java.JDBCGateway

Interoperability approach is better as it solves most problems and user should just enter the query, etc. "Raw" can be faster and allows for fine-tuning.

Now, to keep data synced there are several approaches available:

• If source table has UpdatedOn field, track it and get rows updated only after last sync.
• Journals: some databases provide parsable journals, use them to determine which rows changed in relevant tables.
• Triggers: sometimes source table has triggers (i.e. Audit) which while do not provide explicit UpdatedOn field nonetheless can be used to determine row update time.
• Hashing: hash incoming data and save the hash, update the row only if hash changed.

If you can modify source database - add UpdatedOn field, it's the best6 solution.

Linked tables allow you not to store data permanently, but the cube would be rebuilt each time. With other approaches syncing cube is enough.

Also check this guide on DeepSee Data Connectors.

Use parameters instead of building the query manually. Everything would be escaped automatically.

I'm calling load code like this:

csession ensemble "##class(isc.git.GitLab).load()"

ObjectScript:

/// Do a full load
/// do ##class(isc.git.GitLab).load()
ClassMethod load()
{
    try {
        set dir = "/src"
        do ..log("Importing dir " _ dir)
        do $system.OBJ.ImportDir(dir, "*.xml", "c", .errors, 1)
        throw:$get(errors,0)'=0 ##class(%Exception.General).%New("Load & compile error")
        halt
    } catch ex {
        write !,$System.Status.GetErrorText(ex.AsStatus()),!
        do $system.Process.Terminate(, 1)
    }
}

This way process terminates abnormally on error:

do $system.Process.Terminate(, 1)

And it's usually reported as error in CI/CD systems.

Additionally you can grep for "Load & compile error".

I'm currently writing a series of articles on continuous delivery, check it out (latest part).