Add commands flags based on static map (#4332)

* Add commands flags based on static map

* Clean up CommandFlagsRegistryGenerator

* more fixes to CommandFlagsRegistryGenerator

* Introduce CommandFlagsRegistry interface

- Add new interface and move CommandFlag enum there
- Generate StaticCommandFlagsRegistry instead of embedding generated code into CommandObject
- Allow passing custom CommandFlagsRegistry to ClusterClientBuilder

* Fix formatting

* Add support for sub-commands

* Use CommandArguments in the interface and hierarchical approach in static registry

* Expose get() on CommandArguments for cleaner code

* Use byte array based look up to improve performance

* (clean up) Separate generated command flags registry initialisation from actual implementation (#4345)

* (clean up) Extract generated registry initialization

* regenerate after clean up

* reformat

* Clean up StaticCommandFlagsRegistry

---------

Co-authored-by: Ivo Gaydazhiev <ivo.gaydazhiev@redis.com>

Author: uglide

pom.xml

@@ -360,6 +360,8 @@
 						<!-- Exclude integration tests from unit-test phase -->
 						<exclude>**/*IntegrationTest.java</exclude>
 						<exclude>**/*IntegrationTests.java</exclude>
+						<!-- Exclude code generators - these are tools, not tests -->
+						<exclude>**/codegen/**/*.java</exclude>
 					</excludes>
 					<!--<trimStackTrace>false</trimStackTrace>-->
 				</configuration>
@@ -535,6 +537,7 @@
 						<include>**/MultiDb*.java</include>
 						<include>**/ClientTestUtil.java</include>
 						<include>**/ReflectionTestUtil.java</include>
+						<include>**/*CommandFlags*.java</include>
 					</includes>
 				</configuration>
 				<executions>

src/main/java/redis/clients/jedis/CommandArguments.java

@@ -195,6 +195,16 @@ public int size() {
     return args.size();
   }
 
+  /**
+   * Get the argument at the specified index.
+   * @param index the index of the argument to retrieve (0-based, where 0 is the command itself)
+   * @return the Rawable argument at the specified index
+   * @throws IndexOutOfBoundsException if the index is out of range
+   */
+  public Rawable get(int index) {
+    return args.get(index);
+  }
+
   @Override
   public Iterator<Rawable> iterator() {
     return args.iterator();

src/main/java/redis/clients/jedis/CommandFlagsRegistry.java

@@ -0,0 +1,52 @@
+package redis.clients.jedis;
+
+import java.util.EnumSet;
+
+/**
+ * Registry interface for command flags. Provides a mapping from Redis commands to their flags. This
+ * interface allows for different implementations of the flags registry.
+ */
+public interface CommandFlagsRegistry {
+
+  /**
+   * Command flags based on command flags exposed by Redis. See
+   * <a href="https://redis.io/docs/latest/commands/command/#flags">Command flags</a> for more
+   * details.
+   * <p>
+   * Flags description:
+   * <ul>
+   * <li>READONLY: Command doesn't modify data</li>
+   * <li>WRITE: Command may modify data</li>
+   * <li>DENYOOM: Command may increase memory usage (deny if out of memory)</li>
+   * <li>ADMIN: Administrative command</li>
+   * <li>PUBSUB: Pub/Sub related command</li>
+   * <li>NOSCRIPT: Command not allowed in scripts</li>
+   * <li>SORT_FOR_SCRIPT: Command output needs sorting for scripts</li>
+   * <li>LOADING: Command allowed while database is loading</li>
+   * <li>STALE: Command allowed on stale replicas</li>
+   * <li>SKIP_MONITOR: Command not shown in MONITOR output</li>
+   * <li>ASKING: Command allowed in cluster ASKING state</li>
+   * <li>FAST: Command has O(1) time complexity</li>
+   * <li>MOVABLEKEYS: Command key positions may vary</li>
+   * <li>MODULE: Module command</li>
+   * <li>BLOCKING: Command may block the client</li>
+   * <li>NO_AUTH: Command allowed without authentication</li>
+   * <li>NO_ASYNC_LOADING: Command not allowed during async loading</li>
+   * <li>NO_MULTI: Command not allowed in MULTI/EXEC</li>
+   * <li>NO_MANDATORY_KEYS: Command may work without keys</li>
+   * <li>ALLOW_BUSY: Command allowed when server is busy</li>
+   * </ul>
+   */
+  enum CommandFlag {
+    READONLY, WRITE, DENYOOM, ADMIN, PUBSUB, NOSCRIPT, SORT_FOR_SCRIPT, LOADING, STALE,
+    SKIP_MONITOR, SKIP_SLOWLOG, ASKING, FAST, MOVABLEKEYS, MODULE, BLOCKING, NO_AUTH,
+    NO_ASYNC_LOADING, NO_MULTI, NO_MANDATORY_KEYS, ALLOW_BUSY
+  }
+
+  /**
+   * Get the flags for a given command.
+   * @param commandArguments the command arguments containing the command and its parameters
+   * @return EnumSet of CommandFlag for this command, or empty set if command has no flags
+   */
+  EnumSet<CommandFlag> getFlags(CommandArguments commandArguments);
+}

src/main/java/redis/clients/jedis/StaticCommandFlagsRegistry.java

@@ -0,0 +1,207 @@
+package redis.clients.jedis;
+
+import redis.clients.jedis.args.Rawable;
+import redis.clients.jedis.commands.ProtocolCommand;
+import redis.clients.jedis.util.JedisByteMap;
+import redis.clients.jedis.util.SafeEncoder;
+
+import java.util.EnumSet;
+import java.util.Map;
+
+/**
+ * Static implementation of CommandFlagsRegistry.
+ */
+public class StaticCommandFlagsRegistry implements CommandFlagsRegistry {
+
+  // Empty flags constant for commands with no flags
+  public static final EnumSet<CommandFlag> EMPTY_FLAGS = EnumSet.noneOf(CommandFlag.class);
+
+  // Singleton instance
+  private static final StaticCommandFlagsRegistry REGISTRY = createRegistry();
+
+  private final Commands commands;
+
+  private StaticCommandFlagsRegistry(Commands commands) {
+    this.commands = commands;
+  }
+
+  /**
+   * Get the singleton instance of the static command flags registry.
+   * <p>
+   * DO NOT USE THIS METHOD UNLESS YOU KNOW WHAT YOU ARE DOING.
+   * </p>
+   * @return StaticCommandFlagsRegistry
+   */
+  public static StaticCommandFlagsRegistry registry() {
+    return REGISTRY;
+  }
+
+  private static StaticCommandFlagsRegistry createRegistry() {
+
+    Builder builder = new Builder();
+
+    // Delegate population to generated class
+    StaticCommandFlagsRegistryInitializer.initialize(builder);
+
+    return builder.build();
+  }
+
+  /**
+   * Get the flags for a given command. Flags are looked up from a static registry based on the
+   * command arguments. This approach significantly reduces memory usage by sharing flag instances
+   * across all CommandObject instances.
+   * <p>
+   * For commands with subcommands (e.g., FUNCTION LOAD, ACL SETUSER), this method implements a
+   * hierarchical lookup strategy:
+   * <ol>
+   * <li>First, retrieve the parent command using CommandArguments.getCommand()</li>
+   * <li>Check if this is a parent command (has subcommands in the registry)</li>
+   * <li>If it is a parent command, attempt to get the child/subcommand by:
+   * <ul>
+   * <li>Extracting the second argument from the CommandArguments object</li>
+   * <li>Matching this second argument against the child items of the parent command</li>
+   * </ul>
+   * </li>
+   * <li>Return the appropriate flags based on whether a child command was found or just use the
+   * parent command's flags</li>
+   * </ol>
+   * @param commandArguments the command arguments containing the command and its parameters
+   * @return EnumSet of CommandFlag for this command, or empty set if command has no flags
+   */
+  @Override
+  public EnumSet<CommandFlag> getFlags(CommandArguments commandArguments) {
+    // Get the parent command
+    ProtocolCommand cmd = commandArguments.getCommand();
+    byte[] raw = cmd.getRaw();
+
+    // Convert to uppercase using SafeEncoder utility (faster than String.toUpperCase())
+    byte[] uppercaseBytes = SafeEncoder.toUpperCase(raw);
+
+    // Look up the parent command in the registry using byte array key
+    // Object registryEntry = COMMAND_FLAGS_REGISTRY.get(uppercaseBytes);
+    CommandMeta commandMeta = commands.getCommand(uppercaseBytes);
+
+    if (commandMeta == null) {
+      // Command not found in registry
+      return EMPTY_FLAGS;
+    }
+
+    if (!commandMeta.hasSubcommands()) {
+      // Check if this is a simple command without subcommands
+      return commandMeta.getFlags();
+    } else {
+      // Parent command with subcommands
+      // Try to extract the subcommand from the second argument
+      byte[] subCommand = getSubCommand(commandArguments);
+      if (subCommand != null) {
+        CommandMeta subCommandMeta = commandMeta.getSubcommand(subCommand);
+        if (subCommandMeta != null) {
+          return subCommandMeta.getFlags();
+        } else {
+          // (second argument exists but not a recognized subcommand , return parent flags
+          return commandMeta.getFlags();
+        }
+      } else {
+        // no second argument (no subcommand), return parent flags
+        return commandMeta.getFlags();
+      }
+    }
+  }
+
+  private byte[] getSubCommand(CommandArguments commandArguments) {
+    if (commandArguments.size() > 1) {
+      Rawable secondArg = commandArguments.get(1);
+      byte[] subRaw = secondArg.getRaw();
+
+      // Convert to uppercase using SafeEncoder utility
+      return SafeEncoder.toUpperCase(subRaw);
+    } else {
+      return null;
+    }
+  }
+
+  // Internal class to hold subcommand mappings for parent commands.
+  static class Commands {
+
+    final JedisByteMap<CommandMeta> commands = new JedisByteMap<>();
+
+    boolean isEmpty() {
+      return commands.isEmpty();
+    }
+
+    public Commands register(byte[] cmd, CommandMeta command) {
+      commands.put(cmd, command);
+      return this;
+    }
+
+    public boolean containsKey(byte[] command) {
+      return commands.containsKey(command);
+    }
+
+    public CommandMeta getCommand(byte[] command) {
+      return commands.get(command);
+    }
+
+    public Map<byte[], CommandMeta> getCommands() {
+      return commands;
+    }
+  }
+
+  //
+  static class CommandMeta {
+
+    final EnumSet<CommandFlag> flags;
+
+    final Commands subcommands = new Commands();
+
+    CommandMeta(EnumSet<CommandFlag> flags) {
+      this.flags = flags;
+    }
+
+    void putSubCommand(byte[] subCommand, CommandMeta subCommandMeta) {
+      this.subcommands.register(subCommand, subCommandMeta);
+    }
+
+    boolean hasSubcommands() {
+      return !subcommands.isEmpty();
+    }
+
+    EnumSet<CommandFlag> getFlags() {
+      if (flags == null) {
+        return EMPTY_FLAGS;
+      }
+
+      return flags;
+    }
+
+    CommandMeta getSubcommand(byte[] subcommand) {
+      return subcommands.getCommand(subcommand);
+    }
+  }
+
+  static public class Builder {
+
+    private final Commands commands = new Commands();
+
+    public Builder register(String name, EnumSet<CommandFlag> flags) {
+      commands.register(SafeEncoder.encode(name), new CommandMeta(flags));
+      return this;
+    }
+
+    public Builder register(String name, String subcommand, EnumSet<CommandFlag> flags) {
+      byte[] cmdName = SafeEncoder.encode(name);
+
+      if (!commands.containsKey(cmdName)) {
+        commands.register(SafeEncoder.encode(name), new CommandMeta(EMPTY_FLAGS));
+      }
+
+      byte[] subCmdName = SafeEncoder.encode(subcommand);
+      commands.getCommand(cmdName).putSubCommand(subCmdName, new CommandMeta(flags));
+      return this;
+    }
+
+    public StaticCommandFlagsRegistry build() {
+      return new StaticCommandFlagsRegistry(commands);
+    }
+  }
+}