Hallo ,

ich hab folgendes Problem:

Eine Auswertung soll dahingehend vorgenommen werden, dass bestimmte
Elemente inklusive

einer Wildcard selectiert werden.

Am nachfolgenden Beispiel ist dies zu sehen:



+---------+-------+-----+-----+

| Feld1 | Feld2 | VON | BIS |

+---------+-------+-----+-----+

| OBJEKT1 | 1234 | A* | |

| OBJEKT1 | 1235 | AA | AF |

+---------+-------+-----+-----+

2 rows in set (0.00 sec)

GEsucht werden alle Objekt1 die den Wert 'AB' besitzen. Dabei können
Wildcards vergeben worden

sein, aber auch Intervalle.



Mein Bisheriges SQL Statement "SELECT * FROM `test_von` WHERE
`FELD1`='OBJEKT1' AND (((VON<='AB' AND 'AB'<=BIS) or VON='*'));"

liefert mir folgendes Ergebnis:

+---------+-------+-----+-----+

| Feld1 | Feld2 | VON | BIS |

+---------+-------+-----+-----+

| OBJEKT1 | 1235 | AA | AF |

+---------+-------+-----+-----+



Wie man sehen kann ist das leider falsch.

Wie kann ich den SQL Befehl dahingehend ab‰ndern, dass er mir Wildcards
an beliebiger Stelle mit berücksichtigt.

Geht das?



Danke für eure Hilfe.



Grüße Ralf

Andreas
--
Andreas Kretschmer
Linux - weil ich es mir wert bin!
GnuPG-ID 0x3FFF606C http://wwwkeys.de.pgp.net
Deutsche PostgreSQL User Group: http://pgug.de

Ralf Miller!

> GEsucht werden alle Objekt1 die den Wert 'AB' besitzen. Dabei können
> Wildcards vergeben worden sein, aber auch Intervalle.

Was sind das für Wildcards, einfach das was ich vermute, wenn ich A*
lese? Anstatt dem * würde sich dann ein % anbieten, damit kann LIKE
nämlich direkt umgehen. Ansonsten gehen auch reguläre Ausdrücke mit
REGEXP bzw. RLIKE.

Der * kann aber auch im SELECT direct in ein % getauscht werden, dann geht
es auch mit LIKE:

SELECT * FROM wild;
+---------+-------+------+------+
| feld1 | feld2 | von | bis |
+---------+-------+------+------+
| OBJEKT1 | 1234 | A* | NULL |
| OBJEKT2 | 1235 | AA | AF |
| OBJEKT3 | 1236 | AF | AK |
+---------+-------+------+------+
3 rows in set (0.00 sec)

SELECT * FROM wild
WHERE (bis IS NOT NULL AND von <= "AB" AND bis >= "AB")
OR (bis IS NULL AND "AB" LIKE REPLACE(von, '*', '%'));
+---------+-------+------+------+
| feld1 | feld2 | von | bis |
+---------+-------+------+------+
| OBJEKT1 | 1234 | A* | NULL |
| OBJEKT2 | 1235 | AA | AF |
+---------+-------+------+------+
2 rows in set (0.00 sec)


Das mit dem NULL habe ich der Eindeutigkeit halber benutzt, ggf. den Check
raus nehmen (bei den Beispielen hier sollte es nichtmal etwas ausmachen,
da die Range im Fall einer Wildcard mit leerem "bis" dann leer wäre).


Gruß
Daniel

On 2007-07-11 11:16:07 +0200, Daniel Fischer <spam [at] erinye.com> said:



Hy Daniel,

danke das ist genau das was ich suchte. Ich wusste nicht, dass man
hierfür LIKE und Replace sowie das % kombinieren kann. Super.

Danke
Grüße
Ralf

Hallo,

jetzt habe ich doch noch ein Problem.
Ich habe meine Daten nun folgendermaßen vorhanden:
+---------+-------+------+------+
| FELD1 | FELD2 | VON | BIS |
+---------+-------+------+------+
| Objekt1 | 1 | S* | |
| Objekt1 | 1 | SU05 | |
| Objekt1 | 1 | SE01 | |
| Objekt1 | 1 | SU5* | |
| Objekt1 | 1 | SE* | SE08 |
| Objekt1 | 1 | S_* | |
+---------+-------+------+------+

Ich möchte nun alle Elemente die SE01 besitzen. Dies versuche ich nun
mitfolgender Auswertung:
SELECT * FROM `tab2` WHERE `FELD1`='OBJEKT1' AND ((((VON<='SE01' AND
'SE01'<=BIS) OR (VON='SE01' AND BIS ='')) or (VON='*') or ('SE01' like
replace(trim(VON),'*','%'))));

Nur leider ist das Ergebnis folgendes:
+---------+-------+------+------+
| FELD1 | FELD2 | VON | BIS |
+---------+-------+------+------+
| Objekt1 | 1 | S* | |
| Objekt1 | 1 | SE01 | |
| Objekt1 | 1 | SE* | SE08 |
| Objekt1 | 1 | S_* | |
+---------+-------+------+------+

Die letzte Zeile S_* ist leider zuviel. Wie könnte ich das Statement
anpassen, dass er die richtigen Einträge zieht?
Wäre super, wenn mir hier jemand weiterhelfen könnte.
Grüße und Danke
Ralf

On 2007-07-11 11:16:07 +0200, Daniel Fischer <spam [at] erinye.com> said:

> Ralf Miller!
>
>> GEsucht werden alle Objekt1 die den Wert 'AB' besitzen. Dabei können
>> Wildcards vergeben worden sein, aber auch Intervalle.
>
> Was sind das für Wildcards, einfach das was ich vermute, wenn ich A*
> lese? Anstatt dem * würde sich dann ein % anbieten, damit kann LIKE
> nämlich direkt umgehen. Ansonsten gehen auch reguläre Ausdrücke mit
> REGEXP bzw. RLIKE.
>
> Der * kann aber auch im SELECT direct in ein % getauscht werden, dann geht
> es auch mit LIKE:
>
> SELECT * FROM wild;
> +---------+-------+------+------+
> | feld1 | feld2 | von | bis |
> +---------+-------+------+------+
> | OBJEKT1 | 1234 | A* | NULL | | OBJEKT2 | 1235 | AA | AF | |
> OBJEKT3 | 1236 | AF | AK | +---------+-------+------+------+
> 3 rows in set (0.00 sec)
>
> SELECT * FROM wild WHERE (bis IS NOT NULL AND von <= "AB" AND bis >= "AB")
> OR (bis IS NULL AND "AB" LIKE REPLACE(von, '*', '%'));
> +---------+-------+------+------+
> | feld1 | feld2 | von | bis |
> +---------+-------+------+------+
> | OBJEKT1 | 1234 | A* | NULL |
> | OBJEKT2 | 1235 | AA | AF |
> +---------+-------+------+------+
> 2 rows in set (0.00 sec)
>
>
> Das mit dem NULL habe ich der Eindeutigkeit halber benutzt, ggf. den Check
> raus nehmen (bei den Beispielen hier sollte es nichtmal etwas ausmachen,
> da die Range im Fall einer Wildcard mit leerem "bis" dann leer wäre).
>
>
> Gruß
> Daniel

Ralf Miller schrieb:

> SELECT [...] WHERE [...] 'SE01' like replace(trim(VON),'*','%') [...]
>
> Nur leider ist das Ergebnis folgendes:
> +---------+-------+------+------+
> | FELD1 | FELD2 | VON | BIS |
> +---------+-------+------+------+
> | Objekt1 | 1 | S_* | |
> +---------+-------+------+------+
>
> Die letzte Zeile S_* ist leider zuviel. Wie könnte ich das Statement
> anpassen, dass er die richtigen Einträge zieht?

'_' ist - wie '%' - ein WQL-Wildcard und steht für ein beliebiges Zeichen.

Versuch's mal mit RLIKE. Dann kanst Du Dir auch Dein REPLACE schenken:

SELECT ... WHERE ... 'SE01' RLIKE TRIM(VON) ...

> On 2007-07-11 11:16:07 +0200, Daniel Fischer <spam [at] erinye.com> said:
>
>> [Fullquote gesnipt]

http://learn.to/quote

Gruß. Claus

Hy Claus,

danke schon mal für die Erläuterung der Ursache meines Problems.
Jetzt habe ich mal Deinen Tipp versucht und komme auf folgendes Statement:
SELECT * FROM `tab2` WHERE `FELD1`='OBJEKT1' AND ((((VON<='SE01' AND
'SE01'<=BIS) OR (VON='SE01' AND BIS ='')) or (VON='*') or ('SE01' RLIKE
trim(VON))));

Das liefert mir nun folgende Auswertung:
+---------+-------+------+------+
| FELD1 | FELD2 | VON | BIS |
+---------+-------+------+------+
| OBJEKT1 | 0 | 0* | B* |
| Objekt1 | 1 | S* | |
| Objekt1 | 1 | SE01 | |
| Objekt1 | 1 | SE* | SE08 |
| Objekt1 | 1 | S_* | |
+---------+-------+------+------+
(Ich habe die Ursprungstabelle um die erste Zeile erweitert.
Leider ist auch hier S_* drin und ergänzend werden nun auch die erste
Zeile gezogen, die eigentlich nicht dazugehört, da SE01 bicht zwischen
oder gleich von bis ist.
Hast Du vielleicht einen weiteren Tip wie ich damit umgehen könnte,
dass es die richtige Auswertung zieht.

Danke
Ralf

On 2007-07-23 09:16:37 +0200, Claus Reibenstein <4spammersonly [at] web.de> said:

> Ralf Miller schrieb:
>
>> SELECT [...] WHERE [...] 'SE01' like replace(trim(VON),'*','%') [...]
>>
>> Nur leider ist das Ergebnis folgendes:
>> +---------+-------+------+------+
>> | FELD1 | FELD2 | VON | BIS |
>> +---------+-------+------+------+
>> | Objekt1 | 1 | S_* | |
>> +---------+-------+------+------+
>>
>> Die letzte Zeile S_* ist leider zuviel. Wie könnte ich das Statement
>> anpassen, dass er die richtigen Einträge zieht?
>
> '_' ist - wie '%' - ein WQL-Wildcard und steht für ein beliebiges Zeichen.
>
> Versuch's mal mit RLIKE. Dann kanst Du Dir auch Dein REPLACE schenken:
>
> SELECT ... WHERE ... 'SE01' RLIKE TRIM(VON) ...
>
>> On 2007-07-11 11:16:07 +0200, Daniel Fischer <spam [at] erinye.com> said:
>>
>>> [Fullquote gesnipt]
>
> http://learn.to/quote
>
> Gruß. Claus

Ralf Miller!

> Leider ist auch hier S_* drin und ergänzend werden nun auch die erste
> Zeile gezogen, die eigentlich nicht dazugehört, da SE01 bicht zwischen
> oder gleich von bis ist.

RLIKE ist wie LIKE, nur mit regulären Ausdrücken. Du wirst dir eins von
den beiden aussuchen müssen und sicherstellen, dass deine Muster sich an
die Syntax dafür halten. In der Regel heisst das einfach nur, die
Sonderzeichen zu escapen, z.B. bei LIKE alle _ die nicht als Wildcard
gelten sollten als \_ schreiben.


Gruß
Daniel