Ich habe 2 SQL Datenbank tabellen mit Umsatzinformationen. Hier Beispieldaten:

# select \* from journal_accounting;

id | amount | baseamount | currency | date | exchangerate | reference | type  
----+------------+------------+----------+------------+--------------+---------------------------------------------------------------------------+------------------
27 | 2202.0000 | | EUR | 2025-02-12 | | c530a7aa-52c5-4dcf-be62-fd8946c4050b | Rechnungsausgang
28 | 13445.2800 | | EUR | 2025-02-17 | | 5c8fa50b-22fc-4f3f-b302-bb46842bb69e | Rechnungsausgang
29 | 3080.0000 | | EUR | 2025-03-06 | | c0e966a5-5a0d-45a7-9413-eeffadd0ea27 | Rechnungsausgang
30 | 20730.0000 | | EUR | 2025-02-17 | | c554aacd-b096-4102-aebf-a0cf5023d159 | Rechnungsausgang
31 | 370.0000 | | EUR | 2025-03-04 | | 69666156-dd0f-40cc-9f84-543c69e3a534 | Rechnungsausgang
32 | 1957.6800 | | EUR | 2025-03-10 | | 8522399b-e953-47e9-b18e-f9cfbc6565b0 | Rechnungsausgang
33 | 225.0000 | 220.7400 | USD | 2025-03-07 | 1.019307 | 0528bc9f-b0d9-4079-a89a-af2c978f141d | Rechnungsausgang
38 | 2806.9600 | | EUR | 2025-02-18 | | 9d0929a9-1790-4001-bce1-fb376a8032aa | Rechnungsausgang

# select \* from journal_accounting_attribute;

id | key | value | journalaccounting_id
-----+-------------+------------------------------------------+----------------------
1 | space.name | | 1
2 | dbtr.name | SHANGHAI AS. DEV. PROSP. INT LOG. Co.Ltd | 1
3 | dbtr.number | D18516 | 1
4 | dbtr.name | SHANGHAI AS. DEV. PROSP. INT LOG. Co.Ltd | 2
5 | space.name | | 2
6 | dbtr.number | D18516 | 2
7 | dbtr.number | D16571 | 3
8 | space.name | | 3
9 | dbtr.name | Bixwood AB | 3

Wie würdest Du ein Select Statement erstellen, das alle Umsätze pro Firma pro Währung nach Datum aufschlüsselt?

# Umsätze Nach Firma

SELECT
ja.date,
ja.currency,
jaa.value AS "Firma",
COALESCE(jab.value, '') AS "Firmennummer",
SUM(ja.amount) AS "Gesamtbetrag"
FROM
journal_accounting ja
LEFT JOIN
journal_accounting_attribute jaa ON ja.id = jaa.journalaccounting_id AND jaa.key = 'dbtr.name'
LEFT JOIN
journal_accounting_attribute jab ON ja.id = jab.journalaccounting_id AND jab.key = 'dbtr.number'
WHERE
jaa.key IN ('dbtr.name', 'dbtr.number')
GROUP BY
ja.date,
ja.currency,
jaa.value,
jab.value
ORDER BY
ja.date,
ja.currency,
jaa.value;

# Umsätze nach Firma und Monat

SELECT
DATE_TRUNC('month', ja.date) AS "Monat",
ja.currency,
jaa.value AS "Firma",
SUM(ja.amount) AS "Gesamtbetrag"
FROM
journal_accounting ja
LEFT JOIN
journal_accounting_attribute jaa ON ja.id = jaa.journalaccounting_id AND jaa.key = 'dbtr.name'
WHERE
jaa.key IN ('dbtr.name')
GROUP BY
"Monat",
ja.currency,
jaa.value
ORDER BY
"Monat",
ja.currency,
jaa.value;

# Nur nach Monat

SELECT
DATE_TRUNC('month', ja.date) AS "Monat",
SUM(ja.amount) AS "Gesamtbetrag"
FROM
journal_accounting ja
WHERE
ja.type = 'Rechnungsausgang'
GROUP BY
"Monat"
ORDER BY
"Monat";
Monat | Gesamtbetrag
------------------------+--------------
2025-02-01 00:00:00+00 | 39184.2400
2025-03-01 00:00:00+00 | 5407.6800

# Java Impl

```java
import org.imixs.workflow.office.journal.JournalAccounting;
import org.imixs.workflow.office.journal.JournalAccounting_;
import org.imixs.workflow.office.journal.QJournalAccounting;
import java.time.LocalDate;
import java.util.List;

import jakarta.persistence.EntityManager;
import jakarta.persistence.TemporalType;
import jakarta.persistence.TypedQuery;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.CriteriaQuery;
import jakarta.persistence.criteria.Predicate;
import jakarta.persistence.criteria.Root;

public class JournalAccountingRepository {

    private final EntityManager entityManager;

    public JournalAccountingRepository(EntityManager entityManager) {
        this.entityManager = entityManager;
    }

    public List<Object[]> findByMonth() {
        CriteriaBuilder cb = entityManager.getCriteriaBuilder();
        CriteriaQuery<Object[]> cq = cb.createQuery(Object[].class);
        Root<JournalAccounting> root = cq.from(JournalAccounting.class);

        // Define the projection
        cq.multiselect(
                cb.function("DATE_TRUNC", LocalDate.class, root.get(JournalAccounting_.date), cb.literal("MONTH")),
                cb.sum(root.get(JournalAccounting_.amount))
        );

        // Define the where clause
        Predicate predicate = cb.equal(root.get(JournalAccounting_.type), "Rechnungsausgang");
        cq.where(predicate);

        // Define the group by clause
        cq.groupBy(root.get(JournalAccounting_.date).as(LocalDate.class));

        // Order by month
        cq.orderBy(cb.asc(root.get(JournalAccounting_.date).as(LocalDate.class)));

        TypedQuery<Object[]> query = entityManager.createQuery(cq);
        return query.getResultList();
    }
}
```