Angabe zum jeweils höchsten Jahr, alle anderen nicht

[Paul-Werner]

Hallo zusammen,

vielleicht könnt ihr mir hier helfen?

Ich habe, stark vereinfacht eine Tabelle
Jahr, kurz, lang.

(kleine Beispiel als erstelle_tab beigefügt)

Aus dieser Tabelle muss ich jeweils den Eintrag mit dem letztem Jahreswert gruppiert nach kurz erhalten.

Gewünschtes Ergebnis als ergebnis.txt beigefügt.

Nur bekomme ich das nicht hin. In meiner großen Tabelle werden wenn ich Select MAX(JAHR) Group By Klein verwende zu viele Zeilen nicht ausgegeben.

Kann mir bitte jemand helfen?

Vielen Dank
Paul-Werner

 

[akretschmer]

mir ist unklar, nach welchen Regeln das Ergebnis kommen soll. Aber wenn man ORDER BY JAHR DESC LIMIT 3 macht kommt das richtige raus...

postgres=# select * from tab;
 jahr | kurz |  lang   
------+------+---------
 2018 | a    | Blatt a
 2019 | a    | Blatt B
 2020 | a    | Blatt C
 2021 | a    | Blatt D
 2019 | b    | Blatt D
 2019 | b    | F
 2023 | b    | Y
 2021 | r    | Y
(8 rows)

postgres=# select * from tab  order by jahr desc limit 3;
 jahr | kurz |  lang   
------+------+---------
 2023 | b    | Y
 2021 | a    | Blatt D
 2021 | r    | Y
(3 rows)

postgres=#

Bitte zeige deine Beispiele doch einfach mit normal an, damit man das nicht erst downloaden muss.

 

[ukulele]

Unbedingt den Select und ggf. eine Fehlermeldung posten. Beim Gruppieren muss jede Spalte entweder gruppiert oder über eine Funktion aggregiert werden, ist es vielleicht daran gescheitert?

 

[Paul-Werner]

Die Originaltabelle kann ich hier leider nicht posten. Zu viele Daten, die dem Datenschutz unterliegen.

Ursprünglich habe ich eine Tabelle (gekürzt)

CREATE TABLE t_import_kontostruktur (
HHJ TEXT,
HKZ TEXT,
Kapitel TEXT,
Titel TEXT,
E1 TEXT,
E2 TEXT,
Bezeichnung TEXT
)

Was in Titel steht hat nicht immer eine Ebene 1;
Was in Ebene 1 steht hat immer einen Titel, jedoch nicht immer eine Ebene 2;
Was in Ebene 2 steht hat immer einen Titel und eine Ebene 1;

Das HHJ betrifft die Jahre 2018 bis 2013.
Über die Jahre hinweg hat sich Die Bezeichnung ggf. geändert. Ich benötige stets auf die neues Version der Bezeichnung, unabhängig vom Jahr.

Die Tabelle habe ich nach Titel, Ebene 1 und Ebene 2 aufgelöst

So habe ich die reinen Titelzeilen extrahiert

REATE VIEW v_kto_BSt AS
SELECT MAX(HHJ) AS HHJ,
Titel,
Kapitel || '/' || Titel AS BSt,
Bezeichnung AS Zweckbestimmung,
'' AS E1,
'' AS BStE1,
'' AS Ebene1,
'' AS E2,
'' AS BStE1E2,
'' AS Ebene2,
CASE WHEN E2 IS NULL THEN CASE WHEN E1 IS NULL THEN Kapitel || '/' || Titel ELSE Kapitel || '/' || Titel || ' E1: ' || E1 END ELSE Kapitel || '/' || Titel || ' E1: ' || E1 || ' E2: ' || E2 END AS Buchung,
CASE WHEN E2 IS NULL THEN CASE WHEN E1 IS NULL THEN HHJ || '-' || Kapitel || '/' || Titel ELSE HHJ || '-' || Kapitel || '/' || Titel || ' E1: ' || E1 END ELSE HHJ || '-' || Kapitel || '/' || Titel || ' E1: ' || E1 || ' E2: ' || E2 END AS IDBSt
FROM t_import_kontostruktur
WHERE Kapitel IS NOT NULL AND
E1 IS NULL AND
E2 IS NULL
GROUP BY Buchung

So habe ich die reinen Ebene 1-Zeilen extrahiert

CREATE VIEW v_kto_Ebene1 AS
SELECT MAX(t_import_kontostruktur.HHJ) AS HHJ,
t_import_kontostruktur.Kapitel AS Kapitel,
t_import_kontostruktur.Titel AS Titel,
t_import_kontostruktur.Kapitel || '/' || t_import_kontostruktur.Titel AS BSt1,
v_kto_BSt.Zweckbestimmung,
t_import_kontostruktur.E1 AS E1,
t_import_kontostruktur.Kapitel || '/' || t_import_kontostruktur.Titel || ' E1: ' || t_import_kontostruktur.E1 AS BStE1,
t_import_kontostruktur.Bezeichnung AS Ebene1,
'' AS E2,
'' AS BStE1E2,
'' AS Ebene2,
CASE WHEN t_import_kontostruktur.E2 IS NULL THEN CASE WHEN t_import_kontostruktur.E1 IS NULL THEN t_import_kontostruktur.Kapitel || '/' || t_import_kontostruktur.Titel ELSE t_import_kontostruktur.Kapitel || '/' || t_import_kontostruktur.Titel || ' E1: ' || t_import_kontostruktur.E1 END ELSE t_import_kontostruktur.Kapitel || '/' || t_import_kontostruktur.Titel || ' E1: ' || t_import_kontostruktur.E1 || ' E2: ' || t_import_kontostruktur.E2 END AS Buchung,
CASE WHEN t_import_kontostruktur.E2 IS NULL THEN CASE WHEN t_import_kontostruktur.E1 IS NULL THEN t_import_kontostruktur.HHJ || '-' || t_import_kontostruktur.Kapitel || '/' || t_import_kontostruktur.Titel ELSE t_import_kontostruktur.HHJ || '-' || t_import_kontostruktur.Kapitel || '/' || t_import_kontostruktur.Titel || ' E1: ' || t_import_kontostruktur.E1 END ELSE t_import_kontostruktur.HHJ || '-' || t_import_kontostruktur.Kapitel || '/' || t_import_kontostruktur.Titel || ' E1: ' || t_import_kontostruktur.E1 || ' E2: ' || t_import_kontostruktur.E2 END AS IDBSt
FROM t_import_kontostruktur
INNER JOIN
v_kto_BSt ON BSt1 = v_kto_BSt.BSt
WHERE t_import_kontostruktur.Kapitel IS NOT NULL AND
t_import_kontostruktur.E1 IS NOT NULL AND
t_import_kontostruktur.E2 IS NULL
GROUP BY Buchung

Hier wollte ich die Ebene 2-Zeilen extrahieren - das Problem

CREATE VIEW v_kto_Ebene2 AS
SELECT t_import_kontostruktur.HHJ AS HHJ,
t_import_kontostruktur.Kapitel AS Kapitel,
t_import_kontostruktur.Titel AS Titel,
t_import_kontostruktur.Kapitel || '/' || t_import_kontostruktur.Titel AS BSt0,
v_kto_Ebene1.Zweckbestimmung,
t_import_kontostruktur.E1 AS E1,
t_import_kontostruktur.Kapitel || '/' || t_import_kontostruktur.Titel || ' E1: ' || t_import_kontostruktur.E1 AS BSt2,
v_kto_Ebene1.Ebene1 AS Ebene1,
t_import_kontostruktur.E2 AS E2,
t_import_kontostruktur.Kapitel || '/' || t_import_kontostruktur.Titel || ' E1: ' || t_import_kontostruktur.E1 || ' E2: ' || t_import_kontostruktur.E2 AS BStE1E2,
t_import_kontostruktur.Bezeichnung AS Ebene2,
CASE WHEN t_import_kontostruktur.E2 IS NULL THEN CASE WHEN t_import_kontostruktur.E1 IS NULL THEN t_import_kontostruktur.Kapitel || '/' || t_import_kontostruktur.Titel ELSE t_import_kontostruktur.Kapitel || '/' || t_import_kontostruktur.Titel || ' E1: ' || t_import_kontostruktur.E1 END ELSE t_import_kontostruktur.Kapitel || '/' || t_import_kontostruktur.Titel || ' E1: ' || t_import_kontostruktur.E1 || ' E2: ' || t_import_kontostruktur.E2 END AS Buchung,
CASE WHEN t_import_kontostruktur.E2 IS NULL THEN CASE WHEN t_import_kontostruktur.E1 IS NULL THEN t_import_kontostruktur.HHJ || '-' || t_import_kontostruktur.Kapitel || '/' || t_import_kontostruktur.Titel ELSE t_import_kontostruktur.HHJ || '-' || t_import_kontostruktur.Kapitel || '/' || t_import_kontostruktur.Titel || ' E1: ' || t_import_kontostruktur.E1 END ELSE t_import_kontostruktur.HHJ || '-' || t_import_kontostruktur.Kapitel || '/' || t_import_kontostruktur.Titel || ' E1: ' || t_import_kontostruktur.E1 || ' E2: ' || t_import_kontostruktur.E2 END AS IDBSt
FROM t_import_kontostruktur
INNER JOIN
v_kto_Ebene1 ON BSt2 = v_kto_Ebene1.BStE1
WHERE t_import_kontostruktur.Kapitel IS NOT NULL AND
t_import_kontostruktur.E1 IS NOT NULL AND
t_import_kontostruktur.E2 IS NOT NULL

Zum Schluss will ich alle extrahierten Zeilen zusammenfassen, damit ich die einer anderen Tabelle mit mehr als 340.000 Zeilen zuordnen kann.

CREATE VIEW v_kto_kontostrukur AS
SELECT *
FROM v_kto_BSt
UNION
SELECT *
FROM v_kto_Ebene1
UNION
SELECT *
FROM v_kto_Ebene2

jede Buchung darf nur 1 x vorkommen und zwar in der nach HHJ neuesten Version.

Vielleicht etwas umständlich, aber ich weiss mir leider anderweitig nicht weiter.

Einen schönen Tag noch
Paul-Werner

 

[ukulele]

Ich bezog das auch nicht auf die orignal Daten oder Tabellen sondern auf dein Demo Code.

An dem Select sieht man es sofort, der ist falsch:

SELECT MAX(HHJ) AS HHJ,
Titel,
Kapitel || '/' || Titel AS BSt,
Bezeichnung AS Zweckbestimmung,
'' AS E1,
'' AS BStE1,
'' AS Ebene1,
'' AS E2,
'' AS BStE1E2,
'' AS Ebene2,
CASE WHEN E2 IS NULL THEN CASE WHEN E1 IS NULL THEN Kapitel || '/' || Titel ELSE Kapitel || '/' || Titel || ' E1: ' || E1 END ELSE Kapitel || '/' || Titel || ' E1: ' || E1 || ' E2: ' || E2 END AS Buchung,
CASE WHEN E2 IS NULL THEN CASE WHEN E1 IS NULL THEN HHJ || '-' || Kapitel || '/' || Titel ELSE HHJ || '-' || Kapitel || '/' || Titel || ' E1: ' || E1 END ELSE HHJ || '-' || Kapitel || '/' || Titel || ' E1: ' || E1 || ' E2: ' || E2 END AS IDBSt
FROM t_import_kontostruktur
WHERE Kapitel IS NOT NULL AND
E1 IS NULL AND
E2 IS NULL
GROUP BY Buchung

Spalten müssen entweder gruppiert oder aggregiert werden, alle anderen Spalten dürfen nicht im Select-Teil stehen. Also Titel, Kapitel, Bezeichnung, E2 (im CASE), E1 (im CASE), HHJ (im CASE)...

Du kannst erst in einem inneren Select Gruppieren und dann die anderen benötigten Werte dazu joinen aber du musst erst vernünftig gruppieren.

 

[Paul-Werner]

Das habe ich hoffentlich richtig verstanden

Spalten müssen entweder gruppiert oder aggregiert werden, alle anderen Spalten dürfen nicht im Select-Teil stehen. Also Titel, Kapitel, Bezeichnung, E2 (im CASE), E1 (im CASE), HHJ (im CASE)...

Die Titel

CREATE VIEW v_kto_BSt AS
    SELECT MAX(t_import_kontostruktur.HHJ) AS HHJ,
                  CASE WHEN E2 IS NULL THEN CASE WHEN E1 IS NULL THEN Kapitel || '/' || Titel ELSE Kapitel || '/' || Titel || ' E1: ' || E1 END ELSE Kapitel || '/' || Titel || ' E1: ' || E1 || ' E2: ' || E2 END AS Buchung
      FROM t_import_kontostruktur
     WHERE Kapitel IS NOT NULL AND
           E1 IS NULL AND
           E2 IS NULL
     GROUP BY Buchung
ORDER BY Buchung ASC

Das gibt 143 Zeilen, mit jeweils der letzten Jahresangabe --> richtig!


Ebene 1

CREATE VIEW v_kto_E1 AS
   SELECT MAX(t_import_kontostruktur.HHJ) AS HHJ,
                   t_import_kontostruktur.Kapitel || '/' || t_import_kontostruktur.Titel || '/' ||  CASE WHEN length(t_import_kontostruktur.E1) > 1 then Ltrim(t_import_kontostruktur.E1,0) ELSE t_import_kontostruktur.E1 END
                AS Buchung
      FROM t_import_kontostruktur
      WHERE t_import_kontostruktur.Kapitel IS NOT NULL AND
           t_import_kontostruktur.E1 IS NOT NULL AND
           t_import_kontostruktur.E2 IS NULL
           GROUP BY Buchung
           ORDER BY Buchung ASC

Das gibt 260 Zeilen mit jeweils der letzten Jahresangabe --> richtig

E1 ist in der Quelle als Textffeld definiert. Einige Eintragungen sind ganze Worte, bei anderen Ziffern. Leider wurden einige Ziffern mit führender 0 erfasst. Das waren dann 265 Zeilen. Mit dem CASE blieben die korrekten 260 Zeilen übrig.

Ebene 2

CREATE VIEW v_kto_E2 AS
  SELECT
    MAX(t_import_kontostruktur.HHJ) AS HHJ,
    CASE WHEN t_import_kontostruktur.E2 IS NULL THEN CASE WHEN t_import_kontostruktur.E1 IS NULL THEN  t_import_kontostruktur.Kapitel || '/' || t_import_kontostruktur.Titel ELSE t_import_kontostruktur.Kapitel || '/' || t_import_kontostruktur.Titel || '/' ||  CASE WHEN length(t_import_kontostruktur.E1) > 1 then Ltrim(t_import_kontostruktur.E1,0) ELSE t_import_kontostruktur.E1 END  END ELSE t_import_kontostruktur.Kapitel || '/' || t_import_kontostruktur.Titel || '/' ||  CASE WHEN length(t_import_kontostruktur.E1) > 1 then Ltrim(t_import_kontostruktur.E1,0) ELSE t_import_kontostruktur.E1 END  || '/' || t_import_kontostruktur.E2 END AS Buchung
   FROM t_import_kontostruktur
WHERE t_import_kontostruktur.Kapitel IS NOT NULL AND
           t_import_kontostruktur.E1 IS NOT NULL AND
           t_import_kontostruktur.E2 IS NOT NULL
Group BY Buchung
           Order by Buchung ASC

Das ergibt 168 Zeilen mit jeweils der letzten Jahresangabe --> richtig!

Das habe ich leider nicht verstanden

Du kannst erst in einem inneren Select Gruppieren und dann die anderen benötigten Werte dazu joinen aber du musst erst vernünftig gruppieren.

 

[ukulele]

Du verwendest immer noch Spalten wie z.B. t_import_kontostruktur.E2 im CASE (im Select-Teil) die nicht aggregiert wurden und auch nicht unter GROUP BY stehen. Das ist nicht Regelkonform und sollte eigentlich einen Fehler werfen. Beispiel mit MSSQL:

SELECT    max(datum) AS datum,
        (CASE WHEN A IS NOT NULL THEN 1 ELSE 0 END) AS A
FROM    tabelle
GROUP BY B

Msg 8120, Level 16, State 1, Line 2
Die tabelle.A-Spalte ist in der Auswahlliste ungültig, da sie nicht in einer Aggregatfunktion und nicht in der GROUP BY-Klausel enthalten ist.

Jetzt hast du das Ergebnis deiner CASE-Anweisung "Buchung" genannt und gruppierst nach "Buchung". MSSQL würde jetzt eine Spalte "Buchung" suchen und daher einen Fehler werfen, meiner Meinung nach geht das auch nicht anders und müsste bei SQLite auch so sein. Du könntest aber die CASE-Anweisung identisch in das GROUP BY aufnehmen:

CREATE VIEW v_kto_BSt AS

    SELECT MAX(t_import_kontostruktur.HHJ) AS HHJ,

                  (CASE WHEN E2 IS NULL THEN CASE WHEN E1 IS NULL THEN Kapitel || '/' || Titel ELSE Kapitel || '/' || Titel || ' E1: ' || E1 END ELSE Kapitel || '/' || Titel || ' E1: ' || E1 || ' E2: ' || E2 END) AS Buchung

      FROM t_import_kontostruktur

     WHERE Kapitel IS NOT NULL AND

           E1 IS NULL AND

           E2 IS NULL

     GROUP BY (CASE WHEN E2 IS NULL THEN CASE WHEN E1 IS NULL THEN Kapitel || '/' || Titel ELSE Kapitel || '/' || Titel || ' E1: ' || E1 END ELSE Kapitel || '/' || Titel || ' E1: ' || E1 || ' E2: ' || E2 END)

PS: ORDER BY kann eigentlich nicht Teil einer View sein, das muss in das Statement was später die View abfragt.

Wenn es wirklich darum geht zu einer Gruppierung weitere Informationen aus der Spalte zu holen, deren HHJ Wert dann mit dem max() übereinstimmt gibt es Wege das zu lösen und wir haben grade erst in einem anderen Thread mehrere Varianten gezeigt. Meine Aussage

Das habe ich leider nicht verstanden

Du kannst erst in einem inneren Select Gruppieren und dann die anderen benötigten Werte dazu joinen aber du musst erst vernünftig gruppieren.

Bezog sich auf eine meiner Meinung nach am leichtesten verständliche Version für Einsteiger, siehe:

SQL, max(Value), gruppiert über Zeitraum, mit zugehörigem Zeitpunkt

Hallo, ich sehe wahrscheinlich den Wald vor lauter Bäumen nicht. Ich habe eine SQL-Tabelle mit Wetterdaten über einen Zeitraum mit jeweils 5-Minuten-Abständen. Jeder Datensatz umfasst die gemessenen Werte sowie das entsprechende Datum mit Uhrzeit. Ich möchte nun für einen bestimmten Zeitraum...

www.datenbankforum.com

Aber in dem selben Thread gibt es noch weitere Alternativen die genauso gut geeignet sind.

 

[Paul-Werner]

Mal sehen, ob ich es jetzt verstanden habe.

Agreggieren:
MAX(HHJ)

Gruppieren:
Das ist das CASE nach GROUP BY.
Es ist nicht richtig (hat aber bei SQLite funktioniert) wenn ich im SELECT-Teil ein Alias für das CASE vergebe und nach dem Alias gruppiere.
Ich muss das CASE nach GROUP BY in Klammern wiederholen.

Das gibt mir die grundsätzlich erforderlichen Daten.

Joinen:
Um meine weiter erforderlichen Daten aus der Quelltabelle zu ziehen joine ich die mit einem Alias.
Hier kann ich zum Join On das Alias aus dem SELECT-Bereich verwenden.

 SELECT MAX(ta.HHJ) AS HHJ,

 (CASE WHEN ta.E2 IS NULL THEN CASE WHEN ta.E1 IS NULL THEN ta.Kapitel || '/' || ta.Titel ELSE ta.Kapitel || '/' || ta.Titel || '/' || ta.E1 END ELSE ta.Kapitel || '/' || ta.Titel || '/' || ta.E1 || '/' || ta.E2 END) AS Buchung,
                  tb.Bezeichnung

      FROM t_import_kontostruktur AS ta
      LEFT JOIN t_import_kontostruktur AS tb ON Buchung = (CASE WHEN tb.E2 IS NULL THEN CASE WHEN tb.E1 IS NULL THEN tb.Kapitel || '/' || tb.Titel ELSE tb.Kapitel || '/' || tb.Titel || '/' || tb.E1 END ELSE tb.Kapitel || '/' || tb.Titel || '/' || tb.E1 || '/' || tb.E2 END)

     WHERE ta.Kapitel IS NOT NULL AND

           ta.E1 IS NULL AND

           ta.E2 IS NULL

     GROUP BY (CASE WHEN ta.E2 IS NULL THEN CASE WHEN ta.E1 IS NULL THEN ta.Kapitel || '/' || ta.Titel ELSE ta.Kapitel || '/' || ta.Titel || '/' || ta.E1 END ELSE ta.Kapitel || '/' || ta.Titel || '/' || ta.E1 || '/' || ta.E2 END)

Ist das so richtig?

 

[ukulele]

Mal sehen, ob ich es jetzt verstanden habe.

Agreggieren:
MAX(HHJ)

Korrekt.

Gruppieren:
Das ist das CASE nach GROUP BY.

Korrekt.

Es ist nicht richtig (hat aber bei SQLite funktioniert) wenn ich im SELECT-Teil ein Alias für das CASE vergebe und nach dem Alias gruppiere.
Ich muss das CASE nach GROUP BY in Klammern wiederholen.

Jein, ich hätte nicht gedacht das es funktioniert. Wenn SQLite das kann ist es okay, dann kann man auch den Alias nutzen. Umso wichtiger wenn du hier Code postest zu unterscheiden ob ein Fehler kommt oder einfach nur nicht das erwartete Ergebnis.

Joinen:
Um meine weiter erforderlichen Daten aus der Quelltabelle zu ziehen joine ich die mit einem Alias.
Hier kann ich zum Join On das Alias aus dem SELECT-Bereich verwenden.

 SELECT MAX(ta.HHJ) AS HHJ,

 (CASE WHEN ta.E2 IS NULL THEN CASE WHEN ta.E1 IS NULL THEN ta.Kapitel || '/' || ta.Titel ELSE ta.Kapitel || '/' || ta.Titel || '/' || ta.E1 END ELSE ta.Kapitel || '/' || ta.Titel || '/' || ta.E1 || '/' || ta.E2 END) AS Buchung,
                  tb.Bezeichnung

      FROM t_import_kontostruktur AS ta
      LEFT JOIN t_import_kontostruktur AS tb ON Buchung = (CASE WHEN tb.E2 IS NULL THEN CASE WHEN tb.E1 IS NULL THEN tb.Kapitel || '/' || tb.Titel ELSE tb.Kapitel || '/' || tb.Titel || '/' || tb.E1 END ELSE tb.Kapitel || '/' || tb.Titel || '/' || tb.E1 || '/' || tb.E2 END)

     WHERE ta.Kapitel IS NOT NULL AND

           ta.E1 IS NULL AND

           ta.E2 IS NULL

     GROUP BY (CASE WHEN ta.E2 IS NULL THEN CASE WHEN ta.E1 IS NULL THEN ta.Kapitel || '/' || ta.Titel ELSE ta.Kapitel || '/' || ta.Titel || '/' || ta.E1 END ELSE ta.Kapitel || '/' || ta.Titel || '/' || ta.E1 || '/' || ta.E2 END)

Ist das so richtig?

Nein sry. Erst wird in einem inneren Select gruppiert / aggregiert und auf das Ergebnis kann gejoint werden. Also z.B.:

    SELECT    t.HHJ,
            CASE WHEN E2 IS NULL THEN CASE WHEN E1 IS NULL THEN Kapitel || '/' || Titel ELSE Kapitel || '/' || Titel || ' E1: ' || E1 END ELSE Kapitel || '/' || Titel || ' E1: ' || E1 || ' E2: ' || E2 END AS Buchung
    FROM (    SELECT    MAX(t_import_kontostruktur.HHJ) AS HHJ,
                    Buchung
            FROM    t_import_kontostruktur
            WHERE    Kapitel IS NOT NULL AND
                    E1 IS NULL AND
                    E2 IS NULL
            GROUP BY Buchung
            ) t
    INNER JOIN t_import_kontostruktur
    ON        t.Buchung = t_import_kontostruktur.Buchung
    AND        t.HHJ = t_import_kontostruktur.HHJ
    AND        t_import_kontostruktur.Kapitel IS NOT NULL
    AND        t_import_kontostruktur.E1 IS NULL
    AND        t_import_kontostruktur.E2 IS NULL

 

[Paul-Werner]

Danke Dir.
Leider funktioniert Dein SQL-Statement nicht.
Wenn ich es eingebe kommt

Ausführung wurde mit Fehlern beendet.
Ergebnis: no such column: Buchung

Die Spalte Buchung wird mit dem CASE generiert.

 

[dabadepdu]

Ich hab mir jetzt nicht die Statements angeschaut, aber bei no such column gibt es nicht viele Möglichkeiten:
- am häufigsten Tippfehler oder noch schlimmer Fehler die durch die Verwendung von Hochkomma und so Zeug in Feldnamen resultieren.
- Alias Fehler
- Ebenen Fehler

Für die ersten beiden Varianten hilft es nicht, aber eine sehr einfache und überall funktionierende Möglichkeit, auf generierte Spalten zuzugreifen:

select g.x1, g.x3, g.generierte_spalte from
(select x1,x3, x1*x3 as generierte_spalte from meine_tabelle) g

Also Klammer um den Teil der generiert und auf der nächsten Ebene den Feinschliff machen.

 

[Paul-Werner]

Einen schönen guten Morgen,

ich denke ich habe es:

SELECT
t1.HHJ,
t1.Buchung,
t2.Bezeichnung
FROM (
    SELECT MAX(t_import_kontostruktur.HHJ) AS HHJ,
           CASE WHEN E2 IS NULL
        THEN CASE WHEN E1 IS NULL
            THEN Kapitel || '/' || Titel
            ELSE Kapitel || '/' || Titel || '/' ||
                CASE WHEN LENGTH(t_import_kontostruktur.E1) > 1
                    THEN LTRIM(t_import_kontostruktur.E1,0)
                    ELSE t_import_kontostruktur.E1
                    END 
            END
        ELSE Kapitel || '/' || Titel || '/' ||
                CASE WHEN LENGTH(t_import_kontostruktur.E1) > 1
                    THEN LTRIM(t_import_kontostruktur.E1,0)
                    ELSE t_import_kontostruktur.E1
                    END 
                        || '/' || E2
                END AS Buchung
    FROM t_import_kontostruktur
    WHERE Kapitel IS NOT NULL
        
    GROUP BY
    (CASE WHEN E2 IS NULL
        THEN CASE WHEN E1 IS NULL
            THEN Kapitel || '/' || Titel
            ELSE Kapitel || '/' || Titel || '/' ||
                CASE WHEN LENGTH(t_import_kontostruktur.E1) > 1
                    THEN LTRIM(t_import_kontostruktur.E1,0)
                    ELSE t_import_kontostruktur.E1
                    END 
                END
        ELSE Kapitel || '/' || Titel || '/' ||
                CASE WHEN LENGTH(t_import_kontostruktur.E1) > 1
                    THEN LTRIM(t_import_kontostruktur.E1,0)
                    ELSE t_import_kontostruktur.E1
                END 
                    || '/' || E2 END)
     ) AS t1
    
     LEFT JOIN t_import_kontostruktur AS t2
     ON t1.Buchung =
        CASE WHEN t2.E2 IS NULL
            THEN CASE WHEN t2.E1 IS NULL
                THEN t2.Kapitel || '/' || t2.Titel
                ELSE t2.Kapitel || '/' || t2.Titel || '/' ||
                    (CASE WHEN LENGTH(t2.E1) > 1
                        THEN LTRIM(t2.E1,0)
                        ELSE t2.E1
                    END)
                END
        ELSE t2.Kapitel || '/' || t2.Titel || '/' ||
            (CASE WHEN LENGTH(t2.E1) > 1
                THEN LTRIM(t2.E1,0)
                ELSE t2.E1
            END)
        || '/' || t2.E2
        END
         AND t2.Kapitel IS NOT NULL

     GROUP BY Buchung

@ukulele:
Vielen Dank für Deine Geduld und Deine Unterstützung.

Eine schöne Woche noch
Paul-Werner

 

[ukulele]

Danke Dir.
Leider funktioniert Dein SQL-Statement nicht.
Wenn ich es eingebe kommt

Ausführung wurde mit Fehlern beendet.
Ergebnis: no such column: Buchung
Die Spalte Buchung wird mit dem CASE generiert.

Jo das ist einfach das Resultat weil ich nicht wusste ob es eine Spalte Buchung gibt und für den Code angenommen habe das es eine gibt.

Wenn der Code jetzt funktioniert dann gut so, ich will mich jetzt nicht so weit aus dem Fenster lehnen und SQLite optimieren