Zeigen ein eins-zu-viele-Beziehung, die als 2-Spalten - 1 Datensatz (ID & Komma getrennte Liste)

Ich bin mir nicht sicher, informix sql, aber in MSSQL oder Oracle, man könnte dies mit der

DECODE oder CASE-Schlüsselwörter, indem Sie Sie zusammen. Dies würde jedoch erfordern, dass Sie wissen, alle möglichen Werte vor der Zeit, die spröde ist.

Ich gehe davon aus, dass der Grund, warum Sie nicht wie das ZEUG Schlüsselwort ist, weil informix nicht unterstützt?

Oracle unterstützt auch das VERBINDEN VON Schlüsselwörtern, die funktionieren würde, aber wieder, können nicht unterstützt werden von informix.

Wahrscheinlich die beste Antwort wäre der Aufbau dieser Ausgabe in Ihre client - /Daten-Schicht, nach der Abfrage. Gibt es einen bestimmten Grund, warum dies getan werden muss in der Abfrage?

Gebäude auf Jonathan Leffler Beispiel, und auf RET get Kommentare über die Reihenfolge der verketteten Werte, mit Hilfe des Informix 12.10FC8DE, ich kam mit der folgenden Benutzer-Aggregat:

CREATE FUNCTION mgc_init
(
    dummy VARCHAR(255)
)
RETURNING
    SET(LVARCHAR(2048) NOT NULL);

    RETURN SET{}::SET(LVARCHAR(2048) NOT NULL);

END FUNCTION;

CREATE FUNCTION mgc_iter
(
    p_result SET(LVARCHAR(2048) NOT NULL)
    , p_value VARCHAR(255)
)
RETURNING
    SET(LVARCHAR(2048) NOT NULL);

    IF p_value IS NOT NULL THEN
        INSERT INTO TABLE(p_result) VALUES (TRIM(p_value));
    END IF;

    RETURN p_result;

END FUNCTION;

CREATE FUNCTION mgc_comb
(
    p_partial1 SET(LVARCHAR(2048) NOT NULL)
    , p_partial2 SET(LVARCHAR(2048) NOT NULL)
)
RETURNING
    SET(LVARCHAR(2048) NOT NULL);

    INSERT INTO TABLE(p_partial1)
        SELECT vc1 FROM TABLE(p_partial2)(vc1);

    RETURN p_partial1;

END FUNCTION;

CREATE FUNCTION mgc_fini
(
    p_final SET(LVARCHAR(2048) NOT NULL)
)
RETURNING
    LVARCHAR;

    DEFINE l_str LVARCHAR(2048);
    DEFINE l_value LVARCHAR(2048);

    LET l_str = NULL;

    FOREACH SELECT vvalue1 INTO l_value FROM TABLE(p_final) AS vt1(vvalue1) ORDER BY vvalue1
        IF l_str IS NULL THEN
            LET l_str = l_value;
        ELSE
            LET l_str = l_str || ',' || l_value;
        END IF;
    END FOREACH;

    RETURN l_str;

END FUNCTION;
GRANT EXECUTE ON mgc_fini TO PUBLIC;

CREATE AGGREGATE m_group_concat
WITH
(
    INIT = mgc_init
    , ITER = mgc_iter
    , COMBINE = mgc_comb
    , FINAL = mgc_fini
);

Verkettete Werte wird keine Duplikate haben und bestellt werden.

Ich verwendet, Informix collections nämlich SET nicht zulassen doppelte Werte, um zu versuchen, um den code etwas einfacher.

Methode ist die Verwendung SET's behalten der Zwischenergebnisse (und die Beseitigung der Duplikate) und am Ende bauen die verkettete Zeichenfolge von der bestellten Werte der letzten SET.

Den Einsatz von LVARCHAR für die SET Elemente ist aufgrund der Tatsache, dass ich anfangs war mit VARCHAR aber der Speicherbedarf war sehr, sehr hoch. In der Dokumentation Hinweise darauf, dass intern Informix kann Gießen die VARCHAR zu CHAR. Ich habe die änderung vorgenommen und es hat in der Tat senken Sie den Speicherbedarf (es ist aber immer noch hoch).

Jedoch, dieses Aggregat Speicher Verbrauch ist um 2 Größenordnungen höher als Jonathan und etwa 2 mal langsamer auf die tests habe ich (mit einer Tabelle mit rund 300 000 Zeilen).

So nutzen Sie mit Sorgfalt. Es verbraucht eine Menge Speicher, und es ist nicht ausgiebig getestet ( es kann sein, Speicherbereiche irgendwo ).

EDIT 1:

Meinen bisherigen code muss undichten eine Speicher-Struktur irgendwo (oder intern Informix hält die Sammlung der abgeleiteten Tabellen um, und kann es generiert eine Menge von diesen).

So, immer noch versuchen, zu vermeiden, dass code der Aggregat-Funktion in C , hier ist eine weitere alternative, mit Informix BSON integrierten Funktionen, verwenden viel weniger Speicher und etwas schneller.

CREATE FUNCTION m2gc_init
(
    dummy VARCHAR(255)
)
RETURNING
    BSON;

    RETURN '{"terms":[]}'::JSON::BSON;

END FUNCTION;

CREATE FUNCTION m2gc_iter
(
    p_result BSON
    , p_value VARCHAR(255)
)
RETURNING
    BSON;

    DEFINE l_add_array_element LVARCHAR(2048);

    IF p_value IS NOT NULL THEN
        LET l_add_array_element = '{ $addToSet: { terms: "' || TRIM(p_value) || '" } }';
        LET p_result = BSON_UPDATE(p_result, l_add_array_element);
    END IF;

    RETURN p_result;

END FUNCTION;

CREATE FUNCTION m2gc_comb
(
    p_partial1 BSON
    , p_partial2 BSON
)
RETURNING
    BSON;

    DEFINE l_array_elements LVARCHAR(2048);
    DEFINE l_an_element LVARCHAR(2048);
    DEFINE l_guard INTEGER;

    LET l_array_elements = NULL;
    LET l_guard = BSON_SIZE(p_partial2, 'terms.0');

    IF l_guard > 0 THEN
        WHILE l_guard > 0
            LET l_an_element = BSON_VALUE_LVARCHAR(p_partial2, 'terms.0');
            IF l_array_elements IS NULL THEN
                LET l_array_elements = '"' || l_an_element || '"';
            ELSE
                LET l_array_elements = l_array_elements || ', "' || l_an_element || '"';
            END IF;
            LET p_partial2 = BSON_UPDATE(p_partial2, '{ $pop: { terms: -1 } }');
            LET l_guard = BSON_SIZE(p_partial2, 'terms.0');
        END WHILE;
        LET l_array_elements = '{ $addToSet: { terms: { $each: [ ' || l_array_elements || ' ] } } }';        
        LET p_partial1 = BSON_UPDATE(p_partial1, l_array_elements);
    END IF;

    RETURN p_partial1;

END FUNCTION;


CREATE FUNCTION m2gc_fini
(
    p_final BSON
)
RETURNING
    LVARCHAR;

    DEFINE l_str_agg LVARCHAR(2048);
    DEFINE l_an_element LVARCHAR(2048);
    DEFINE l_iter_int INTEGER;
    DEFINE l_guard INTEGER;

    LET l_str_agg = NULL;
    LET l_guard = BSON_SIZE(p_final, 'terms.0');

    IF l_guard > 0 THEN
        LET p_final = BSON_UPDATE(p_final, '{ $push: { terms: { $each: [], $sort: 1 } } }');    
        LET l_iter_int = 0;
        WHILE l_guard > 0
            LET l_an_element = BSON_VALUE_LVARCHAR(p_final, 'terms.' || l_iter_int);
            IF l_str_agg IS NULL THEN
                LET l_str_agg = TRIM(l_an_element);
            ELSE
                LET l_str_agg = l_str_agg || ',' || TRIM(l_an_element);
            END IF;
            LET l_iter_int = l_iter_int + 1;
            LET l_guard = BSON_SIZE(p_final, 'terms.' || l_iter_int);
        END WHILE;
    END IF;
    RETURN l_str_agg;

END FUNCTION;

CREATE AGGREGATE m2_group_concat
WITH
(
    INIT = m2gc_init
    , ITER = m2gc_iter
    , COMBINE = m2gc_comb
    , FINAL = m2gc_fini
)
;

Den aggregierten Wert der bestellten entspricht und ohne Duplikate.

Wieder, das war nicht richtig getestet. Es ist nur ein POC.

Eines der Probleme ist, dass es nicht bereinigen die input-Werte.
Einige der BSON Manipulation Funktionen erhalten Parameter, die gebaut werden, die durch verketten von Zeichenfolgen und nicht escaped Zeichen können brechen diese Parameter.
Zum Beispiel, eine Zeichenfolge mit Anführungszeichen auf Sie: 'I"BrokeIt') hervorrufen können, ein Sortiment von Fehler (Assert-Fehler enthalten).

Und ich bin mir sicher es gibt andere Probleme.

Jedoch, der Speicherverbrauch dieser Implementierung ist in der gleichen Größenordnung wie in Jonathan B. und um 60% langsamer (auch hier nur sehr rudimentäre Tests durchgeführt).