This code performs the task of parsing a database-stored blob...

September 3, 2025 at 01:58 PM

private static Map<String, Map<String, Object>> parseBlobAndExtract(String uuid, Config cfg) {
   Map<String, Map<String, Object>> tableKeyMap = new LinkedHashMap<>();
   try (Connection c = getSchema2Connection(cfg);
        PreparedStatement ps = c.prepareStatement("SELECT BUSINESS_OBJECT FROM BO_EXTN_DETAIL WHERE BANCS_CORRELATION_ID = ?")) {
       ps.setString(1, uuid);
       ResultSet rs = ps.executeQuery();
       if (!rs.next()) {
           System.out.println("UUID not found in BO_EXTN.");
           return tableKeyMap;
       }
       String blob = new String(rs.getBlob(1).getBytes(1, (int) rs.getBlob(1).length()));
       String[] lines = blob.split("\\r?\\n");
       for (int i = 0; i < lines.length; i++) {
           String line = lines[i].trim();
           /* 1??  When we hit "MessageHeader", look upward for the quoted table token */
           if (line.contains("\"MessageHeader\"")) {
               String rawTable = null;
               for (int j = i - 1; j >= 0; j--) {
                   String up = lines[j].trim();
                   if (up.matches("\"[^\"]+\"\\s*:\\s*\\{?")) {
                       rawTable = up.substring(up.indexOf('"') + 1, up.lastIndexOf('"'));
                       break;
                   }
               }
               if (rawTable == null) continue;
               String cleanedTable = cleanPrefixAndSuffix(rawTable, cfg).toUpperCase();
               Map<String, Object> keyValues = new LinkedHashMap<>();
               /* 2??  Find the "Key" block within next ~20 lines */
               int keyIndex = -1;
               for (int j = i; j < Math.min(i + 20, lines.length); j++) {
                   if (lines[j].contains("\"KeyVal\"")) { keyIndex = j; break; }
               }
               if (keyIndex == -1) continue;
               /* 3??  Get "#text" line (usually +2) to read key names */
               String keysRaw = null;
               for (int j = keyIndex; j <= keyIndex + 5 && j < lines.length; j++) {
                   if (lines[j].contains("\"#text\"")) {
                       keysRaw = lines[j].split(":", 2)[1].replaceAll("[\"{}]", "").trim();
                       break;
                   }
               }
               if (keysRaw == null) continue;
               /* 4??  Parse key names */
               List<String> keyNames = new ArrayList<>();
               for (String k : keysRaw.split("-")) {
                   String name = k.split(":")[0].trim().toUpperCase();
                   if (!name.isEmpty()) keyNames.add(name);
               }
               /* 5??  For each key, find its value (#text two lines below the key block) */
               for (String key : keyNames) {
                   for (int j = i; j < lines.length; j++) {
                       String l = lines[j].replace("\"", "").trim().toUpperCase();
                       if (l.startsWith(key + ":")) {
                           for (int k = j; k <= j + 5 && k < lines.length; k++) {
                               if (lines[k].contains("\"#text\"")) {
                                   String val = lines[k].split(":", 2)[1]
                                                  .replaceAll("[\"{},]", "").trim();
                                   keyValues.put(key, val);
                                   break;
                               }
                           }
                           break;
                       }
                   }
               }
               /* 6??  Store & print */
               if (!keyValues.isEmpty()) {
                   tableKeyMap.put(cleanedTable, keyValues);
                   System.out.println("TABLE  : " + cleanedTable);
                   keyValues.forEach((k,v) -> System.out.println(" " + k + " = " + v));
               }
           }
       }
   } catch (Exception e) {
       e.printStackTrace();
   }
   return tableKeyMap;
}

This code performs the task of parsing a database-stored blob (a large object such as a binary or text data) and extracting structured data from it. Here's a breakdown of what the code does:

1. Setup and Database Query

The method is named parseBlobAndExtract and takes a string uuid and a configuration cfg as inputs.
It initializes a result map, tableKeyMap, which will store the extracted information.
It establishes a database connection (getSchema2Connection(cfg)), and runs a query to fetch a blob value (BUSINESS_OBJECT) from the table BO_EXTN_DETAIL, filtering by the BANCS_CORRELATION_ID which matches the provided uuid.
If no result (no uuid match) is found, the method logs a message and returns the empty tableKeyMap.

2. Processing the Blob Data

The blob is fetched and converted to a String, splitting its content into lines.
The method iterates over the lines to process them.

3. Locating a Specific Block (`MessageHeader`)

It searches for lines containing "MessageHeader". When found:
1. Searches lines above it for a "quoted table token” (a line matching the format "TOKEN" : { to determine the associated table name). If found, it cleans and normalizes (e.g., uppercases) the table name using the helper cleanPrefixAndSuffix(rawTable, cfg).
2. Resumes scanning the subsequent lines to find a block starting with "KeyVal". This is expected to define key-value mappings.

4. Extracting Key Names

The method finds a line containing "#text", which should hold raw key names formatted in some way. The key names are split, cleaned, and collected into a list.

5. Extracting Key-Value Pairs

For each key name identified:
1. The method searches forward in the blob to find its matching line.
2. Once the key is found, it searches (a bounded number of lines ahead) for its value, which is stored in a similar "#text" field.
3. Key-value mappings are stored in a keyValues map.

6. Storing and Logging Results

The extracted keyValues map is associated with the cleaned table name in tableKeyMap.
Results are printed, listing the table name (TABLE) and its key-value pairs.

7. Error Handling

The logic is enclosed in a try-catch block to safely handle database, parsing, or runtime exceptions (which are logged/stored as stack traces).

Summary of Functionality

In summary, this method:

Queries a database for a blob associated with the given uuid.
Parses and extracts structured data from the blob, specifically focusing on:
- A table identifier (found near "MessageHeader" lines).
- Key-value pairs (from "KeyVal" and "#text" blocks).
Organizes the extracted data into a nested map (tableKeyMap):
- Outer map key: table identifier.
- Inner map: key-value pairs for that table.
Logs or prints the results step-by-step.

Use Case

This function appears to process hierarchically structured text (possibly in JSON-like syntax) stored as a blob in a database, potentially representing business objects with metadata. It's designed to extract and catalog specific headers and associated key-value data for further use or analysis.

Generate your own explanations

Download our vscode extension

Read other generated explanations

Built by @thebuilderjr