Suchbedingungen

[`NOT`]	`predicate`
	(`search-condition`)
`search-condition`		`AND`	`search-condition`
		`OR`

This Dokument behandelt folgende Themen:

search-condition
predicate

`search-condition`

Eine search-condition kann aus einer einfachen Bedingung (predicate) bestehen oder aus mehreren search-conditions, die durch die Boole’schen Operatoren AND, OR und NOT verknüpft werden, wobei die Reihenfolge der Auswertung außerdem durch entsprechende Klammerung bestimmt werden kann.

Beispiel:

DEFINE DATA LOCAL 
01 NAME   (A20) 
01 AGE    (I2) 
END-DEFINE 
... 
SELECT * 
  INTO NAME, AGE 
  FROM SQL-PERSONNEL 
  WHERE AGE = 32 AND NAME > 'K' 
END-SELECT 
...

`predicate`

Ein predicate gibt eine Bedingung an, die "wahr", "falsch" oder "unbekannt" sein kann.

In einer search-condition kann ein predicate aus einer einfachen oder komplexen Vergleichsoperation oder anderen Arten von Bedingung bestehen.

Beispiel:

SELECT NAME, AGE 
  INTO VIEW PERS 
  FROM SQL-PERSONNEL 
  WHERE AGE BETWEEN 20 AND 30    
    0R AGE IN ( 32, 34, 36 ) 
    AND NAME LIKE '%er' 
    ...

Anmerkung:
Das Prozentzeichen (%) kann zu Konflikten mit Natural-Terminalkommandos führen. In diesem Fall müssen Sie als Steuerzeichen für Terminalkommandos ein anderes Zeichen als % definieren (siehe Ändern des Terminalkommando-Steuerzeichens ).

Die einzelnen predicates sind auf den folgenden Seiten beschrieben (weitere Informationen zu predicates finden Sie in der betreffenden Literatur). Entsprechend der obigen Syntax heißen sie wie folgt:

The individual predicates are explained in the following topics (for further information on predicates, please refer to the relevant literature). According to the syntax above, they are called as follows:

comparison-predicate
BETWEEN-predicate
DISTINCT-predicate
LIKE-predicate
NULL-predicate
IN-predicate
quantified-predicate
EXISTS-predicate
XMLEXISTS-predicate

`comparison-predicate`

`scalar-expression`	`comparison`		`scalar-expression`
`row-value-expression`		=	`row-value-expression`
		<>

Ein comparison-predicate vergleicht zwei Werte oder einen Satz Werte mit einem anderen Satz Werte.

Siehe Informationen zu scalar-expression.

`comparison`

	`=`
	`<`
	`>`
	`<=`
	`>=`
	`< >`

comparison kann einer der folgenden Operatoren sein:

`=`	gleich
`<`	kleiner als
`>`	größer als
`<=`	kleiner gleich
`>=`	größer gleich
`<>`	ungleich

`subquery`

(select-expression)

Eine subquery ist eine select-expression innerhalb einer anderen select-expression.

Beispiel:

DEFINE DATA LOCAL 
1 #NAME    (A20) 
1 #PERSNR  (I4) 
END-DEFINE 
... 
SELECT NAME, PERSNR 
  INTO #NAME, #PERSNR 
  FROM SQL-PERSONNEL 
  WHERE PERSNR IN 
    ( SELECT PERSNR 
        FROM SQL-AUTOMOBILES 
        WHERE COLOR = 'black' )  
        ... 
END-SELECT

Weitere Informationen siehe SELECT-Ausdrücke.

`BETWEEN-predicate`

scalar-expression [NOT] BETWEEN scalar-expression AND scalar-expression

Ein BETWEEN-predicate vergleicht einen Wert mit einem Bereich von Werten.

Siehe Informationen zu scalar-expression.

`DISTINCT-predicate`

	`scalar-expression` `IS` [`NOT`] `DISTINCT FROM` `scalar-expression`
	`row-value-expression` `IS` [`NOT`] `DISTINCT FROM` `row-value-expression`

Ein DISTINCT-predicate vergleicht einen Wert mit einem anderen Wert oder einen Satz Werte mit einem anderen Satz Werte.

`LIKE-predicate`

`column-reference` [`NOT`] `LIKE`		`atom`		[`ESCAPE` `atom`]
		`special-register`

Ein LIKE-predicate sucht nach Zeichenketten, die ein bestimmtes Muster haben.

Siehe Informationen zu column-reference, atom und special-register.

`NULL-predicate`

column-reference IS [NOT] NULL

Ein NULL-predicate prüft auf Nullwerte.

Wenn die Compiler-Option DB2ARRY auf ON gesetzt ist, kann ein Natural-Array oder ein feststehender Indexbereich eines Arrays als atom angegeben werden. Der Natural SQL Compiler zerlegt dann das Array oder den feststehenden Indexbereich in eine Liste mit skalaren host-variables.

Siehe Informationen zu column-reference.

`IN-predicate`

	`scalar-expression` [`NOT`] `IN`		`subquery`
			`row-value-expression`
	`row-value-expression` [`NOT`] `IN` `subquery`

Ein IN-predicate vergleicht einen Wert oder einen Satz Werte mit einer Sammlung von Werten.

Siehe Informationen zu scalar-expression, atom und special-register.

Siehe Informationen zu subquery.

`quantified-predicate`

`scalar-expression`	`comparison`		`SOME` `ANY` `ALL`	`subquery`
`row-value-expression`	`=`		`SOME` `ANY`	`subquery`
`row-value-expression`	`<>`	`ALL`		`subquery`

Ein quantified-predicate vergleicht einen Wert oder einen Satz Werte mit einer Sammlung von Werten.

Siehe Informationen zu scalar-expression, comparison und subquery.

`EXISTS-predicate`

EXISTS subquery

Ein EXISTS-predicate prüft, ob bestimmte Zeilen vorhanden sind.

Die Bedingung des EXISTS-predicate kann nur erfüllt werden, wenn das Ergebnis der ausgewerteten subquery nicht leer ist, d.h. wenn mindestens ein Datensatz (eine Zeile) in der FROM-Tabelle der subquery die WHERE-Klausel-Suchbedingung dieser subquery erfüllt.

Beispiel für EXISTS:

DEFINE DATA LOCAL 
1 #NAME    (A20) 
END-DEFINE 
... 
SELECT NAME 
  INTO #NAME 
  FROM SQL-PERSONNEL 
  WHERE EXISTS 
    ( SELECT * 
      FROM SQL-EMPLOYEES 
      WHERE PERSNR > 1000  
        AND NAME < 'L' ) 
        ... 
END-SELECT 
...

Siehe Informationen zu subquery.

`XMLEXISTS-predicate`

`XMLEXISTS` `(xquery-expression-constant`		`BY REF`		`)`
		`PASSING` `xquery-argument`,...

`xquery-argument`

	`xquery-context-item-expression`
	`xquery-context-item-expression` `AS` `identifier`

Das XMLEXISTS-predicate prüft, ob ein XPATH-Ausdruck eine Folge von einem oder mehreren items zurückgibt. Weitere Informationen siehe IBM Db2 XML Guide.