REDIS commands should use database transient values

[lvca]

REDIS commands that read/update/delete transient values should work against the new LocalDatabase.globalVariables map.

[gramian]

Could this be as easy as just replacing defaultBucket by globalVariables?

It needs to be made sure a deletion corresponds to setting to null, and checking for existence is counting not-nulls form the Redis side.

A map, object needs to allow @type properties, but won't have @rid (?), so transient and persistent records can be moved from one to the other and vice versa.

[lvca]

Digging more on this, I see we need a database object to access to its global variables, but some REDIS commands now store into the centralized defaultBucket. It would be better, I think, to declare a default database, and work ALWAYS against a database. So we can use the temporary map and persistence as well.

Then we could use the redis command SELECT <db-name> to switch the database. In Redis the SELECT accepts a number 0-15 (database id), so it would be a little different with the db name.

Then, every command should support the prefix, like we already do. If the prefix is used, then it's referring to the database name, otherwise goes with the selected database if any, otherwise with the default database in configuration.

WDYT?

[lvca]

Then the globalVariables will be accessible from both REDIS and SQL. Example:

@Test
  void testGlobalVariablesSharedWithSQL() throws Exception {
    // This test verifies that Redis SET/GET uses the same storage as SQL variables

    // Set a value via Redis
    executeCommand(0, "redis", "SET sharedVar hello_from_redis");

    // Verify we can read it back via Redis
    JSONObject response = executeCommand(0, "redis", "GET sharedVar");
    assertThat(getResultValue(response)).isEqualTo("hello_from_redis");

    // Verify the value is accessible via SQL using $variable syntax
    final Database database = getServerDatabase(0, getDatabaseName());
    try (final ResultSet rs = database.query("sql", "SELECT $sharedVar as val")) {
      assertThat(rs.hasNext()).isTrue();
      final Result result = rs.next();
      assertThat((String) result.getProperty("val")).isEqualTo("hello_from_redis");
    }

    // Set another value via Redis and verify it's in the global variables map
    executeCommand(0, "redis", "SET counter 100");
    executeCommand(0, "redis", "INCR counter");

    // The incremented value should be accessible
    response = executeCommand(0, "redis", "GET counter");
    assertThat(getResultValueAsLong(response)).isEqualTo(101L);

    // And also via SQL
    try (final ResultSet rs = database.query("sql", "SELECT $counter as val")) {
      assertThat(rs.hasNext()).isTrue();
      final Result result = rs.next();
      assertThat(((Number) result.getProperty("val")).longValue()).isEqualTo(101L);
    }
  }

[lvca]

Then we could create an object on both database persistent type:

HSET MyDatabase.Account "{'id':123,'email':'jay.miner@commodore.com','firstName':'Jay','lastName':'Miner'}"

And transient in the global variables (simply omitting the type name):

HSET MyDatabase "{'id':123,'email':'jay.miner@commodore.com','firstName':'Jay','lastName':'Miner'}"

WDYT?

[lvca]

Like this:

  HSET:
  - HSET <database> <type> <json>... → Persistent (creates documents in database type)
  - HSET <database> <json>... → Transient (stores JSON in globalVariables, second arg starts with {)
    - Uses id field from JSON as the key

  HGET, HEXISTS:
  - HGET <database>.<index> <key> → Persistent (by index)
  - HGET <database> #rid → Persistent (by RID)
  - HGET <database> <key> → Transient (no dot, key doesn't start with #)

  HDEL:
  - HDEL <database>.<index> <keys>... → Persistent (delete by index)
  - HDEL <database> <keys>... → Transient (no dot, deletes from globalVariables)

  HMGET:
  - HMGET <database>.<index> <keys>... → Persistent (by index)
  - HMGET <database> <keys>... → Transient (no dot, gets from globalVariables)

[gramian]

I cannot follow; I thought the trick was to have only hash commands persistent, as the hash is emulated by the type? So only non-H-commands like SET interact with global variables, while H-commands like HSET use the target type name as hash.

The database could be determined by the server path when using the Redis protocol, while when using HTTP, the database is already in the path.

So:

SET temp "value"

allows:

SELECT $temp -- returns "value"

And:

HSET doc text "info"

allows:

SELECT text FROM doc -- returns "info"

All in all, omitting the <database> part from your proposal, and replace the current central Redis defaultBucket with a per-database map.

PS: AFAIK The Redis SELECT command is currently not implemented and when supporting Redis only per-database, it is not needed IMHO.

[gramian]

Seems to be the onlz feasible way, as there is no way to select the database through the connection.

[lvca]

You can set the default database for redis with a new global setting:

REDIS_DEFAULT_DATABASE("arcadedb.redis.defaultDatabase", SCOPE.SERVER,
      "Default database name for Redis protocol connections. If set, RAM commands (SET, GET, etc.) will use this database's globalVariables. Empty means no default (requires SELECT command or key prefix)", String.class, ""),