Convert Django QuerySets to Markdown Tables

@sync_to_async
def queryset_to_markdown_table(data_dict):
    """
    Convert a dictionary (from a QuerySet) to a markdown-formatted table string.
    """
    if not data_dict:
        return "No data available."

    # Get keys (column names) from the first item
    keys = list(data_dict[0].keys()) if data_dict else []

    # Start building the markdown table
    markdown = "| " + " | ".join(keys) + " |\n"
    markdown += "|" + "---"|" * len(keys) + "\n"

    # Add data rows
    for item in data_dict:
        row_data = [str(item.get(key, '')) for key in keys]
        markdown += "| " + " | ".join(row_data) + " |\n"

    return markdown

Turning QuerySets into Markdown Tables: A Handy Function

Have you ever needed to display data from a Django QuerySet in a readable format, especially in environments like documentation or reports? This function provides a neat way to convert a QuerySet (represented as a list of dictionaries) into a Markdown table.

What it Does

At its core, the queryset_to_markdown_table function takes a list of dictionaries, where each dictionary represents a row of data (think of it as the result of .values() on a QuerySet). It then structures this data into a Markdown table string.

1. Handles Empty Data: It first checks if the input data_dict is empty. If so, it returns a simple “No data available.” message.
2. Extracts Column Names: It retrieves the keys from the first dictionary in the list. These keys become the column headers of the table.
3. Builds the Table Header: It constructs the Markdown table header using the extracted keys and adds the separator line (---|---).
4. Adds Data Rows: It iterates through each dictionary in the data_dict and creates a row in the Markdown table. It safely retrieves data using .get() to handle missing keys.

How to Use It

Let’s say you have a Django model called Product, and you want to display some of its data in a Markdown table.

from asgiref.sync import sync_to_async
# Assuming you have a Product model and a queryset
# products = Product.objects.all().values('id', 'name', 'price')
# data = list(products)

# result = await queryset_to_markdown_table(data)
# print(result)

Important Note: The @sync_to_async decorator makes this function compatible with asynchronous contexts, which are common in modern Django projects using ASGI. If you are using this in a synchronous context, you can remove the decorator, but it is good practice to include it for broader compatibility.

Why is this useful?

• Readability: Markdown tables are easily readable in various platforms, including documentation systems (like ReadTheDocs), issue trackers (like GitHub), and even simple text editors.
• Reporting: Quickly generate reports from database queries in a shareable format.
• Documentation: Include database information in your project’s documentation.

This function offers a simple yet effective way to transform data from your Django models into a presentable Markdown table, improving data communication and documentation in your projects.