This code performs the following functions: 1. Initialize a Data Structure...

September 2, 2025 at 03:25 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 following functions:

Initialize a Data Structure
The method initializes a LinkedHashMap, tableKeyMap, which will store mappings from table names (as String) to their associated key-value data (as a map of String to Object).
Database Connection and Query Execution
- It establishes a database connection using getSchema2Connection(cfg).
- Queries the BO_EXTN_DETAIL table for a record where BANCS_CORRELATION_ID matches the provided uuid. The query retrieves the BUSINESS_OBJECT column of the result set if a match is found.
- If no record is found, it prints a message and returns the empty tableKeyMap.
Extract Blob Data
- The code retrieves the BUSINESS_OBJECT data as a BLOB from the result set.
- It converts the BLOB data to a String and splits it into lines.
Parse the Blob Data
The code processes the lines of the blob to identify table names, keys, and their associated values.
- Finding "MessageHeader": It iterates over the lines of the blob. Upon encountering a line containing "MessageHeader", it looks upward for a quoted table token (e.g., "TableName": pattern). This token represents the table's logical name.
- Cleaning the Table Name: The found table name is cleaned using cleanPrefixAndSuffix(rawTable, cfg) and converted to uppercase.
Extract a "Key" Block
- Searches the next ~20 lines for a "KeyVal" block after locating a "MessageHeader".
- From within "KeyVal", it extracts a "#text" line to determine key names—the keys are split, cleaned, and converted to uppercase.
Find Key Values
For each extracted key:
- It looks within the line set for occurrences of the key name.
- Retrieves the corresponding value from the "#text" line (usually located a few lines below the key definition).
Store the Results
- If key-value data is successfully extracted, the cleaned table name (from step 4) is used as a key in the tableKeyMap, and the extracted key-value data is stored as a nested map under this key.
- It prints the table name and its associated key-value pairs.
Error Handling
- If an exception is encountered during execution, it prints the stack trace for debugging.
Return Extracted Data
- The method finally returns the tableKeyMap, which contains the parsed and processed key-value data for the identified tables.

Purpose

The method's goal is to:

Retrieve and extract structured information from a BLOB stored in the database, associated with a specific uuid.
Parse this structured data (likely in JSON-like format), map table names to corresponding key-value pairs, and return this mapping in a nested dictionary structure (tableKeyMap).

Key Use Case

Process database-serialized BLOB objects, interpret them as containing metadata or structured information, and extract meaningful relationships such as mappings between logical table names and their keys/values for further processing or display.

Generate your own explanations

Download our vscode extension

Read other generated explanations

Built by @thebuilderjr

This code performs the following functions: 1. **Initialize a Data Structure**...

Purpose

Key Use Case

This code performs the following functions: 1. Initialize a Data Structure...