This project looks quite promising for parsing the actual data: https://github.com/ap0405140/MSSQLLogAnalyzer

But as others mentioned, this information is not well documented and you need to use some arcane/unsupported methods to read the logs, ie. FN_DBLOG / FN_DUMP_DBLOG, so be careful while using this in production environment.

1. Extract Rowlog Content

First, you need to query the fn_dblog function to get the rowlog content.

SELECT 
    [Current LSN], 
    [Operation], 
    [Context], 
    [AllocUnitName], 
    [Page ID], 
    [Slot ID], 
    [RowLog Contents 0], 
    [RowLog Contents 1]
FROM 
    fn_dblog(NULL, NULL)
WHERE
    [AllocUnitName] = 'dbo.YourTableName' AND 
    [Operation] IN ('LOP_MODIFY_ROW', 'LOP_INSERT_ROW', 'LOP_DELETE_ROW');

2. Convert Rowlog Content to Varbinary

The RowLog Contents 0 and RowLog Contents 1 columns are in a hexadecimal string format. You need to convert them to varbinary to work with them:

SELECT 
    CONVERT(varbinary(max), '0x' + [RowLog Contents 0]) AS RowLogContents0,
    CONVERT(varbinary(max), '0x' + [RowLog Contents 1]) AS RowLogContents1
FROM 
    -- your previous query here

3. Interpret the Binary Data

This is the tricky part. The format of the binary data depends on the type of operation and the structure of the table. You need to understand the structure of your table and the way SQL Server stores data on pages to interpret this data correctly.

If the table has a simple structure (e.g., a single integer column), you might be able to manually decode the binary data. For example:

SELECT 
    CAST(SUBSTRING(RowLogContents0, 5, 4) AS int) AS OldValue,
    CAST(SUBSTRING(RowLogContents1, 5, 4) AS int) AS NewValue
FROM 
    -- your previous query here

In this example, the SUBSTRING function is used to extract the relevant part of the binary data, and the CAST function is used to convert it to an integer.

4. Using a Helper Function

For more complex tables or for a more generic solution, you might want to write a helper function that takes the table name, rowlog content, and other necessary information as parameters and returns the decoded data. This function would need to use dynamic SQL to query the table’s metadata and generate the appropriate CAST and SUBSTRING expressions based on the table’s column types and sizes.

Decoding the transaction log content in SQL Server is a complex task because the transaction log is not meant to be human-readable. However, there are some undocumented functions and methods that can be used for this purpose. Keep in mind that using undocumented features is not recommended for production systems, as they may change in future releases and can lead to instability.

One approach is to use the fn_dblog function along with some filtering and interpretation. Below is a basic example that may help you get started. Please note that this is for educational purposes, and you should test it thoroughly in a non-production environment.

-- Enable undocumented commands
DBCC TRACEON(3604);

-- View transaction log for a specific database
DBCC LOG(<YourDatabaseName>);

-- Disable undocumented commands
DBCC TRACEOFF(3604);

This will display information about the transaction log for the specified database. Look for the transaction you're interested in and examine the log records. The Current LSN and Operation columns can be particularly useful.

For decoding the actual data changes, you might want to look into the fn_dump_dblog function. This function allows you to read the physical log file and interpret the log records.

Again, keep in mind that these methods are not officially documented or supported, and they might not work in future versions of SQL Server. If you need to decode transaction log information for a specific purpose, consider using a third-party tool that is designed for this task and is more likely to be stable across different SQL Server versions.

Moreover, consider using features like Change Data Capture (CDC) or temporal tables if you need to track changes to your data in a more structured and supported manner. These features are designed to capture and store changes to data in a readable format.