Amazon Redshift unterstützt UDFs ab Patch 198 nicht mehr die Erstellung von neuem Python. Das bestehende Python UDFs wird bis zum 30. Juni 2026 weiterhin funktionieren. Weitere Informationen finden Sie im [Blog-Posting](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # Beispiele Im folgenden Beispiel werden verschiedene Spalten- und Tabellenattribute in CREATE TABLE-Anweisungen von Amazon Redshift gezeigt. Weitere Informationen zu CREATE TABLE, einschließlich Parameterdefinitionen, finden Sie unter [CREATE TABLE](r_CREATE_TABLE_NEW.md). In vielen der Beispiele werden Tabellen und Daten aus dem *TICKIT*-Beispieldatensatz verwendet. Weitere Informationen finden Sie unter [Beispieldatenbank](https://docs.aws.amazon.com/redshift/latest/dg/c_sampledb.html). In einem Befehl CREATE TABLE können Sie dem Tabellennamen den Datenbanknamen und den Schemanamen voranstellen. Beispiel: `dev_database.public.sales` Der Datenbankname muss die Datenbank bezeichnen, mit der Sie verbunden sind. Jeder Versuch, Datenbankobjekte in einer anderen Datenbank zu erstellen, schlägt mit einem Fehler aufgrund einer ungültigen Operation fehl. ## Erstellen einer Tabelle mit einem Verteilungsschlüssel, einem zusammengesetzten Sortierschlüssel und Kompression Im folgenden Beispiel wird eine SALES-Tabelle in der Datenbank TICKIT erstellt, in der für verschiedene Tabellen Kompression definiert wird. LISTID ist als Verteilungsschlüssel deklariert und LISTID und SELLERID sind als zusammengesetzter mehrspaltiger Sortierschlüssel deklariert. Darüber hinaus sind Primärschlüssel- und Fremdschlüsseleinschränkungen für die Tabelle definiert. Bevor Sie die Tabelle in dem Beispiel erstellen, müssen Sie möglicherweise jeder Spalte, auf die durch einen Fremdschlüssel verwiesen wird, eine Einschränkung UNIQUE hinzufügen, falls keine Einschränkungen existieren. ``` create table sales( salesid integer not null, listid integer not null, sellerid integer not null, buyerid integer not null, eventid integer not null encode mostly16, dateid smallint not null, qtysold smallint not null encode mostly8, pricepaid decimal(8,2) encode delta32k, commission decimal(8,2) encode delta32k, saletime timestamp, primary key(salesid), foreign key(listid) references listing(listid), foreign key(sellerid) references users(userid), foreign key(buyerid) references users(userid), foreign key(dateid) references date(dateid)) distkey(listid) compound sortkey(listid,sellerid); ``` Es folgen die Ergebnisse: ``` schemaname | tablename | column | type | encoding | distkey | sortkey | notnull -----------+-----------+------------+-----------------------------+----------+---------+---------+-------- public | sales | salesid | integer | lzo | false | 0 | true public | sales | listid | integer | none | true | 1 | true public | sales | sellerid | integer | none | false | 2 | true public | sales | buyerid | integer | lzo | false | 0 | true public | sales | eventid | integer | mostly16 | false | 0 | true public | sales | dateid | smallint | lzo | false | 0 | true public | sales | qtysold | smallint | mostly8 | false | 0 | true public | sales | pricepaid | numeric(8,2) | delta32k | false | 0 | false public | sales | commission | numeric(8,2) | delta32k | false | 0 | false public | sales | saletime | timestamp without time zone | lzo | false | 0 | false ``` Das folgende Beispiel erstellt die Tabelle t1 mit einer groß-/kleinschreibungsneutralen Spalte col1. ``` create table T1 ( col1 Varchar(20) collate case_insensitive ); insert into T1 values ('bob'), ('john'), ('Tom'), ('JOHN'), ('Bob'); ``` Fragen Sie die Tabelle ab: ``` select * from T1 where col1 = 'John'; col1 ------ john JOHN (2 rows) ``` ## Erstellen einer Tabelle mit einem überlappenden Sortierschlüssel Im folgenden Beispiel wird die Tabelle CUSTOMER mit einem überlappenden Sortierschlüssel erstellt. ``` create table customer_interleaved ( c_custkey integer not null, c_name varchar(25) not null, c_address varchar(25) not null, c_city varchar(10) not null, c_nation varchar(15) not null, c_region varchar(12) not null, c_phone varchar(15) not null, c_mktsegment varchar(10) not null) diststyle all interleaved sortkey (c_custkey, c_city, c_mktsegment); ``` ## Erstellen einer Tabelle mit IF NOT EXISTS Im folgenden Beispiel wird entweder die Tabelle CITIES erstellt oder es erfolgt keine Aktion und es wird eine Meldung zurückgegeben, wenn die Tabelle bereits vorhanden ist: ``` create table if not exists cities( cityid integer not null, city varchar(100) not null, state char(2) not null); ``` ## Erstellen einer Tabelle mit der Verteilung ALL Im folgenden Beispiel wird die Tabelle VENUE mit der Verteilung ALL erstellt. ``` create table venue( venueid smallint not null, venuename varchar(100), venuecity varchar(30), venuestate char(2), venueseats integer, primary key(venueid)) diststyle all; ``` ## Erstellen einer Tabelle mit der Verteilung EVEN Im folgenden Befehl wird eine Tabelle namens MYEVENT mit drei Spalten erstellt. ``` create table myevent( eventid int, eventname varchar(200), eventcity varchar(30)) diststyle even; ``` Die Tabelle wird gleichmäßig verteilt und ist nicht sortiert. Für die Tabelle wurden keine DISTKEY- oder SORTKEY-Spalten deklariert. ``` select "column", type, encoding, distkey, sortkey from pg_table_def where tablename = 'myevent'; column | type | encoding | distkey | sortkey -----------+------------------------+----------+---------+--------- eventid | integer | lzo | f | 0 eventname | character varying(200) | lzo | f | 0 eventcity | character varying(30) | lzo | f | 0 (3 rows) ``` ## Erstellen einer temporären Tabelle, die wie eine andere Tabelle ist (LIKE) Im folgenden Befehl wird eine temporäre Tabelle namens TEMPEVENT erstellt, deren Spalten aus der Tabelle EVENT geerbt werden. ``` create temp table tempevent(like event); ``` Diese Tabelle erbt darüber hinaus die Attribute DISTKEY und SORTKEY der übergeordneten Tabelle: ``` select "column", type, encoding, distkey, sortkey from pg_table_def where tablename = 'tempevent'; column | type | encoding | distkey | sortkey -----------+-----------------------------+----------+---------+--------- eventid | integer | none | t | 1 venueid | smallint | none | f | 0 catid | smallint | none | f | 0 dateid | smallint | none | f | 0 eventname | character varying(200) | lzo | f | 0 starttime | timestamp without time zone | bytedict | f | 0 (6 rows) ``` ## Erstellen einer Tabelle mit einer IDENTITY-Spalte Im folgenden Beispiel wird eine Tabelle namens VENUE\$1IDENT erstellt, die eine IDENTITY-Spalte namens VENUEID besitzt. Diese Spalte beginnt mit 0 und wird für jeden Datensatz um 1 erhöht. VENUEID ist auch als Primärschlüssel der Tabelle deklariert. ``` create table venue_ident(venueid bigint identity(0, 1), venuename varchar(100), venuecity varchar(30), venuestate char(2), venueseats integer, primary key(venueid)); ``` ## Erstellen einer Tabelle mit einer Standard-IDENTITY-Spalte Im folgenden Beispiel wird eine Tabelle mit dem Namen erstellt `t1`. Diese Tabelle hat eine IDENTITY-Spalte mit dem, Namen `hist_id` und eine Standard-IDENTITY-Spalte mit dem Namen `base_id`. ``` CREATE TABLE t1( hist_id BIGINT IDENTITY NOT NULL, /* Cannot be overridden */ base_id BIGINT GENERATED BY DEFAULT AS IDENTITY NOT NULL, /* Can be overridden */ business_key varchar(10) , some_field varchar(10) ); ``` Die Einfügung einer Zeile in die Tabelle zeigt, dass `hist_id`- und `base_id`-Werte generiert werden. ``` INSERT INTO T1 (business_key, some_field) values ('A','MM'); ``` ``` SELECT * FROM t1; hist_id | base_id | business_key | some_field ---------+---------+--------------+------------ 1 | 1 | A | MM ``` Die Einfügung einer zweiten Zeile zeigt, dass der Standardwert für `base_id` generiert wird. ``` INSERT INTO T1 (base_id, business_key, some_field) values (DEFAULT, 'B','MNOP'); ``` ``` SELECT * FROM t1; hist_id | base_id | business_key | some_field ---------+---------+--------------+------------ 1 | 1 | A | MM 2 | 2 | B | MNOP ``` Die Einfügung einer dritten Zeile zeigt, dass der Wert für `base_id` nicht eindeutig sein muss. ``` INSERT INTO T1 (base_id, business_key, some_field) values (2,'B','MNNN'); ``` ``` SELECT * FROM t1; hist_id | base_id | business_key | some_field ---------+---------+--------------+------------ 1 | 1 | A | MM 2 | 2 | B | MNOP 3 | 2 | B | MNNN ``` ## Erstellen einer Tabelle mit DEFAULT-Spaltenwerten Im folgenden Beispiel wird die Tabelle CATEGORYDEF erstellt, die für jede Spalte Standardwerte deklariert: ``` create table categorydef( catid smallint not null default 0, catgroup varchar(10) default 'Special', catname varchar(10) default 'Other', catdesc varchar(50) default 'Special events', primary key(catid)); insert into categorydef values(default,default,default,default); ``` ``` select * from categorydef; catid | catgroup | catname | catdesc -------+----------+---------+---------------- 0 | Special | Other | Special events (1 row) ``` ## Die Optionen DISTSTYLE, DISTKEY und SORTKEY Im folgenden Beispiel wird gezeigt, wie die Optionen DISTSTYLE, DISTKEY und SORTKEY funktionieren. In diesem Beispiel COL1 ist dies der Verteilungsschlüssel. Daher muss der Verteilungsstil entweder auf KEY festgelegt oder nicht festgelegt werden. Standardmäßig besitzt die Tabelle keinen Sortierschlüssel und ist daher nicht sortiert: ``` create table t1(col1 int distkey, col2 int) diststyle key; ``` ``` select "column", type, encoding, distkey, sortkey from pg_table_def where tablename = 't1'; column | type | encoding | distkey | sortkey -------+---------+----------+---------+--------- col1 | integer | az64 | t | 0 col2 | integer | az64 | f | 0 ``` Im folgenden Beispiel wird dieselbe Spalte als Verteilungs- und Sortierschlüssel definiert. Auch hier muss der Verteilungsstil entweder auf KEY festgelegt werden oder wird nicht festgelegt. ``` create table t2(col1 int distkey sortkey, col2 int); ``` ``` select "column", type, encoding, distkey, sortkey from pg_table_def where tablename = 't2'; column | type | encoding | distkey | sortkey -------+---------+----------+---------+--------- col1 | integer | none | t | 1 col2 | integer | az64 | f | 0 ``` Im folgenden Beispiel ist keine Spalte als Verteilungsschlüssel festgelegt, COL2 sondern als Sortierschlüssel festgelegt, und der Verteilungsstil ist auf ALL festgelegt: ``` create table t3(col1 int, col2 int sortkey) diststyle all; ``` ``` select "column", type, encoding, distkey, sortkey from pg_table_def where tablename = 't3'; Column | Type | Encoding | DistKey | SortKey -------+---------+----------+---------+-------- col1 | integer | az64 | f | 0 col2 | integer | none | f | 1 ``` Im folgenden Beispiel ist der Verteilungsstil auf EVEN festgelegt, und es ist kein Sortierschlüssel explizit festgelegt. Daher wird die Tabelle gleichmäßig verteilt, jedoch nicht sortiert. ``` create table t4(col1 int, col2 int) diststyle even; ``` ``` select "column", type, encoding, distkey, sortkey from pg_table_def where tablename = 't4'; column | type |encoding | distkey | sortkey --------+---------+---------+---------+-------- col1 | integer | az64 | f | 0 col2 | integer | az64 | f | 0 ``` ## Erstellen einer Tabelle mit der Option ENCODE AUTO Im folgenden Beispiel wird die Tabelle `t1` mit automatischer Komprimierungskodierung erstellt. ENCODE AUTO ist der Standard für Tabellen, wenn Sie für keine Spalte einen Kodierungstyp angeben. ``` create table t1(c0 int, c1 varchar); ``` Im folgenden Beispiel wird die Tabelle `t2` mit automatischer Komprimierungskodierung erstellt, indem ENCODE AUTO angegeben wird. ``` create table t2(c0 int, c1 varchar) encode auto; ``` Im folgenden Beispiel wird die Tabelle `t3` mit automatischer Komprimierungskodierung erstellt, indem ENCODE AUTO angegeben wird. Spalte `c0` wird mit dem anfänglichen Kodierungstyp DELTA definiert. Amazon Redshift kann die Kodierung ändern, wenn eine andere Kodierung eine bessere Abfrageleistung bietet. ``` create table t3(c0 int encode delta, c1 varchar) encode auto; ``` Im folgenden Beispiel wird die Tabelle `t4` mit automatischer Komprimierungskodierung erstellt, indem ENCODE AUTO angegeben wird. Die Spalte `c0` wird mit einer Anfangskodierung von DELTA definiert, und die Spalte `c1` wird mit einer Anfangskodierung von LZO definiert. Amazon Redshift kann diese Kodierungen ändern, wenn andere Kodierungen eine bessere Abfrageleistung liefern. ``` create table t4(c0 int encode delta, c1 varchar encode lzo) encode auto; ```