UDF für eine ganze Spalte und alle Zeilen

[I-c-H]

Hallo Selfer,

ich hab Big Google, Yahoo und auch Bing rauf und runter befragt, doch keiner weiß so Recht eine Antwort.

Ist es möglich eine Funktion zu schreiben, die ALLE Zeilen einer (oder mehrerer) Spalte(n) bearbeitet? Wenn ja, wie?

Ich möchte so zum Beispiel On The Fly bestimmte Berechnungen durchführen.
Ich würde mich, wenn's sein muss, auch damit zufriedengeben, wenn diese Funktion nur eine Zeile zurückgeben kann.

MySQL-Funktionen wie COUNT(*) kriegt das ja auch irgendwie gebacken.

Danke für jede Hilfe!

Gruß

[vt1816]

Hallo und willkommen hier im Forum.

Hast Du es mal mit dem MySQL-Handbuch versucht?
Und die Funktion mit ein wenig PHP-Code zu verkleiden sollte dann auch kein Problem mehr darstellen - oder?

[I-c-H]

Ja, habe ich.
Leider kann ich da aber keinen Hinweis auf einen Lösungsansatz finden.
Die dort beschriebene Prozedur geht von zwei konstanten Werten aus.

Also entweder von

Funktion(string1, string2)

oder

Funktion(Subquery, string2)

- der Subquery darf seinerseits aber auch nur EIN Argument liefern, ansonsten erscheint eine Fehlermeldung, dass zu viele Argumente vorhanden wären.

Gruß

[vt1816]

Zitat von I-c-H

[...]
Die dort beschriebene Prozedur geht von zwei konstanten Werten aus.

Wo steht hier was von nur zwei Argumenten?

UPDATE [LOW_PRIORITY] [IGNORE] tbl_name
SET col_name1=expr1 [, col_name2=expr2 ...]
[WHERE where_condition]
[ORDER BY ...]
[LIMIT row_count]

[I-c-H]

Ich glaube du hast mich falsch verstanden.
Ich ändere das Beispiel noch mal:

returnSomething(ARGUMENT1, ARGUMENT2)

oder

returnSomething(Subquery, ARGUMENT2)

der SUBQUERY darf aber nur EIN Argument zurückliefern, ansonsten erscheint eine Fehlermeldung.


Fallbeispiel (nicht ganz sinnig, aber egal):
returnSomething(Argument1, Argument2) gibt alle Buchstaben aus Argument 2 aus, die nicht in Argument 1 vorhanden sind.

Diese Funktion arbeitet auch völlig korrekt, wenn ich sie so anwende:

SELECT returnSomething('Otto', 'Otti')

Ausgabe: i

Sie funktioniert auch, wenn:

returnSomething((SELECT `spalte` FROM `table` WHERE ID = 5), 'Otti')

Sie funktioniert aber nicht, wenn der Subquery mehrere Argumente zurückliefert.

SELECT returnSomething((SELECT `spalte` FROM `table` WHERE `name` LIKE (%O%)), 'Otti')

In diesem Beispiel würde ich z.B. eine Ergebnisliste für jede Zeile von `table` generieren wollen. Diese Liste enthält dann alle die Buchstaben von 'Otti', die nicht in der aktuellen Zeile von `spalte`stehen.

PROBLEM:
Wie arbeite ich mit einem Subquery der mehr als ein Argument enthält?
Oder alternativ: Wie ließe sich das sonst noch (in MySQL) umsetzen?

[vt1816]

Zitat von I-c-H

Ich glaube du hast mich falsch verstanden.
[...]

Da könntest Du Recht haben.

Denn auch das

Zitat von I-c-H

SELECT returnSomething('Otto', 'Otti')

Ausgabe: i

verstehe ich nicht.

Wie möchtest Du den Rückgabewert einer Funktion als zu selektierendes Feld einbinden - zumal Du hier mit einem Rückgabewertbeispiel

Zitat von I-c-H

Diese Liste enthält dann alle die Buchstaben von 'Otti', die nicht in der aktuellen Zeile von `spalte`stehen.

von einzelnen Buchstaben sprichst.

Möchtest Du die Rückgabewerte nicht eher in der WHERE-Klausel verwenden? Bist Du sicher was Du willst?

[I-c-H]

Die Funktion returnSomething(Argument1, Argument2) gibt irgendetwas zurück.

Machen wir's noch einfacher (warum nicht gleich so? :) )

returnSomething addiert die beiden Argumente miteinander.

Ich habe eine Tabelle "Zahlen":
ID, Wert
1 12
2 15
3 18
4 21
5 24

SELECT returnSomething((SELECT `wert` FROM `Zahlen`), 5) AS Summe

Die Rückgabewerte werden nun für jede Zeile einzeln aufgelistet:

Summe
17
20
23
26
29

Da der Subquery

(SELECT `wert` FROM `Zahlen`)

aber mehr als ein Argument (mehr als eine Zeile) zurückliefert, erhalte ich eine Warnung und keine Liste (wie gewünscht).

Folgender Subquery würde nur ein Argument zurückliefern und funktionieren:

(SELECT `wert` FROM `Zahlen` WHERE ID = 2)

Der Rückgabewert von returnSomething:
Summe
20

[vt1816]

Solange Du nicht verstehst/verstehen möchtest, dass das hier

Zitat von I-c-H

[...]

SELECT returnSomething((SELECT `wert` FROM `Zahlen`), 5) AS Summe

Mist (mir fällt kein anderes jugendfreies Wort ein) ist, werden wir nicht voran kommen.
Denn selbst wenn - so wie Du es möchtest - Deine Funktion nur einen Wert zurück gibt, würde das Ergebnis wie - zum Beispiel - folgt aussehen:

SELECT 20 AS Summe FROM table WHERE bedingung ORDER BY ... ASC

Und das ist nun mal M...

Vlt. wäre es besser Du outest Deinen Code und die daraus resultierende Fehlermeldung(en) hier - dann sehen wir weiter.

[I-c-H]

Denn selbst wenn - so wie Du es möchtest - Deine Funktion nur einen Wert zurück gibt, würde das Ergebnis wie

Ich möchte genau dieses Verhalten NICHT haben. Ich möchte, dass die Ergebnisliste mit mehreren Ergebnissen zurückgegeben wird.
Summe
17
20
23
26
29

Du kannst ja mal eine Datenbank anlegen.
DB: Test

CREATE DATABASE  `test` ;

Und dann erstellst du eine Tabelle

CREATE TABLE  `test`.`testworte` (
`ID` INT NOT NULL ,
`Worte` VARCHAR( 50 ) NOT NULL ,
PRIMARY KEY (  `ID` )
) ENGINE = MYISAM

Anschließend befüllen wir die mal mit Testwerten:

INSERT INTO  `test`.`testworte` (
`ID` ,
`Worte`
)
VALUES (
'1',  'automatik'
), (
'2',  'automotor'
);

Dann spielen wir die Levenshtein-Funktion für die Datenbank ein

DELIMITER //
CREATE FUNCTION LEVENSHTEIN (s1 VARCHAR(255), s2 VARCHAR(255))
  RETURNS INT
    DETERMINISTIC
      BEGIN
        DECLARE s1_len, s2_len, i, j, c, c_temp, cost INT;
        DECLARE s1_char CHAR;
        DECLARE cv0, cv1 VARBINARY(256);
        SET s1_len = CHAR_LENGTH(s1), s2_len = CHAR_LENGTH(s2), cv1 = 0x00, j = 1, i = 1, c = 0;
        IF s1 = s2 THEN
          RETURN 0;
        ELSEIF s1_len = 0 THEN
          RETURN s2_len;
        ELSEIF s2_len = 0 THEN
          RETURN s1_len;
        ELSE
          WHILE j <= s2_len DO
            SET cv1 = CONCAT(cv1, UNHEX(HEX(j))), j = j + 1;
          END WHILE;
          WHILE i <= s1_len DO
            SET s1_char = SUBSTRING(s1, i, 1), c = i, cv0 = UNHEX(HEX(i)), j = 1;
            WHILE j <= s2_len DO
                SET c = c + 1;
                IF s1_char = SUBSTRING(s2, j, 1) THEN SET cost = 0; ELSE SET cost = 1; END IF;
                SET c_temp = CONV(HEX(SUBSTRING(cv1, j, 1)), 16, 10) + cost;
                IF c > c_temp THEN SET c = c_temp; END IF;
                SET c_temp = CONV(HEX(SUBSTRING(cv1, j+1, 1)), 16, 10) + 1;
                IF c > c_temp THEN SET c = c_temp; END IF;
                SET cv0 = CONCAT(cv0, UNHEX(HEX(c))), j = j + 1;
            END WHILE;
            SET cv1 = cv0, i = i + 1;
          END WHILE;
        END IF;
        RETURN c;
      END
//

Dann machst Du folgendes

SELECT LEVENSHTEIN('autos', 'auto') AS Ergebnis

Du wirst eine Zeile zurückerhalten mit dem Ergebnis 1.

Als nächstes probierst Du mal

SELECT LEVENSHTEIN((SELECT `worte` FROM `testworte` WHERE ID = 2), 'auto') AS Ergebnis

Und dann probiers mal so:

SELECT LEVENSHTEIN((SELECT `worte` FROM `testworte`), 'auto') AS Ergebnis

Ich möchte jetzt zwei Ergebniszeilen haben. Stattdessen erhalte ich die Fehlermeldung, dass der Subquery mehr als 1 Argument zurückliefert.

Probiers mal aus - ich weiß was Du meinst, aber das will ich nicht.

Ziel ist es auf diese Weise eine Liste ähnlicher Worte zu generieren, z.B. so

SELECT worte 
FROM testworte 
WHERE LEAST(
         SELECT LEVENSHTEIN
                (
                 (SELECT `worte` FROM `testworte` WHERE ID = 2), 'auto'
                  ) AS Ergebnis)

[feuervogel]

also entweder du veränderst deine levenshtein-funktion, so dass sie als erstes argument ein queryset annimmt, und iterierst dann über alle elemente oder aber du baust die iteration in dein statement ein...vielleicht so:

SELECT LEVENSHTEIN(worte, 'auto') AS Ergebnis, worte from test.testworte order by Ergebnis ASC;