@memberjunction/db-auto-doc 4.0.0 → 4.2.0

package/prompts/query-planning.md

@@ -0,0 +1,144 @@
+# Query Planning for Database Documentation
+
+You are designing a set of reference SQL queries for the **{{ focusTable }}** table in the **{{ schemaName }}** schema. These queries will serve as examples for AI agents and developers.
+
+## Database Context
+
+**Database Type:** {{ databaseType }}
+
+**Focus Table:** {{ focusTable }}
+{{ tables[0].description }}
+
+**Row Count:** {{ tables[0].rowCount }}
+
+### Columns
+{% for col in tables[0].columns %}
+- **{{ col.name }}** ({{ col.dataType }}){% if col.isPrimaryKey %} [PRIMARY KEY]{% endif %}{% if col.isForeignKey %} [FOREIGN KEY]{% endif %}
+  {% if col.description %}{{ col.description }}{% endif %}
+  {% if col.possibleValues %}Possible values: {{ col.possibleValues | jsoninline }}{% endif %}
+{% endfor %}
+
+### Relationships
+{% if tables[0].foreignKeys.length > 0 %}
+**Foreign Keys:**
+{% for fk in tables[0].foreignKeys %}
+- {{ fk.column }} → {{ fk.referencesTable }}.{{ fk.referencesColumn }}
+{% endfor %}
+{% endif %}
+
+{% if tables[0].dependents.length > 0 %}
+**Referenced By:** {{ tables[0].dependents | join(', ') }}
+{% endif %}
+
+{% if tables.length > 1 %}
+### Related Tables Available
+{% for table in tables | slice(1) %}
+- **{{ table.name }}** ({{ table.rowCount }} rows){% if table.description %}: {{ table.description }}{% endif %}
+{% endfor %}
+{% endif %}
+
+{% if seedContext %}
+## Database Purpose
+{{ seedContext }}
+{% endif %}
+
+{% if existingQueries.length > 0 %}
+## Already Planned Queries
+Avoid duplicating these query patterns:
+{% for q in existingQueries %}
+- {{ q.name }} ({{ q.queryType }}, {{ q.queryPattern }})
+{% endfor %}
+{% endif %}
+
+---
+
+## Task
+
+Plan **{{ queriesPerTable }}** diverse, high-quality reference queries for the {{ focusTable }} table. Each query should demonstrate different patterns and business use cases.
+
+### Query Types to Consider
+- **aggregation**: GROUP BY with counts/sums/averages
+- **filter**: SELECT with WHERE clauses
+- **join**: Queries with related tables
+- **detail**: Detailed record views
+- **summary**: High-level aggregations
+- **ranking**: TOP N / ORDER BY queries
+- **time-series**: Date-based aggregations (if date columns exist)
+- **drill-down**: Detail queries that support summary aggregations
+
+### Query Patterns to Use
+- simple-select
+- filtered-select
+- aggregation-group-by
+- time-series-aggregation (if date columns available)
+- join-detail
+- left-join-counts
+- drill-down-detail
+- ranking-top-n
+- multi-level-aggregation
+
+### Complexity Distribution
+- 40% simple: Basic SELECTs, single-table queries
+- 40% moderate: JOINs, GROUP BY, basic aggregations
+- 20% complex: Multi-table JOINs, nested aggregations, complex filtering
+
+### Requirements
+1. **Diversity**: Each query should demonstrate a different pattern or use case
+2. **Business Value**: Focus on real-world business questions
+3. **Alignment**: If creating summary + detail pairs, note their relationship in `relatedQueryIds`
+4. **Realistic**: Queries should reflect actual data analysis needs
+5. **Progressive Complexity**: Start simple, build to more complex patterns
+
+### Multi-Query Alignment
+When planning related queries (e.g., summary + drill-down detail):
+- Use `relatedQueryIds` to link them
+- Ensure they use **consistent filtering logic**
+- Plan alignment notes for implementation phase
+
+Example alignment issue to AVOID:
+- Summary: "COUNT(*) FROM Registrations" (counts ALL)
+- Detail: "SELECT * FROM Registrations WHERE Status='Attended'" (filters by status)
+- ❌ Numbers won't match - bad user experience
+
+Correct approach:
+- Summary: "COUNT(*) FROM Registrations WHERE Status='Attended'"
+- Detail: "SELECT * FROM Registrations WHERE Status='Attended'"
+- ✅ Aligned filtering = numbers match
+
+---
+
+## Output Format
+
+Return a JSON object with this structure:
+
+```json
+{
+  "queries": [
+    {
+      "id": "unique-id-1",
+      "name": "Clear, Descriptive Query Name",
+      "description": "What this query does and returns",
+      "businessPurpose": "Why someone would run this query - what business question it answers",
+      "queryType": "aggregation|filter|join|detail|summary|ranking|time-series|drill-down",
+      "queryPattern": "simple-select|filtered-select|aggregation-group-by|time-series-aggregation|join-detail|left-join-counts|drill-down-detail|ranking-top-n|multi-level-aggregation",
+      "complexity": "simple|moderate|complex",
+      "primaryEntities": [
+        {"schema": "{{ schemaName }}", "table": "{{ focusTable }}", "alias": "main"}
+      ],
+      "relatedEntities": [
+        {"schema": "{{ schemaName }}", "table": "RelatedTable", "alias": "rel"}
+      ],
+      "relatedQueryIds": ["unique-id-2"],
+      "confidence": 0.95,
+      "reasoning": "Why this query is valuable and how it differs from others"
+    }
+  ]
+}
+```
+
+**IMPORTANT:**
+- Generate exactly {{ queriesPerTable }} diverse queries
+- Ensure variety in queryType and queryPattern
+- Link related queries via relatedQueryIds for alignment tracking
+- All output must be valid, parseable JSON
+- Use realistic business terminology from the domain

package/prompts/query-refinement.md

@@ -0,0 +1,151 @@
+# Refine SQL Query Based on Results
+
+You are reviewing the results of a SQL query to determine if it correctly fulfills its intended business purpose. Analyze the sample results and suggest improvements if needed.
+
+## Query Information
+
+**Query ID:** {{ queryPlan.id }}
+**Name:** {{ queryPlan.name }}
+**Description:** {{ queryPlan.description }}
+**Business Purpose:** {{ queryPlan.businessPurpose }}
+**Type:** {{ queryPlan.queryType }}
+**Pattern:** {{ queryPlan.queryPattern }}
+
+## Database Context
+
+**Database Type:** {{ databaseType }}
+**Schema:** {{ schemaName }}
+
+### Primary Table: {{ focusTable }}
+{{ tableInfo.description }}
+
+**Columns:**
+{% for col in tableInfo.columns %}
+- **{{ col.name }}** ({{ col.dataType }}){% if col.isPrimaryKey %} [PK]{% endif %}{% if col.isForeignKey %} [FK → {{ col.foreignKeyReferences.referencesTable }}]{% endif %}
+  {% if col.description %}{{ col.description }}{% endif %}
+  {% if col.possibleValues %}Values: {{ col.possibleValues | jsoninline }}{% endif %}
+{% endfor %}
+
+{% if relatedTables.length > 0 %}
+### Related Tables
+{% for table in relatedTables %}
+**{{ table.name }}** ({{ table.rowCount }} rows)
+{% if table.description %}{{ table.description }}{% endif %}
+
+Columns:
+{% for col in table.columns %}
+- {{ col.name }} ({{ col.dataType }}){% if col.isPrimaryKey %} [PK]{% endif %}
+{% endfor %}
+
+{% endfor %}
+{% endif %}
+
+---
+
+## Current Query
+
+### SQL
+```sql
+{{ currentSQL }}
+```
+
+### Parameters
+{% for param in parameters %}
+- **@{{ param.name }}** ({{ param.dataType }}): {{ param.description }}
+{% endfor %}
+
+### Expected Result Columns
+{% for col in sampleResultColumns %}
+- **{{ col.name }}** ({{ col.dataType }}): {{ col.description }}{% if col.isMeasure %} [Measure]{% endif %}{% if col.isDimension %} [Dimension]{% endif %}
+{% endfor %}
+
+---
+
+## Sample Results
+
+The query returned **{{ totalRows }} rows**. Here are {{ sampleRows.length }} sample rows:
+
+{% if sampleRows.length > 0 %}
+| {% for col in resultColumnNames %}{{ col }} | {% endfor %}
+| {% for col in resultColumnNames %}--- | {% endfor %}
+{% for row in sampleRows %}
+| {% for col in resultColumnNames %}{{ row[col] }} | {% endfor %}
+{% endfor %}
+{% else %}
+*No rows returned*
+{% endif %}
+
+{% if refinementNumber > 1 %}
+### Previous Refinement Attempts
+This is refinement attempt {{ refinementNumber }} of {{ maxRefinements }}.
+
+{% for attempt in previousRefinements %}
+**Attempt {{ loop.index }}:**
+Feedback: {{ attempt.feedback }}
+{% endfor %}
+{% endif %}
+
+---
+
+## Task
+
+Analyze the sample results and determine if the query correctly fulfills its business purpose.
+
+### Questions to Consider
+
+1. **Data Completeness**: Are we getting the expected columns and data? Are any important fields missing?
+
+2. **Filter Correctness**: Do the results match the intended filters? For example:
+   - If filtering by "Active" status, do all rows show "Active"?
+   - If filtering by date range, are dates within the expected range?
+
+3. **Aggregation Accuracy**: If this is an aggregation query:
+   - Do the counts/sums/averages seem reasonable?
+   - Is the grouping correct?
+
+4. **Join Behavior**: Are we including or excluding records correctly?
+   - Are there unexpected NULL values from missing joins?
+   - Are we over-filtering by using INNER JOIN instead of LEFT JOIN?
+
+5. **Business Logic**: Does the data make sense for the stated business purpose?
+   - Any unexpected patterns or outliers?
+   - Any values that shouldn't appear based on the query intent?
+
+### Decision
+
+Based on your analysis, decide one of the following:
+
+1. **KEEP** - The query is correct and results match the business purpose
+2. **REFINE** - The query needs improvements to better match the business purpose
+
+---
+
+## Output Format
+
+Return a JSON object:
+
+```json
+{
+  "decision": "KEEP" | "REFINE",
+  "analysis": "Brief analysis of the results and why they do or don't match the business purpose",
+  "issues": [
+    "List of specific issues found (if any)"
+  ],
+  "refinedQuery": {
+    "sqlQuery": "SELECT ... (only if decision is REFINE)",
+    "parameters": [...],
+    "sampleResultColumns": [...],
+    "filteringRules": [...],
+    "aggregationRules": [...],
+    "joinRules": [...],
+    "alignmentNotes": "..."
+  },
+  "refinementExplanation": "What was changed and why (only if decision is REFINE)"
+}
+```
+
+**IMPORTANT:**
+- Only provide `refinedQuery` if decision is "REFINE"
+- The refined SQL must be valid and executable against {{ databaseType }}
+- Preserve the original business purpose - don't change what the query is meant to do
+- Focus on correctness, not optimization

package/prompts/schema-level-sanity-check.md

@@ -0,0 +1,114 @@
+You are reviewing an entire database schema to ensure all table descriptions are coherent, consistent, and logically sound when considered together as a complete system.
+
+## Schema: {{ schemaName }}
+
+Total tables: {{ tableCount }}
+
+### Schema Description
+{{ schemaDescription }}
+
+### All Tables in Schema
+
+{% for table in tables %}
+#### {{ table.name }}
+
+**Dependency Level**: {{ table.dependencyLevel }}
+**Row Count**: {{ table.rowCount }}
+
+**Description**: {{ table.description }}
+
+**Key Columns**:
+{% for column in table.keyColumns %}
+- **{{ column.name }}** ({{ column.dataType }}): {{ column.description }}
+{% endfor %}
+
+**Relationships**:
+- Depends On: {% for dep in table.dependsOn %}{{ dep.table }}{% if not loop.last %}, {% endif %}{% endfor %}
+- Referenced By: {% for dep in table.dependents %}{{ dep.table }}{% if not loop.last %}, {% endif %}{% endfor %}
+
+---
+
+{% endfor %}
+
+## Your Task
+
+Perform a holistic review of this entire schema and identify **MATERIAL** issues that affect the overall coherence and understanding of the database.
+
+Focus on:
+
+1. **Schema-Wide Consistency**: Are business concepts described consistently across all tables?
+2. **Relationship Network**: Do the relationships between tables make logical sense?
+3. **Missing Relationships**: Are there implied relationships not captured in foreign keys?
+4. **Business Domain Alignment**: Do all tables fit the stated business domain(s)?
+5. **Naming Convention Issues**: Are there tables that seem misnamed or miscategorized?
+6. **Architectural Patterns**: Do you see patterns (audit, configuration, transaction) that should be documented?
+
+## What Counts as MATERIAL
+
+**MATERIAL issues** (flag these):
+- Tables described with contradictory purposes
+- Relationship chains that don't make business sense
+- Core business entities misidentified or misdescribed
+- Critical patterns not recognized (e.g., audit trail, versioning)
+- Terminology used inconsistently across tables in ways that confuse understanding
+- Missing schema-level context that would help interpret individual tables
+
+**NOT material** (ignore these):
+- Minor wording variations
+- Different description styles
+- Redundant information across tables
+- Grammar or formatting
+- Obvious facts already captured elsewhere
+
+## Response Format
+
+Generate a JSON response with this exact structure:
+
+```json
+{
+  "hasMaterialIssues": false,
+  "schemaCoherence": "overall | good | fair | poor",
+  "overallAssessment": "High-level summary of schema documentation quality",
+  "schemaLevelIssues": [
+    {
+      "issueType": "consistency | relationships | business_domain | naming | architecture | missing_pattern",
+      "severity": "high | medium | low",
+      "description": "Specific description of the schema-wide issue",
+      "affectedTables": ["Table1", "Table2", "Table3"],
+      "suggestedSchemaDescription": "If the schema description should be added/updated"
+    }
+  ],
+  "tableIssues": [
+    {
+      "tableName": "TableName",
+      "issueType": "description | business_purpose | relationships | terminology",
+      "severity": "high | medium | low",
+      "description": "What's wrong with this table's description",
+      "suggestedFix": "How to correct the table description"
+    }
+  ],
+  "architecturalPatterns": [
+    {
+      "pattern": "audit_trail | configuration | lookup | transaction | versioning | soft_delete | hierarchy",
+      "tables": ["Table1", "Table2"],
+      "description": "Pattern identified and how it should be documented"
+    }
+  ],
+  "businessDomainSuggestions": [
+    {
+      "suggestedDomain": "Domain name",
+      "reasoning": "Why this domain applies to this schema",
+      "confidence": "high | medium | low"
+    }
+  ]
+}
+```
+
+**Guidelines:**
+- Set `hasMaterialIssues: true` ONLY if corrections are needed
+- Be specific about which tables need description updates
+- Identify architectural patterns that should be explicitly documented
+- Suggest business domains if not already specified
+- Focus on issues that would mislead database users or developers
+
+Return ONLY valid JSON. Do not include markdown code fences or explanatory text.

package/prompts/schema-sanity-check.md

@@ -0,0 +1,54 @@
+You are reviewing all table descriptions within the "{{ schemaName }}" schema for consistency and completeness.
+
+## Schema Tables
+
+{% for table in tables %}
+### {{ table.name }}
+**Description**: {{ table.description }}
+
+**Columns**:
+{% for col in table.columns %}
+- {{ col.name }}: {{ col.description }}
+{% endfor %}
+
+{% endfor %}
+
+---
+
+## Your Task
+
+Review the table and column descriptions for consistency, coherence, and completeness.
+
+Generate a JSON response with this exact structure:
+
+```json
+{
+  "schemaDescription": "A high-level description of what this schema contains and its overall purpose",
+  "inconsistencies": [
+    "Description of any contradictions or inconsistencies found between table descriptions",
+    "Note any tables that seem to serve similar purposes but are described differently"
+  ],
+  "suggestions": [
+    "Suggestions for improving clarity or completeness",
+    "Recommendations for additional context or details"
+  ]
+}
+```
+
+**Guidelines:**
+1. **Schema Description**: Synthesize the table descriptions into a coherent schema-level summary
+2. **Inconsistencies**: Look for:
+   - Contradictory descriptions between related tables
+   - Similar tables described with different terminology
+   - Missing relationships or unclear dependencies
+   - Descriptions that don't align with column details
+3. **Suggestions**: Provide actionable recommendations for improvement
+4. **If no issues found**: Return empty arrays for inconsistencies and suggestions
+
+**Focus on:**
+- Terminology consistency across tables
+- Logical coherence of the schema as a whole
+- Completeness of explanations
+- Clarity and precision of language
+
+Return ONLY valid JSON. Do not include markdown code fences or explanatory text.

package/prompts/semantic-comparison.md

@@ -0,0 +1,78 @@
+You are comparing two versions of database table documentation to determine if there are MATERIAL differences in informational content.
+
+## Table: {{ schemaName }}.{{ tableName }}
+
+### Previous Version (Iteration {{ previousIteration }})
+
+**Table Description**: {{ previousTableDescription }}
+
+**Column Descriptions**:
+{% for col in previousColumns %}
+- **{{ col.columnName }}**: {{ col.description }}
+{% endfor %}
+
+---
+
+### Current Version (Iteration {{ currentIteration }})
+
+**Table Description**: {{ currentTableDescription }}
+
+**Column Descriptions**:
+{% for col in currentColumns %}
+- **{{ col.columnName }}**: {{ col.description }}
+{% endfor %}
+
+---
+
+## Your Task
+
+Compare these two versions and determine if there are **MATERIAL** changes in informational content. Ignore stylistic differences, rewording, or changes in phrasing that don't affect the actual meaning.
+
+Generate a JSON response with this exact structure:
+
+```json
+{
+  "tableMateriallyChanged": false,
+  "tableChangeReasoning": "Explain what material information changed, or why no material change occurred",
+  "columnChanges": [
+    {
+      "columnName": "ColumnName",
+      "materiallyChanged": false,
+      "changeReasoning": "Brief explanation of what changed or why no material change"
+    }
+  ]
+}
+```
+
+**Guidelines:**
+
+1. **Material Changes** include:
+   - Change in actual purpose or meaning of table/column
+   - Addition or removal of key information
+   - Correction of factual errors
+   - Change in data relationships or constraints described
+   - Clarification that changes understanding (not just wording)
+
+2. **NOT Material Changes** (mark as false):
+   - Rewording with same meaning ("flag indicating" vs "boolean flag indicating")
+   - Stylistic changes ("stores" vs "contains")
+   - Reordering of phrases with same content
+   - Grammar improvements that don't change meaning
+   - Different phrasing of identical information
+
+3. **For each column**:
+   - Compare previous vs current description
+   - Set `materiallyChanged: true` only if informational content differs
+   - Provide reasoning that references specific semantic differences
+
+4. **For the table**:
+   - Set `tableMateriallyChanged: true` if the table description's meaning changed
+   - Consider if the overall understanding of the table's purpose differs
+
+**Important:**
+- Be strict about what counts as "material" - we want to avoid unnecessary iterations
+- If you're unsure whether a change is material, it probably isn't
+- Focus on INFORMATION content, not presentation style
+- All columns from the current version must be included in columnChanges array
+
+Return ONLY valid JSON. Do not include markdown code fences or explanatory text.

package/prompts/single-query-generation.md

@@ -0,0 +1,155 @@
+# Generate SQL for Single Query
+
+You are implementing SQL for a planned reference query. This query will serve as an example for AI agents and developers.
+
+## Query Plan
+
+**Query ID:** {{ queryPlan.id }}
+**Name:** {{ queryPlan.name }}
+**Description:** {{ queryPlan.description }}
+**Business Purpose:** {{ queryPlan.businessPurpose }}
+**Type:** {{ queryPlan.queryType }}
+**Pattern:** {{ queryPlan.queryPattern }}
+**Complexity:** {{ queryPlan.complexity }}
+
+{% if queryPlan.relatedQueryIds.length > 0 %}
+**Related Queries:** {{ queryPlan.relatedQueryIds | join(', ') }}
+⚠️ **ALIGNMENT REQUIRED**: This query must use consistent filtering logic with its related queries!
+{% endif %}
+
+## Database Context
+
+**Database Type:** {{ databaseType }}
+**Schema:** {{ schemaName }}
+
+### Primary Table: {{ focusTable }}
+{{ tableInfo.description }}
+
+**Columns:**
+{% for col in tableInfo.columns %}
+- **{{ col.name }}** ({{ col.dataType }}){% if col.isPrimaryKey %} [PK]{% endif %}{% if col.isForeignKey %} [FK → {{ col.foreignKeyReferences.referencesTable }}]{% endif %}
+  {% if col.description %}{{ col.description }}{% endif %}
+  {% if col.possibleValues %}Values: {{ col.possibleValues | jsoninline }}{% endif %}
+{% endfor %}
+
+{% if relatedTables.length > 0 %}
+### Related Tables
+{% for table in relatedTables %}
+**{{ table.name }}** ({{ table.rowCount }} rows)
+{% if table.description %}{{ table.description }}{% endif %}
+
+Columns:
+{% for col in table.columns %}
+- {{ col.name }} ({{ col.dataType }}){% if col.isPrimaryKey %} [PK]{% endif %}
+{% endfor %}
+
+{% endfor %}
+{% endif %}
+
+{% if relatedQueryPlans.length > 0 %}
+## Related Query Plans (for alignment)
+{% for plan in relatedQueryPlans %}
+### {{ plan.name }} (ID: {{ plan.id }})
+- **Type:** {{ plan.queryType }}
+- **Purpose:** {{ plan.businessPurpose }}
+- **Description:** {{ plan.description }}
+{% endfor %}
+
+⚠️ **CRITICAL**: Your SQL MUST use filtering logic that aligns with these related queries!
+{% endif %}
+
+---
+
+## Task
+
+Generate executable, parameterized SQL for this query plan.
+
+### Requirements
+
+1. **Executable SQL**: Must be valid SQL for {{ databaseType }}
+2. **Parameterized**: Use `@ParameterName` for dynamic values
+3. **Efficient**: Use appropriate indexes (primary keys, foreign keys)
+4. **Well-Formatted**: Readable, properly indented SQL
+5. **Documented Logic**: Explain filtering, aggregation, and join rules
+
+### Parameter Guidelines
+- Use descriptive parameter names: `@StartDate`, `@MemberID`, `@Status`
+- Include diverse example values that reflect real data patterns
+- Mark required vs. optional parameters
+- Provide default values where appropriate
+
+### Business Logic Documentation
+Document the **rules and logic** that make this query work correctly:
+
+**Filtering Rules**: What filters are applied and why
+- Example: "Always filter by Status='Active' to exclude archived records"
+- Example: "Date range filters use >= StartDate AND < EndDate for consistency"
+
+**Aggregation Rules**: How data is grouped and calculated
+- Example: "Use COUNT(DISTINCT MemberID) to avoid double-counting"
+- Example: "GROUP BY uses fiscal quarters (Oct-Dec = Q1)"
+
+**Join Rules**: How tables are related
+- Example: "LEFT JOIN ensures all events included even without registrations"
+- Example: "INNER JOIN filters to only members with active certifications"
+
+**Alignment Notes** (if relatedQueryIds exist):
+- Explicitly state how filtering must match related queries
+- Example: "MUST filter by Status='Completed' to match summary query totals"
+
+### Sample Result Columns
+Define what columns the query returns and what they mean:
+- Column name
+- Data type
+- Description
+- Whether it's a measure (numeric metric) or dimension (grouping)
+
+---
+
+## Output Format
+
+Return a JSON object with this structure:
+
+```json
+{
+  "sqlQuery": "SELECT ...",
+  "parameters": [
+    {
+      "name": "ParameterName",
+      "dataType": "VARCHAR|INT|DATE|...",
+      "description": "What this parameter controls",
+      "required": true,
+      "defaultValue": "DefaultIfAny",
+      "exampleValues": ["Example1", "Example2", "Example3"]
+    }
+  ],
+  "sampleResultColumns": [
+    {
+      "name": "ColumnName",
+      "dataType": "VARCHAR|INT|DECIMAL|...",
+      "description": "What this column contains",
+      "isMeasure": false,
+      "isDimension": true
+    }
+  ],
+  "filteringRules": [
+    "Explicit rule about how filtering works in this query"
+  ],
+  "aggregationRules": [
+    "Explicit rule about how aggregation works (if applicable)"
+  ],
+  "joinRules": [
+    "Explicit rule about how tables are joined (if applicable)"
+  ],
+  "alignmentNotes": "How this query's filtering logic aligns with related queries (if relatedQueryIds exist)"
+}
+```
+
+**IMPORTANT:**
+- SQL must be executable against {{ databaseType }}
+- All JSON must be valid and parseable
+- Use actual column names from the schema above
+- Parameters use `@ParameterName` syntax for {{ databaseType }}
+{% if queryPlan.relatedQueryIds.length > 0 %}
+- **CRITICAL**: Filtering logic MUST align with related queries to prevent mismatched totals!
+{% endif %}