Kategorien:

Bitweise Ausdrucksfunktionen

BITXOR

Gibt das bitweise XOR von zwei numerischen oder binären Ausdrücken zurück.

Aliasse:

BIT_XOR

Siehe auch:

BITXOR_AGG

Syntax

BITXOR( <expr1> , <expr2> [ , '<padside>' ] )
Copy

Argumente

expr1

Dieser Ausdruck muss einen INTEGER-Wert, einen BINARY-Wert oder einen Wert eines Datentyps ergeben, der in einen INTEGER-Wert umgewandelt werden kann.

expr2

Dieser Ausdruck muss einen INTEGER-Wert, einen BINARY-Wert oder einen Wert eines Datentyps ergeben, der in einen INTEGER-Wert umgewandelt werden kann.

'padside'

Wenn zwei BINARY-Argumentwerte nicht die gleiche Länge haben, gibt er an, auf welcher Seite der Wert mit der kürzeren Länge aufgefüllt werden soll. Geben Sie einen der folgenden Werte an, wobei Groß- und Kleinschreibung keine Rolle spielen:

  • LEFT – Den Wert auf der linken Seite auffüllen.

  • RIGHT – Den Wert auf der rechten Seite auffüllen.

Der kürzere Wert wird mit Nullen aufgefüllt, sodass er der Länge des längeren Werts entspricht.

Dieses Argument ist nur gültig, wenn BINARY-Ausdrücke angegeben sind.

Wenn die Länge von zwei BINARY-Werten unterschiedlich ist, ist dieses Argument erforderlich.

Rückgabewerte

Gibt einen INTEGER-Wert, einen BINARY-Wert oder einen NULL-Wert zurück:

  • Wenn die Eingabeausdrücke INTEGER-Werte enthalten, wird ein INTEGER-Wert zurückgegeben, der das bitweise XOR der Eingabeausdrücke darstellt.

  • Wenn die Eingabeausdrücke BINARY-Werte enthalten, wird ein BINARY-Wert zurückgegeben, der das bitweise XOR der Eingabeausdrücke darstellt.

  • Wenn einer der Eingabewerte NULL ist, wird NULL zurückgegeben.

Nutzungshinweise

  • Beide Eingabeausdrücke müssen einen Wert desselben Datentyps ergeben, entweder INTEGER oder BINARY.

  • Wenn der Datentyp einer der beiden Argumente numerisch aber nicht INTEGER ist (z. B. FLOAT, DECIMAL usw.), dann wird das Argument in einen INTEGER-Wert umgewandelt.

  • Wenn der Datentyp eines der beiden Argumente eine Zeichenfolge ist (z. B. VARCHAR), wird das Argument nach Möglichkeit in einen INTEGER Wert umgewandelt. So wird beispielsweise die Zeichenfolge 12.3 in 12 umgewandelt. Wenn der Wert nicht in einen INTEGER-Wert umgewandelt werden kann, wird der Wert als NULL behandelt.

  • Die Funktion wandelt Argumente nicht implizit in BINARY-Werte um.

Beispiele

Die folgenden Abschnitte enthalten Beispiele für INTEGER-Argumentwerte und BINARY-Argumentwerte.

Verwendung von BITAND, BITOR und BITXOR mit INTEGER-Argumentwerten

Erstellen Sie eine einfache Tabelle und fügen Sie die Daten ein:

CREATE OR REPLACE TABLE bits (ID INTEGER, bit1 INTEGER, bit2 INTEGER);
Copy
INSERT INTO bits (ID, bit1, bit2) VALUES 
  (   11,    1,     1),    -- Bits are all the same.
  (   24,    2,     4),    -- Bits are all different.
  (   42,    4,     2),    -- Bits are all different.
  ( 1624,   16,    24),    -- Bits overlap.
  (65504,    0, 65504),    -- Lots of bits (all but the low 6 bits).
  (    0, NULL,  NULL)     -- No bits.
  ;
Copy

Führen Sie die Abfrage aus:

SELECT bit1, 
       bit2, 
       BITAND(bit1, bit2), 
       BITOR(bit1, bit2), 
       BITXOR(bit1, BIT2)
  FROM bits
  ORDER BY bit1;
Copy
+------+-------+--------------------+-------------------+--------------------+
| BIT1 |  BIT2 | BITAND(BIT1, BIT2) | BITOR(BIT1, BIT2) | BITXOR(BIT1, BIT2) |
|------+-------+--------------------+-------------------+--------------------|
|    0 | 65504 |                  0 |             65504 |              65504 |
|    1 |     1 |                  1 |                 1 |                  0 |
|    2 |     4 |                  0 |                 6 |                  6 |
|    4 |     2 |                  0 |                 6 |                  6 |
|   16 |    24 |                 16 |                24 |                  8 |
| NULL |  NULL |               NULL |              NULL |               NULL |
+------+-------+--------------------+-------------------+--------------------+

Verwendung von BITAND, BITOR und BITXOR mit BINARY-Argumentwerten

Erstellen Sie eine einfache Tabelle und fügen Sie die Daten ein:

CREATE OR REPLACE TABLE bits (ID INTEGER, bit1 BINARY(2), bit2 BINARY(2), bit3 BINARY(4));

INSERT INTO bits VALUES
  (1, x'1010', x'0101', x'11001010'),
  (2, x'1100', x'0011', x'01011010'),
  (3, x'BCBC', x'EEFF', x'ABCDABCD'),
  (4, NULL, NULL, NULL);
Copy

Bemerkung

Die BINARY-Werte werden in der Notation x'value' eingefügt, wobei value hexadezimale Ziffern enthält. Weitere Informationen dazu finden Sie unter Eingabe und Ausgabe von Binärdaten.

Ausführen einer Abfrage auf BINARY-Spalten gleicher Länge:

SELECT bit1,
       bit2,
       BITAND(bit1, bit2),
       BITOR(bit1, bit2),
       BITXOR(bit1, bit2)
  FROM bits;
Copy
+------+------+--------------------+-------------------+--------------------+
| BIT1 | BIT2 | BITAND(BIT1, BIT2) | BITOR(BIT1, BIT2) | BITXOR(BIT1, BIT2) |
|------+------+--------------------+-------------------+--------------------|
| 1010 | 0101 | 0000               | 1111              | 1111               |
| 1100 | 0011 | 0000               | 1111              | 1111               |
| BCBC | EEFF | ACBC               | FEFF              | 5243               |
| NULL | NULL | NULL               | NULL              | NULL               |
+------+------+--------------------+-------------------+--------------------+

Wenn Sie versuchen, eine Abfrage auf BINARY-Spalten mit unterschiedlichen Längen auszuführen, ohne das Argument 'padside' anzugeben, wird ein Fehler zurückgegeben:

SELECT bit1,
       bit3,
       BITAND(bit1, bit3),
       BITOR(bit1, bit3),
       BITXOR(bit1, bit3)
  FROM bits;
Copy
100544 (22026): The lengths of two variable-sized fields do not match: first length 2, second length 4

Führen Sie eine Abfrage auf BINARY-Spalten unterschiedlicher Länge aus und füllen Sie den kleineren Argumentwert auf der linken Seite auf:

SELECT bit1,
       bit3,
       BITAND(bit1, bit3, 'LEFT'),
       BITOR(bit1, bit3, 'LEFT'),
       BITXOR(bit1, bit3, 'LEFT')
  FROM bits;
Copy
+------+----------+----------------------------+---------------------------+----------------------------+
| BIT1 | BIT3     | BITAND(BIT1, BIT3, 'LEFT') | BITOR(BIT1, BIT3, 'LEFT') | BITXOR(BIT1, BIT3, 'LEFT') |
|------+----------+----------------------------+---------------------------+----------------------------|
| 1010 | 11001010 | 00001010                   | 11001010                  | 11000000                   |
| 1100 | 01011010 | 00001000                   | 01011110                  | 01010110                   |
| BCBC | ABCDABCD | 0000A88C                   | ABCDBFFD                  | ABCD1771                   |
| NULL | NULL     | NULL                       | NULL                      | NULL                       |
+------+----------+----------------------------+---------------------------+----------------------------+

Führen Sie eine Abfrage auf BINARY-Spalten unterschiedlicher Länge aus und füllen Sie den kleineren Argumentwert auf der rechten Seite auf:

SELECT bit1,
       bit3,
       BITAND(bit1, bit3, 'RIGHT'),
       BITOR(bit1, bit3, 'RIGHT'),
       BITXOR(bit1, bit3, 'RIGHT')
  FROM bits;
Copy
+------+----------+-----------------------------+----------------------------+-----------------------------+
| BIT1 | BIT3     | BITAND(BIT1, BIT3, 'RIGHT') | BITOR(BIT1, BIT3, 'RIGHT') | BITXOR(BIT1, BIT3, 'RIGHT') |
|------+----------+-----------------------------+----------------------------+-----------------------------|
| 1010 | 11001010 | 10000000                    | 11101010                   | 01101010                    |
| 1100 | 01011010 | 01000000                    | 11011010                   | 10011010                    |
| BCBC | ABCDABCD | A88C0000                    | BFFDABCD                   | 1771ABCD                    |
| NULL | NULL     | NULL                        | NULL                       | NULL                        |
+------+----------+-----------------------------+----------------------------+-----------------------------+
Sprache: Deutsch