CREATE TABLE "delete" (
        ogc_fid         serial ,
        typename        varchar,
        featureid       varchar,
        context         varchar,                -- delete/replace/update
        safetoignore    varchar,                -- replace.safetoignore 'true'/'false'
        replacedBy      varchar,                -- gmlid
        anlass          varchar[],              -- update.anlass
        endet           character(20),          -- update.endet
        ignored         boolean DEFAULT false,  -- Satz wurde nicht verarbeitet
        PRIMARY KEY (ogc_fid)
);

SELECT AddGeometryColumn('delete','dummy',25833,'POINT',2);

CREATE INDEX delete_fid ON "delete"(featureid);

COMMENT ON TABLE "delete"             IS 'Hilfstabelle für das Speichern von Löschinformationen.';
COMMENT ON COLUMN delete.typename     IS 'Objektart, also Name der Tabelle, aus der das Objekt zu löschen ist.';
COMMENT ON COLUMN delete.featureid    IS 'gml_id des zu löschenden Objekts (falls ein Objekt in einer Datei in verschiedenen Version angesprochen wird mit Timestamp).';
COMMENT ON COLUMN delete.context      IS 'Operation ''delete'', ''replace'' oder ''update''.';
COMMENT ON COLUMN delete.safetoignore IS 'Attribut safeToIgnore von wfsext:Replace';
COMMENT ON COLUMN delete.replacedBy   IS 'gml_id des Objekts, das featureid ersetzt';
COMMENT ON COLUMN delete.anlass       IS 'Anlaß des Endes';
COMMENT ON COLUMN delete.endet        IS 'Zeitpunkt des Endes';
COMMENT ON COLUMN delete.ignored      IS 'Löschsatz wurde ignoriert';


CREATE TABLE ax_fortfuehrungsauftrag (
	direkt boolean,
	ausgabeform character varying,
	crs character varying,
	anzahlDerNachkommastellen integer,
	standard boolean,
	profilkennung character varying,
	antragsnummer integer,
	auftragsnummer integer,
	impliziteloeschungderreservierung integer,
	verarbeitungsart integer,
	geometriebehandlung boolean,
	mittemporaeremarbeitsbereich boolean,
	mitobjektenimfortfuehrungsgebiet boolean,
	mitfortfuehrungsnachweis boolean,
	id serial ,
	jahr integer  DEFAULT date_part('year'::text, now()),
	gemkgnr integer ,
	lfdnr integer ,
	bemerkung text,
	auftragsdatei character varying,
	created_at timestamp without time zone  DEFAULT now(),
	updated_at timestamp without time zone  DEFAULT now(),
	user_name character varying 
);



-- Postprocessing

CREATE TABLE alkis.n_nutzung
(
  gml_id character varying ,
  beginnt timestamp without time zone ,
  endet timestamp without time zone,
  nutzungsartengruppe integer , -- Tausenderstelle = Nutzungsartengruppe nach ALKIS-nutzungsartenschluessel MV
  werteart1 integer , -- Bestimmende Werteart 1 nach ALKIS-Objektartenkatalog MV
  werteart2 integer , -- Bestimmende Werteart 2 nach ALKIS-Objektartenkatalog MV
  info integer, -- Weitere verschlüsselte Information zur Nutzung. Aus verschiedenen Feldern importiert. Siehe "nutzung_meta.fldinfo".
  zustand integer, -- ZUS "Zustand" beschreibt, ob der Abschnitt ungenutzt ist.
  name character varying, -- NAM Eigenname
  bezeichnung character varying, -- weitere unverschlüsselte Information wie Zweitname, Bezeichnung, fachliche Nummerierung usw.
  wkb_geometry geometry(Polygon,25833),
  gid serial ,
  datumderletztenueberpruefung timestamp without time zone,
  herkunft_source_source_ax_datenerhebung character varying[],
  CONSTRAINT n_nutzung_pk PRIMARY KEY (gml_id, beginnt)
);
CREATE INDEX n_nutzung_geom_idx ON alkis.n_nutzung USING gist (wkb_geometry);
COMMENT ON TABLE alkis.n_nutzung
  IS 'Zusammenfassung von 26 Tabellen des Objektbereiches "Tatsächliche Nutzung".';
COMMENT ON COLUMN alkis.n_nutzung.nutzungsartengruppe IS 'Tausenderstelle = Nutzungsartengruppe nach ALKIS-nutzungsartenschluessel MV';
COMMENT ON COLUMN alkis.n_nutzung.werteart1 IS 'Bestimmende Werteart 1 nach ALKIS-Objektartenkatalog MV';
COMMENT ON COLUMN alkis.n_nutzung.werteart2 IS 'Bestimmende Werteart 2 nach ALKIS-Objektartenkatalog MV';
COMMENT ON COLUMN alkis.n_nutzung.info IS 'Weitere verschlüsselte Information zur Nutzung. Aus verschiedenen Feldern importiert. Siehe "nutzung_meta.fldinfo".';
COMMENT ON COLUMN alkis.n_nutzung.zustand IS 'ZUS "Zustand" beschreibt, ob der Abschnitt ungenutzt ist.';
COMMENT ON COLUMN alkis.n_nutzung.name IS 'NAM Eigenname';
COMMENT ON COLUMN alkis.n_nutzung.bezeichnung IS 'weitere unverschlüsselte Information wie Zweitname, Bezeichnung, fachliche Nummerierung usw.';



CREATE TABLE lk_aemtergemeinden
(
  id serial ,
  kreis_name character varying(255),
  kreis_schluessel character(5),
  amt_schluessel character(4),
  amt_name character varying(255),
  gemeinde_schluessel character(8),
  gemeinde_name character varying(255),
  regionalschluessel character(12),
  gemeindeverband_schluessel character(9),
  dienststelle_schluessel character varying(6)
);


CREATE TABLE pp_kreis (
    gid			serial,
    land		text ,
    regierungsbezirk	text,
    kreis		text ,
    kreisname		character varying(80),
    anz_aemter		integer,		-- Anzahl Aemter
    CONSTRAINT pp_kreis_pk PRIMARY KEY (land, kreis)
  );

CREATE UNIQUE INDEX pp_kreis_gid_ix ON pp_kreis (gid);

-- Gesamtflaeche
SELECT AddGeometryColumn('pp_kreis','the_geom',25833,'MULTIPOLYGON',2);
CREATE INDEX pp_kreis_gidx ON pp_kreis USING gist(the_geom);

-- vereinfachte Gesamtflaeche
SELECT AddGeometryColumn('pp_kreis','simple_geom',25833,'MULTIPOLYGON',2);
CREATE INDEX pp_kreis_sgidx ON pp_kreis USING gist(simple_geom);


  COMMENT ON TABLE  pp_kreis             IS 'Post-Processing: Kreis';
  COMMENT ON COLUMN pp_kreis.kreis       IS 'Kreisschlüssel';
  COMMENT ON COLUMN pp_kreis.the_geom    IS 'präzise Geometrie aus Summe aller Ämter';
  COMMENT ON COLUMN pp_kreis.simple_geom    IS 'vereinfachte Geometrie für die Suche und die Anzeige von Übersichten in kleinen Maßstäben.';


-- Tabelle fuer Aemter
-- ========================

  CREATE TABLE pp_amt (
    gid			serial,
    land		text ,
    regierungsbezirk	text,
    kreis		text,
    amt			text ,
    amtsname		character varying(80),
    anz_gemeinden	integer,
		postleitzahlpostzustellung varchar,
		ort_post varchar,
		strasse varchar,
		hausnummer varchar,
		fax varchar[],
		telefon varchar[],
		weitereadressen varchar[],
    CONSTRAINT pp_aemter_pk PRIMARY KEY (land, kreis, amt)
  );

CREATE UNIQUE INDEX pp_amt_gid_ix ON pp_amt (gid);

-- Gesamtflaeche
SELECT AddGeometryColumn('pp_amt','the_geom',25833,'MULTIPOLYGON',2);
CREATE INDEX pp_amt_gidx ON pp_amt USING gist(the_geom);

-- vereinfachte Gesamtflaeche
SELECT AddGeometryColumn('pp_amt','simple_geom',25833,'MULTIPOLYGON',2);
CREATE INDEX pp_amt_sgidx ON pp_amt USING gist(simple_geom);


  COMMENT ON TABLE  pp_amt            	IS 'Post-Processing: Amt';
  COMMENT ON COLUMN pp_amt.amt       	IS 'Amtsschlüssel';
  COMMENT ON COLUMN pp_amt.the_geom  	IS 'präzise Geometrie aus Summe aller Gemeinden';
  COMMENT ON COLUMN pp_amt.simple_geom    IS 'vereinfachte Geometrie für die Suche und die Anzeige von Übersichten in kleinen Maßstäben.';



-- Tabelle fuer Gemeinden
-- ========================

  CREATE TABLE pp_gemeinde (
    gid			serial,
    land		text ,
    regierungsbezirk	text,
    kreis		text,
    gemeinde		text ,
    gemeindename	character varying(80),
 -- gkz			character varying(03),	-- wird (noch) nicht benutzt
    anz_gemarkg		integer,		-- Anzahl Gemarkungen
    CONSTRAINT pp_gemeinde_pk PRIMARY KEY (land, kreis, gemeinde)
  );

CREATE UNIQUE INDEX pp_gemeinde_gid_ix ON pp_gemeinde (gid);

-- Gesamtflaeche
SELECT AddGeometryColumn('pp_gemeinde','the_geom',25833,'MULTIPOLYGON',2);
CREATE INDEX pp_gemeinde_gidx ON pp_gemeinde USING gist(the_geom);

-- vereinfachte Gesamtflaeche
SELECT AddGeometryColumn('pp_gemeinde','simple_geom',25833,'MULTIPOLYGON',2);
CREATE INDEX pp_gemeinde_sgidx ON pp_gemeinde USING gist(simple_geom);


  COMMENT ON TABLE  pp_gemeinde                IS 'Post-Processing: Gemeinde';
  COMMENT ON COLUMN pp_gemeinde.gemeinde       IS 'Gemeindenummer';
--COMMENT ON COLUMN pp_gemeinde.gkz            IS 'Gemeindekennziffer für Mandant';
  COMMENT ON COLUMN pp_gemeinde.the_geom       IS 'präzise Geometrie aus Summe aller Gemarkungen';
  COMMENT ON COLUMN pp_gemeinde.simple_geom    IS 'vereinfachte Geometrie für die Suche und die Anzeige von Übersichten in kleinen Maßstäben.';


-- Tabelle fuer Gemarkungen
-- ========================

-- Für die Regelung der Zugriffsberechtigung einer Gemeindeverwaltung auf die 
-- Flurstücke in ihrem Gebiet braucht man die Information, in welcher Gemeinde eine Gemarkung liegt.
-- 'ax_gemeinde' und 'ax_gemarkung' haben aber im ALKIS keinerlei Beziehung zueinander - kaum zu glauben!
-- Nur über die Auswertung der Flurstücke kann man die Zuordnung ermitteln.
-- Da nicht ständig mit 'SELECT DISTINCT' sämtliche Flurstücke durchsucht werden können, 
-- muss diese Information als (redundante) Tabelle nach dem Laden zwischengespeichert werden. 

  CREATE TABLE pp_gemarkung (
    gid			serial,
    land		text ,
    regierungsbezirk	text,
    kreis		text,
    gemeinde		text ,	-- fast ein Foreign-Key Constraint
    gemarkung		text ,
		schluesselgesamt text,																				-- hinzugefügt am 21.10.2015
    gemarkungsname	character varying(80),
    anz_flur		integer,		-- Anzahl Fluren
    CONSTRAINT pp_gemarkung_pk PRIMARY KEY (land, gemarkung)
  );

CREATE UNIQUE INDEX pp_gemarkung_gid_ix ON pp_gemarkung (gid);

-- Gesamtfläche
SELECT AddGeometryColumn('pp_gemarkung','the_geom',25833,'MULTIPOLYGON',2);
CREATE INDEX pp_gemarkung_gidx ON pp_gemarkung USING gist(the_geom);

-- vereinfachte Gesamtfläche
SELECT AddGeometryColumn('pp_gemarkung','simple_geom',25833,'MULTIPOLYGON',2);
CREATE INDEX pp_gemarkung_sgidx ON pp_gemarkung USING gist(simple_geom);


COMMENT ON TABLE  pp_gemarkung               IS 'Post-Processing: Gemarkung. u.a. liegt in welcher Gemeinde';
COMMENT ON COLUMN pp_gemarkung.gemeinde      IS 'Gemeindenummer';
COMMENT ON COLUMN pp_gemarkung.gemarkung     IS 'Gemarkungsnummer';
COMMENT ON COLUMN pp_gemarkung.the_geom      IS 'präzise Geometrie aus Summe aller Fluren';
COMMENT ON COLUMN pp_gemarkung.simple_geom   IS 'vereinfachte Geometrie für die Suche und die Anzeige von Übersichten in kleinen Maßstäben.';


-- Tabelle fuer Fluren
-- ===================

  CREATE TABLE pp_flur (
    gid			serial,
    land		text ,
    regierungsbezirk	text,
    kreis		text,
    gemarkung		text ,
    flurnummer		integer ,
    anz_fs		integer,		-- Anzahl Flurstücke
    CONSTRAINT pp_flur_pk PRIMARY KEY (land, gemarkung, flurnummer)
  );

-- ALTER TABLE pp_flur ADD COLUMN gid serial;
CREATE UNIQUE INDEX pp_flur_gid_ix ON pp_flur (gid);

-- Gesamtfläche
SELECT AddGeometryColumn('pp_flur','the_geom',25833,'MULTIPOLYGON',2);
CREATE INDEX pp_flur_gidx ON pp_flur USING gist(the_geom);

-- vereinfachte Gesamtflaeche
SELECT AddGeometryColumn('pp_flur','simple_geom',25833,'MULTIPOLYGON',2);
CREATE INDEX pp_flur_sgidx ON pp_flur USING gist(simple_geom);


COMMENT ON TABLE  pp_flur                IS 'Post-Processing: Flur';
COMMENT ON COLUMN pp_flur.gemarkung      IS 'Gemarkungsnummer';
COMMENT ON COLUMN pp_flur.the_geom       IS 'Geometrie aus Summe aller Flurstücke';
COMMENT ON COLUMN pp_flur.simple_geom    IS 'vereinfachte Geometrie für die Suche und die Anzeige von Übersichten in kleinen Maßstäben.';



CREATE TABLE pp_flurstueck_nr (
    gid		serial,
    fsgml	varchar,
		beginnt timestamp without time zone,
		endet timestamp without time zone,
		f_beginnt timestamp without time zone,
		f_endet timestamp without time zone,
    fsnum	character varying(10),
		abweichenderrechtszustand	varchar,
    CONSTRAINT pp_flurstueck_nr_pk  PRIMARY KEY (gid)
  );

SELECT AddGeometryColumn('pp_flurstueck_nr','the_geom',25833,'POINT',2);

-- Geometrischer Index
CREATE INDEX pp_flurstueck_nr_gidx ON pp_flurstueck_nr USING gist(the_geom);

-- Foreig-Key Index
CREATE INDEX fki_pp_flurstueck_nr_gml ON pp_flurstueck_nr(fsgml);

COMMENT ON TABLE  pp_flurstueck_nr           IS 'Post-Processing: Position der Flurstücksnummer in der Karte';
COMMENT ON COLUMN pp_flurstueck_nr.fsgml     IS 'gml_id des zugehörigen Flurstücks-Objektes';
COMMENT ON COLUMN pp_flurstueck_nr.fsnum     IS 'Label, Darzustellende FS-Nummer als Bruch';
COMMENT ON COLUMN pp_flurstueck_nr.abweichenderrechtszustand	IS 'Dient der möglichen Ausblendung von Flurstücksnummern in Verfahren der Bodenordnung (siehe Objektart "Bau-, Raum- oder Bodenordnungsrecht", AA "Art der Festlegung", Werte 1750, 1770, 2100 bis 2340) bei denen ein neuer Rechtszustand eingetreten ist und das amtliche Verzeichnis der jeweiligen ausführenden Stelle maßgebend ist.'; -- hinzugefügt am 25.06.2015
COMMENT ON COLUMN pp_flurstueck_nr.the_geom  IS 'Position der Flurstücksnummer in der Karte';


-- NEU 2013-10-24
-- Tabelle für die Präsentation von Straßen-Namen und -Klassifikationen
-- Tabelle "pp_strassenname" speichert den VIEW "ap_pto_stra".

--DROP TABLE pp_strassenname;
CREATE TABLE pp_strassenname 
(   gid		serial ,
    gml_id character(16),
 -- advstandardmodell character varying[],
    schriftinhalt character varying, -- Label: anzuzeigender Text
    hor character varying,
    ver character varying,
 -- signaturnummer character varying,
 -- darstellungsprioritaet integer,
    art character varying,
    winkel double precision,
		gemeinde character varying,
		lage character varying,
    CONSTRAINT pp_snam_pk  PRIMARY KEY (gid)
);

SELECT AddGeometryColumn('pp_strassenname','the_geom',25833,'POINT',2);
CREATE INDEX pp_snam_gidx ON pp_strassenname USING gist(the_geom); 

  COMMENT ON TABLE  pp_strassenname                IS 'Post-Processing: Label der Straßennamen in der Karte. Auszug aus ap_pto.';

  COMMENT ON COLUMN pp_strassenname.gid            IS 'Editierschlüssel der Tabelle';
  COMMENT ON COLUMN pp_strassenname.gml_id         IS 'Objektschlüssel des Präsentationsobjektes aus ap_pto. Zur Verbindung mit Katalog.';
  COMMENT ON COLUMN pp_strassenname.schriftinhalt  IS 'Label, darzustellender Name der Straße oder Klassifikation';
  COMMENT ON COLUMN pp_strassenname.hor            IS 'Horizontale Ausrichtung des Textes zur Punkt-Koordinate: linksbündig, zentrisch, ...';
  COMMENT ON COLUMN pp_strassenname.ver            IS 'Vertikale   Ausrichtung des Textes zur Punkt-Koordinate: Basis, ..';
  COMMENT ON COLUMN pp_strassenname.art            IS 'Klasse der Straße: Straße, Weg, .. , BezKlassifizierungStrasse';
  COMMENT ON COLUMN pp_strassenname.winkel         IS 'Drehung des Textes';
  COMMENT ON COLUMN pp_strassenname.the_geom       IS 'Position (Punkt) der Labels in der Karte';


CREATE TABLE pp_zuordungspfeilspitze_flurstueck
(
  ogc_fid integer,
  winkel double precision,
	beginnt character(20),
	endet character(20),
	abweichenderrechtszustand varchar			-- eingefügt am 25.06.2015
);

SELECT AddGeometryColumn('pp_zuordungspfeilspitze_flurstueck','geom',25833,'POINT',2);
CREATE INDEX pp_zuordungspfeilspitze_flurstueckgidx ON pp_zuordungspfeilspitze_flurstueck USING gist(geom);


CREATE TABLE pp_zuordungspfeilspitze_bodensch
(
  ogc_fid integer,
  winkel double precision
);

SELECT AddGeometryColumn('pp_zuordungspfeilspitze_bodensch','geom',25833,'POINT',2);
CREATE INDEX pp_zuordungspfeilspitze_bodenschgidx ON pp_zuordungspfeilspitze_bodensch USING gist(geom);



CREATE TABLE alkis.pp_flurstueckshistorie
(
  flurstueckskennzeichen character varying,
  zeitpunktderentstehung date,
  vorgaengerflurstueckskennzeichen character varying[],
  nachfolgerflurstueckskennzeichen character varying[]
);

CREATE INDEX ON alkis.pp_flurstueckshistorie
 USING btree (flurstueckskennzeichen);

CREATE INDEX ON alkis.pp_flurstueckshistorie
 USING gin (vorgaengerflurstueckskennzeichen);

CREATE INDEX ON alkis.pp_flurstueckshistorie
 USING gin (nachfolgerflurstueckskennzeichen);
 







CREATE OR REPLACE FUNCTION alkis.postprocessing()
  RETURNS void AS
$BODY$


SET enable_seqscan = off;


TRUNCATE alkis.pp_flurstueckshistorie;

INSERT INTO alkis.pp_flurstueckshistorie 
	SELECT flurstueckskennzeichen,
		zeitpunktderentstehung,
		vorgaengerflurstueckskennzeichen,
		nachfolgerflurstueckskennzeichen
  FROM 
		alkis.ax_historischesflurstueckohneraumbezug
  WHERE 
		endet IS NULL
	UNION ALL
	(	SELECT DISTINCT ON (f.flurstueckskennzeichen) 
			f.flurstueckskennzeichen,
			f.zeitpunktderentstehung,
			COALESCE(vva.vorgaengerflurstueckskennzeichen, vna.vorgaengerflurstueckskennzeichen) AS vorgaengerflurstueckskennzeichen,
			n.nachfolgerflurstueckskennzeichen
		FROM alkis.ax_flurstueck f
			LEFT JOIN LATERAL ( SELECT 
														array_agg(hf.flurstueckskennzeichen) AS vorgaengerflurstueckskennzeichen
													FROM 
														alkis.ax_historischesflurstueckohneraumbezug hf
													WHERE 
														hf.endet IS NULL AND 
														ARRAY[f.flurstueckskennzeichen] <@ hf.nachfolgerflurstueckskennzeichen) vva ON true
			LEFT JOIN LATERAL ( SELECT 
														array_agg(u.flurstueckskennzeichen) AS vorgaengerflurstueckskennzeichen
													FROM 
														alkis.ax_fortfuehrungsfall ff,
														LATERAL unnest(ff.zeigtaufaltesflurstueck) u(flurstueckskennzeichen)
													WHERE 
														ff.endet IS NULL AND 
														ARRAY[f.flurstueckskennzeichen] <@ ff.zeigtaufneuesflurstueck AND NOT ARRAY[f.flurstueckskennzeichen] <@ ff.zeigtaufaltesflurstueck) vna ON true
			LEFT JOIN LATERAL ( SELECT 
														array_agg(u.flurstueckskennzeichen) AS nachfolgerflurstueckskennzeichen
													FROM 
														alkis.ax_fortfuehrungsfall ff,
														LATERAL unnest(ff.zeigtaufneuesflurstueck) u(flurstueckskennzeichen)
													WHERE 
														ff.endet IS NULL AND 
														ARRAY[f.flurstueckskennzeichen] <@ ff.zeigtaufaltesflurstueck AND NOT ARRAY[f.flurstueckskennzeichen] <@ ff.zeigtaufneuesflurstueck) n ON true
		ORDER BY 
			f.flurstueckskennzeichen, f.beginnt DESC);

ANALYZE alkis.pp_flurstueckshistorie;


-- =================================
-- Flurstuecksnummern-Label-Position
-- =================================

  TRUNCATE alkis.pp_flurstueck_nr;  -- effektiver als DELETE

 INSERT INTO alkis.pp_flurstueck_nr
          ( fsgml, beginnt, endet, f_beginnt, f_endet, fsnum, abweichenderrechtszustand, the_geom )															-- angepasst am 25.06.2015
     SELECT DISTINCT f.gml_id,p.beginnt,p.endet,f.beginnt, f.endet,
           f.zaehler::text || COALESCE ('/' || f.nenner::text, '') AS fsnum, f.abweichenderrechtszustand,		-- angepasst am 25.06.2015
           p.wkb_geometry  -- manuelle Position des Textes
      FROM alkis.ap_pto             p
      JOIN alkis.ax_flurstueck      f ON f.gml_id = any(p.dientzurdarstellungvon)
     AND p.art = 'ZAE_NEN';

-- Tabelle aus View befüllen
TRUNCATE alkis.pp_strassenname;
INSERT INTO alkis.pp_strassenname (gml_id, schriftinhalt, hor, ver, art, winkel, the_geom, gemeinde, lage)
       SELECT gml_id, schriftinhalt, hor, ver, art, winkel, wkb_geometry, gemeinde, lage
       FROM (
			 SELECT p.ogc_fid,
         l.gml_id,                               -- wird im PP zum Nachladen aus Katalog gebraucht
      -- p.advstandardmodell       AS modell,    -- TEST
      -- l.unverschluesselt, l.lage AS schluessel, -- zur Lage  TEST
         p.schriftinhalt,                        -- WMS: LABELITEM
         p.art,                                  -- WMS: CLASSITEM
         p.horizontaleausrichtung  AS hor,       -- Verfeinern der Text-Position ..
         p.vertikaleausrichtung    AS ver,       --  .. durch Klassifizierung hor/ver
         p.drehwinkel * 57.296     AS winkel,    -- * 180 / Pi
         p.wkb_geometry,
         l.gemeinde,
         l.lage
    FROM alkis.ap_pto p
    JOIN alkis.ax_lagebezeichnungohnehausnummer l
      ON l.gml_id = ANY (p.dientzurdarstellungvon)
   WHERE p.endet IS NULL
     AND l.endet IS NULL
     AND  p.art IN ('Strasse','Weg','Platz','BezKlassifizierungStrasse') -- CLASSES im LAYER
     AND (   'DKKM1000' = ANY (p.advstandardmodell) -- "Lika 1000" bevorzugen
       -- OR 'DLKM'     = ANY (p.advstandardmodell) -- oder auch Kataster allgemein
           -- Ersatzweise auch "keine Angabe", aber nur wenn es keinen besseren Text zur Lage gibt
          OR (p.advstandardmodell IS NULL
               -- Alternativen zur Legebezeichnung suchen in P- und L-Version
               AND (SELECT s.ogc_fid FROM alkis.ap_lto s -- irgend ein Feld eines anderen Textes (suchen)
                      JOIN alkis.ax_lagebezeichnungohnehausnummer ls ON ls.gml_id = ANY(s.dientzurdarstellungvon)
                     WHERE ls.gml_id = l.gml_id AND NOT s.advstandardmodell IS NULL
                     LIMIT 1  -- einer reicht als Beweis
                   ) IS NULL  -- "Subquery IS NULL" liefert true wenn kein weiterer Text gefunden wird
               AND (SELECT s.ogc_fid FROM alkis.ap_pto s
                      JOIN alkis.ax_lagebezeichnungohnehausnummer ls ON ls.gml_id = ANY(s.dientzurdarstellungvon)
                     WHERE ls.gml_id = l.gml_id AND NOT s.advstandardmodell IS NULL LIMIT 1
                   ) IS NULL
              )
         )
			 )as foo; -- View sucht das passende advstandardmodell

-- Schriftinhalt ergänzen
-- Das sind die Standardschreibweisen aus dem Katalog, die nicht mehr redundant in ap_pto sind.
UPDATE alkis.pp_strassenname  p
   SET schriftinhalt =     -- Hier ist der Label noch leer
   -- Subquery "Gib mir den Straßennamen":
   ( SELECT k.bezeichnung                         -- Straßenname ..
       FROM alkis.ax_lagebezeichnungkatalogeintrag k    --  .. aus Katalog
       JOIN alkis.ax_lagebezeichnungohnehausnummer l    -- verwendet als Lage o.H.
         ON (k.land=l.land AND k.regierungsbezirk=l.regierungsbezirk AND k.kreis=l.kreis AND k.gemeinde=l.gemeinde AND k.lage=l.lage )
      WHERE p.gml_id = l.gml_id
      and k.endet is null
      and l.endet is null
    )
WHERE     p.schriftinhalt IS NULL
   AND NOT p.the_geom      IS NULL;   



-- G E M A R K U N G

  TRUNCATE alkis.pp_gemarkung;

-- Vorkommende Paarungen Gemarkung <-> Gemeinde in ax_Flurstueck
INSERT INTO alkis.pp_gemarkung
  (               land, regierungsbezirk, kreis, gemeinde, gemarkung, schluesselgesamt)					-- angepasst am 21.10.2015
  SELECT DISTINCT land, gemeindezugehoerigkeit_regierungsbezirk, gemeindezugehoerigkeit_kreis, gemeindezugehoerigkeit_gemeinde, gemarkungsnummer, land||gemarkungsnummer		-- angepasst am 21.10.2015
  FROM            alkis.ax_flurstueck
  WHERE           endet IS NULL
  ORDER BY        land, gemeindezugehoerigkeit_regierungsbezirk, gemeindezugehoerigkeit_kreis, gemeindezugehoerigkeit_gemeinde, gemarkungsnummer 
;

-- Namen der Gemarkung dazu als Optimierung bei der Auskunft 
UPDATE alkis.pp_gemarkung a
   SET gemarkungsname =
   ( SELECT b.bezeichnung 
     FROM    alkis.ax_gemarkung b
     WHERE a.land=b.land
       AND a.gemarkung=b.gemarkungsnummer
       AND b.endet IS NULL
   );


-- G E M E I N D E

--DELETE FROM pp_gemeinde;
  TRUNCATE alkis.pp_gemeinde;

-- Vorkommende Gemeinden aus den gemarkungen
INSERT INTO alkis.pp_gemeinde
  (               land, regierungsbezirk, kreis, gemeinde)
  SELECT DISTINCT land, regierungsbezirk, kreis, gemeinde
  FROM            alkis.pp_gemarkung
  ORDER BY        land, regierungsbezirk, kreis, gemeinde 
;


-- Namen der Gemeinde dazu als Optimierung bei der Auskunft 
UPDATE alkis.pp_gemeinde a
   SET gemeindename =
   ( SELECT b.bezeichnung 
     FROM    alkis.ax_gemeinde b
     WHERE a.land=b.land 
       AND a.regierungsbezirk=b.regierungsbezirk 
       AND a.kreis=b.kreis
       AND a.gemeinde=b.gemeinde
       AND b.endet IS NULL
   );


TRUNCATE alkis.pp_amt;
	 
INSERT INTO alkis.pp_amt
  (land, regierungsbezirk, kreis, amt, amtsname, postleitzahlpostzustellung, ort_post, strasse, hausnummer, fax, telefon, weitereadressen)
  SELECT DISTINCT g.land, g.regierungsbezirk, g.kreis, a.amt_schluessel,
                  CASE WHEN position('(' in a.amt_name) > 0
                    THEN substr(a.amt_name, 1, position('(' in a.amt_name)-2)
                    ELSE a.amt_name
                  END as amt_name,
                  postleitzahlpostzustellung,
                  ort_post,
                  strasse,
                  hausnummer,
                  fax,
                  telefon,
                  weitereadressen
  FROM            alkis.pp_gemeinde g, alkis.lk_aemtergemeinden a
  LEFT JOIN    	  alkis.ax_dienststelle d ON d.schluesselgesamt = a.dienststelle_schluessel AND stellenart IN (1700, 1900)
  LEFT JOIN       alkis.ax_anschrift an ON d.hat = an.gml_id
  WHERE           g.land||g.regierungsbezirk||g.kreis||lpad(g.gemeinde::text, 3,'00') = a.gemeinde_schluessel and an.endet is null and d.endet is null 
  ORDER BY        g.land, g.regierungsbezirk, g.kreis;
	 
-- ==============================================================================
-- Geometrien der Flurstücke schrittweise zu groesseren Einheiten zusammen fassen
-- ==============================================================================

DELETE FROM alkis.pp_flur;

INSERT INTO alkis.pp_flur (land, regierungsbezirk, kreis, gemarkung, flurnummer, anz_fs, the_geom )
   SELECT  f.land, f.gemeindezugehoerigkeit_regierungsbezirk, f.gemeindezugehoerigkeit_kreis, f.gemarkungsnummer as gemarkung, f.flurnummer, 
           count(gml_id) as anz_fs,
           st_multi(st_union(f.wkb_geometry)) AS the_geom		-- angepasst am 10.03.2016
     FROM  alkis.ax_flurstueck f
     WHERE f.endet IS NULL
  GROUP BY f.land, f.gemeindezugehoerigkeit_regierungsbezirk, f.gemeindezugehoerigkeit_kreis, f.gemarkungsnummer, f.flurnummer;
	

-- Fluren zu Gemarkungen zusammen fassen
-- -------------------------------------

-- Flächen vereinigen
UPDATE alkis.pp_gemarkung a
  SET the_geom = 
   ( SELECT st_multi(st_union(b.the_geom)) AS the_geom		-- angepasst am 10.03.2016
       FROM alkis.pp_flur b
      WHERE a.land      = b.land 
        AND a.gemarkung = b.gemarkung
   );
	 

-- Fluren zaehlen
UPDATE alkis.pp_gemarkung a
  SET anz_flur = 
   ( SELECT count(flurnummer) AS anz_flur 
     FROM    alkis.pp_flur b
     WHERE a.land      = b.land 
       AND a.gemarkung = b.gemarkung
   ); -- Gemarkungsnummer ist je BundesLand eindeutig


-- Gemarkungen zu Gemeinden zusammen fassen
-- ----------------------------------------

-- Flächen vereinigen (aus der bereits vereinfachten Geometrie)
UPDATE alkis.pp_gemeinde a
  SET the_geom = 
   ( SELECT st_multi(st_union(b.the_geom)) AS the_geom		-- angepasst am 10.03.2016
     FROM    alkis.pp_gemarkung b
     WHERE a.land     = b.land 
			AND a.regierungsbezirk = b.regierungsbezirk			-- hinzugefügt am 18.09.2015
			AND	a.kreis = b.kreis														-- hinzugefügt am 18.09.2015
      AND a.gemeinde = b.gemeinde
   );
	 

-- Gemarkungen zählen
UPDATE alkis.pp_gemeinde a
  SET anz_gemarkg = 
   ( SELECT count(gemarkung) AS anz_gemarkg 
     FROM    alkis.pp_gemarkung b
     WHERE a.land     = b.land 
		 AND a.regierungsbezirk = b.regierungsbezirk				-- hinzugefügt am 18.09.2015
		 AND	a.kreis = b.kreis															-- hinzugefügt am 18.09.2015
     AND a.gemeinde = b.gemeinde
   );

	 
-- Flächen vereinigen (aus der bereits vereinfachten Geometrie)
UPDATE alkis.pp_amt a
  SET the_geom = 
   (SELECT st_multi(st_union(b.the_geom)) AS the_geom			-- angepasst am 10.03.2016
    FROM alkis.pp_gemeinde b, alkis.lk_aemtergemeinden c
    WHERE      
    b.land||b.regierungsbezirk||b.kreis||lpad(b.gemeinde::text,3,'00') = c.gemeinde_schluessel
       AND c.amt_schluessel = a.amt
    GROUP BY c.amt_name
   );
	 

-- Gemeinden zählen
UPDATE alkis.pp_amt a
  SET anz_gemeinden = 
   ( SELECT count(gemeinde) AS anz_gemeinden 
     FROM    alkis.pp_gemeinde b, alkis.lk_aemtergemeinden c
     WHERE      
    
    b.land||b.regierungsbezirk||b.kreis||lpad(b.gemeinde::text,3,'00') = c.gemeinde_schluessel
       AND c.amt_schluessel = a.amt
    GROUP BY c.amt_name
   );

-- Ämter zu Kreis zusammenfassen
-- ----------------------------------------

DELETE FROM alkis.pp_kreis;

INSERT INTO alkis.pp_kreis (land, regierungsbezirk, kreis, kreisname, anz_aemter, the_geom)
SELECT  a.land, a.regierungsbezirk, a.kreis, k.bezeichnung, count(a.amt), st_multi(st_union(a.the_geom))
FROM  alkis.pp_amt a, alkis.ax_kreisregion k
WHERE a.kreis = k.kreis
AND k.endet IS NULL
GROUP BY a.land, a.regierungsbezirk, a.kreis, k.bezeichnung;


-- Löcher schliessen	 
UPDATE alkis.pp_flur SET the_geom = Filter_Rings(the_geom, 10);		-- hinzugefügt am 10.03.2016	 
UPDATE alkis.pp_gemarkung SET the_geom = Filter_Rings(the_geom, 10);		-- hinzugefügt am 10.03.2016
UPDATE alkis.pp_gemeinde SET the_geom = Filter_Rings(the_geom, 10);		-- hinzugefügt am 10.03.2016
UPDATE alkis.pp_amt SET the_geom = Filter_Rings(the_geom, 10);		-- hinzugefügt am 10.03.2016
UPDATE alkis.pp_kreis SET the_geom = Filter_Rings(the_geom, 10);		-- hinzugefügt am 10.03.2016
	 
-- Geometrie glätten / vereinfachen
-- Diese "simplen" Geometrien sollen nur für die Darstellung einer Übersicht verwendet werden.
-- Ablage der simplen Geometrie in einem alternativen Geometriefeld im gleichen Datensatz.

UPDATE alkis.pp_flur      SET simple_geom = st_simplify(the_geom, 0.4); -- Flur 

UPDATE alkis.pp_gemarkung SET simple_geom = st_simplify(the_geom, 2.0); -- Gemarkung  (Wirkung siehe pp_gemarkung_analyse)

UPDATE alkis.pp_gemeinde  SET simple_geom = st_simplify(the_geom, 5.0); -- Gemeinde (Wirkung siehe pp_gemeinde_analyse)

UPDATE alkis.pp_amt SET simple_geom = st_simplify(the_geom, 5.0); 

UPDATE alkis.pp_kreis SET simple_geom = st_simplify(the_geom, 5.0); 



TRUNCATE alkis.pp_zuordungspfeilspitze_flurstueck;
INSERT INTO alkis.pp_zuordungspfeilspitze_flurstueck
SELECT l.ogc_fid,st_azimuth(st_pointn(l.wkb_geometry, 1), st_pointn(l.wkb_geometry, 2)) * (- 180::double precision) / pi() + 90::double precision AS winkel, l.beginnt,l.endet, f.abweichenderrechtszustand, st_startpoint(l.wkb_geometry) AS wkb_geometry
   FROM alkis.ap_lpo l
   JOIN alkis.ax_flurstueck f ON f.gml_id = ANY (l.dientzurdarstellungvon)
  WHERE l.art::text = 'Pfeil' AND ('DKKM1000' ~~ ANY (l.advstandardmodell));

TRUNCATE alkis.pp_zuordungspfeilspitze_bodensch;
INSERT INTO alkis.pp_zuordungspfeilspitze_bodensch
SELECT l.ogc_fid, st_azimuth(st_pointn(l.wkb_geometry, 1), st_pointn(l.wkb_geometry, 2)) * (- 180::double precision) / pi() + 90::double precision AS winkel, st_startpoint(l.wkb_geometry) AS wkb_geometry
   FROM alkis.ap_lpo l
   JOIN alkis.ax_bodenschaetzung b ON b.gml_id = any(l.dientzurdarstellungvon)
  WHERE l.art::text = 'Pfeil' AND ('DKKM1000' ~~ ANY (l.advstandardmodell)) AND b.endet IS NULL AND l.endet IS NULL;

UPDATE alkis.ax_anschrift SET postleitzahlpostzustellung = lpad(postleitzahlpostzustellung, 5, '0') WHERE bestimmungsland is null;		-- Hinzugefügt am 18.01.2016



DELETE FROM alkis.n_nutzung;

-- 01 REO: ax_Wohnbauflaeche
INSERT INTO alkis.n_nutzung (gml_id, beginnt, endet, nutzungsartengruppe, werteart1, werteart2, info, zustand, name, bezeichnung, wkb_geometry)
  SELECT              gml_id, beginnt, endet, 11,                  0,      0,      artderbebauung, zustand, name, null,        wkb_geometry 
  FROM alkis.ax_wohnbauflaeche
  WHERE st_geometrytype(wkb_geometry) = 'ST_Polygon';

-- 02 REO: ax_IndustrieUndGewerbeflaeche
-- -------------------------------------
INSERT INTO alkis.n_nutzung (gml_id, beginnt, endet, nutzungsartengruppe, werteart1, werteart2, info, zustand, name, bezeichnung, wkb_geometry)
  SELECT              gml_id, beginnt, endet, 12,                  coalesce(funktion, 0),  coalesce(lagergut, foerdergut, 0), null, zustand, name, null,        wkb_geometry 
  FROM alkis.ax_industrieundgewerbeflaeche
  WHERE st_geometrytype(wkb_geometry) = 'ST_Polygon';

-- 03 REO: ax_Halde
-- -------------------------------------
INSERT INTO alkis.n_nutzung (gml_id, beginnt, endet, nutzungsartengruppe, werteart1, werteart2, info, zustand, name, bezeichnung, wkb_geometry)
  SELECT              gml_id, beginnt, endet, 13,                  coalesce(lagergut, 0),  0, null, zustand, name, null,        wkb_geometry 
  FROM alkis.ax_halde
  WHERE st_geometrytype(wkb_geometry) = 'ST_Polygon';

-- 04 ax_Bergbaubetrieb
-- -------------------------------------
INSERT INTO alkis.n_nutzung (gml_id, beginnt, endet, nutzungsartengruppe, werteart1, werteart2, info, zustand, name, bezeichnung, wkb_geometry)
  SELECT              gml_id, beginnt, endet, 14,                  coalesce(abbaugut, 0),  0, null, zustand, name, null,        wkb_geometry 
  FROM alkis.ax_bergbaubetrieb
  WHERE st_geometrytype(wkb_geometry) = 'ST_Polygon';

-- 05 REO: ax_TagebauGrubeSteinbruch
-- -------------------------------------
INSERT INTO alkis.n_nutzung (gml_id, beginnt, endet, nutzungsartengruppe, werteart1, werteart2, info, zustand, name, bezeichnung, wkb_geometry)
  SELECT              gml_id, beginnt, endet, 15,                  coalesce(abbaugut, 0),  0, null, zustand, name, null,        wkb_geometry 
  FROM alkis.ax_tagebaugrubesteinbruch
  WHERE st_geometrytype(wkb_geometry) = 'ST_Polygon';

-- 06 REO: ax_FlaecheGemischterNutzung
-- -------------------------------------
INSERT INTO alkis.n_nutzung (gml_id, beginnt, endet, nutzungsartengruppe, werteart1, werteart2, info, zustand, name, bezeichnung, wkb_geometry)
  SELECT              gml_id, beginnt, endet, 16,                  coalesce(funktion, 0),  0, null, zustand, name, null,        wkb_geometry 
  FROM alkis.ax_flaechegemischternutzung
  WHERE st_geometrytype(wkb_geometry) = 'ST_Polygon';

-- 07 REO: ax_FlaecheBesondererFunktionalerPraegung
-- -------------------------------------
INSERT INTO alkis.n_nutzung (gml_id, beginnt, endet, nutzungsartengruppe, werteart1, werteart2, info, zustand, name, bezeichnung, wkb_geometry)
  SELECT              gml_id, beginnt, endet, 17,                  coalesce(funktion, 0),  0, null, zustand, name, null,        wkb_geometry 
  FROM alkis.ax_flaechebesondererfunktionalerpraegung
  WHERE st_geometrytype(wkb_geometry) = 'ST_Polygon';

-- 08 REO: ax_SportFreizeitUndErholungsflaeche
-- -------------------------------------
INSERT INTO alkis.n_nutzung (gml_id, beginnt, endet, nutzungsartengruppe, werteart1, werteart2, info, zustand, name, bezeichnung, wkb_geometry)
  SELECT              gml_id, beginnt, endet, 18,                  coalesce(funktion, 0),  0, null, zustand, name, null,        wkb_geometry 
  FROM alkis.ax_sportfreizeitunderholungsflaeche
  WHERE st_geometrytype(wkb_geometry) = 'ST_Polygon';

-- 09 REO: ax_Friedhof
-- -------------------------------------
INSERT INTO alkis.n_nutzung (gml_id, beginnt, endet, nutzungsartengruppe, werteart1, werteart2, info, zustand, name, bezeichnung, wkb_geometry)
  SELECT              gml_id, beginnt, endet, 19,                  coalesce(funktion, 0),  0, null, zustand, name, null,        wkb_geometry 
  FROM alkis.ax_friedhof
  WHERE st_geometrytype(wkb_geometry) = 'ST_Polygon';

-- 10 ax_Strassenverkehr
-- -------------------------------------
INSERT INTO alkis.n_nutzung (gml_id, beginnt, endet, nutzungsartengruppe, werteart1, werteart2, info,   zustand, name, bezeichnung, wkb_geometry)
  SELECT              gml_id, beginnt, endet, 21,                  coalesce(funktion, 0),  0, null,   zustand, zeigtaufexternes_name, zweitname,   wkb_geometry 
  FROM alkis.ax_strassenverkehr
  WHERE st_geometrytype(wkb_geometry) = 'ST_Polygon';

-- 11 ax_Weg
-- -------------------------------------
INSERT INTO alkis.n_nutzung (gml_id, beginnt, endet, nutzungsartengruppe, werteart1, werteart2, info,  zustand, name, bezeichnung, wkb_geometry)
  SELECT              gml_id, beginnt, endet, 22,                  coalesce(funktion, 0),  0, null,  null,    zeigtaufexternes_name, bezeichnung, wkb_geometry 
  FROM alkis.ax_weg
  WHERE st_geometrytype(wkb_geometry) = 'ST_Polygon';

-- 12 ax_Platz
-- -------------------------------------
INSERT INTO alkis.n_nutzung (gml_id, beginnt, endet, nutzungsartengruppe, werteart1, werteart2, info, zustand, name, bezeichnung, wkb_geometry)
  SELECT              gml_id, beginnt, endet, 23,                  coalesce(funktion, 0),  0, null, null,    zeigtaufexternes_name, zweitname,   wkb_geometry 
  FROM alkis.ax_platz
  WHERE st_geometrytype(wkb_geometry) = 'ST_Polygon';

-- 13 ax_Bahnverkehr
-- -------------------------------------
INSERT INTO alkis.n_nutzung (gml_id, beginnt, endet, nutzungsartengruppe, werteart1,                         werteart2, info,          zustand, name,        bezeichnung, wkb_geometry)
  SELECT              gml_id, beginnt, endet, 24,                  coalesce(funktion, bahnkategorie[1], 0), 0, null, zustand, NULL, null,        wkb_geometry 
  FROM alkis.ax_bahnverkehr
  WHERE st_geometrytype(wkb_geometry) = 'ST_Polygon';

-- 14 ax_Flugverkehr
-- -------------------------------------
INSERT INTO alkis.n_nutzung (gml_id, beginnt, endet, nutzungsartengruppe, werteart1,               werteart2, info,  zustand, name, bezeichnung, wkb_geometry)
  SELECT              gml_id, beginnt, endet, 25,                  coalesce(funktion, art, 0), 0, null,  zustand, zeigtaufexternes_name, bezeichnung, wkb_geometry 
  FROM alkis.ax_flugverkehr
  WHERE st_geometrytype(wkb_geometry) = 'ST_Polygon';

-- 15 ax_Schiffsverkehr
-- -------------------------------------
INSERT INTO alkis.n_nutzung (gml_id, beginnt, endet, nutzungsartengruppe, werteart1, werteart2, info, zustand, name, bezeichnung, wkb_geometry)
  SELECT              gml_id, beginnt, endet, 26,                  coalesce(funktion, 0),  0, null, zustand, zeigtaufexternes_name, null,        wkb_geometry 
  FROM alkis.ax_schiffsverkehr
  WHERE st_geometrytype(wkb_geometry) = 'ST_Polygon';

-- 16 ax_Landwirtschaft
-- -------------------------------------
INSERT INTO alkis.n_nutzung (gml_id, beginnt, endet, nutzungsartengruppe, werteart1,          werteart2, info, zustand, name, bezeichnung, wkb_geometry)
  SELECT              gml_id, beginnt, endet, 31,                  coalesce(vegetationsmerkmal, 0), 0, null, null,    name, null,        wkb_geometry 
  FROM alkis.ax_landwirtschaft
  WHERE st_geometrytype(wkb_geometry) = 'ST_Polygon';

-- 17 ax_Wald
-- -------------------------------------
INSERT INTO alkis.n_nutzung (gml_id, beginnt, endet, nutzungsartengruppe, werteart1,          werteart2, info, zustand, name, bezeichnung, wkb_geometry)
  SELECT              gml_id, beginnt, endet, 32,                  coalesce(vegetationsmerkmal, 0), 0, null, null,    name, bezeichnung, wkb_geometry 
  FROM alkis.ax_wald
  WHERE st_geometrytype(wkb_geometry) = 'ST_Polygon';

-- 18 ax_Gehoelz
-- -------------------------------------
INSERT INTO alkis.n_nutzung (gml_id, beginnt, endet, nutzungsartengruppe, werteart1,          werteart2, info, zustand, name, bezeichnung, wkb_geometry)
  SELECT              gml_id, beginnt, endet, 33,                  coalesce(vegetationsmerkmal, 0), 0, null, null,    null, null,        wkb_geometry 
  FROM alkis.ax_gehoelz
  WHERE st_geometrytype(wkb_geometry) = 'ST_Polygon';

-- 19 ax_Heide
-- -------------------------------------
INSERT INTO alkis.n_nutzung (gml_id, beginnt, endet, nutzungsartengruppe, werteart1, werteart2, info, zustand, name, bezeichnung, wkb_geometry)
  SELECT              gml_id, beginnt, endet, 34,                  0,      0, null, null,    name, null,        wkb_geometry 
  FROM alkis.ax_heide
  WHERE st_geometrytype(wkb_geometry) = 'ST_Polygon';

-- 20 ax_Moor
-- -------------------------------------
INSERT INTO alkis.n_nutzung (gml_id, beginnt, endet, nutzungsartengruppe, werteart1, werteart2, info, zustand, name, bezeichnung, wkb_geometry)
  SELECT              gml_id, beginnt, endet, 35,                  0,      0, null, null,    name, null,        wkb_geometry 
  FROM alkis.ax_moor
  WHERE st_geometrytype(wkb_geometry) = 'ST_Polygon';

-- 21 ax_Sumpf
-- -------------------------------------
INSERT INTO alkis.n_nutzung (gml_id, beginnt, endet, nutzungsartengruppe, werteart1, werteart2, info, zustand, name, bezeichnung, wkb_geometry)
  SELECT              gml_id, beginnt, endet, 36,                  0,      0, null, null,    name, null,        wkb_geometry 
  FROM alkis.ax_sumpf
  WHERE st_geometrytype(wkb_geometry) = 'ST_Polygon';

-- 22 ax_UnlandVegetationsloseFlaeche
-- -------------------------------------
INSERT INTO alkis.n_nutzung (gml_id, beginnt, endet, nutzungsartengruppe, werteart1, werteart2, info,                 zustand, name, bezeichnung, wkb_geometry)
  SELECT              gml_id, beginnt, endet, 37,                  coalesce(funktion, 0),  coalesce(oberflaechenmaterial, 0), null, null,    name, null,        wkb_geometry 
  FROM alkis.ax_unlandvegetationsloseflaeche
  WHERE st_geometrytype(wkb_geometry) = 'ST_Polygon';

-- 24 ax_Fliessgewaesser
-- -------------------------------------
INSERT INTO alkis.n_nutzung (gml_id, beginnt, endet, nutzungsartengruppe, werteart1, werteart2, info, zustand,  name, bezeichnung, wkb_geometry)
  SELECT              gml_id, beginnt, endet, 41,                  coalesce(funktion, 0),  0, null, zustand,  zeigtaufexternes_name, null,        wkb_geometry 
  FROM alkis.ax_fliessgewaesser
  WHERE st_geometrytype(wkb_geometry) = 'ST_Polygon';

-- 25 ax_Hafenbecken
-- -------------------------------------
INSERT INTO alkis.n_nutzung (gml_id, beginnt, endet, nutzungsartengruppe, werteart1, werteart2, info,    zustand,   name, bezeichnung, wkb_geometry)
  SELECT              gml_id, beginnt, endet, 42,                  coalesce(funktion, 0),  0, null, null,      zeigtaufexternes_name, null,        wkb_geometry 
  FROM alkis.ax_hafenbecken
  WHERE st_geometrytype(wkb_geometry) = 'ST_Polygon';

-- 26 ax_StehendesGewaesser
-- -------------------------------------
INSERT INTO alkis.n_nutzung (gml_id, beginnt, endet, nutzungsartengruppe, werteart1, werteart2, info, zustand, name, bezeichnung,         wkb_geometry)
  SELECT              gml_id, beginnt, endet, 43,                  coalesce(funktion, 0),  0, null, null,    zeigtaufexternes_name, seekennzahl, wkb_geometry 
  FROM alkis.ax_stehendesgewaesser
  WHERE st_geometrytype(wkb_geometry) = 'ST_Polygon';

-- 27 ax_Meer
-- -------------------------------------
INSERT INTO alkis.n_nutzung (gml_id, beginnt, endet, nutzungsartengruppe, werteart1, werteart2, info, zustand, name, bezeichnung, wkb_geometry)
  SELECT              gml_id, beginnt, endet, 44,                  coalesce(funktion, 0),  0, null, null,    zeigtaufexternes_name, bezeichnung, wkb_geometry 
  FROM alkis.ax_meer
  WHERE st_geometrytype(wkb_geometry) = 'ST_Polygon';

$BODY$
  LANGUAGE sql VOLATILE
  COST 100;



CREATE OR REPLACE FUNCTION alkis.execute_hist_operations(
	)
    RETURNS void
    LANGUAGE 'plpgsql'
    COST 100
    VOLATILE 
AS $BODY$
DECLARE
	r alkis.delete%ROWTYPE;
	s varchar;
	n integer;
BEGIN
	FOR r IN
		select *
		from alkis.delete 
		order by typename, featureid, context, replacedby, endet
	LOOP
		s := 'UPDATE alkis.' || r.typename || ' SET endet = ''' || coalesce(r.endet, substr(r.replacedby, 17)) || '''';
		IF r.context='update' AND r.anlass IS NOT NULL THEN
			s := s || ',anlass=array_cat(anlass,''{' || array_to_string(r.anlass,',') || '}'')';
		END IF;
		s := s || ' WHERE gml_id=''' || r.featureid || '''' || ' AND beginnt < ''' || coalesce(r.endet, substr(r.replacedby, 17)) || ''' AND (endet IS NULL OR endet = ''' || coalesce(r.endet, substr(r.replacedby, 17)) || ''')';
		EXECUTE s;
		--RAISE INFO '%', s;
		GET DIAGNOSTICS n = ROW_COUNT;
		IF n=0 THEN
			RAISE NOTICE 'Beenden des Objektes % schlug fehl: %', r.featureid, s;
		ELSE
			IF n>1 THEN
				RAISE NOTICE 'Es gab mehrere Objektversionen von % die jetzt alle beendet wurden: %', r.featureid, s;
			END IF;
			s := 'DELETE FROM alkis.delete WHERE ogc_fid = ' || r.ogc_fid;
			EXECUTE s;
			GET DIAGNOSTICS n = ROW_COUNT;
			IF n<>1 THEN
				RAISE EXCEPTION 'Löschen des Eintrags in der delete-Tabelle schlug fehl: %', s;
			END IF;
		END IF;
	END LOOP;
END;
$BODY$;

CREATE TABLE alkis.import
(
  id serial ,
  datum timestamp without time zone DEFAULT now(),
  datei text,
  status text
);



CREATE TABLE n_nutzungsartenschluessel (
    nutzungsartengruppe integer NOT NULL,
    nutzungsart integer,
    untergliederung1 integer,
    untergliederung2 integer,
    objektart integer NOT NULL,
    werteart1 integer,
    werteart2 integer,
    attributart1 character(3),
    attributart2 character(3)
);


--
-- TOC entry 22645 (class 0 OID 0)
-- Dependencies: 3520
-- Name: COLUMN n_nutzungsartenschluessel.nutzungsartengruppe; Type: COMMENT; Schema: alkis6; Owner: -
--

COMMENT ON COLUMN n_nutzungsartenschluessel.nutzungsartengruppe IS 'Tausenderstelle = Nutzungsartengruppe nach ALKIS-nutzungsartenschluessel MV';


--
-- TOC entry 22646 (class 0 OID 0)
-- Dependencies: 3520
-- Name: COLUMN n_nutzungsartenschluessel.nutzungsart; Type: COMMENT; Schema: alkis6; Owner: -
--

COMMENT ON COLUMN n_nutzungsartenschluessel.nutzungsart IS 'Hunderterstelle = Nutzungsart nach ALKIS-nutzungsartenschluessel MV';


--
-- TOC entry 22647 (class 0 OID 0)
-- Dependencies: 3520
-- Name: COLUMN n_nutzungsartenschluessel.untergliederung1; Type: COMMENT; Schema: alkis6; Owner: -
--

COMMENT ON COLUMN n_nutzungsartenschluessel.untergliederung1 IS 'Zehnerstelle = Untergliederung 1. Stufe nach ALKIS-nutzungsartenschluessel MV';


--
-- TOC entry 22648 (class 0 OID 0)
-- Dependencies: 3520
-- Name: COLUMN n_nutzungsartenschluessel.untergliederung2; Type: COMMENT; Schema: alkis6; Owner: -
--

COMMENT ON COLUMN n_nutzungsartenschluessel.untergliederung2 IS 'Einerstelle = Untergliederung 2. Stufe nach ALKIS-nutzungsartenschluessel MV';


--
-- TOC entry 22649 (class 0 OID 0)
-- Dependencies: 3520
-- Name: COLUMN n_nutzungsartenschluessel.objektart; Type: COMMENT; Schema: alkis6; Owner: -
--

COMMENT ON COLUMN n_nutzungsartenschluessel.objektart IS 'Objektart nach ALKIS-Objektartenkatalog MV';


--
-- TOC entry 22650 (class 0 OID 0)
-- Dependencies: 3520
-- Name: COLUMN n_nutzungsartenschluessel.werteart1; Type: COMMENT; Schema: alkis6; Owner: -
--

COMMENT ON COLUMN n_nutzungsartenschluessel.werteart1 IS 'Bestimmende Werteart 1 nach ALKIS-Objektartenkatalog MV';


--
-- TOC entry 22651 (class 0 OID 0)
-- Dependencies: 3520
-- Name: COLUMN n_nutzungsartenschluessel.werteart2; Type: COMMENT; Schema: alkis6; Owner: -
--

COMMENT ON COLUMN n_nutzungsartenschluessel.werteart2 IS 'Bestimmende Werteart 2 nach ALKIS-Objektartenkatalog MV';


--
-- TOC entry 22640 (class 0 OID 159585419)
-- Dependencies: 3520
-- Data for Name: n_nutzungsartenschluessel; Type: TABLE DATA; Schema: alkis6; Owner: -
--

INSERT INTO n_nutzungsartenschluessel VALUES (12, 4, 1, 2, 41002, 2612, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 4, 2, 1, 41002, 2621, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 4, 2, 2, 41002, 2622, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 4, 2, 3, 41002, 2623, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 1, 0, 1, 41002, 1701, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 3, 0, 1, 41002, 2501, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 3, 0, 2, 41002, 2502, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 4, 0, 1, 41002, 2601, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 4, 0, 2, 41002, 2602, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 1, 1, 0, 41002, 1710, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 1, 2, 0, 41002, 1720, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 1, 3, 0, 41002, 1730, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 1, 4, 0, 41002, 1740, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 1, 5, 0, 41002, 1750, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 1, 6, 0, 41002, 1760, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 1, 7, 0, 41002, 1770, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 1, 8, 0, 41002, 1780, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 1, 9, 0, 41002, 1790, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 2, 1, 0, 41002, 1410, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 2, 2, 0, 41002, 1420, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 2, 3, 0, 41002, 1430, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 2, 4, 0, 41002, 1440, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 2, 5, 0, 41002, 1450, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 2, 6, 0, 41002, 1460, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 2, 7, 0, 41002, 1470, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 2, 8, 0, 41002, 1480, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 2, 9, 0, 41002, 1490, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 3, 1, 0, 41002, 2510, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 3, 2, 0, 41002, 2520, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 3, 3, 0, 41002, 2530, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 3, 4, 0, 41002, 2540, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 3, 5, 0, 41002, 2550, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 3, 6, 0, 41002, 2560, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 3, 7, 0, 41002, 2570, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 3, 8, 0, 41002, 2580, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 4, 1, 0, 41002, 2610, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 4, 2, 0, 41002, 2620, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 4, 3, 0, 41002, 2630, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 4, 4, 0, 41002, 2640, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 1, 0, 0, 41002, 1700, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 2, 0, 0, 41002, 1400, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 3, 0, 0, 41002, 2500, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 4, 0, 0, 41002, 2600, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 1, 4, 1, 41002, 1740, 7000, 'FKT', 'LGT');
INSERT INTO n_nutzungsartenschluessel VALUES (12, 1, 4, 2, 41002, 1740, 1000, 'FKT', 'LGT');
INSERT INTO n_nutzungsartenschluessel VALUES (12, 1, 4, 3, 41002, 1740, 4000, 'FKT', 'LGT');
INSERT INTO n_nutzungsartenschluessel VALUES (12, 1, 4, 4, 41002, 1740, 2000, 'FKT', 'LGT');
INSERT INTO n_nutzungsartenschluessel VALUES (12, 1, 4, 5, 41002, 1740, 3000, 'FKT', 'LGT');
INSERT INTO n_nutzungsartenschluessel VALUES (12, 1, 4, 6, 41002, 1740, 6000, 'FKT', 'LGT');
INSERT INTO n_nutzungsartenschluessel VALUES (12, 1, 4, 7, 41002, 1740, 8000, 'FKT', 'LGT');
INSERT INTO n_nutzungsartenschluessel VALUES (12, 1, 4, 8, 41002, 1740, 5000, 'FKT', 'LGT');
INSERT INTO n_nutzungsartenschluessel VALUES (12, 3, 1, 1, 41002, 2510, 1000, 'FKT', 'FGT');
INSERT INTO n_nutzungsartenschluessel VALUES (12, 3, 1, 2, 41002, 2510, 2000, 'FKT', 'FGT');
INSERT INTO n_nutzungsartenschluessel VALUES (12, 3, 1, 3, 41002, 2510, 3000, 'FKT', 'FGT');
INSERT INTO n_nutzungsartenschluessel VALUES (12, 3, 1, 4, 41002, 2510, 4000, 'FKT', 'FGT');
INSERT INTO n_nutzungsartenschluessel VALUES (12, 3, 1, 5, 41002, 2510, 5000, 'FKT', 'FGT');
INSERT INTO n_nutzungsartenschluessel VALUES (13, 0, 0, 1, 41003, 1000, 0, 'LGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (13, 0, 0, 2, 41003, 2000, 0, 'LGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (13, 0, 0, 3, 41003, 4000, 0, 'LGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (13, 0, 0, 4, 41003, 5000, 0, 'LGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (13, 0, 0, 5, 41003, 6000, 0, 'LGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (13, 0, 0, 6, 41003, 7000, 0, 'LGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (13, 0, 0, 7, 41003, 8000, 0, 'LGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 1, 1, 41004, 1001, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 1, 2, 41004, 1007, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 2, 1, 41004, 2002, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 2, 2, 41004, 2003, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 2, 3, 41004, 2005, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 2, 4, 41004, 2006, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 2, 5, 41004, 2013, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 2, 6, 41004, 2021, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 3, 1, 41004, 3001, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 3, 2, 41004, 3002, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 3, 3, 41004, 3003, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 3, 4, 41004, 3004, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 3, 5, 41004, 3005, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 3, 6, 41004, 3006, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 3, 7, 41004, 3007, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 3, 8, 41004, 3008, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 3, 9, 41004, 3009, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 4, 1, 41004, 3010, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 4, 2, 41004, 3011, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 5, 1, 41004, 4020, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 5, 2, 41004, 4021, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 5, 3, 41004, 4022, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 5, 4, 41004, 4030, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 6, 1, 41004, 5001, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 6, 2, 41004, 5002, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 6, 3, 41004, 5003, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 6, 4, 41004, 5004, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 6, 5, 41004, 5005, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 6, 6, 41004, 5006, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 6, 7, 41004, 5007, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 6, 8, 41004, 5011, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 1, 0, 41004, 1000, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 2, 0, 41004, 2000, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 3, 0, 41004, 3000, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 5, 0, 41004, 4000, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 6, 0, 41004, 5000, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 1, 2, 41005, 1002, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 1, 3, 41005, 1003, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 1, 4, 41005, 1004, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 1, 5, 41005, 1005, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 1, 6, 41005, 1006, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 1, 7, 41005, 1007, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 1, 4, 0, 41002, 1740, 9999, 'FKT', 'LGT');
INSERT INTO n_nutzungsartenschluessel VALUES (13, 0, 0, 0, 41003, 9999, 0, 'LGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 0, 0, 41005, 9999, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 0, 0, 0, 41008, 9999, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (22, 0, 0, 0, 42006, 9999, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (43, 0, 0, 0, 44006, 9999, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 1, 8, 41005, 1008, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 1, 9, 41005, 1009, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 2, 1, 41005, 1011, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 2, 2, 41005, 1012, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 2, 3, 41005, 1013, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 3, 1, 41005, 2001, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 3, 2, 41005, 2002, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 3, 3, 41005, 2003, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 3, 4, 41005, 2004, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 3, 5, 41005, 2005, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 3, 6, 41005, 2006, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 3, 7, 41005, 2007, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 3, 8, 41005, 2008, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 3, 9, 41005, 2009, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 4, 1, 41005, 2010, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 4, 2, 41005, 2011, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 4, 3, 41005, 2012, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 4, 4, 41005, 2013, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 4, 5, 41005, 2014, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 4, 6, 41005, 2015, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 4, 7, 41005, 2016, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 4, 8, 41005, 2017, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 4, 9, 41005, 2018, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 5, 1, 41005, 2019, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 5, 2, 41005, 2020, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 5, 3, 41004, 2021, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 6, 1, 41005, 4010, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 6, 2, 41005, 4020, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 6, 3, 41005, 4021, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 1, 1, 41005, 1001, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 6, 4, 41005, 4022, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 6, 5, 41005, 4030, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 7, 1, 41005, 5001, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 7, 2, 41005, 5002, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 7, 3, 41005, 5005, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 7, 4, 41005, 5007, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 7, 5, 41005, 5008, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 7, 6, 41005, 5009, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 7, 7, 41005, 5010, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 1, 0, 41005, 1000, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 3, 0, 41005, 2000, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 6, 0, 41005, 4000, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 7, 0, 41005, 5000, 0, 'AGT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (16, 2, 1, 1, 41006, 2710, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (16, 2, 1, 2, 41006, 2720, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 2, 1, 1, 41008, 4211, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 3, 2, 1, 41008, 4321, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 3, 3, 1, 41008, 4331, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 4, 3, 1, 41008, 4431, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 1, 0, 1, 41008, 4101, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 3, 0, 1, 41008, 4301, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (16, 1, 1, 0, 41006, 2110, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (16, 1, 2, 0, 41006, 2120, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (16, 1, 3, 0, 41006, 2130, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (16, 1, 4, 0, 41006, 2140, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (16, 1, 5, 0, 41006, 2150, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (16, 1, 6, 0, 41006, 2160, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (16, 2, 1, 0, 41006, 2730, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (17, 1, 1, 0, 41007, 1110, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (17, 1, 2, 0, 41007, 1120, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (17, 1, 3, 0, 41007, 1130, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (17, 1, 4, 0, 41007, 1140, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (17, 1, 5, 0, 41007, 1150, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (17, 1, 6, 0, 41007, 1160, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (17, 1, 7, 0, 41007, 1170, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (17, 3, 1, 0, 41007, 1310, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (17, 3, 2, 0, 41007, 1320, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 1, 1, 0, 41008, 4110, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 1, 2, 0, 41008, 4120, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 1, 3, 0, 41008, 4130, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 1, 4, 0, 41008, 4140, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 1, 5, 0, 41008, 4150, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 1, 6, 0, 41008, 4160, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 1, 7, 0, 41008, 4170, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 2, 1, 0, 41008, 4210, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 2, 2, 0, 41008, 4220, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 2, 3, 0, 41008, 4230, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 2, 4, 0, 41008, 4240, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 2, 5, 0, 41008, 4250, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 2, 6, 0, 41008, 4260, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 2, 7, 0, 41008, 4270, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 2, 8, 0, 41008, 4280, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 2, 9, 0, 41008, 4290, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 3, 1, 0, 41008, 4310, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 3, 2, 0, 41008, 4320, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 3, 3, 0, 41008, 4330, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 4, 1, 0, 41008, 4410, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 4, 2, 0, 41008, 4420, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 4, 3, 0, 41008, 4430, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 4, 4, 0, 41008, 4440, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 4, 5, 0, 41008, 4450, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 4, 6, 0, 41008, 4460, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 4, 7, 0, 41008, 4470, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (43, 1, 1, 1, 44006, 8631, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (22, 0, 1, 1, 42006, 5211, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (22, 0, 1, 2, 42006, 5212, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (41, 1, 1, 0, 44001, 8210, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (41, 1, 2, 0, 44001, 8220, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (41, 1, 3, 0, 44001, 8230, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (41, 3, 1, 0, 44001, 8410, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (43, 1, 1, 0, 44006, 8630, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (43, 1, 2, 0, 44006, 8640, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (19, 0, 1, 0, 41009, 9403, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (19, 0, 2, 0, 41009, 9404, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (21, 0, 1, 0, 42001, 5130, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (22, 0, 1, 0, 42006, 5210, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (22, 0, 2, 0, 42006, 5220, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (22, 0, 3, 0, 42006, 5230, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (22, 0, 4, 0, 42006, 5240, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (22, 0, 5, 0, 42006, 5250, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (22, 0, 6, 0, 42006, 5260, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (23, 0, 1, 0, 42009, 5130, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (23, 0, 2, 0, 42009, 5310, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (23, 0, 3, 0, 42009, 5320, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 0, 0, 1, 41008, 4001, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (11, 0, 0, 0, 41001, 0, 0, NULL, NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (19, 0, 0, 1, 41009, 9401, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (19, 0, 0, 2, 41009, 9402, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (21, 0, 0, 1, 42001, 2311, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (21, 0, 0, 2, 42001, 2312, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 0, 0, 0, 41002, 0, 0, NULL, NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 3, 2, 1, 41002, 2521, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 3, 2, 2, 41002, 2522, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (13, 0, 0, 0, 41003, 0, 0, NULL, NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 3, 3, 1, 41002, 2531, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 3, 3, 2, 41002, 2532, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (14, 0, 0, 0, 41004, 0, 0, NULL, NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (15, 0, 0, 0, 41005, 0, 0, NULL, NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (16, 0, 0, 0, 41006, 0, 0, NULL, NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 3, 5, 1, 41002, 2551, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 3, 5, 2, 41002, 2552, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 3, 6, 1, 41002, 2561, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 3, 6, 2, 41002, 2562, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (21, 0, 0, 3, 42001, 2313, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (16, 1, 0, 0, 41006, 2100, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (16, 2, 0, 0, 41006, 2700, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (16, 3, 0, 0, 41006, 6800, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (26, 0, 1, 0, 42016, 5610, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (26, 0, 2, 0, 42016, 5620, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (26, 0, 3, 0, 42016, 5630, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (26, 0, 4, 0, 42016, 5640, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (31, 1, 1, 0, 43001, 1011, 0, 'VEG', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (31, 1, 2, 0, 43001, 1012, 0, 'VEG', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (31, 1, 3, 0, 43001, 1013, 0, 'VEG', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (31, 2, 1, 0, 43001, 1021, 0, 'VEG', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (31, 3, 1, 0, 43001, 1031, 0, 'VEG', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (31, 5, 1, 0, 43001, 1051, 0, 'VEG', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (31, 5, 2, 0, 43001, 1052, 0, 'VEG', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (32, 3, 1, 0, 43002, 1310, 0, 'VEG', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (32, 3, 2, 0, 43002, 1320, 0, 'VEG', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (31, 1, 0, 0, 43001, 1010, 0, 'VEG', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (31, 2, 0, 0, 43001, 1020, 0, 'VEG', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (31, 3, 0, 0, 43001, 1030, 0, 'VEG', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (31, 4, 0, 0, 43001, 1040, 0, 'VEG', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (31, 5, 0, 0, 43001, 1050, 0, 'VEG', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (31, 6, 0, 0, 43001, 1200, 0, 'VEG', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (32, 1, 0, 0, 43002, 1100, 0, 'VEG', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (32, 2, 0, 0, 43002, 1200, 0, 'VEG', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (32, 3, 0, 0, 43002, 1300, 0, 'VEG', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (33, 0, 1, 0, 43003, 1400, 0, 'VEG', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (37, 0, 2, 1, 43007, 1110, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (37, 0, 2, 2, 43007, 1120, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (37, 0, 1, 0, 43007, 1000, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (37, 0, 2, 0, 43007, 1100, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (37, 0, 3, 0, 43007, 1200, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (37, 0, 4, 0, 43007, 1300, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (37, 0, 1, 1, 43007, 1000, 1010, 'FKT', 'OFM');
INSERT INTO n_nutzungsartenschluessel VALUES (37, 0, 1, 2, 43007, 1000, 1020, 'FKT', 'OFM');
INSERT INTO n_nutzungsartenschluessel VALUES (37, 0, 1, 3, 43007, 1000, 1030, 'FKT', 'OFM');
INSERT INTO n_nutzungsartenschluessel VALUES (37, 0, 1, 4, 43007, 1000, 1040, 'FKT', 'OFM');
INSERT INTO n_nutzungsartenschluessel VALUES (37, 0, 1, 5, 43007, 1000, 1110, 'FKT', 'OFM');
INSERT INTO n_nutzungsartenschluessel VALUES (37, 0, 1, 6, 43007, 1000, 1120, 'FKT', 'OFM');
INSERT INTO n_nutzungsartenschluessel VALUES (17, 0, 0, 0, 41007, 0, 0, NULL, NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 0, 0, 0, 41008, 0, 0, NULL, NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (19, 0, 0, 0, 41009, 0, 0, NULL, NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (21, 0, 0, 0, 42001, 0, 0, NULL, NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (22, 0, 0, 0, 42006, 0, 0, NULL, NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (23, 0, 0, 0, 42009, 0, 0, NULL, NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (24, 0, 0, 0, 42010, 0, 0, NULL, NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (25, 0, 0, 0, 42015, 0, 0, NULL, NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (26, 0, 0, 0, 42016, 0, 0, NULL, NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (31, 0, 0, 0, 43001, 0, 0, NULL, NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (32, 0, 0, 0, 43002, 0, 0, NULL, NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (33, 0, 0, 0, 43003, 0, 0, NULL, NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (34, 0, 0, 0, 43004, 0, 0, NULL, NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (35, 0, 0, 0, 43005, 0, 0, NULL, NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (36, 0, 0, 0, 43006, 0, 0, NULL, NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (37, 0, 0, 0, 43007, 0, 0, NULL, NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (41, 0, 0, 0, 44001, 0, 0, NULL, NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (42, 0, 0, 0, 44005, 0, 0, NULL, NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (43, 0, 0, 0, 44006, 0, 0, NULL, NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (44, 0, 0, 0, 44007, 0, 0, NULL, NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 3, 7, 1, 41002, 2571, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 3, 7, 2, 41002, 2572, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 3, 8, 1, 41002, 2581, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 3, 8, 2, 41002, 2582, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (12, 4, 1, 1, 41002, 2611, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (16, 4, 0, 0, 41006, 7600, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (17, 1, 0, 0, 41007, 1100, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (17, 2, 0, 0, 41007, 1200, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (17, 3, 0, 0, 41007, 1300, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 1, 0, 0, 41008, 4100, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 2, 0, 0, 41008, 4200, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 3, 0, 0, 41008, 4300, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (18, 4, 0, 0, 41008, 4400, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (23, 0, 4, 0, 42009, 5330, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (23, 0, 5, 0, 42009, 5340, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (23, 0, 6, 0, 42009, 5350, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (41, 1, 0, 0, 44001, 8200, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (41, 2, 0, 0, 44001, 8300, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (41, 3, 0, 0, 44001, 8400, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (41, 4, 0, 0, 44001, 8500, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (43, 1, 0, 0, 44006, 8610, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (43, 2, 0, 0, 44006, 8620, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (42, 0, 1, 0, 44005, 8810, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (44, 0, 1, 0, 44007, 8710, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (24, 0, 0, 1, 42010, 2321, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (24, 0, 0, 2, 42010, 2322, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (24, 0, 1, 1, 42010, 1102, 0, 'BKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (24, 0, 1, 2, 42010, 1104, 0, 'BKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (24, 0, 1, 3, 42010, 1400, 0, 'BKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (24, 0, 1, 4, 42010, 1500, 0, 'BKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (24, 0, 2, 1, 42010, 1201, 0, 'BKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (24, 0, 2, 2, 42010, 1202, 0, 'BKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (24, 0, 3, 1, 42010, 1301, 0, 'BKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (24, 0, 3, 2, 42010, 1302, 0, 'BKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (24, 0, 1, 0, 42010, 1100, 0, 'BKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (24, 0, 2, 0, 42010, 1200, 0, 'BKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (24, 0, 3, 0, 42010, 1300, 0, 'BKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (24, 0, 4, 0, 42010, 1600, 0, 'BKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (25, 0, 0, 1, 42015, 5501, 0, 'FKT', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (25, 0, 1, 1, 42015, 5511, 0, 'ART', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (25, 0, 1, 2, 42015, 5512, 0, 'ART', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (25, 0, 1, 0, 42015, 5510, 0, 'ART', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (25, 0, 2, 0, 42015, 5520, 0, 'ART', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (25, 0, 3, 0, 42015, 5530, 0, 'ART', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (25, 0, 4, 0, 42015, 5540, 0, 'ART', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (25, 0, 5, 0, 42015, 5550, 0, 'ART', NULL);
INSERT INTO n_nutzungsartenschluessel VALUES (26, 0, 0, 1, 42016, 2341, 0, 'FKT', NULL);


--
-- TOC entry 22109 (class 1259 OID 159585766)
-- Name: n_nutzungsartenschluessel_nutzungsartengruppe2_ix; Type: INDEX; Schema: alkis6; Owner: -
--

CREATE INDEX n_nutzungsartenschluessel_nutzungsartengruppe2_ix ON n_nutzungsartenschluessel USING btree (nutzungsartengruppe, werteart1, werteart2);


--
-- TOC entry 22110 (class 1259 OID 159585767)
-- Name: n_nutzungsartenschluessel_nutzungsartengruppe_ix; Type: INDEX; Schema: alkis6; Owner: -
--

CREATE INDEX n_nutzungsartenschluessel_nutzungsartengruppe_ix ON n_nutzungsartenschluessel USING btree (nutzungsartengruppe, nutzungsart, untergliederung1, untergliederung2);


--
-- TOC entry 22111 (class 1259 OID 159585768)
-- Name: n_nutzungsartenschluessel_objektart_ix; Type: INDEX; Schema: alkis6; Owner: -
--

CREATE INDEX n_nutzungsartenschluessel_objektart_ix ON n_nutzungsartenschluessel USING btree (objektart, werteart1, werteart2);





CREATE TABLE n_nutzungsartengruppe (
    schluessel integer NOT NULL,
    gruppe character varying(100) NOT NULL,
    bereich character varying(100) NOT NULL
);


--
-- TOC entry 22647 (class 0 OID 0)
-- Dependencies: 3521
-- Name: COLUMN n_nutzungsartengruppe.schluessel; Type: COMMENT; Schema: alkis6; Owner: -
--

COMMENT ON COLUMN n_nutzungsartengruppe.schluessel IS 'Tausenderstelle = Nutzungsartengruppe';


--
-- TOC entry 22648 (class 0 OID 0)
-- Dependencies: 3521
-- Name: COLUMN n_nutzungsartengruppe.gruppe; Type: COMMENT; Schema: alkis6; Owner: -
--

COMMENT ON COLUMN n_nutzungsartengruppe.gruppe IS 'Nutzungsartengruppe nach ALKIS-Nutzungsartenkatalog MV';


--
-- TOC entry 22649 (class 0 OID 0)
-- Dependencies: 3521
-- Name: COLUMN n_nutzungsartengruppe.bereich; Type: COMMENT; Schema: alkis6; Owner: -
--

COMMENT ON COLUMN n_nutzungsartengruppe.bereich IS 'Nutzungsartenbereich nach ALKIS-Nutzungsartenkatalog MV';


--
-- TOC entry 22642 (class 0 OID 159585769)
-- Dependencies: 3521
-- Data for Name: n_nutzungsartengruppe; Type: TABLE DATA; Schema: alkis6; Owner: -
--

INSERT INTO n_nutzungsartengruppe VALUES (11, 'Wohnbaufläche', 'Siedlung');
INSERT INTO n_nutzungsartengruppe VALUES (12, 'Industrie- und Gewerbefläche', 'Siedlung');
INSERT INTO n_nutzungsartengruppe VALUES (13, 'Halde', 'Siedlung');
INSERT INTO n_nutzungsartengruppe VALUES (14, 'Bergbaubetrieb', 'Siedlung');
INSERT INTO n_nutzungsartengruppe VALUES (15, 'Tagebau, Grube, Steinbruch', 'Siedlung');
INSERT INTO n_nutzungsartengruppe VALUES (16, 'Fläche gemischter Nutzung', 'Siedlung');
INSERT INTO n_nutzungsartengruppe VALUES (17, 'Fläche besonderer funktionaler Prägung', 'Siedlung');
INSERT INTO n_nutzungsartengruppe VALUES (18, 'Sport-, Freizeit- und Erholungsfläche', 'Siedlung');
INSERT INTO n_nutzungsartengruppe VALUES (19, 'Friedhof', 'Siedlung');
INSERT INTO n_nutzungsartengruppe VALUES (21, 'Straßenverkehr', 'Verkehr');
INSERT INTO n_nutzungsartengruppe VALUES (22, 'Weg', 'Verkehr');
INSERT INTO n_nutzungsartengruppe VALUES (23, 'Platz', 'Verkehr');
INSERT INTO n_nutzungsartengruppe VALUES (24, 'Bahnverkehr', 'Verkehr');
INSERT INTO n_nutzungsartengruppe VALUES (25, 'Flugverkehr', 'Verkehr');
INSERT INTO n_nutzungsartengruppe VALUES (26, 'Schiffsverkehr', 'Verkehr');
INSERT INTO n_nutzungsartengruppe VALUES (31, 'Landwirtschaft', 'Vegetation');
INSERT INTO n_nutzungsartengruppe VALUES (32, 'Wald', 'Vegetation');
INSERT INTO n_nutzungsartengruppe VALUES (33, 'Gehölz', 'Vegetation');
INSERT INTO n_nutzungsartengruppe VALUES (34, 'Heide', 'Vegetation');
INSERT INTO n_nutzungsartengruppe VALUES (35, 'Moor', 'Vegetation');
INSERT INTO n_nutzungsartengruppe VALUES (36, 'Sumpf', 'Vegetation');
INSERT INTO n_nutzungsartengruppe VALUES (37, 'Unland / Vegetationslose Fläche', 'Vegetation');
INSERT INTO n_nutzungsartengruppe VALUES (41, 'Fließgewässer', 'Gewässer');
INSERT INTO n_nutzungsartengruppe VALUES (42, 'Hafenbecken', 'Gewässer');
INSERT INTO n_nutzungsartengruppe VALUES (43, 'Stehendes Gewässer', 'Gewässer');
INSERT INTO n_nutzungsartengruppe VALUES (44, 'Meer', 'Gewässer');


--
-- TOC entry 22113 (class 2606 OID 159585773)
-- Name: n_nutzungsartengruppe_pk; Type: CONSTRAINT; Schema: alkis6; Owner: -
--

ALTER TABLE ONLY n_nutzungsartengruppe
    ADD CONSTRAINT n_nutzungsartengruppe_pk PRIMARY KEY (schluessel);
		
		
		
		
CREATE TABLE n_nutzungsart (
    nutzungsartengruppe integer NOT NULL,
    schluessel integer NOT NULL,
    nutzungsart character varying(100) NOT NULL
);


--
-- TOC entry 22650 (class 0 OID 0)
-- Dependencies: 3522
-- Name: COLUMN n_nutzungsart.nutzungsartengruppe; Type: COMMENT; Schema: alkis6; Owner: -
--

COMMENT ON COLUMN n_nutzungsart.nutzungsartengruppe IS 'Tausenderstelle = Nutzungsartengruppe nach ALKIS-Nutzungsartenkatalog MV';


--
-- TOC entry 22651 (class 0 OID 0)
-- Dependencies: 3522
-- Name: COLUMN n_nutzungsart.schluessel; Type: COMMENT; Schema: alkis6; Owner: -
--

COMMENT ON COLUMN n_nutzungsart.schluessel IS 'Hunderterstelle = Nutzungsart';


--
-- TOC entry 22652 (class 0 OID 0)
-- Dependencies: 3522
-- Name: COLUMN n_nutzungsart.nutzungsart; Type: COMMENT; Schema: alkis6; Owner: -
--

COMMENT ON COLUMN n_nutzungsart.nutzungsart IS 'Nutzungsart nach ALKIS-Nutzungsartenkatalog MV';


--
-- TOC entry 22645 (class 0 OID 159585800)
-- Dependencies: 3522
-- Data for Name: n_nutzungsart; Type: TABLE DATA; Schema: alkis6; Owner: -
--

INSERT INTO n_nutzungsart VALUES (12, 1, 'Industrie und Gewerbe');
INSERT INTO n_nutzungsart VALUES (12, 2, 'Handel und Dienstleistung');
INSERT INTO n_nutzungsart VALUES (12, 3, 'Versorgungsanlage');
INSERT INTO n_nutzungsart VALUES (12, 4, 'Entsorgung');
INSERT INTO n_nutzungsart VALUES (16, 1, 'Gebäude- und Freifläche, Mischnutzung mit Wohnen');
INSERT INTO n_nutzungsart VALUES (16, 2, 'Gebäude- und Freifläche Land- und Forstwirtschaft');
INSERT INTO n_nutzungsart VALUES (16, 3, 'Landwirtschaftliche Betriebsfläche');
INSERT INTO n_nutzungsart VALUES (16, 4, 'Forstwirtschaftliche Betriebsfläche');
INSERT INTO n_nutzungsart VALUES (17, 1, 'Öffentliche Zwecke');
INSERT INTO n_nutzungsart VALUES (17, 2, 'Parken');
INSERT INTO n_nutzungsart VALUES (17, 3, 'Historische Anlage');
INSERT INTO n_nutzungsart VALUES (18, 1, 'Sportanlage');
INSERT INTO n_nutzungsart VALUES (18, 2, 'Freizeitanlage');
INSERT INTO n_nutzungsart VALUES (18, 3, 'Erholungsfläche');
INSERT INTO n_nutzungsart VALUES (18, 4, 'Grünanlage');
INSERT INTO n_nutzungsart VALUES (31, 1, 'Ackerland');
INSERT INTO n_nutzungsart VALUES (31, 2, 'Grünland');
INSERT INTO n_nutzungsart VALUES (31, 3, 'Gartenland');
INSERT INTO n_nutzungsart VALUES (31, 4, 'Weingarten');
INSERT INTO n_nutzungsart VALUES (31, 5, 'Obstplantage');
INSERT INTO n_nutzungsart VALUES (31, 6, 'Brachland');
INSERT INTO n_nutzungsart VALUES (32, 1, 'Laubholz');
INSERT INTO n_nutzungsart VALUES (32, 2, 'Nadelholz');
INSERT INTO n_nutzungsart VALUES (32, 3, 'Laub- und Nadelholz');
INSERT INTO n_nutzungsart VALUES (41, 1, 'Fluss');
INSERT INTO n_nutzungsart VALUES (41, 2, 'Kanal');
INSERT INTO n_nutzungsart VALUES (41, 3, 'Graben');
INSERT INTO n_nutzungsart VALUES (41, 4, 'Bach');
INSERT INTO n_nutzungsart VALUES (43, 1, 'See');
INSERT INTO n_nutzungsart VALUES (43, 2, 'Teich');


--
-- TOC entry 22116 (class 2606 OID 159585804)
-- Name: n_nutzungsart_pk; Type: CONSTRAINT; Schema: alkis6; Owner: -
--

ALTER TABLE ONLY n_nutzungsart
    ADD CONSTRAINT n_nutzungsart_pk PRIMARY KEY (nutzungsartengruppe, schluessel);
		
		
		
		

CREATE TABLE n_untergliederung1 (
    nutzungsartengruppe integer NOT NULL,
    nutzungsart integer NOT NULL,
    schluessel integer NOT NULL,
    untergliederung1 character varying(100) NOT NULL
);


--
-- TOC entry 22656 (class 0 OID 0)
-- Dependencies: 3523
-- Name: COLUMN n_untergliederung1.nutzungsartengruppe; Type: COMMENT; Schema: alkis6; Owner: -
--

COMMENT ON COLUMN n_untergliederung1.nutzungsartengruppe IS 'Tausenderstelle = Nutzungsartengruppe nach ALKIS-Nutzungsartenkatalog MV';


--
-- TOC entry 22657 (class 0 OID 0)
-- Dependencies: 3523
-- Name: COLUMN n_untergliederung1.nutzungsart; Type: COMMENT; Schema: alkis6; Owner: -
--

COMMENT ON COLUMN n_untergliederung1.nutzungsart IS 'Hunderterstelle = Nutzungsart nach ALKIS-Nutzungsartenkatalog MV';


--
-- TOC entry 22658 (class 0 OID 0)
-- Dependencies: 3523
-- Name: COLUMN n_untergliederung1.schluessel; Type: COMMENT; Schema: alkis6; Owner: -
--

COMMENT ON COLUMN n_untergliederung1.schluessel IS 'Zehnerstelle = Untergliederung 1. Stufe';


--
-- TOC entry 22659 (class 0 OID 0)
-- Dependencies: 3523
-- Name: COLUMN n_untergliederung1.untergliederung1; Type: COMMENT; Schema: alkis6; Owner: -
--

COMMENT ON COLUMN n_untergliederung1.untergliederung1 IS 'Untergliederung 1. Stufe nach ALKIS-Nutzungsartenkatalog MV';


--
-- TOC entry 3524 (class 1259 OID 159585971)
-- Name: n_untergliederung2; Type: TABLE; Schema: alkis6; Owner: -
--

CREATE TABLE n_untergliederung2 (
    nutzungsartengruppe integer NOT NULL,
    nutzungsart integer NOT NULL,
    untergliederung1 integer NOT NULL,
    schluessel integer NOT NULL,
    untergliederung2 character varying(100) NOT NULL
);


--
-- TOC entry 22660 (class 0 OID 0)
-- Dependencies: 3524
-- Name: COLUMN n_untergliederung2.nutzungsartengruppe; Type: COMMENT; Schema: alkis6; Owner: -
--

COMMENT ON COLUMN n_untergliederung2.nutzungsartengruppe IS 'Tausenderstelle = Nutzungsartengruppe nach ALKIS-Nutzungsartenkatalog MV';


--
-- TOC entry 22661 (class 0 OID 0)
-- Dependencies: 3524
-- Name: COLUMN n_untergliederung2.nutzungsart; Type: COMMENT; Schema: alkis6; Owner: -
--

COMMENT ON COLUMN n_untergliederung2.nutzungsart IS 'Hunderterstelle = Nutzungsart nach ALKIS-Nutzungsartenkatalog MV';


--
-- TOC entry 22662 (class 0 OID 0)
-- Dependencies: 3524
-- Name: COLUMN n_untergliederung2.untergliederung1; Type: COMMENT; Schema: alkis6; Owner: -
--

COMMENT ON COLUMN n_untergliederung2.untergliederung1 IS 'Zehnerstelle = Untergliederung 1. Stufe nach ALKIS-Nutzungsartenkatalog MV';


--
-- TOC entry 22663 (class 0 OID 0)
-- Dependencies: 3524
-- Name: COLUMN n_untergliederung2.schluessel; Type: COMMENT; Schema: alkis6; Owner: -
--

COMMENT ON COLUMN n_untergliederung2.schluessel IS 'Einerstelle = Untergliederung 2. Stufe';


--
-- TOC entry 22664 (class 0 OID 0)
-- Dependencies: 3524
-- Name: COLUMN n_untergliederung2.untergliederung2; Type: COMMENT; Schema: alkis6; Owner: -
--

COMMENT ON COLUMN n_untergliederung2.untergliederung2 IS 'Untergliederung 2. Stufe nach ALKIS-Nutzungsartenkatalog MV';


--
-- TOC entry 22650 (class 0 OID 159585835)
-- Dependencies: 3523
-- Data for Name: n_untergliederung1; Type: TABLE DATA; Schema: alkis6; Owner: -
--

INSERT INTO n_untergliederung1 VALUES (12, 1, 1, 'Produktion');
INSERT INTO n_untergliederung1 VALUES (12, 1, 2, 'Handwerk');
INSERT INTO n_untergliederung1 VALUES (12, 1, 3, 'Tankstelle');
INSERT INTO n_untergliederung1 VALUES (12, 1, 4, 'Lagerplatz');
INSERT INTO n_untergliederung1 VALUES (12, 1, 5, 'Transport');
INSERT INTO n_untergliederung1 VALUES (12, 1, 6, 'Forschung');
INSERT INTO n_untergliederung1 VALUES (12, 1, 7, 'Grundstoff');
INSERT INTO n_untergliederung1 VALUES (12, 1, 8, 'Betriebliche Sozialeinrichtung');
INSERT INTO n_untergliederung1 VALUES (12, 1, 9, 'Werft');
INSERT INTO n_untergliederung1 VALUES (12, 2, 1, 'Verwaltung, freie Berufe');
INSERT INTO n_untergliederung1 VALUES (12, 2, 2, 'Bank, Kredit');
INSERT INTO n_untergliederung1 VALUES (12, 2, 3, 'Versicherung');
INSERT INTO n_untergliederung1 VALUES (12, 2, 4, 'Handel');
INSERT INTO n_untergliederung1 VALUES (12, 2, 5, 'Ausstellung, Messe');
INSERT INTO n_untergliederung1 VALUES (12, 2, 6, 'Beherbergung');
INSERT INTO n_untergliederung1 VALUES (12, 2, 7, 'Restauration');
INSERT INTO n_untergliederung1 VALUES (12, 2, 8, 'Vergnügung');
INSERT INTO n_untergliederung1 VALUES (12, 2, 9, 'Gärtnerei');
INSERT INTO n_untergliederung1 VALUES (12, 3, 1, 'Förderanlage');
INSERT INTO n_untergliederung1 VALUES (12, 3, 2, 'Wasserwerk');
INSERT INTO n_untergliederung1 VALUES (12, 3, 3, 'Kraftwerk');
INSERT INTO n_untergliederung1 VALUES (12, 3, 4, 'Umspannstation');
INSERT INTO n_untergliederung1 VALUES (12, 3, 5, 'Raffinerie');
INSERT INTO n_untergliederung1 VALUES (12, 3, 6, 'Gaswerk');
INSERT INTO n_untergliederung1 VALUES (12, 3, 7, 'Heizwerk');
INSERT INTO n_untergliederung1 VALUES (12, 3, 8, 'Funk- und Fernmeldeanlage');
INSERT INTO n_untergliederung1 VALUES (12, 4, 1, 'Kläranlage, Klärwerk');
INSERT INTO n_untergliederung1 VALUES (12, 4, 2, 'Abfallbehandlungsanlage');
INSERT INTO n_untergliederung1 VALUES (12, 4, 3, 'Deponie (oberirdisch)');
INSERT INTO n_untergliederung1 VALUES (12, 4, 4, 'Deponie (untertägig)');
INSERT INTO n_untergliederung1 VALUES (14, 0, 1, 'Erden, Lockergestein');
INSERT INTO n_untergliederung1 VALUES (14, 0, 2, 'Steine, Gestein, Festgestein');
INSERT INTO n_untergliederung1 VALUES (14, 0, 3, 'Erze');
INSERT INTO n_untergliederung1 VALUES (14, 0, 5, 'Treib- und Brennstoffe');
INSERT INTO n_untergliederung1 VALUES (14, 0, 6, 'Industrieminerale, Salze');
INSERT INTO n_untergliederung1 VALUES (15, 0, 1, 'Erden, Lockergestein');
INSERT INTO n_untergliederung1 VALUES (15, 0, 3, 'Steine, Gestein, Festgestein');
INSERT INTO n_untergliederung1 VALUES (15, 0, 6, 'Treib- und Brennstoffe');
INSERT INTO n_untergliederung1 VALUES (15, 0, 7, 'Industrieminerale, Salze');
INSERT INTO n_untergliederung1 VALUES (16, 1, 1, 'Wohnen mit Öffentlich');
INSERT INTO n_untergliederung1 VALUES (16, 1, 2, 'Wohnen mit Handel und Dienstleistungen');
INSERT INTO n_untergliederung1 VALUES (16, 1, 3, 'Wohnen mit Gewerbe und Industrie');
INSERT INTO n_untergliederung1 VALUES (16, 1, 4, 'Öffentlich mit Wohnen');
INSERT INTO n_untergliederung1 VALUES (16, 1, 5, 'Handel und Dienstleistungen mit Wohnen');
INSERT INTO n_untergliederung1 VALUES (16, 1, 6, 'Gewerbe und Industrie mit Wohnen');
INSERT INTO n_untergliederung1 VALUES (16, 2, 1, 'Wohnen und Betrieb');
INSERT INTO n_untergliederung1 VALUES (17, 1, 1, 'Verwaltung');
INSERT INTO n_untergliederung1 VALUES (17, 1, 2, 'Bildung und Forschung');
INSERT INTO n_untergliederung1 VALUES (17, 1, 3, 'Kultur');
INSERT INTO n_untergliederung1 VALUES (17, 1, 4, 'Religiöse Einrichtung');
INSERT INTO n_untergliederung1 VALUES (17, 1, 5, 'Gesundheit, Kur');
INSERT INTO n_untergliederung1 VALUES (17, 1, 6, 'Soziales');
INSERT INTO n_untergliederung1 VALUES (17, 1, 7, 'Sicherheit und Ordnung');
INSERT INTO n_untergliederung1 VALUES (17, 3, 1, 'Burg-, Festungsanlage');
INSERT INTO n_untergliederung1 VALUES (17, 3, 2, 'Schlossanlage');
INSERT INTO n_untergliederung1 VALUES (18, 1, 1, 'Golfplatz');
INSERT INTO n_untergliederung1 VALUES (18, 1, 2, 'Sportplatz');
INSERT INTO n_untergliederung1 VALUES (18, 1, 3, 'Rennbahn');
INSERT INTO n_untergliederung1 VALUES (18, 1, 4, 'Reitplatz');
INSERT INTO n_untergliederung1 VALUES (18, 1, 5, 'Schießanlage');
INSERT INTO n_untergliederung1 VALUES (18, 1, 6, 'Eis-, Rollschuhbahn');
INSERT INTO n_untergliederung1 VALUES (18, 1, 7, 'Tennisplatz');
INSERT INTO n_untergliederung1 VALUES (18, 2, 1, 'Zoo');
INSERT INTO n_untergliederung1 VALUES (18, 2, 2, 'Safaripark, Wildpark');
INSERT INTO n_untergliederung1 VALUES (18, 2, 3, 'Freizeitpark');
INSERT INTO n_untergliederung1 VALUES (18, 2, 4, 'Freilichttheater');
INSERT INTO n_untergliederung1 VALUES (18, 2, 5, 'Freilichtmuseum');
INSERT INTO n_untergliederung1 VALUES (18, 2, 6, 'Autokino, Freilichtkino');
INSERT INTO n_untergliederung1 VALUES (18, 2, 7, 'Verkehrsübungsplatz');
INSERT INTO n_untergliederung1 VALUES (18, 2, 8, 'Hundeübungsplatz');
INSERT INTO n_untergliederung1 VALUES (18, 2, 9, 'Modellflugplatz');
INSERT INTO n_untergliederung1 VALUES (18, 3, 1, 'Wochenend- und Ferienhausfläche');
INSERT INTO n_untergliederung1 VALUES (18, 3, 2, 'Schwimmbad, Freibad');
INSERT INTO n_untergliederung1 VALUES (18, 3, 3, 'Campingplatz');
INSERT INTO n_untergliederung1 VALUES (18, 4, 1, 'Grünfläche');
INSERT INTO n_untergliederung1 VALUES (18, 4, 2, 'Park');
INSERT INTO n_untergliederung1 VALUES (18, 4, 3, 'Botanischer Garten');
INSERT INTO n_untergliederung1 VALUES (18, 4, 4, 'Kleingarten');
INSERT INTO n_untergliederung1 VALUES (18, 4, 5, 'Wochenendplatz');
INSERT INTO n_untergliederung1 VALUES (18, 4, 6, 'Garten');
INSERT INTO n_untergliederung1 VALUES (18, 4, 7, 'Spielplatz, Bolzplatz');
INSERT INTO n_untergliederung1 VALUES (19, 0, 1, 'Friedhof (Park)');
INSERT INTO n_untergliederung1 VALUES (19, 0, 2, 'Historischer Friedhof');
INSERT INTO n_untergliederung1 VALUES (21, 0, 1, 'Fußgängerzone');
INSERT INTO n_untergliederung1 VALUES (22, 0, 1, 'Fahrweg');
INSERT INTO n_untergliederung1 VALUES (22, 0, 2, 'Fußweg');
INSERT INTO n_untergliederung1 VALUES (22, 0, 3, 'Gang');
INSERT INTO n_untergliederung1 VALUES (22, 0, 4, 'Radweg');
INSERT INTO n_untergliederung1 VALUES (22, 0, 5, 'Rad- und Fußweg');
INSERT INTO n_untergliederung1 VALUES (22, 0, 6, 'Reitweg');
INSERT INTO n_untergliederung1 VALUES (23, 0, 1, 'Fußgängerzone');
INSERT INTO n_untergliederung1 VALUES (23, 0, 2, 'Parkplatz');
INSERT INTO n_untergliederung1 VALUES (23, 0, 3, 'Rastplatz');
INSERT INTO n_untergliederung1 VALUES (23, 0, 4, 'Raststätte');
INSERT INTO n_untergliederung1 VALUES (23, 0, 5, 'Marktplatz');
INSERT INTO n_untergliederung1 VALUES (23, 0, 6, 'Festplatz');
INSERT INTO n_untergliederung1 VALUES (24, 0, 1, 'Eisenbahn');
INSERT INTO n_untergliederung1 VALUES (24, 0, 2, 'Stadtbahn');
INSERT INTO n_untergliederung1 VALUES (24, 0, 3, 'Seilbahn, Bergbahn');
INSERT INTO n_untergliederung1 VALUES (24, 0, 4, 'Magnetschwebebahn');
INSERT INTO n_untergliederung1 VALUES (25, 0, 1, 'Flughafen');
INSERT INTO n_untergliederung1 VALUES (25, 0, 2, 'Verkehrslandeplatz');
INSERT INTO n_untergliederung1 VALUES (25, 0, 3, 'Hubschrauberflugplatz');
INSERT INTO n_untergliederung1 VALUES (25, 0, 4, 'Landeplatz, Sonderlandeplatz');
INSERT INTO n_untergliederung1 VALUES (25, 0, 5, 'Segelfluggelände');
INSERT INTO n_untergliederung1 VALUES (26, 0, 1, 'Hafenanlage (Landfläche)');
INSERT INTO n_untergliederung1 VALUES (26, 0, 2, 'Schleuse (Landfläche)');
INSERT INTO n_untergliederung1 VALUES (26, 0, 3, 'Anlegestelle');
INSERT INTO n_untergliederung1 VALUES (26, 0, 4, 'Fähranlage');
INSERT INTO n_untergliederung1 VALUES (31, 1, 1, 'Streuobstacker');
INSERT INTO n_untergliederung1 VALUES (31, 1, 2, 'Hopfen');
INSERT INTO n_untergliederung1 VALUES (31, 1, 3, 'Spargel');
INSERT INTO n_untergliederung1 VALUES (31, 2, 1, 'Streuobstwiese');
INSERT INTO n_untergliederung1 VALUES (31, 3, 1, 'Baumschule');
INSERT INTO n_untergliederung1 VALUES (31, 5, 1, 'Obstbaumplantage');
INSERT INTO n_untergliederung1 VALUES (31, 5, 2, 'Obststrauchplantage');
INSERT INTO n_untergliederung1 VALUES (32, 3, 1, 'Laubwald mit Nadelholz');
INSERT INTO n_untergliederung1 VALUES (32, 3, 2, 'Nadelwald mit Laubholz');
INSERT INTO n_untergliederung1 VALUES (33, 0, 1, 'Latschenkiefer');
INSERT INTO n_untergliederung1 VALUES (37, 0, 1, 'Vegetationslose Fläche');
INSERT INTO n_untergliederung1 VALUES (37, 0, 2, 'Gewässerbegleitfläche');
INSERT INTO n_untergliederung1 VALUES (37, 0, 3, 'Sukzessionsfläche');
INSERT INTO n_untergliederung1 VALUES (37, 0, 4, 'Naturnahe Fläche');
INSERT INTO n_untergliederung1 VALUES (41, 1, 1, 'Altwasser');
INSERT INTO n_untergliederung1 VALUES (41, 1, 2, 'Altarm');
INSERT INTO n_untergliederung1 VALUES (41, 1, 3, 'Flussmündungstrichter');
INSERT INTO n_untergliederung1 VALUES (41, 3, 1, 'Fleet');
INSERT INTO n_untergliederung1 VALUES (42, 0, 1, 'Sportboothafenbecken');
INSERT INTO n_untergliederung1 VALUES (43, 1, 1, 'Stausee');
INSERT INTO n_untergliederung1 VALUES (43, 1, 2, 'Baggersee');
INSERT INTO n_untergliederung1 VALUES (44, 0, 1, 'Küstengewässer');


--
-- TOC entry 22651 (class 0 OID 159585971)
-- Dependencies: 3524
-- Data for Name: n_untergliederung2; Type: TABLE DATA; Schema: alkis6; Owner: -
--

INSERT INTO n_untergliederung2 VALUES (12, 1, 0, 1, 'Gebäude- und Freifläche Industrie und Gewerbe');
INSERT INTO n_untergliederung2 VALUES (12, 1, 4, 1, 'Abraum');
INSERT INTO n_untergliederung2 VALUES (12, 1, 4, 2, 'Baustoffe');
INSERT INTO n_untergliederung2 VALUES (12, 1, 4, 3, 'Erde');
INSERT INTO n_untergliederung2 VALUES (12, 1, 4, 4, 'Kohle');
INSERT INTO n_untergliederung2 VALUES (12, 1, 4, 5, 'Öl');
INSERT INTO n_untergliederung2 VALUES (12, 1, 4, 6, 'Schlacke');
INSERT INTO n_untergliederung2 VALUES (12, 1, 4, 7, 'Schrott, Altmaterial');
INSERT INTO n_untergliederung2 VALUES (12, 1, 4, 8, 'Schutt');
INSERT INTO n_untergliederung2 VALUES (12, 3, 0, 1, 'Gebäude- und Freifläche Versorgungsanlage');
INSERT INTO n_untergliederung2 VALUES (12, 3, 0, 2, 'Betriebsfläche Versorgungsanlage');
INSERT INTO n_untergliederung2 VALUES (12, 3, 1, 1, 'Erdöl');
INSERT INTO n_untergliederung2 VALUES (12, 3, 1, 2, 'Erdgas');
INSERT INTO n_untergliederung2 VALUES (12, 3, 1, 3, 'Sole, Lauge');
INSERT INTO n_untergliederung2 VALUES (12, 3, 1, 4, 'Kohlensäure');
INSERT INTO n_untergliederung2 VALUES (12, 3, 1, 5, 'Erdwärme');
INSERT INTO n_untergliederung2 VALUES (12, 3, 2, 1, 'Gebäude- und Freifläche Versorgungsanlage, Wasser');
INSERT INTO n_untergliederung2 VALUES (12, 3, 2, 2, 'Betriebsfläche Versorgungsanlage, Wasser');
INSERT INTO n_untergliederung2 VALUES (12, 3, 3, 1, 'Gebäude- und Freifläche Versorgungsanlage, Elektrizität');
INSERT INTO n_untergliederung2 VALUES (12, 3, 3, 2, 'Betriebsfläche Versorgungsanlage, Elektrizität');
INSERT INTO n_untergliederung2 VALUES (12, 3, 5, 1, 'Gebäude- und Freifläche Versorgungsanlage, Öl');
INSERT INTO n_untergliederung2 VALUES (12, 3, 5, 2, 'Betriebsfläche Versorgungsanlage, Öl');
INSERT INTO n_untergliederung2 VALUES (12, 3, 6, 1, 'Gebäude- und Freifläche Versorgungsanlage, Gas');
INSERT INTO n_untergliederung2 VALUES (12, 3, 6, 2, 'Betriebsfläche Versorgungsanlage, Gas');
INSERT INTO n_untergliederung2 VALUES (12, 3, 7, 1, 'Gebäude- und Freifläche Versorgungsanlage, Wärme');
INSERT INTO n_untergliederung2 VALUES (12, 3, 7, 2, 'Betriebsfläche Versorgungsanlage, Wärme');
INSERT INTO n_untergliederung2 VALUES (12, 3, 8, 1, 'Gebäude- und Freifläche Versorgungsanlage, Funk- und Fernmeldewesen');
INSERT INTO n_untergliederung2 VALUES (12, 3, 8, 2, 'Betriebsfläche Versorgungsanlage, Funk- und Fernmeldewesen');
INSERT INTO n_untergliederung2 VALUES (12, 4, 0, 1, 'Gebäude- und Freifläche Entsorgungsanlage');
INSERT INTO n_untergliederung2 VALUES (12, 4, 0, 2, 'Betriebsfläche Entsorgungsanlage');
INSERT INTO n_untergliederung2 VALUES (12, 4, 1, 1, 'Gebäude- und Freifläche Entsorgungsanlage, Abwasserbeseitigung');
INSERT INTO n_untergliederung2 VALUES (12, 4, 1, 2, 'Betriebsfläche Entsorgungsanlage, Abwasserbeseitigung');
INSERT INTO n_untergliederung2 VALUES (12, 4, 2, 1, 'Gebäude- und Freifläche Entsorgungsanlage, Abfallbeseitigung');
INSERT INTO n_untergliederung2 VALUES (12, 4, 2, 2, 'Betriebsfläche Entsorgungsanlage, Abfallbeseitigung');
INSERT INTO n_untergliederung2 VALUES (12, 4, 2, 3, 'Betriebsfläche Entsorgungsanlage, Schlamm');
INSERT INTO n_untergliederung2 VALUES (13, 0, 0, 1, 'Baustoffe');
INSERT INTO n_untergliederung2 VALUES (13, 0, 0, 2, 'Kohle');
INSERT INTO n_untergliederung2 VALUES (13, 0, 0, 3, 'Erde');
INSERT INTO n_untergliederung2 VALUES (13, 0, 0, 4, 'Schutt');
INSERT INTO n_untergliederung2 VALUES (13, 0, 0, 5, 'Schlacke');
INSERT INTO n_untergliederung2 VALUES (13, 0, 0, 6, 'Abraum');
INSERT INTO n_untergliederung2 VALUES (13, 0, 0, 7, 'Schrott, Altmaterial');
INSERT INTO n_untergliederung2 VALUES (14, 0, 1, 1, 'Ton');
INSERT INTO n_untergliederung2 VALUES (14, 0, 1, 2, 'Kalk, Kalktuff, Kreide');
INSERT INTO n_untergliederung2 VALUES (14, 0, 2, 1, 'Schiefer, Dachschiefer');
INSERT INTO n_untergliederung2 VALUES (14, 0, 2, 2, 'Metamorpher Schiefer');
INSERT INTO n_untergliederung2 VALUES (14, 0, 2, 3, 'Kalkstein');
INSERT INTO n_untergliederung2 VALUES (14, 0, 2, 4, 'Dolomitstein');
INSERT INTO n_untergliederung2 VALUES (14, 0, 2, 5, 'Basalt, Diabas');
INSERT INTO n_untergliederung2 VALUES (14, 0, 2, 6, 'Talkschiefer, Speckstein');
INSERT INTO n_untergliederung2 VALUES (14, 0, 3, 1, 'Eisen');
INSERT INTO n_untergliederung2 VALUES (14, 0, 3, 2, 'Buntmetallerze');
INSERT INTO n_untergliederung2 VALUES (14, 0, 3, 3, 'Kupfer');
INSERT INTO n_untergliederung2 VALUES (14, 0, 3, 4, 'Blei');
INSERT INTO n_untergliederung2 VALUES (14, 0, 3, 5, 'Zink');
INSERT INTO n_untergliederung2 VALUES (14, 0, 3, 6, 'Zinn');
INSERT INTO n_untergliederung2 VALUES (14, 0, 3, 7, 'Wismut, Kobalt, Nickel');
INSERT INTO n_untergliederung2 VALUES (14, 0, 3, 8, 'Uran');
INSERT INTO n_untergliederung2 VALUES (14, 0, 3, 9, 'Mangan');
INSERT INTO n_untergliederung2 VALUES (14, 0, 4, 1, 'Antimon');
INSERT INTO n_untergliederung2 VALUES (14, 0, 4, 2, 'Edelmetallerze');
INSERT INTO n_untergliederung2 VALUES (14, 0, 5, 1, 'Kohle');
INSERT INTO n_untergliederung2 VALUES (14, 0, 5, 2, 'Braunkohle');
INSERT INTO n_untergliederung2 VALUES (14, 0, 5, 3, 'Steinkohle');
INSERT INTO n_untergliederung2 VALUES (14, 0, 5, 4, 'Ölschiefer');
INSERT INTO n_untergliederung2 VALUES (14, 0, 6, 1, 'Gipsstein');
INSERT INTO n_untergliederung2 VALUES (14, 0, 6, 2, 'Anhydritstein');
INSERT INTO n_untergliederung2 VALUES (14, 0, 6, 3, 'Steinsalz');
INSERT INTO n_untergliederung2 VALUES (14, 0, 6, 4, 'Kalisalz');
INSERT INTO n_untergliederung2 VALUES (14, 0, 6, 5, 'Kalkspat');
INSERT INTO n_untergliederung2 VALUES (14, 0, 6, 6, 'Flussspat');
INSERT INTO n_untergliederung2 VALUES (14, 0, 6, 7, 'Schwerspat');
INSERT INTO n_untergliederung2 VALUES (14, 0, 6, 8, 'Graphit');
INSERT INTO n_untergliederung2 VALUES (15, 0, 1, 1, 'Ton');
INSERT INTO n_untergliederung2 VALUES (15, 0, 1, 2, 'Bentonit');
INSERT INTO n_untergliederung2 VALUES (15, 0, 1, 3, 'Kaolin');
INSERT INTO n_untergliederung2 VALUES (15, 0, 1, 4, 'Lehm');
INSERT INTO n_untergliederung2 VALUES (15, 0, 1, 5, 'Löß, Lößlehm');
INSERT INTO n_untergliederung2 VALUES (15, 0, 1, 6, 'Mergel');
INSERT INTO n_untergliederung2 VALUES (15, 0, 1, 7, 'Kalk, Kalktuff, Kreide');
INSERT INTO n_untergliederung2 VALUES (15, 0, 1, 8, 'Sand');
INSERT INTO n_untergliederung2 VALUES (15, 0, 1, 9, 'Kies, Kiessand');
INSERT INTO n_untergliederung2 VALUES (15, 0, 2, 1, 'Farberden');
INSERT INTO n_untergliederung2 VALUES (15, 0, 2, 2, 'Quarzsand');
INSERT INTO n_untergliederung2 VALUES (15, 0, 2, 3, 'Kieselerde');
INSERT INTO n_untergliederung2 VALUES (15, 0, 3, 1, 'Tonstein');
INSERT INTO n_untergliederung2 VALUES (15, 0, 3, 2, 'Schiefer, Dachschiefer');
INSERT INTO n_untergliederung2 VALUES (15, 0, 3, 3, 'Metamorpher Schiefer');
INSERT INTO n_untergliederung2 VALUES (15, 0, 3, 4, 'Mergelstein');
INSERT INTO n_untergliederung2 VALUES (15, 0, 3, 5, 'Kalkstein');
INSERT INTO n_untergliederung2 VALUES (15, 0, 3, 6, 'Dolomitstein');
INSERT INTO n_untergliederung2 VALUES (15, 0, 3, 7, 'Travertin');
INSERT INTO n_untergliederung2 VALUES (15, 0, 3, 8, 'Marmor');
INSERT INTO n_untergliederung2 VALUES (15, 0, 3, 9, 'Sandstein');
INSERT INTO n_untergliederung2 VALUES (15, 0, 4, 1, 'Grauwacke');
INSERT INTO n_untergliederung2 VALUES (15, 0, 4, 2, 'Quarzit');
INSERT INTO n_untergliederung2 VALUES (15, 0, 4, 3, 'Gneis');
INSERT INTO n_untergliederung2 VALUES (15, 0, 4, 4, 'Basalt, Diabas ');
INSERT INTO n_untergliederung2 VALUES (15, 0, 4, 5, 'Andesit');
INSERT INTO n_untergliederung2 VALUES (15, 0, 4, 6, 'Porphyr, Quarzporphyr');
INSERT INTO n_untergliederung2 VALUES (15, 0, 4, 7, 'Granit');
INSERT INTO n_untergliederung2 VALUES (15, 0, 4, 8, 'Granodiorit');
INSERT INTO n_untergliederung2 VALUES (15, 0, 4, 9, 'Tuff-, Bimsstein');
INSERT INTO n_untergliederung2 VALUES (15, 0, 5, 1, 'Trass');
INSERT INTO n_untergliederung2 VALUES (15, 0, 5, 2, 'Lavaschlacke');
INSERT INTO n_untergliederung2 VALUES (15, 0, 5, 3, 'Talkschiefer, Speckstein');
INSERT INTO n_untergliederung2 VALUES (15, 0, 6, 1, 'Torf');
INSERT INTO n_untergliederung2 VALUES (15, 0, 6, 2, 'Kohle');
INSERT INTO n_untergliederung2 VALUES (15, 0, 6, 3, 'Braunkohle');
INSERT INTO n_untergliederung2 VALUES (15, 0, 6, 4, 'Steinkohle');
INSERT INTO n_untergliederung2 VALUES (15, 0, 6, 5, 'Ölschiefer');
INSERT INTO n_untergliederung2 VALUES (15, 0, 7, 1, 'Gipsstein');
INSERT INTO n_untergliederung2 VALUES (15, 0, 7, 2, 'Anhydritstein');
INSERT INTO n_untergliederung2 VALUES (15, 0, 7, 3, 'Kalkspat');
INSERT INTO n_untergliederung2 VALUES (15, 0, 7, 4, 'Schwerspat');
INSERT INTO n_untergliederung2 VALUES (15, 0, 7, 5, 'Quarz');
INSERT INTO n_untergliederung2 VALUES (15, 0, 7, 6, 'Feldspat');
INSERT INTO n_untergliederung2 VALUES (15, 0, 7, 7, 'Pegmatitsand');
INSERT INTO n_untergliederung2 VALUES (16, 2, 1, 1, 'Wohnen');
INSERT INTO n_untergliederung2 VALUES (16, 2, 1, 2, 'Betrieb');
INSERT INTO n_untergliederung2 VALUES (18, 0, 0, 1, 'Gebäude- und Freifläche Sport, Freizeit und Erholung');
INSERT INTO n_untergliederung2 VALUES (18, 1, 0, 1, 'Gebäude- und Freifläche Erholung, Sport');
INSERT INTO n_untergliederung2 VALUES (18, 2, 1, 1, 'Gebäude- und Freifläche Erholung, Zoologie');
INSERT INTO n_untergliederung2 VALUES (18, 3, 0, 1, 'Gebäude- und Freifläche Erholung');
INSERT INTO n_untergliederung2 VALUES (18, 3, 2, 1, 'Gebäude- und Freifläche Erholung, Bad');
INSERT INTO n_untergliederung2 VALUES (18, 3, 3, 1, 'Gebäude- und Freifläche Erholung, Camping');
INSERT INTO n_untergliederung2 VALUES (18, 4, 3, 1, 'Gebäude- und Freifläche Erholung, Botanik');
INSERT INTO n_untergliederung2 VALUES (19, 0, 0, 1, 'Gebäude- und Freifläche Friedhof');
INSERT INTO n_untergliederung2 VALUES (19, 0, 0, 2, 'Friedhof (ohne Gebäude)');
INSERT INTO n_untergliederung2 VALUES (21, 0, 0, 1, 'Gebäude- und Freifläche zu Verkehrsanlagen, Straße');
INSERT INTO n_untergliederung2 VALUES (21, 0, 0, 2, 'Verkehrsbegleitfläche Straße');
INSERT INTO n_untergliederung2 VALUES (21, 0, 0, 3, 'Straßenentwässerungsanlage');
INSERT INTO n_untergliederung2 VALUES (22, 0, 1, 1, 'Hauptwirtschaftsweg');
INSERT INTO n_untergliederung2 VALUES (22, 0, 1, 2, 'Wirtschaftsweg');
INSERT INTO n_untergliederung2 VALUES (24, 0, 0, 1, 'Gebäude- und Freifläche zu Verkehrsanlagen, Schiene');
INSERT INTO n_untergliederung2 VALUES (24, 0, 0, 2, 'Verkehrsbegleitfläche Bahnverkehr');
INSERT INTO n_untergliederung2 VALUES (24, 0, 1, 1, 'Güterverkehr');
INSERT INTO n_untergliederung2 VALUES (24, 0, 1, 2, 'S-Bahn');
INSERT INTO n_untergliederung2 VALUES (24, 0, 1, 3, 'Museumsbahn');
INSERT INTO n_untergliederung2 VALUES (24, 0, 1, 4, 'Bahn im Freizeitpark');
INSERT INTO n_untergliederung2 VALUES (24, 0, 2, 1, 'Straßenbahn');
INSERT INTO n_untergliederung2 VALUES (24, 0, 2, 2, 'U-Bahn');
INSERT INTO n_untergliederung2 VALUES (24, 0, 3, 1, 'Zahnradbahn');
INSERT INTO n_untergliederung2 VALUES (24, 0, 3, 2, 'Standseilbahn');
INSERT INTO n_untergliederung2 VALUES (25, 0, 0, 1, 'Gebäude- und Freifläche zu Verkehrsanlagen, Luftfahrt');
INSERT INTO n_untergliederung2 VALUES (25, 0, 1, 1, 'Internationaler Flughafen');
INSERT INTO n_untergliederung2 VALUES (25, 0, 1, 2, 'Regionalflughafen');
INSERT INTO n_untergliederung2 VALUES (26, 0, 0, 1, 'Gebäude- und Freifläche zu Verkehrsanlagen, Schifffahrt');
INSERT INTO n_untergliederung2 VALUES (37, 0, 1, 1, 'Fels');
INSERT INTO n_untergliederung2 VALUES (37, 0, 1, 2, 'Steine, Schotter');
INSERT INTO n_untergliederung2 VALUES (37, 0, 1, 3, 'Geröll');
INSERT INTO n_untergliederung2 VALUES (37, 0, 1, 4, 'Sand');
INSERT INTO n_untergliederung2 VALUES (37, 0, 1, 5, 'Schnee');
INSERT INTO n_untergliederung2 VALUES (37, 0, 1, 6, 'Eis, Firn');
INSERT INTO n_untergliederung2 VALUES (37, 0, 2, 1, 'Bebaute Gewässerbegleitfläche');
INSERT INTO n_untergliederung2 VALUES (37, 0, 2, 2, 'Unbebaute Gewässerbegleitfläche');
INSERT INTO n_untergliederung2 VALUES (43, 1, 1, 1, 'Speicherbecken');
INSERT INTO n_untergliederung2 VALUES (12, 1, 4, 0, 'Sonstiges');
INSERT INTO n_untergliederung2 VALUES (13, 0, 0, 0, 'Sonstiges');
INSERT INTO n_untergliederung2 VALUES (15, 0, 0, 0, 'Sonstiges');
INSERT INTO n_untergliederung2 VALUES (18, 0, 0, 0, 'Sonstiges');
INSERT INTO n_untergliederung2 VALUES (22, 0, 0, 0, 'Sonstiges');
INSERT INTO n_untergliederung2 VALUES (43, 0, 0, 0, 'Soll');


--
-- TOC entry 22119 (class 2606 OID 159585839)
-- Name: n_untergliederung1_pk; Type: CONSTRAINT; Schema: alkis6; Owner: -
--

ALTER TABLE ONLY n_untergliederung1
    ADD CONSTRAINT n_untergliederung1_pk PRIMARY KEY (nutzungsartengruppe, nutzungsart, schluessel);


--
-- TOC entry 22121 (class 2606 OID 159585975)
-- Name: n_untergliederung2_pk; Type: CONSTRAINT; Schema: alkis6; Owner: -
--

ALTER TABLE ONLY n_untergliederung2
    ADD CONSTRAINT n_untergliederung2_pk PRIMARY KEY (nutzungsartengruppe, nutzungsart, untergliederung1, schluessel);




-- Tabellen für Adressänderungsfunktionalität

CREATE TABLE alkis.ax_person_temp(											-- am 03.06.2015 hinzugefügt
  gml_id character varying(16) NOT NULL,								-- am 03.06.2015 hinzugefügt
  hat character varying NOT NULL,												-- am 03.06.2015 hinzugefügt
	datum timestamp without time zone,										-- am 03.06.2015 hinzugefügt
	user_id integer,																			-- am 03.06.2015 hinzugefügt
  CONSTRAINT ax_person_temp_pk PRIMARY KEY (gml_id)			-- am 03.06.2015 hinzugefügt
);																							-- am 03.06.2015 hinzugefügt

CREATE SEQUENCE alkis.ax_anschrift_temp_seq
  INCREMENT 1
  MINVALUE 1
  MAXVALUE 9223372036854775807
  START 1
  CACHE 1;

CREATE TABLE alkis.ax_anschrift_temp(
  gml_id character varying(16) NOT NULL DEFAULT ('DE_'::text || lpad((nextval(('alkis.ax_anschrift_temp_seq'::text)::regclass))::text, 13, '0'::text)),			-- am 08.06.2015 geändert
  ort_post character varying NOT NULL,
  postleitzahlpostzustellung character varying NOT NULL,
  strasse character varying NOT NULL,
  hausnummer character varying NOT NULL,
	ortsteil character varying,						-- am 02.06.2015 hinzugefügt
	datum timestamp without time zone,
	user_id integer,
  CONSTRAINT ax_anschrift_temp_pk PRIMARY KEY (gml_id)
);




-- Views

CREATE VIEW alkis.strassen AS 
 SELECT p.ogc_fid,
    l.gml_id,
    COALESCE(p.schriftinhalt, k.bezeichnung) AS schriftinhalt,
    p.art,
    p.horizontaleausrichtung AS hor,
    p.vertikaleausrichtung AS ver,
    (p.drehwinkel * (57.296)::double precision) AS winkel,
    p.wkb_geometry
   FROM ((alkis.ap_pto p
     JOIN alkis.ax_lagebezeichnungohnehausnummer l ON ((l.gml_id = ANY (p.dientzurdarstellungvon))))
     JOIN alkis.ax_lagebezeichnungkatalogeintrag k ON (((((l.kreis)::text = (k.kreis)::text) AND ((l.gemeinde)::text = (k.gemeinde)::text)) AND ((l.lage)::text = (k.lage)::text))))
  WHERE (((p.endet IS NULL) AND (l.endet IS NULL)) AND (k.endet IS NULL));
CREATE VIEW alkis.s_zugehoerigkeitshaken_flurstueck AS 
 SELECT p.ogc_fid,
    p.beginnt,
    p.endet,
    p.wkb_geometry,
    (p.drehwinkel * (57.296)::double precision) AS drehwinkel,
    f.flurstueckskennzeichen,
    f.abweichenderrechtszustand
   FROM (alkis.ap_ppo p
     JOIN alkis.ax_flurstueck f ON ((f.gml_id = ANY (p.dientzurdarstellungvon))))
  WHERE ((p.art)::text = 'Haken'::text);
CREATE VIEW alkis.s_zuordungspfeil_flurstueck AS 
 SELECT l.ogc_fid,
    l.beginnt,
    l.endet,
    f.abweichenderrechtszustand,
    l.wkb_geometry
   FROM (alkis.ap_lpo l
     JOIN alkis.ax_flurstueck f ON ((f.gml_id = ANY (l.dientzurdarstellungvon))))
  WHERE (((l.art)::text = 'Pfeil'::text) AND ('DKKM1000'::text ~~ ANY ((l.advstandardmodell)::text[])));
CREATE VIEW alkis.s_hausnummer_gebaeude AS 
 SELECT p.ogc_fid,
    p.beginnt,
    p.endet,
    l.hausnummer,
    (p.drehwinkel * (57.296)::double precision) AS drehwinkel,
    p.wkb_geometry
   FROM (alkis.ap_pto p
     JOIN alkis.ax_lagebezeichnungmithausnummer l ON (((l.gml_id = ANY (p.dientzurdarstellungvon)) AND (l.endet IS NULL))))
  WHERE ((p.art)::text = 'HNR'::text);
	
CREATE OR REPLACE VIEW alkis.lk_grenzpunkte
 AS
 SELECT o.ogc_fid,
    o.gml_id,
    o.punktkennung,
    ltrim(to_char("substring"(o.punktkennung::text, 1, 9)::integer, '999 99 99 99'::text), ' '::text) AS nbz,
    ltrim("substring"(o.punktkennung::text, 10, 6), '0'::text) AS pnr,
    o.beginnt AS o_beginnt,
    o.endet AS o_endet,
    d.bezeichnung AS zustaendige_stelle,
    o.zustaendigestelle_stelle,
    o.zeitpunktderentstehung,
        CASE
            WHEN o.festgestelltergrenzpunkt::text = 'true'::text THEN 'Ja'::text
            ELSE 'Nein'::text
        END AS festgestelltergrenzpunkt,
    da.bezeichnung AS ausgesetzteabmarkung_stelle,
    l.beschreibung AS verm_bedeutung,
    o.abmarkung_marke,
    ba.beschreibung AS bemerkung_zurabmarkung,
    o.bemerkungzurabmarkung,
    o.zeigtauf,
    array_to_string(o.sonstigeeigenschaft, ', '::text) AS sonstigeeigenschaft,
    o.relativehoehe,
    o.besonderepunktnummer,
    o.zeigtaufexternes_art AS o_zeigtaufexternes_art,
    o.zeigtaufexternes_name AS o_zeigtaufexternes_name,
    o.zeigtaufexternes_uri AS o_zeigtaufexternes_uri,
    p.gml_id AS ax_punktortta_gml_id,
    p.beginnt AS p_beginnt,
    p.endet AS p_endet,
    "substring"(st_astext(p.wkb_geometry), '\((.*)\)'::text) AS "position",
    ks.beschreibung AS koordinatenstatus_beschreibung,
    p.koordinatenstatus,
    m.beschreibung AS punktgenauigkeit,
    p.genauigkeitsstufe,
    n.beschreibung AS punktvertrauenswuerdigkeit,
    p.vertrauenswuerdigkeit,
    e.beschreibung AS datenerhebung,
    array_to_string(p.processstep_ax_datenerhebung_punktort, ','::text) AS source_description,
    p.zeigtaufexternes_art AS p_zeigtaufexternes_art,
    p.zeigtaufexternes_name AS p_zeigtaufexternes_name,
    p.zeigtaufexternes_uri AS p_zeigtaufexternes_uri,
    ( SELECT string_agg(concat(COALESCE(u.beschreibung, 'Erhebung'::character varying), ': ', to_char(u.zeitpunkt, 'DD.MM.YYYY'::text)), ', '::text) AS string_agg
           FROM UNNEST(p.processstep_ax_li_processstep_punktort_description, p.processstep_datetime) u(beschreibung, zeitpunkt)
          WHERE u.zeitpunkt IS NOT NULL) AS erhebung_berechnung,
        CASE
            WHEN p.lagezuverlaessigkeit::text = 'true'::text THEN 'Ja'::text
            ELSE 'Nein'::text
        END AS lagezuverlaessigkeit,
    p.ueberpruefungsdatum,
    p.hinweise,
        CASE
            WHEN p.kartendarstellung::text = 'true'::text THEN 'Ja'::text
            ELSE 'Nein'::text
        END AS kartendarstellung,
    p.wkb_geometry
   FROM alkis.ax_grenzpunkt o
     JOIN alkis.ax_punktortta p ON o.gml_id = ANY (p.istteilvon)
     JOIN alkis.ax_marke l ON l.wert = o.abmarkung_marke
     LEFT JOIN alkis.ax_genauigkeitsstufe_punktort m ON m.wert = p.genauigkeitsstufe
     LEFT JOIN alkis.ax_vertrauenswuerdigkeit_punktort n ON n.wert = p.vertrauenswuerdigkeit
     LEFT JOIN alkis.ax_bemerkungzurabmarkung_grenzpunkt ba ON o.bemerkungzurabmarkung = ba.wert
     LEFT JOIN alkis.ax_datenerhebung_punktort e ON e.wert = ANY (p.processstep_ax_datenerhebung_punktort::integer[])
     LEFT JOIN alkis.ax_dienststelle d ON o.zustaendigestelle_land::text = d.land::text AND o.zustaendigestelle_stelle::text = d.stelle::text
     LEFT JOIN alkis.ax_dienststelle da ON o.zustaendigestelle_land::text = da.land::text AND o.ausgesetzteabmarkung_stelle::text = da.stelle::text
     LEFT JOIN alkis.ax_koordinatenstatus_punktort ks ON p.koordinatenstatus = ks.wert
  WHERE d.endet IS NULL AND da.endet IS NULL;

CREATE VIEW alkis.lk_so_punkte AS 
 SELECT o.ogc_fid,
    o.beginnt,
    o.endet,
    o.punktkennung,
    o.sonstigeeigenschaft,
    o.vermarkung_marke,
    l.beschreibung AS verm_bedeutung,
    p.genauigkeitsstufe,
    m.beschreibung AS punktgenauigkeit,
    p.vertrauenswuerdigkeit,
    n.beschreibung AS bedeutung,
    st_astext(p.wkb_geometry) AS koord,
    p.wkb_geometry
   FROM ((((alkis.ax_sonstigervermessungspunkt o
     JOIN alkis.ax_punktortau p ON ((o.gml_id = ANY (p.istteilvon))))
     JOIN alkis.ax_marke l ON ((l.wert = o.vermarkung_marke)))
     LEFT JOIN alkis.ax_genauigkeitsstufe_punktort m ON ((m.wert = p.genauigkeitsstufe)))
     LEFT JOIN alkis.ax_vertrauenswuerdigkeit_punktort n ON ((n.wert = p.vertrauenswuerdigkeit)));

CREATE OR REPLACE VIEW alkis.lk_sp
 AS
 SELECT o.ogc_fid,
    o.gml_id,
    o.punktkennung,
    ltrim(to_char("substring"(o.punktkennung::text, 1, 9)::integer, '999 99 99 99'::text), ' '::text) AS nbz,
    ltrim("substring"(o.punktkennung::text, 10, 6), '0'::text) AS pnr,
    o.beginnt AS o_beginnt,
    o.endet AS o_endet,
    d.bezeichnung AS zustaendige_stelle,
    o.zustaendigestelle_stelle,
    l.beschreibung AS verm_bedeutung,
    o.vermarkung_marke,
    ap.gml_id AS ap_gml_id,
    array_to_string(o.sonstigeeigenschaft, ', '::text) AS sonstigeeigenschaft,
    o.relativehoehe,
    o.zeigtaufexternes_art AS o_zeigtaufexternes_art,
    o.zeigtaufexternes_name AS o_zeigtaufexternes_name,
    o.zeigtaufexternes_uri AS o_zeigtaufexternes_uri,
    p.gml_id AS ax_punktortta_gml_id,
    p.beginnt AS p_beginnt,
    p.endet AS p_endet,
    "substring"(st_astext(p.wkb_geometry), '\((.*)\)'::text) AS "position",
    ks.beschreibung AS koordinatenstatus_beschreibung,
    p.koordinatenstatus,
    m.beschreibung AS punktgenauigkeit,
    p.genauigkeitsstufe,
    n.beschreibung AS punktvertrauenswuerdigkeit,
    p.vertrauenswuerdigkeit,
    e.beschreibung AS datenerhebung,
    array_to_string(p.processstep_ax_datenerhebung_punktort, ','::text) AS source_description,
    p.zeigtaufexternes_art AS p_zeigtaufexternes_art,
    p.zeigtaufexternes_name AS p_zeigtaufexternes_name,
    p.zeigtaufexternes_uri AS p_zeigtaufexternes_uri,
    ( SELECT string_agg(concat(COALESCE(u.beschreibung, 'Erhebung'::character varying), ': ', to_char(u.zeitpunkt, 'DD.MM.YYYY'::text)), ', '::text) AS string_agg
           FROM UNNEST(p.processstep_ax_li_processstep_punktort_description, p.processstep_datetime) u(beschreibung, zeitpunkt)
          WHERE u.zeitpunkt IS NOT NULL) AS erhebung_berechnung,
        CASE
            WHEN p.lagezuverlaessigkeit::text = 'true'::text THEN 'Ja'::text
            ELSE 'Nein'::text
        END AS lagezuverlaessigkeit,
    p.ueberpruefungsdatum,
    p.hinweise,
        CASE
            WHEN p.kartendarstellung::text = 'true'::text THEN 'Ja'::text
            ELSE 'Nein'::text
        END AS kartendarstellung,
    p.wkb_geometry
   FROM alkis.ax_sicherungspunkt o
     JOIN alkis.ax_punktortau p ON o.gml_id = ANY (p.istteilvon)
     JOIN alkis.ax_marke l ON l.wert = o.vermarkung_marke
     LEFT JOIN alkis.ax_genauigkeitsstufe_punktort m ON m.wert = p.genauigkeitsstufe
     LEFT JOIN alkis.ax_vertrauenswuerdigkeit_punktort n ON n.wert = p.vertrauenswuerdigkeit
     LEFT JOIN alkis.ax_datenerhebung_punktort e ON e.wert = ANY (p.processstep_ax_datenerhebung_punktort::integer[])
     LEFT JOIN alkis.ax_dienststelle d ON o.zustaendigestelle_land::text = d.land::text AND o.zustaendigestelle_stelle::text = d.stelle::text
     LEFT JOIN alkis.ax_koordinatenstatus_punktort ks ON p.koordinatenstatus = ks.wert
     LEFT JOIN alkis.ax_aufnahmepunkt ap ON o.gml_id = ANY (ap.hat)
  WHERE d.endet IS NULL;
	
CREATE OR REPLACE VIEW alkis.lk_ap
 AS
 SELECT o.ogc_fid,
    o.gml_id,
    o.punktkennung,
    ltrim(to_char("substring"(o.punktkennung::text, 1, 9)::integer, '999 99 99 99'::text), ' '::text) AS nbz,
    ltrim("substring"(o.punktkennung::text, 10, 6), '0'::text) AS pnr,
    o.beginnt AS o_beginnt,
    o.endet AS o_endet,
    d.bezeichnung AS zustaendige_stelle,
    o.zustaendigestelle_stelle,
    l.beschreibung AS verm_bedeutung,
    o.vermarkung_marke,
    o.hat,
    array_to_string(o.sonstigeeigenschaft, ', '::text) AS sonstigeeigenschaft,
    o.relativehoehe,
    o.zeigtaufexternes_art AS o_zeigtaufexternes_art,
    o.zeigtaufexternes_name AS o_zeigtaufexternes_name,
    o.zeigtaufexternes_uri AS o_zeigtaufexternes_uri,
    p.gml_id AS ax_punktortta_gml_id,
    p.beginnt AS p_beginnt,
    p.endet AS p_endet,
    "substring"(st_astext(p.wkb_geometry), '\((.*)\)'::text) AS "position",
    ks.beschreibung AS koordinatenstatus_beschreibung,
    p.koordinatenstatus,
    m.beschreibung AS punktgenauigkeit,
    p.genauigkeitsstufe,
    n.beschreibung AS punktvertrauenswuerdigkeit,
    p.vertrauenswuerdigkeit,
    e.beschreibung AS datenerhebung,
    array_to_string(p.processstep_ax_datenerhebung_punktort, ','::text) AS source_description,
    p.zeigtaufexternes_art AS p_zeigtaufexternes_art,
    p.zeigtaufexternes_name AS p_zeigtaufexternes_name,
    p.zeigtaufexternes_uri AS p_zeigtaufexternes_uri,
    ( SELECT string_agg(concat(COALESCE(u.beschreibung, 'Erhebung'::character varying), ': ', to_char(u.zeitpunkt, 'DD.MM.YYYY'::text)), ', '::text) AS string_agg
           FROM UNNEST(p.processstep_ax_li_processstep_punktort_description, p.processstep_datetime) u(beschreibung, zeitpunkt)
          WHERE u.zeitpunkt IS NOT NULL) AS erhebung_berechnung,
        CASE
            WHEN p.lagezuverlaessigkeit::text = 'true'::text THEN 'Ja'::text
            ELSE 'Nein'::text
        END AS lagezuverlaessigkeit,
    p.ueberpruefungsdatum,
    p.hinweise,
        CASE
            WHEN p.kartendarstellung::text = 'true'::text THEN 'Ja'::text
            ELSE 'Nein'::text
        END AS kartendarstellung,
    p.wkb_geometry
   FROM alkis.ax_aufnahmepunkt o
     JOIN alkis.ax_punktortau p ON o.gml_id = ANY (p.istteilvon)
     JOIN alkis.ax_marke l ON l.wert = o.vermarkung_marke
     LEFT JOIN alkis.ax_genauigkeitsstufe_punktort m ON m.wert = p.genauigkeitsstufe
     LEFT JOIN alkis.ax_vertrauenswuerdigkeit_punktort n ON n.wert = p.vertrauenswuerdigkeit
     LEFT JOIN alkis.ax_datenerhebung_punktort e ON e.wert = ANY (p.processstep_ax_datenerhebung_punktort::integer[])
     LEFT JOIN alkis.ax_dienststelle d ON o.zustaendigestelle_land::text = d.land::text AND o.zustaendigestelle_stelle::text = d.stelle::text
     LEFT JOIN alkis.ax_koordinatenstatus_punktort ks ON p.koordinatenstatus = ks.wert
  WHERE d.endet IS NULL;

CREATE OR REPLACE VIEW alkis.lk_gebaeudepunkte
 AS
 SELECT o.ogc_fid,
    o.gml_id,
    o.punktkennung,
    ltrim(to_char("substring"(o.punktkennung::text, 1, 9)::integer, '999 99 99 99'::text), ' '::text) AS nbz,
    ltrim("substring"(o.punktkennung::text, 10, 6), '0'::text) AS pnr,
    o.beginnt AS o_beginnt,
    o.endet AS o_endet,
    d.bezeichnung AS zustaendige_stelle,
    o.zustaendigestelle_stelle,
    o.zeigtaufexternes_art,
    o.zeigtaufexternes_name,
    o.zeigtaufexternes_uri,
    o.sonstigeeigenschaft,
    p.gml_id AS ax_punktortag_gml_id,
    p.beginnt AS p_beginnt,
    p.endet AS p_endet,
    "substring"(st_astext(p.wkb_geometry), '\((.*)\)'::text) AS "position",
    ks.beschreibung AS koordinatenstatus_beschreibung,
    p.koordinatenstatus,
    m.beschreibung AS punktgenauigkeit,
    p.genauigkeitsstufe,
    n.beschreibung AS punktvertrauenswuerdigkeit,
    p.vertrauenswuerdigkeit,
    e.beschreibung AS datenerhebung,
    array_to_string(p.processstep_ax_datenerhebung_punktort, ','::text) AS source_description,
    p.zeigtaufexternes_art AS p_zeigtaufexternes_art,
    p.zeigtaufexternes_name AS p_zeigtaufexternes_name,
    p.zeigtaufexternes_uri AS p_zeigtaufexternes_uri,
    ( SELECT string_agg(concat(COALESCE(u.beschreibung, 'Erhebung'::character varying), ': ', to_char(u.zeitpunkt, 'DD.MM.YYYY'::text)), ', '::text) AS string_agg
           FROM UNNEST(p.processstep_ax_li_processstep_punktort_description, p.processstep_datetime) u(beschreibung, zeitpunkt)
          WHERE u.zeitpunkt IS NOT NULL) AS erhebung_berechnung,
        CASE
            WHEN p.lagezuverlaessigkeit::text = 'true'::text THEN 'Ja'::text
            ELSE 'Nein'::text
        END AS lagezuverlaessigkeit,
    p.ueberpruefungsdatum,
    p.hinweise,
        CASE
            WHEN p.kartendarstellung::text = 'true'::text THEN 'Ja'::text
            ELSE 'Nein'::text
        END AS kartendarstellung,
    p.wkb_geometry
   FROM alkis.ax_besonderergebaeudepunkt o
     JOIN alkis.ax_punktortag p ON o.gml_id = ANY (p.istteilvon)
     LEFT JOIN alkis.ax_genauigkeitsstufe_punktort m ON m.wert = p.genauigkeitsstufe
     LEFT JOIN alkis.ax_vertrauenswuerdigkeit_punktort n ON n.wert = p.vertrauenswuerdigkeit
     LEFT JOIN alkis.ax_datenerhebung_punktort e ON e.wert = ANY (p.processstep_ax_datenerhebung_punktort::integer[])
     LEFT JOIN alkis.ax_dienststelle d ON o.zustaendigestelle_land::text = d.land::text AND o.zustaendigestelle_stelle::text = d.stelle::text
     LEFT JOIN alkis.ax_koordinatenstatus_punktort ks ON p.koordinatenstatus = ks.wert
  WHERE d.endet IS NULL;

CREATE OR REPLACE VIEW alkis.lk_gebaeude
 AS
 SELECT o.ogc_fid,
    o.gml_id,
    o.beginnt,
    o.endet,
    o.gebaeudefunktion,
    p.beschreibung AS bezeichner,
    w.wert AS weiterefunktion,
    o.name,
    o.zustand,
    z.beschreibung AS gebaeudezustand,
    o.hoehe,
    o.lagezurerdoberflaeche,
    o.dachform,
    d.beschreibung AS dach_bezeichner,
    o.hochhaus,
    o.herkunft_source_source_ax_datenerhebung[1] AS ax_datenerhebung,
    da.beschreibung AS herkunft,
    o.wkb_geometry
   FROM alkis.ax_gebaeude o
     LEFT JOIN alkis.ax_gebaeudefunktion p ON p.wert = o.gebaeudefunktion
     LEFT JOIN alkis.ax_dachform d ON d.wert = o.dachform
     LEFT JOIN alkis.ax_zustand_gebaeude z ON z.wert = o.zustand
     LEFT JOIN alkis.ax_weitere_gebaeudefunktion w ON w.wert = ANY (o.weiteregebaeudefunktion)
     LEFT JOIN alkis.ax_datenerhebung da ON da.wert = o.herkunft_source_source_ax_datenerhebung[1]::integer;

CREATE VIEW alkis.lk_grabloch AS 
 SELECT gr.ogc_fid,
    gr.gml_id,
    gr.gml_id AS identifier,
    gr.beginnt,
    gr.endet,
    gr.advstandardmodell,
    gr.anlass,
    gr.zeigtaufexternes_art AS art,
    gr.zeigtaufexternes_name AS name,
    gr.bedeutung,
    be.beschreibung,
    gr.ingemarkung_land,
    gr.ingemarkung_gemarkungsnummer,
    gr.nummerdesgrablochs,
    gr.wkb_geometry AS the_geom
   FROM alkis.ax_grablochderbodenschaetzung gr,
    alkis.ax_bedeutung_grablochderbodenschaetzung be
  WHERE (be.wert = ANY (gr.bedeutung));
CREATE VIEW alkis.lk_muster_vergleichsstueck AS 
 SELECT mu.ogc_fid,
    mu.gml_id,
    mu.gml_id AS identifier,
    mu.beginnt,
    mu.endet,
    mu.advstandardmodell,
    mu.anlass,
    mu.merkmal,
    me.beschreibung AS gruppe,
    mu.nummer,
    mu.nutzungsart,
    ku.beschreibung AS kultur,
    mu.bodenart,
    art.beschreibung,
    mu.zustandsstufe,
    mu.bodenstufe,
    z.beschreibung AS zustandsstufe_beschreibung,
    bs.beschreibung AS bodenstufe_beschreibung,
    mu.entstehungsart,
    mu.klimastufe,
    mu.wasserverhaeltnisse,
    e1.beschreibung AS entstehungsart_beschreibung,
    e2.beschreibung AS klimastufe_beschreibung,
    e3.beschreibung AS wasserverhaeltnisse_beschreibung,
    mu.bodenzahlodergruenlandgrundzahl,
    mu.ackerzahlodergruenlandzahl,
    mu.wkb_geometry AS the_geom
   FROM (((((alkis.ax_musterundvergleichsstueck mu
     LEFT JOIN alkis.ax_merkmal_musterundvergleichsstueck me ON ((mu.merkmal = me.wert)))
     LEFT JOIN alkis.ax_bodenart_bodenschaetzung art ON ((mu.bodenart = art.wert)))
     LEFT JOIN alkis.ax_nutzungsart_bodenschaetzung ku ON ((mu.nutzungsart = ku.wert)))
     LEFT JOIN alkis.ax_zustandsstufe z ON z.wert = mu.zustandsstufe
     LEFT JOIN alkis.ax_bodenstufe bs ON bs.wert = mu.bodenstufe 
     )
     LEFT JOIN alkis.ax_entstehungsart e1 ON e1.wert = mu.entstehungsart 
     LEFT JOIN alkis.ax_klimastufe e2 ON e2.wert = mu.klimastufe
     LEFT JOIN alkis.ax_wasserverhaeltnisse e3 ON e3.wert = mu.wasserverhaeltnisse

     );
CREATE VIEW alkis.lk_nutzungen AS 
 SELECT n.gid,
    n.gml_id,
    n.beginnt,
    n.endet,
    n.werteart1,
    n.werteart2,
    n.info,
        CASE
            WHEN (n.info = 1000) THEN 'Art der Bebauung - Offen'::text
            WHEN (n.info = 2000) THEN 'Art der Bebauung - Geschlossen'::text
            ELSE NULL::text
        END AS info_bezeichner,
    n.zustand,
    n.name,
    n.bezeichnung,
    ((((nas.nutzungsartengruppe)::text || (nas.nutzungsart)::text) || (nas.untergliederung1)::text) || (nas.untergliederung2)::text) AS nutzungsartschluessel,
    nag.bereich,
    nag.gruppe AS nutzungsartengruppe,
    na.nutzungsart,
    nu1.untergliederung1,
    nu2.untergliederung2,
    nas.nutzungsartengruppe AS nutzungsartengruppeschl,
    nas.nutzungsart AS nutzungsartschl,
    nas.untergliederung1 AS untergliederung1schl,
    nas.untergliederung2 AS untergliederung2schl,
    nas.objektart AS alkis_objart,
    nas.attributart1 AS alkis_attributart1,
    nas.attributart2 AS alkis_attributart2,
    round(st_area(n.wkb_geometry)) AS flaeche,
    n.datumderletztenueberpruefung,
    n.herkunft_source_source_ax_datenerhebung AS datenerhebung_art,
    n.wkb_geometry AS the_geom
   FROM (((((alkis.n_nutzung n
     LEFT JOIN alkis.n_nutzungsartenschluessel nas ON ((((n.nutzungsartengruppe = nas.nutzungsartengruppe) AND (n.werteart1 = nas.werteart1)) AND (n.werteart2 = nas.werteart2))))
     LEFT JOIN alkis.n_nutzungsartengruppe nag ON ((nas.nutzungsartengruppe = nag.schluessel)))
     LEFT JOIN alkis.n_nutzungsart na ON (((nas.nutzungsartengruppe = na.nutzungsartengruppe) AND (nas.nutzungsart = na.schluessel))))
     LEFT JOIN alkis.n_untergliederung1 nu1 ON ((((nas.nutzungsartengruppe = nu1.nutzungsartengruppe) AND (nas.nutzungsart = nu1.nutzungsart)) AND (nas.untergliederung1 = nu1.schluessel))))
     LEFT JOIN alkis.n_untergliederung2 nu2 ON (((((nas.nutzungsartengruppe = nu2.nutzungsartengruppe) AND (nas.nutzungsart = nu2.nutzungsart)) AND (nas.untergliederung1 = nu2.untergliederung1)) AND (nas.untergliederung2 = nu2.schluessel))));


-- Anpassen der Indizes

DROP INDEX IF EXISTS alkis.ax_flurstueck_kennz;
--CREATE INDEX ax_flurstueck_kennz ON alkis.ax_flurstueck USING btree (flurstueckskennzeichen, beginnt DESC);
CREATE INDEX ax_flurstueck_kennz ON alkis.ax_flurstueck USING btree (flurstueckskennzeichen text_pattern_ops, endet DESC, beginnt DESC);

CREATE INDEX ax_historischesflurstueckohneraumbezug_kennz ON alkis.ax_historischesflurstueckohneraumbezug USING btree (flurstueckskennzeichen text_pattern_ops, endet DESC, beginnt DESC);

CREATE INDEX ax_historischesflurstueckohneraumbezug_lgfzn ON alkis.ax_historischesflurstueckohneraumbezug USING btree (land, gemarkungsnummer, flurnummer, zaehler, nenner);

ALTER TABLE alkis.n_nutzung DROP CONSTRAINT IF EXISTS n_nutzung_pk;
--CREATE UNIQUE INDEX n_nutzung_pk ON alkis.n_nutzung USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX n_nutzung_pk ON alkis.n_nutzung USING btree (gml_id, endet DESC, beginnt DESC);

DROP INDEX IF EXISTS alkis.aa_aktivitaet_endet;
--CREATE INDEX aa_aktivitaet_endet ON alkis.aa_aktivitaet USING btree (endet);
CREATE INDEX aa_aktivitaet_endet ON alkis.aa_aktivitaet USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.aa_aktivitaet_gml;
--CREATE UNIQUE INDEX aa_aktivitaet_gml ON alkis.aa_aktivitaet USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX aa_aktivitaet_gml ON alkis.aa_aktivitaet USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.aa_antrag_endet;
--CREATE INDEX aa_antrag_endet ON alkis.aa_antrag USING btree (endet);
CREATE INDEX aa_antrag_endet ON alkis.aa_antrag USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.aa_antrag_gml;
--CREATE UNIQUE INDEX aa_antrag_gml ON alkis.aa_antrag USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX aa_antrag_gml ON alkis.aa_antrag USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.aa_antragsgebiet_endet;
--CREATE INDEX aa_antragsgebiet_endet ON alkis.aa_antragsgebiet USING btree (endet);
CREATE INDEX aa_antragsgebiet_endet ON alkis.aa_antragsgebiet USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.aa_antragsgebiet_gml;
--CREATE UNIQUE INDEX aa_antragsgebiet_gml ON alkis.aa_antragsgebiet USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX aa_antragsgebiet_gml ON alkis.aa_antragsgebiet USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.aa_meilenstein_endet;
--CREATE INDEX aa_meilenstein_endet ON alkis.aa_meilenstein USING btree (endet);
CREATE INDEX aa_meilenstein_endet ON alkis.aa_meilenstein USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.aa_meilenstein_gml;
--CREATE UNIQUE INDEX aa_meilenstein_gml ON alkis.aa_meilenstein USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX aa_meilenstein_gml ON alkis.aa_meilenstein USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.aa_projektsteuerung_endet;
--CREATE INDEX aa_projektsteuerung_endet ON alkis.aa_projektsteuerung USING btree (endet);
CREATE INDEX aa_projektsteuerung_endet ON alkis.aa_projektsteuerung USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.aa_projektsteuerung_gml;
--CREATE UNIQUE INDEX aa_projektsteuerung_gml ON alkis.aa_projektsteuerung USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX aa_projektsteuerung_gml ON alkis.aa_projektsteuerung USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.aa_vorgang_endet;
--CREATE INDEX aa_vorgang_endet ON alkis.aa_vorgang USING btree (endet);
CREATE INDEX aa_vorgang_endet ON alkis.aa_vorgang USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.aa_vorgang_gml;
--CREATE UNIQUE INDEX aa_vorgang_gml ON alkis.aa_vorgang USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX aa_vorgang_gml ON alkis.aa_vorgang USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ap_darstellung_endet;
--CREATE INDEX ap_darstellung_endet ON alkis.ap_darstellung USING btree (endet);
CREATE INDEX ap_darstellung_endet ON alkis.ap_darstellung USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ap_darstellung_gml;
--CREATE UNIQUE INDEX ap_darstellung_gml ON alkis.ap_darstellung USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ap_darstellung_gml ON alkis.ap_darstellung USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ap_fpo_endet;
--CREATE INDEX ap_fpo_endet ON alkis.ap_fpo USING btree (endet);
CREATE INDEX ap_fpo_endet ON alkis.ap_fpo USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ap_fpo_gml;
--CREATE UNIQUE INDEX ap_fpo_gml ON alkis.ap_fpo USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ap_fpo_gml ON alkis.ap_fpo USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ap_lpo_endet;
--CREATE INDEX ap_lpo_endet ON alkis.ap_lpo USING btree (endet);
CREATE INDEX ap_lpo_endet ON alkis.ap_lpo USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ap_lpo_gml;
--CREATE UNIQUE INDEX ap_lpo_gml ON alkis.ap_lpo USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ap_lpo_gml ON alkis.ap_lpo USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ap_lto_endet;
--CREATE INDEX ap_lto_endet ON alkis.ap_lto USING btree (endet);
CREATE INDEX ap_lto_endet ON alkis.ap_lto USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ap_lto_gml;
--CREATE UNIQUE INDEX ap_lto_gml ON alkis.ap_lto USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ap_lto_gml ON alkis.ap_lto USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ap_ppo_endet;
--CREATE INDEX ap_ppo_endet ON alkis.ap_ppo USING btree (endet);
CREATE INDEX ap_ppo_endet ON alkis.ap_ppo USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ap_ppo_gml;
--CREATE UNIQUE INDEX ap_ppo_gml ON alkis.ap_ppo USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ap_ppo_gml ON alkis.ap_ppo USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ap_pto_endet;
--CREATE INDEX ap_pto_endet ON alkis.ap_pto USING btree (endet);
CREATE INDEX ap_pto_endet ON alkis.ap_pto USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ap_pto_gml;
--CREATE UNIQUE INDEX ap_pto_gml ON alkis.ap_pto USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ap_pto_gml ON alkis.ap_pto USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_abgeleitetehoehenlinie_endet;
--CREATE INDEX ax_abgeleitetehoehenlinie_endet ON alkis.ax_abgeleitetehoehenlinie USING btree (endet);
CREATE INDEX ax_abgeleitetehoehenlinie_endet ON alkis.ax_abgeleitetehoehenlinie USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_abgeleitetehoehenlinie_gml;
--CREATE UNIQUE INDEX ax_abgeleitetehoehenlinie_gml ON alkis.ax_abgeleitetehoehenlinie USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_abgeleitetehoehenlinie_gml ON alkis.ax_abgeleitetehoehenlinie USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_abschnitt_endet;
--CREATE INDEX ax_abschnitt_endet ON alkis.ax_abschnitt USING btree (endet);
CREATE INDEX ax_abschnitt_endet ON alkis.ax_abschnitt USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_abschnitt_gml;
--CREATE UNIQUE INDEX ax_abschnitt_gml ON alkis.ax_abschnitt USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_abschnitt_gml ON alkis.ax_abschnitt USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_anderefestlegungnachstrassenrecht_endet;
--CREATE INDEX ax_anderefestlegungnachstrassenrecht_endet ON alkis.ax_anderefestlegungnachstrassenrecht USING btree (endet);
CREATE INDEX ax_anderefestlegungnachstrassenrecht_endet ON alkis.ax_anderefestlegungnachstrassenrecht USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_anderefestlegungnachstrassenrecht_gml;
--CREATE UNIQUE INDEX ax_anderefestlegungnachstrassenrecht_gml ON alkis.ax_anderefestlegungnachstrassenrecht USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_anderefestlegungnachstrassenrecht_gml ON alkis.ax_anderefestlegungnachstrassenrecht USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_anderefestlegungnachwasserrecht_endet;
--CREATE INDEX ax_anderefestlegungnachwasserrecht_endet ON alkis.ax_anderefestlegungnachwasserrecht USING btree (endet);
CREATE INDEX ax_anderefestlegungnachwasserrecht_endet ON alkis.ax_anderefestlegungnachwasserrecht USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_anderefestlegungnachwasserrecht_gml;
--CREATE UNIQUE INDEX ax_anderefestlegungnachwasserrecht_gml ON alkis.ax_anderefestlegungnachwasserrecht USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_anderefestlegungnachwasserrecht_gml ON alkis.ax_anderefestlegungnachwasserrecht USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_anschrift_endet;
--CREATE INDEX ax_anschrift_endet ON alkis.ax_anschrift USING btree (endet);
CREATE INDEX ax_anschrift_endet ON alkis.ax_anschrift USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_anschrift_gml;
--CREATE UNIQUE INDEX ax_anschrift_gml ON alkis.ax_anschrift USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_anschrift_gml ON alkis.ax_anschrift USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_ast_endet;
--CREATE INDEX ax_ast_endet ON alkis.ax_ast USING btree (endet);
CREATE INDEX ax_ast_endet ON alkis.ax_ast USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_ast_gml;
--CREATE UNIQUE INDEX ax_ast_gml ON alkis.ax_ast USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_ast_gml ON alkis.ax_ast USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_aufnahmepunkt_endet;
--CREATE INDEX ax_aufnahmepunkt_endet ON alkis.ax_aufnahmepunkt USING btree (endet);
CREATE INDEX ax_aufnahmepunkt_endet ON alkis.ax_aufnahmepunkt USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_aufnahmepunkt_gml;
--CREATE UNIQUE INDEX ax_aufnahmepunkt_gml ON alkis.ax_aufnahmepunkt USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_aufnahmepunkt_gml ON alkis.ax_aufnahmepunkt USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_bahnstrecke_endet;
--CREATE INDEX ax_bahnstrecke_endet ON alkis.ax_bahnstrecke USING btree (endet);
CREATE INDEX ax_bahnstrecke_endet ON alkis.ax_bahnstrecke USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_bahnstrecke_gml;
--CREATE UNIQUE INDEX ax_bahnstrecke_gml ON alkis.ax_bahnstrecke USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_bahnstrecke_gml ON alkis.ax_bahnstrecke USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_bahnverkehr_endet;
--CREATE INDEX ax_bahnverkehr_endet ON alkis.ax_bahnverkehr USING btree (endet);
CREATE INDEX ax_bahnverkehr_endet ON alkis.ax_bahnverkehr USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_bahnverkehr_gml;
--CREATE UNIQUE INDEX ax_bahnverkehr_gml ON alkis.ax_bahnverkehr USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_bahnverkehr_gml ON alkis.ax_bahnverkehr USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_bahnverkehrsanlage_endet;
--CREATE INDEX ax_bahnverkehrsanlage_endet ON alkis.ax_bahnverkehrsanlage USING btree (endet);
CREATE INDEX ax_bahnverkehrsanlage_endet ON alkis.ax_bahnverkehrsanlage USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_bahnverkehrsanlage_gml;
--CREATE UNIQUE INDEX ax_bahnverkehrsanlage_gml ON alkis.ax_bahnverkehrsanlage USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_bahnverkehrsanlage_gml ON alkis.ax_bahnverkehrsanlage USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_baublock_endet;
--CREATE INDEX ax_baublock_endet ON alkis.ax_baublock USING btree (endet);
CREATE INDEX ax_baublock_endet ON alkis.ax_baublock USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_baublock_gml;
--CREATE UNIQUE INDEX ax_baublock_gml ON alkis.ax_baublock USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_baublock_gml ON alkis.ax_baublock USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_bauraumoderbodenordnungsrecht_endet;
--CREATE INDEX ax_bauraumoderbodenordnungsrecht_endet ON alkis.ax_bauraumoderbodenordnungsrecht USING btree (endet);
CREATE INDEX ax_bauraumoderbodenordnungsrecht_endet ON alkis.ax_bauraumoderbodenordnungsrecht USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_bauraumoderbodenordnungsrecht_gml;
--CREATE UNIQUE INDEX ax_bauraumoderbodenordnungsrecht_gml ON alkis.ax_bauraumoderbodenordnungsrecht USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_bauraumoderbodenordnungsrecht_gml ON alkis.ax_bauraumoderbodenordnungsrecht USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_bauteil_endet;
--CREATE INDEX ax_bauteil_endet ON alkis.ax_bauteil USING btree (endet);
CREATE INDEX ax_bauteil_endet ON alkis.ax_bauteil USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_bauteil_gml;
--CREATE UNIQUE INDEX ax_bauteil_gml ON alkis.ax_bauteil USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_bauteil_gml ON alkis.ax_bauteil USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_bauwerkimgewaesserbereich_endet;
--CREATE INDEX ax_bauwerkimgewaesserbereich_endet ON alkis.ax_bauwerkimgewaesserbereich USING btree (endet);
CREATE INDEX ax_bauwerkimgewaesserbereich_endet ON alkis.ax_bauwerkimgewaesserbereich USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_bauwerkimgewaesserbereich_gml;
--CREATE UNIQUE INDEX ax_bauwerkimgewaesserbereich_gml ON alkis.ax_bauwerkimgewaesserbereich USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_bauwerkimgewaesserbereich_gml ON alkis.ax_bauwerkimgewaesserbereich USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_bauwerkimverkehrsbereich_endet;
--CREATE INDEX ax_bauwerkimverkehrsbereich_endet ON alkis.ax_bauwerkimverkehrsbereich USING btree (endet);
CREATE INDEX ax_bauwerkimverkehrsbereich_endet ON alkis.ax_bauwerkimverkehrsbereich USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_bauwerkimverkehrsbereich_gml;
--CREATE UNIQUE INDEX ax_bauwerkimverkehrsbereich_gml ON alkis.ax_bauwerkimverkehrsbereich USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_bauwerkimverkehrsbereich_gml ON alkis.ax_bauwerkimverkehrsbereich USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_bauwerkoderanlagefuerindustrieundgewerbe_endet;
--CREATE INDEX ax_bauwerkoderanlagefuerindustrieundgewerbe_endet ON alkis.ax_bauwerkoderanlagefuerindustrieundgewerbe USING btree (endet);
CREATE INDEX ax_bauwerkoderanlagefuerindustrieundgewerbe_endet ON alkis.ax_bauwerkoderanlagefuerindustrieundgewerbe USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_bauwerkoderanlagefuerindustrieundgewerbe_gml;
--CREATE UNIQUE INDEX ax_bauwerkoderanlagefuerindustrieundgewerbe_gml ON alkis.ax_bauwerkoderanlagefuerindustrieundgewerbe USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_bauwerkoderanlagefuerindustrieundgewerbe_gml ON alkis.ax_bauwerkoderanlagefuerindustrieundgewerbe USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_bauwerkoderanlagefuersportfreizeitunderholung_endet;
--CREATE INDEX ax_bauwerkoderanlagefuersportfreizeitunderholung_endet ON alkis.ax_bauwerkoderanlagefuersportfreizeitunderholung USING btree (endet);
CREATE INDEX ax_bauwerkoderanlagefuersportfreizeitunderholung_endet ON alkis.ax_bauwerkoderanlagefuersportfreizeitunderholung USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_bauwerkoderanlagefuersportfreizeitunderholung_gml;
--CREATE UNIQUE INDEX ax_bauwerkoderanlagefuersportfreizeitunderholung_gml ON alkis.ax_bauwerkoderanlagefuersportfreizeitunderholung USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_bauwerkoderanlagefuersportfreizeitunderholung_gml ON alkis.ax_bauwerkoderanlagefuersportfreizeitunderholung USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_benutzer_endet;
--CREATE INDEX ax_benutzer_endet ON alkis.ax_benutzer USING btree (endet);
CREATE INDEX ax_benutzer_endet ON alkis.ax_benutzer USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_benutzer_gml;
--CREATE UNIQUE INDEX ax_benutzer_gml ON alkis.ax_benutzer USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_benutzer_gml ON alkis.ax_benutzer USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_benutzergruppemitzugriffskontrolle_endet;
--CREATE INDEX ax_benutzergruppemitzugriffskontrolle_endet ON alkis.ax_benutzergruppemitzugriffskontrolle USING btree (endet);
CREATE INDEX ax_benutzergruppemitzugriffskontrolle_endet ON alkis.ax_benutzergruppemitzugriffskontrolle USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_benutzergruppemitzugriffskontrolle_gml;
--CREATE UNIQUE INDEX ax_benutzergruppemitzugriffskontrolle_gml ON alkis.ax_benutzergruppemitzugriffskontrolle USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_benutzergruppemitzugriffskontrolle_gml ON alkis.ax_benutzergruppemitzugriffskontrolle USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_benutzergruppenba_endet;
--CREATE INDEX ax_benutzergruppenba_endet ON alkis.ax_benutzergruppenba USING btree (endet);
CREATE INDEX ax_benutzergruppenba_endet ON alkis.ax_benutzergruppenba USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_benutzergruppenba_gml;
--CREATE UNIQUE INDEX ax_benutzergruppenba_gml ON alkis.ax_benutzergruppenba USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_benutzergruppenba_gml ON alkis.ax_benutzergruppenba USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_bergbaubetrieb_endet;
--CREATE INDEX ax_bergbaubetrieb_endet ON alkis.ax_bergbaubetrieb USING btree (endet);
CREATE INDEX ax_bergbaubetrieb_endet ON alkis.ax_bergbaubetrieb USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_bergbaubetrieb_gml;
--CREATE UNIQUE INDEX ax_bergbaubetrieb_gml ON alkis.ax_bergbaubetrieb USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_bergbaubetrieb_gml ON alkis.ax_bergbaubetrieb USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_besondereflurstuecksgrenze_endet;
--CREATE INDEX ax_besondereflurstuecksgrenze_endet ON alkis.ax_besondereflurstuecksgrenze USING btree (endet);
CREATE INDEX ax_besondereflurstuecksgrenze_endet ON alkis.ax_besondereflurstuecksgrenze USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_besondereflurstuecksgrenze_gml;
--CREATE UNIQUE INDEX ax_besondereflurstuecksgrenze_gml ON alkis.ax_besondereflurstuecksgrenze USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_besondereflurstuecksgrenze_gml ON alkis.ax_besondereflurstuecksgrenze USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_besonderegebaeudelinie_endet;
--CREATE INDEX ax_besonderegebaeudelinie_endet ON alkis.ax_besonderegebaeudelinie USING btree (endet);
CREATE INDEX ax_besonderegebaeudelinie_endet ON alkis.ax_besonderegebaeudelinie USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_besonderegebaeudelinie_gml;
--CREATE UNIQUE INDEX ax_besonderegebaeudelinie_gml ON alkis.ax_besonderegebaeudelinie USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_besonderegebaeudelinie_gml ON alkis.ax_besonderegebaeudelinie USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_besondererbauwerkspunkt_endet;
--CREATE INDEX ax_besondererbauwerkspunkt_endet ON alkis.ax_besondererbauwerkspunkt USING btree (endet);
CREATE INDEX ax_besondererbauwerkspunkt_endet ON alkis.ax_besondererbauwerkspunkt USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_besondererbauwerkspunkt_gml;
--CREATE UNIQUE INDEX ax_besondererbauwerkspunkt_gml ON alkis.ax_besondererbauwerkspunkt USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_besondererbauwerkspunkt_gml ON alkis.ax_besondererbauwerkspunkt USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_besonderergebaeudepunkt_endet;
--CREATE INDEX ax_besonderergebaeudepunkt_endet ON alkis.ax_besonderergebaeudepunkt USING btree (endet);
CREATE INDEX ax_besonderergebaeudepunkt_endet ON alkis.ax_besonderergebaeudepunkt USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_besonderergebaeudepunkt_gml;
--CREATE UNIQUE INDEX ax_besonderergebaeudepunkt_gml ON alkis.ax_besonderergebaeudepunkt USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_besonderergebaeudepunkt_gml ON alkis.ax_besonderergebaeudepunkt USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_besonderertopographischerpunkt_endet;
--CREATE INDEX ax_besonderertopographischerpunkt_endet ON alkis.ax_besonderertopographischerpunkt USING btree (endet);
CREATE INDEX ax_besonderertopographischerpunkt_endet ON alkis.ax_besonderertopographischerpunkt USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_besonderertopographischerpunkt_gml;
--CREATE UNIQUE INDEX ax_besonderertopographischerpunkt_gml ON alkis.ax_besonderertopographischerpunkt USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_besonderertopographischerpunkt_gml ON alkis.ax_besonderertopographischerpunkt USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_bewertung_endet;
--CREATE INDEX ax_bewertung_endet ON alkis.ax_bewertung USING btree (endet);
CREATE INDEX ax_bewertung_endet ON alkis.ax_bewertung USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_bewertung_gml;
--CREATE UNIQUE INDEX ax_bewertung_gml ON alkis.ax_bewertung USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_bewertung_gml ON alkis.ax_bewertung USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_bodenschaetzung_endet;
--CREATE INDEX ax_bodenschaetzung_endet ON alkis.ax_bodenschaetzung USING btree (endet);
CREATE INDEX ax_bodenschaetzung_endet ON alkis.ax_bodenschaetzung USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_bodenschaetzung_gml;
--CREATE UNIQUE INDEX ax_bodenschaetzung_gml ON alkis.ax_bodenschaetzung USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_bodenschaetzung_gml ON alkis.ax_bodenschaetzung USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_boeschungkliff_endet;
--CREATE INDEX ax_boeschungkliff_endet ON alkis.ax_boeschungkliff USING btree (endet);
CREATE INDEX ax_boeschungkliff_endet ON alkis.ax_boeschungkliff USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_boeschungkliff_gml;
--CREATE UNIQUE INDEX ax_boeschungkliff_gml ON alkis.ax_boeschungkliff USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_boeschungkliff_gml ON alkis.ax_boeschungkliff USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_buchungsblatt_endet;
--CREATE INDEX ax_buchungsblatt_endet ON alkis.ax_buchungsblatt USING btree (endet);
CREATE INDEX ax_buchungsblatt_endet ON alkis.ax_buchungsblatt USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_buchungsblatt_gml;
--CREATE UNIQUE INDEX ax_buchungsblatt_gml ON alkis.ax_buchungsblatt USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_buchungsblatt_gml ON alkis.ax_buchungsblatt USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_buchungsblattbezirk_endet;
--CREATE INDEX ax_buchungsblattbezirk_endet ON alkis.ax_buchungsblattbezirk USING btree (endet);
CREATE INDEX ax_buchungsblattbezirk_endet ON alkis.ax_buchungsblattbezirk USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_buchungsblattbezirk_gml;
--CREATE UNIQUE INDEX ax_buchungsblattbezirk_gml ON alkis.ax_buchungsblattbezirk USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_buchungsblattbezirk_gml ON alkis.ax_buchungsblattbezirk USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_buchungsstelle_endet;
--CREATE INDEX ax_buchungsstelle_endet ON alkis.ax_buchungsstelle USING btree (endet);
CREATE INDEX ax_buchungsstelle_endet ON alkis.ax_buchungsstelle USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_buchungsstelle_gml;
--CREATE UNIQUE INDEX ax_buchungsstelle_gml ON alkis.ax_buchungsstelle USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_buchungsstelle_gml ON alkis.ax_buchungsstelle USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_bundesland_endet;
--CREATE INDEX ax_bundesland_endet ON alkis.ax_bundesland USING btree (endet);
CREATE INDEX ax_bundesland_endet ON alkis.ax_bundesland USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_bundesland_gml;
--CREATE UNIQUE INDEX ax_bundesland_gml ON alkis.ax_bundesland USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_bundesland_gml ON alkis.ax_bundesland USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_dammwalldeich_endet;
--CREATE INDEX ax_dammwalldeich_endet ON alkis.ax_dammwalldeich USING btree (endet);
CREATE INDEX ax_dammwalldeich_endet ON alkis.ax_dammwalldeich USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_dammwalldeich_gml;
--CREATE UNIQUE INDEX ax_dammwalldeich_gml ON alkis.ax_dammwalldeich USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_dammwalldeich_gml ON alkis.ax_dammwalldeich USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_denkmalschutzrecht_endet;
--CREATE INDEX ax_denkmalschutzrecht_endet ON alkis.ax_denkmalschutzrecht USING btree (endet);
CREATE INDEX ax_denkmalschutzrecht_endet ON alkis.ax_denkmalschutzrecht USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_denkmalschutzrecht_gml;
--CREATE UNIQUE INDEX ax_denkmalschutzrecht_gml ON alkis.ax_denkmalschutzrecht USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_denkmalschutzrecht_gml ON alkis.ax_denkmalschutzrecht USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_dienststelle_endet;
--CREATE INDEX ax_dienststelle_endet ON alkis.ax_dienststelle USING btree (endet);
CREATE INDEX ax_dienststelle_endet ON alkis.ax_dienststelle USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_dienststelle_gml;
--CREATE UNIQUE INDEX ax_dienststelle_gml ON alkis.ax_dienststelle USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_dienststelle_gml ON alkis.ax_dienststelle USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_duene_endet;
--CREATE INDEX ax_duene_endet ON alkis.ax_duene USING btree (endet);
CREATE INDEX ax_duene_endet ON alkis.ax_duene USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_duene_gml;
--CREATE UNIQUE INDEX ax_duene_gml ON alkis.ax_duene USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_duene_gml ON alkis.ax_duene USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_einrichtungenfuerdenschiffsverkehr_endet;
--CREATE INDEX ax_einrichtungenfuerdenschiffsverkehr_endet ON alkis.ax_einrichtungenfuerdenschiffsverkehr USING btree (endet);
CREATE INDEX ax_einrichtungenfuerdenschiffsverkehr_endet ON alkis.ax_einrichtungenfuerdenschiffsverkehr USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_einrichtungenfuerdenschiffsverkehr_gml;
--CREATE UNIQUE INDEX ax_einrichtungenfuerdenschiffsverkehr_gml ON alkis.ax_einrichtungenfuerdenschiffsverkehr USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_einrichtungenfuerdenschiffsverkehr_gml ON alkis.ax_einrichtungenfuerdenschiffsverkehr USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_einrichtunginoeffentlichenbereichen_endet;
--CREATE INDEX ax_einrichtunginoeffentlichenbereichen_endet ON alkis.ax_einrichtunginoeffentlichenbereichen USING btree (endet);
CREATE INDEX ax_einrichtunginoeffentlichenbereichen_endet ON alkis.ax_einrichtunginoeffentlichenbereichen USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_einrichtunginoeffentlichenbereichen_gml;
--CREATE UNIQUE INDEX ax_einrichtunginoeffentlichenbereichen_gml ON alkis.ax_einrichtunginoeffentlichenbereichen USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_einrichtunginoeffentlichenbereichen_gml ON alkis.ax_einrichtunginoeffentlichenbereichen USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_einschnitt_endet;
--CREATE INDEX ax_einschnitt_endet ON alkis.ax_einschnitt USING btree (endet);
CREATE INDEX ax_einschnitt_endet ON alkis.ax_einschnitt USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_einschnitt_gml;
--CREATE UNIQUE INDEX ax_einschnitt_gml ON alkis.ax_einschnitt USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_einschnitt_gml ON alkis.ax_einschnitt USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_fahrbahnachse_endet;
--CREATE INDEX ax_fahrbahnachse_endet ON alkis.ax_fahrbahnachse USING btree (endet);
CREATE INDEX ax_fahrbahnachse_endet ON alkis.ax_fahrbahnachse USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_fahrbahnachse_gml;
--CREATE UNIQUE INDEX ax_fahrbahnachse_gml ON alkis.ax_fahrbahnachse USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_fahrbahnachse_gml ON alkis.ax_fahrbahnachse USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_fahrwegachse_endet;
--CREATE INDEX ax_fahrwegachse_endet ON alkis.ax_fahrwegachse USING btree (endet);
CREATE INDEX ax_fahrwegachse_endet ON alkis.ax_fahrwegachse USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_fahrwegachse_gml;
--CREATE UNIQUE INDEX ax_fahrwegachse_gml ON alkis.ax_fahrwegachse USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_fahrwegachse_gml ON alkis.ax_fahrwegachse USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_felsenfelsblockfelsnadel_endet;
--CREATE INDEX ax_felsenfelsblockfelsnadel_endet ON alkis.ax_felsenfelsblockfelsnadel USING btree (endet);
CREATE INDEX ax_felsenfelsblockfelsnadel_endet ON alkis.ax_felsenfelsblockfelsnadel USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_felsenfelsblockfelsnadel_gml;
--CREATE UNIQUE INDEX ax_felsenfelsblockfelsnadel_gml ON alkis.ax_felsenfelsblockfelsnadel USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_felsenfelsblockfelsnadel_gml ON alkis.ax_felsenfelsblockfelsnadel USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_firstlinie_endet;
--CREATE INDEX ax_firstlinie_endet ON alkis.ax_firstlinie USING btree (endet);
CREATE INDEX ax_firstlinie_endet ON alkis.ax_firstlinie USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_firstlinie_gml;
--CREATE UNIQUE INDEX ax_firstlinie_gml ON alkis.ax_firstlinie USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_firstlinie_gml ON alkis.ax_firstlinie USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_flaechebesondererfunktionalerpraegung_endet;
--CREATE INDEX ax_flaechebesondererfunktionalerpraegung_endet ON alkis.ax_flaechebesondererfunktionalerpraegung USING btree (endet);
CREATE INDEX ax_flaechebesondererfunktionalerpraegung_endet ON alkis.ax_flaechebesondererfunktionalerpraegung USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_flaechebesondererfunktionalerpraegung_gml;
--CREATE UNIQUE INDEX ax_flaechebesondererfunktionalerpraegung_gml ON alkis.ax_flaechebesondererfunktionalerpraegung USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_flaechebesondererfunktionalerpraegung_gml ON alkis.ax_flaechebesondererfunktionalerpraegung USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_flaechegemischternutzung_endet;
--CREATE INDEX ax_flaechegemischternutzung_endet ON alkis.ax_flaechegemischternutzung USING btree (endet);
CREATE INDEX ax_flaechegemischternutzung_endet ON alkis.ax_flaechegemischternutzung USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_flaechegemischternutzung_gml;
--CREATE UNIQUE INDEX ax_flaechegemischternutzung_gml ON alkis.ax_flaechegemischternutzung USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_flaechegemischternutzung_gml ON alkis.ax_flaechegemischternutzung USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_fliessgewaesser_endet;
--CREATE INDEX ax_fliessgewaesser_endet ON alkis.ax_fliessgewaesser USING btree (endet);
CREATE INDEX ax_fliessgewaesser_endet ON alkis.ax_fliessgewaesser USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_fliessgewaesser_gml;
--CREATE UNIQUE INDEX ax_fliessgewaesser_gml ON alkis.ax_fliessgewaesser USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_fliessgewaesser_gml ON alkis.ax_fliessgewaesser USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_flugverkehr_endet;
--CREATE INDEX ax_flugverkehr_endet ON alkis.ax_flugverkehr USING btree (endet);
CREATE INDEX ax_flugverkehr_endet ON alkis.ax_flugverkehr USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_flugverkehr_gml;
--CREATE UNIQUE INDEX ax_flugverkehr_gml ON alkis.ax_flugverkehr USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_flugverkehr_gml ON alkis.ax_flugverkehr USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_flugverkehrsanlage_endet;
--CREATE INDEX ax_flugverkehrsanlage_endet ON alkis.ax_flugverkehrsanlage USING btree (endet);
CREATE INDEX ax_flugverkehrsanlage_endet ON alkis.ax_flugverkehrsanlage USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_flugverkehrsanlage_gml;
--CREATE UNIQUE INDEX ax_flugverkehrsanlage_gml ON alkis.ax_flugverkehrsanlage USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_flugverkehrsanlage_gml ON alkis.ax_flugverkehrsanlage USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_flurstueck_endet;
--CREATE INDEX ax_flurstueck_endet ON alkis.ax_flurstueck USING btree (endet);
CREATE INDEX ax_flurstueck_endet ON alkis.ax_flurstueck USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_flurstueck_gml;
--CREATE UNIQUE INDEX ax_flurstueck_gml ON alkis.ax_flurstueck USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_flurstueck_gml ON alkis.ax_flurstueck USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_flurstueck_kennz;
--CREATE INDEX ax_flurstueck_kennz ON alkis.ax_flurstueck USING btree (flurstueckskennzeichen, beginnt DESC);
CREATE INDEX ax_flurstueck_kennz ON alkis.ax_flurstueck USING btree (flurstueckskennzeichen, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_forstrecht_endet;
--CREATE INDEX ax_forstrecht_endet ON alkis.ax_forstrecht USING btree (endet);
CREATE INDEX ax_forstrecht_endet ON alkis.ax_forstrecht USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_forstrecht_gml;
--CREATE UNIQUE INDEX ax_forstrecht_gml ON alkis.ax_forstrecht USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_forstrecht_gml ON alkis.ax_forstrecht USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_fortfuehrungsfall_endet;
--CREATE INDEX ax_fortfuehrungsfall_endet ON alkis.ax_fortfuehrungsfall USING btree (endet);
CREATE INDEX ax_fortfuehrungsfall_endet ON alkis.ax_fortfuehrungsfall USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_fortfuehrungsfall_gml;
--CREATE UNIQUE INDEX ax_fortfuehrungsfall_gml ON alkis.ax_fortfuehrungsfall USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_fortfuehrungsfall_gml ON alkis.ax_fortfuehrungsfall USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_fortfuehrungsnachweisdeckblatt_endet;
--CREATE INDEX ax_fortfuehrungsnachweisdeckblatt_endet ON alkis.ax_fortfuehrungsnachweisdeckblatt USING btree (endet);
CREATE INDEX ax_fortfuehrungsnachweisdeckblatt_endet ON alkis.ax_fortfuehrungsnachweisdeckblatt USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_fortfuehrungsnachweisdeckblatt_gml;
--CREATE UNIQUE INDEX ax_fortfuehrungsnachweisdeckblatt_gml ON alkis.ax_fortfuehrungsnachweisdeckblatt USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_fortfuehrungsnachweisdeckblatt_gml ON alkis.ax_fortfuehrungsnachweisdeckblatt USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_friedhof_endet;
--CREATE INDEX ax_friedhof_endet ON alkis.ax_friedhof USING btree (endet);
CREATE INDEX ax_friedhof_endet ON alkis.ax_friedhof USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_friedhof_gml;
--CREATE UNIQUE INDEX ax_friedhof_gml ON alkis.ax_friedhof USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_friedhof_gml ON alkis.ax_friedhof USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gebaeude_endet;
--CREATE INDEX ax_gebaeude_endet ON alkis.ax_gebaeude USING btree (endet);
CREATE INDEX ax_gebaeude_endet ON alkis.ax_gebaeude USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gebaeude_gml;
--CREATE UNIQUE INDEX ax_gebaeude_gml ON alkis.ax_gebaeude USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_gebaeude_gml ON alkis.ax_gebaeude USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gebaeudeausgestaltung_endet;
--CREATE INDEX ax_gebaeudeausgestaltung_endet ON alkis.ax_gebaeudeausgestaltung USING btree (endet);
CREATE INDEX ax_gebaeudeausgestaltung_endet ON alkis.ax_gebaeudeausgestaltung USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gebaeudeausgestaltung_gml;
--CREATE UNIQUE INDEX ax_gebaeudeausgestaltung_gml ON alkis.ax_gebaeudeausgestaltung USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_gebaeudeausgestaltung_gml ON alkis.ax_gebaeudeausgestaltung USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gebiet_bundesland_endet;
--CREATE INDEX ax_gebiet_bundesland_endet ON alkis.ax_gebiet_bundesland USING btree (endet);
CREATE INDEX ax_gebiet_bundesland_endet ON alkis.ax_gebiet_bundesland USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gebiet_bundesland_gml;
--CREATE UNIQUE INDEX ax_gebiet_bundesland_gml ON alkis.ax_gebiet_bundesland USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_gebiet_bundesland_gml ON alkis.ax_gebiet_bundesland USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gebiet_kreis_endet;
--CREATE INDEX ax_gebiet_kreis_endet ON alkis.ax_gebiet_kreis USING btree (endet);
CREATE INDEX ax_gebiet_kreis_endet ON alkis.ax_gebiet_kreis USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gebiet_kreis_gml;
--CREATE UNIQUE INDEX ax_gebiet_kreis_gml ON alkis.ax_gebiet_kreis USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_gebiet_kreis_gml ON alkis.ax_gebiet_kreis USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gebiet_nationalstaat_endet;
--CREATE INDEX ax_gebiet_nationalstaat_endet ON alkis.ax_gebiet_nationalstaat USING btree (endet);
CREATE INDEX ax_gebiet_nationalstaat_endet ON alkis.ax_gebiet_nationalstaat USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gebiet_nationalstaat_gml;
--CREATE UNIQUE INDEX ax_gebiet_nationalstaat_gml ON alkis.ax_gebiet_nationalstaat USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_gebiet_nationalstaat_gml ON alkis.ax_gebiet_nationalstaat USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gebiet_regierungsbezirk_endet;
--CREATE INDEX ax_gebiet_regierungsbezirk_endet ON alkis.ax_gebiet_regierungsbezirk USING btree (endet);
CREATE INDEX ax_gebiet_regierungsbezirk_endet ON alkis.ax_gebiet_regierungsbezirk USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gebiet_regierungsbezirk_gml;
--CREATE UNIQUE INDEX ax_gebiet_regierungsbezirk_gml ON alkis.ax_gebiet_regierungsbezirk USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_gebiet_regierungsbezirk_gml ON alkis.ax_gebiet_regierungsbezirk USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gebiet_verwaltungsgemeinschaft_endet;
--CREATE INDEX ax_gebiet_verwaltungsgemeinschaft_endet ON alkis.ax_gebiet_verwaltungsgemeinschaft USING btree (endet);
CREATE INDEX ax_gebiet_verwaltungsgemeinschaft_endet ON alkis.ax_gebiet_verwaltungsgemeinschaft USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gebiet_verwaltungsgemeinschaft_gml;
--CREATE UNIQUE INDEX ax_gebiet_verwaltungsgemeinschaft_gml ON alkis.ax_gebiet_verwaltungsgemeinschaft USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_gebiet_verwaltungsgemeinschaft_gml ON alkis.ax_gebiet_verwaltungsgemeinschaft USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gebietsgrenze_endet;
--CREATE INDEX ax_gebietsgrenze_endet ON alkis.ax_gebietsgrenze USING btree (endet);
CREATE INDEX ax_gebietsgrenze_endet ON alkis.ax_gebietsgrenze USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gebietsgrenze_gml;
--CREATE UNIQUE INDEX ax_gebietsgrenze_gml ON alkis.ax_gebietsgrenze USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_gebietsgrenze_gml ON alkis.ax_gebietsgrenze USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gehoelz_endet;
--CREATE INDEX ax_gehoelz_endet ON alkis.ax_gehoelz USING btree (endet);
CREATE INDEX ax_gehoelz_endet ON alkis.ax_gehoelz USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gehoelz_gml;
--CREATE UNIQUE INDEX ax_gehoelz_gml ON alkis.ax_gehoelz USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_gehoelz_gml ON alkis.ax_gehoelz USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gemarkung_endet;
--CREATE INDEX ax_gemarkung_endet ON alkis.ax_gemarkung USING btree (endet);
CREATE INDEX ax_gemarkung_endet ON alkis.ax_gemarkung USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gemarkung_gml;
--CREATE UNIQUE INDEX ax_gemarkung_gml ON alkis.ax_gemarkung USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_gemarkung_gml ON alkis.ax_gemarkung USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gemarkungsteilflur_endet;
--CREATE INDEX ax_gemarkungsteilflur_endet ON alkis.ax_gemarkungsteilflur USING btree (endet);
CREATE INDEX ax_gemarkungsteilflur_endet ON alkis.ax_gemarkungsteilflur USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gemarkungsteilflur_gml;
--CREATE UNIQUE INDEX ax_gemarkungsteilflur_gml ON alkis.ax_gemarkungsteilflur USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_gemarkungsteilflur_gml ON alkis.ax_gemarkungsteilflur USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gemeinde_endet;
--CREATE INDEX ax_gemeinde_endet ON alkis.ax_gemeinde USING btree (endet);
CREATE INDEX ax_gemeinde_endet ON alkis.ax_gemeinde USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gemeinde_gml;
--CREATE UNIQUE INDEX ax_gemeinde_gml ON alkis.ax_gemeinde USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_gemeinde_gml ON alkis.ax_gemeinde USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gemeindeteil_endet;
--CREATE INDEX ax_gemeindeteil_endet ON alkis.ax_gemeindeteil USING btree (endet);
CREATE INDEX ax_gemeindeteil_endet ON alkis.ax_gemeindeteil USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gemeindeteil_gml;
--CREATE UNIQUE INDEX ax_gemeindeteil_gml ON alkis.ax_gemeindeteil USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_gemeindeteil_gml ON alkis.ax_gemeindeteil USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_georeferenziertegebaeudeadresse_endet;
--CREATE INDEX ax_georeferenziertegebaeudeadresse_endet ON alkis.ax_georeferenziertegebaeudeadresse USING btree (endet);
CREATE INDEX ax_georeferenziertegebaeudeadresse_endet ON alkis.ax_georeferenziertegebaeudeadresse USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_georeferenziertegebaeudeadresse_gml;
--CREATE UNIQUE INDEX ax_georeferenziertegebaeudeadresse_gml ON alkis.ax_georeferenziertegebaeudeadresse USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_georeferenziertegebaeudeadresse_gml ON alkis.ax_georeferenziertegebaeudeadresse USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gewaesserachse_endet;
--CREATE INDEX ax_gewaesserachse_endet ON alkis.ax_gewaesserachse USING btree (endet);
CREATE INDEX ax_gewaesserachse_endet ON alkis.ax_gewaesserachse USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gewaesserachse_gml;
--CREATE UNIQUE INDEX ax_gewaesserachse_gml ON alkis.ax_gewaesserachse USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_gewaesserachse_gml ON alkis.ax_gewaesserachse USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gewaessermerkmal_endet;
--CREATE INDEX ax_gewaessermerkmal_endet ON alkis.ax_gewaessermerkmal USING btree (endet);
CREATE INDEX ax_gewaessermerkmal_endet ON alkis.ax_gewaessermerkmal USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gewaessermerkmal_gml;
--CREATE UNIQUE INDEX ax_gewaessermerkmal_gml ON alkis.ax_gewaessermerkmal USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_gewaessermerkmal_gml ON alkis.ax_gewaessermerkmal USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gewaesserstationierungsachse_endet;
--CREATE INDEX ax_gewaesserstationierungsachse_endet ON alkis.ax_gewaesserstationierungsachse USING btree (endet);
CREATE INDEX ax_gewaesserstationierungsachse_endet ON alkis.ax_gewaesserstationierungsachse USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gewaesserstationierungsachse_gml;
--CREATE UNIQUE INDEX ax_gewaesserstationierungsachse_gml ON alkis.ax_gewaesserstationierungsachse USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_gewaesserstationierungsachse_gml ON alkis.ax_gewaesserstationierungsachse USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gewann_endet;
--CREATE INDEX ax_gewann_endet ON alkis.ax_gewann USING btree (endet);
CREATE INDEX ax_gewann_endet ON alkis.ax_gewann USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gewann_gml;
--CREATE UNIQUE INDEX ax_gewann_gml ON alkis.ax_gewann USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_gewann_gml ON alkis.ax_gewann USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gleis_endet;
--CREATE INDEX ax_gleis_endet ON alkis.ax_gleis USING btree (endet);
CREATE INDEX ax_gleis_endet ON alkis.ax_gleis USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_gleis_gml;
--CREATE UNIQUE INDEX ax_gleis_gml ON alkis.ax_gleis USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_gleis_gml ON alkis.ax_gleis USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_grablochderbodenschaetzung_endet;
--CREATE INDEX ax_grablochderbodenschaetzung_endet ON alkis.ax_grablochderbodenschaetzung USING btree (endet);
CREATE INDEX ax_grablochderbodenschaetzung_endet ON alkis.ax_grablochderbodenschaetzung USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_grablochderbodenschaetzung_gml;
--CREATE UNIQUE INDEX ax_grablochderbodenschaetzung_gml ON alkis.ax_grablochderbodenschaetzung USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_grablochderbodenschaetzung_gml ON alkis.ax_grablochderbodenschaetzung USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_grenzpunkt_endet;
--CREATE INDEX ax_grenzpunkt_endet ON alkis.ax_grenzpunkt USING btree (endet);
CREATE INDEX ax_grenzpunkt_endet ON alkis.ax_grenzpunkt USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_grenzpunkt_gml;
--CREATE UNIQUE INDEX ax_grenzpunkt_gml ON alkis.ax_grenzpunkt USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_grenzpunkt_gml ON alkis.ax_grenzpunkt USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_grenzuebergang_endet;
--CREATE INDEX ax_grenzuebergang_endet ON alkis.ax_grenzuebergang USING btree (endet);
CREATE INDEX ax_grenzuebergang_endet ON alkis.ax_grenzuebergang USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_grenzuebergang_gml;
--CREATE UNIQUE INDEX ax_grenzuebergang_gml ON alkis.ax_grenzuebergang USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_grenzuebergang_gml ON alkis.ax_grenzuebergang USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_hafen_endet;
--CREATE INDEX ax_hafen_endet ON alkis.ax_hafen USING btree (endet);
CREATE INDEX ax_hafen_endet ON alkis.ax_hafen USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_hafen_gml;
--CREATE UNIQUE INDEX ax_hafen_gml ON alkis.ax_hafen USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_hafen_gml ON alkis.ax_hafen USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_hafenbecken_endet;
--CREATE INDEX ax_hafenbecken_endet ON alkis.ax_hafenbecken USING btree (endet);
CREATE INDEX ax_hafenbecken_endet ON alkis.ax_hafenbecken USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_hafenbecken_gml;
--CREATE UNIQUE INDEX ax_hafenbecken_gml ON alkis.ax_hafenbecken USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_hafenbecken_gml ON alkis.ax_hafenbecken USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_halde_endet;
--CREATE INDEX ax_halde_endet ON alkis.ax_halde USING btree (endet);
CREATE INDEX ax_halde_endet ON alkis.ax_halde USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_halde_gml;
--CREATE UNIQUE INDEX ax_halde_gml ON alkis.ax_halde USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_halde_gml ON alkis.ax_halde USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_heide_endet;
--CREATE INDEX ax_heide_endet ON alkis.ax_heide USING btree (endet);
CREATE INDEX ax_heide_endet ON alkis.ax_heide USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_heide_gml;
--CREATE UNIQUE INDEX ax_heide_gml ON alkis.ax_heide USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_heide_gml ON alkis.ax_heide USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_heilquellegasquelle_endet;
--CREATE INDEX ax_heilquellegasquelle_endet ON alkis.ax_heilquellegasquelle USING btree (endet);
CREATE INDEX ax_heilquellegasquelle_endet ON alkis.ax_heilquellegasquelle USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_heilquellegasquelle_gml;
--CREATE UNIQUE INDEX ax_heilquellegasquelle_gml ON alkis.ax_heilquellegasquelle USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_heilquellegasquelle_gml ON alkis.ax_heilquellegasquelle USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_historischesbauwerkoderhistorischeeinrichtung_endet;
--CREATE INDEX ax_historischesbauwerkoderhistorischeeinrichtung_endet ON alkis.ax_historischesbauwerkoderhistorischeeinrichtung USING btree (endet);
CREATE INDEX ax_historischesbauwerkoderhistorischeeinrichtung_endet ON alkis.ax_historischesbauwerkoderhistorischeeinrichtung USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_historischesbauwerkoderhistorischeeinrichtung_gml;
--CREATE UNIQUE INDEX ax_historischesbauwerkoderhistorischeeinrichtung_gml ON alkis.ax_historischesbauwerkoderhistorischeeinrichtung USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_historischesbauwerkoderhistorischeeinrichtung_gml ON alkis.ax_historischesbauwerkoderhistorischeeinrichtung USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_historischesflurstueck_endet;
--CREATE INDEX ax_historischesflurstueck_endet ON alkis.ax_historischesflurstueck USING btree (endet);
CREATE INDEX ax_historischesflurstueck_endet ON alkis.ax_historischesflurstueck USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_historischesflurstueck_gml;
--CREATE UNIQUE INDEX ax_historischesflurstueck_gml ON alkis.ax_historischesflurstueck USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_historischesflurstueck_gml ON alkis.ax_historischesflurstueck USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_historischesflurstueckalb_endet;
--CREATE INDEX ax_historischesflurstueckalb_endet ON alkis.ax_historischesflurstueckalb USING btree (endet);
CREATE INDEX ax_historischesflurstueckalb_endet ON alkis.ax_historischesflurstueckalb USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_historischesflurstueckalb_gml;
--CREATE UNIQUE INDEX ax_historischesflurstueckalb_gml ON alkis.ax_historischesflurstueckalb USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_historischesflurstueckalb_gml ON alkis.ax_historischesflurstueckalb USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_historischesflurstueckohneraumbezug_endet;
--CREATE INDEX ax_historischesflurstueckohneraumbezug_endet ON alkis.ax_historischesflurstueckohneraumbezug USING btree (endet);
CREATE INDEX ax_historischesflurstueckohneraumbezug_endet ON alkis.ax_historischesflurstueckohneraumbezug USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_historischesflurstueckohneraumbezug_gml;
--CREATE UNIQUE INDEX ax_historischesflurstueckohneraumbezug_gml ON alkis.ax_historischesflurstueckohneraumbezug USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_historischesflurstueckohneraumbezug_gml ON alkis.ax_historischesflurstueckohneraumbezug USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_hoehenfestpunkt_endet;
--CREATE INDEX ax_hoehenfestpunkt_endet ON alkis.ax_hoehenfestpunkt USING btree (endet);
CREATE INDEX ax_hoehenfestpunkt_endet ON alkis.ax_hoehenfestpunkt USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_hoehenfestpunkt_gml;
--CREATE UNIQUE INDEX ax_hoehenfestpunkt_gml ON alkis.ax_hoehenfestpunkt USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_hoehenfestpunkt_gml ON alkis.ax_hoehenfestpunkt USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_hoehenlinie_endet;
--CREATE INDEX ax_hoehenlinie_endet ON alkis.ax_hoehenlinie USING btree (endet);
CREATE INDEX ax_hoehenlinie_endet ON alkis.ax_hoehenlinie USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_hoehenlinie_gml;
--CREATE UNIQUE INDEX ax_hoehenlinie_gml ON alkis.ax_hoehenlinie USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_hoehenlinie_gml ON alkis.ax_hoehenlinie USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_hoehleneingang_endet;
--CREATE INDEX ax_hoehleneingang_endet ON alkis.ax_hoehleneingang USING btree (endet);
CREATE INDEX ax_hoehleneingang_endet ON alkis.ax_hoehleneingang USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_hoehleneingang_gml;
--CREATE UNIQUE INDEX ax_hoehleneingang_gml ON alkis.ax_hoehleneingang USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_hoehleneingang_gml ON alkis.ax_hoehleneingang USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_industrieundgewerbeflaeche_endet;
--CREATE INDEX ax_industrieundgewerbeflaeche_endet ON alkis.ax_industrieundgewerbeflaeche USING btree (endet);
CREATE INDEX ax_industrieundgewerbeflaeche_endet ON alkis.ax_industrieundgewerbeflaeche USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_industrieundgewerbeflaeche_gml;
--CREATE UNIQUE INDEX ax_industrieundgewerbeflaeche_gml ON alkis.ax_industrieundgewerbeflaeche USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_industrieundgewerbeflaeche_gml ON alkis.ax_industrieundgewerbeflaeche USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_insel_endet;
--CREATE INDEX ax_insel_endet ON alkis.ax_insel USING btree (endet);
CREATE INDEX ax_insel_endet ON alkis.ax_insel USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_insel_gml;
--CREATE UNIQUE INDEX ax_insel_gml ON alkis.ax_insel USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_insel_gml ON alkis.ax_insel USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_kanal_endet;
--CREATE INDEX ax_kanal_endet ON alkis.ax_kanal USING btree (endet);
CREATE INDEX ax_kanal_endet ON alkis.ax_kanal USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_kanal_gml;
--CREATE UNIQUE INDEX ax_kanal_gml ON alkis.ax_kanal USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_kanal_gml ON alkis.ax_kanal USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_klassifizierungnachstrassenrecht_endet;
--CREATE INDEX ax_klassifizierungnachstrassenrecht_endet ON alkis.ax_klassifizierungnachstrassenrecht USING btree (endet);
CREATE INDEX ax_klassifizierungnachstrassenrecht_endet ON alkis.ax_klassifizierungnachstrassenrecht USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_klassifizierungnachstrassenrecht_gml;
--CREATE UNIQUE INDEX ax_klassifizierungnachstrassenrecht_gml ON alkis.ax_klassifizierungnachstrassenrecht USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_klassifizierungnachstrassenrecht_gml ON alkis.ax_klassifizierungnachstrassenrecht USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_klassifizierungnachwasserrecht_endet;
--CREATE INDEX ax_klassifizierungnachwasserrecht_endet ON alkis.ax_klassifizierungnachwasserrecht USING btree (endet);
CREATE INDEX ax_klassifizierungnachwasserrecht_endet ON alkis.ax_klassifizierungnachwasserrecht USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_klassifizierungnachwasserrecht_gml;
--CREATE UNIQUE INDEX ax_klassifizierungnachwasserrecht_gml ON alkis.ax_klassifizierungnachwasserrecht USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_klassifizierungnachwasserrecht_gml ON alkis.ax_klassifizierungnachwasserrecht USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_kleinraeumigerlandschaftsteil_endet;
--CREATE INDEX ax_kleinraeumigerlandschaftsteil_endet ON alkis.ax_kleinraeumigerlandschaftsteil USING btree (endet);
CREATE INDEX ax_kleinraeumigerlandschaftsteil_endet ON alkis.ax_kleinraeumigerlandschaftsteil USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_kleinraeumigerlandschaftsteil_gml;
--CREATE UNIQUE INDEX ax_kleinraeumigerlandschaftsteil_gml ON alkis.ax_kleinraeumigerlandschaftsteil USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_kleinraeumigerlandschaftsteil_gml ON alkis.ax_kleinraeumigerlandschaftsteil USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_kommunalesgebiet_endet;
--CREATE INDEX ax_kommunalesgebiet_endet ON alkis.ax_kommunalesgebiet USING btree (endet);
CREATE INDEX ax_kommunalesgebiet_endet ON alkis.ax_kommunalesgebiet USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_kommunalesgebiet_gml;
--CREATE UNIQUE INDEX ax_kommunalesgebiet_gml ON alkis.ax_kommunalesgebiet USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_kommunalesgebiet_gml ON alkis.ax_kommunalesgebiet USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_kondominium_endet;
--CREATE INDEX ax_kondominium_endet ON alkis.ax_kondominium USING btree (endet);
CREATE INDEX ax_kondominium_endet ON alkis.ax_kondominium USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_kondominium_gml;
--CREATE UNIQUE INDEX ax_kondominium_gml ON alkis.ax_kondominium USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_kondominium_gml ON alkis.ax_kondominium USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_kreisregion_endet;
--CREATE INDEX ax_kreisregion_endet ON alkis.ax_kreisregion USING btree (endet);
CREATE INDEX ax_kreisregion_endet ON alkis.ax_kreisregion USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_kreisregion_gml;
--CREATE UNIQUE INDEX ax_kreisregion_gml ON alkis.ax_kreisregion USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_kreisregion_gml ON alkis.ax_kreisregion USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_lagebezeichnungkatalogeintrag_endet;
--CREATE INDEX ax_lagebezeichnungkatalogeintrag_endet ON alkis.ax_lagebezeichnungkatalogeintrag USING btree (endet);
CREATE INDEX ax_lagebezeichnungkatalogeintrag_endet ON alkis.ax_lagebezeichnungkatalogeintrag USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_lagebezeichnungkatalogeintrag_gml;
--CREATE UNIQUE INDEX ax_lagebezeichnungkatalogeintrag_gml ON alkis.ax_lagebezeichnungkatalogeintrag USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_lagebezeichnungkatalogeintrag_gml ON alkis.ax_lagebezeichnungkatalogeintrag USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_lagebezeichnungmithausnummer_endet;
--CREATE INDEX ax_lagebezeichnungmithausnummer_endet ON alkis.ax_lagebezeichnungmithausnummer USING btree (endet);
CREATE INDEX ax_lagebezeichnungmithausnummer_endet ON alkis.ax_lagebezeichnungmithausnummer USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_lagebezeichnungmithausnummer_gml;
--CREATE UNIQUE INDEX ax_lagebezeichnungmithausnummer_gml ON alkis.ax_lagebezeichnungmithausnummer USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_lagebezeichnungmithausnummer_gml ON alkis.ax_lagebezeichnungmithausnummer USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_lagebezeichnungmitpseudonummer_endet;
--CREATE INDEX ax_lagebezeichnungmitpseudonummer_endet ON alkis.ax_lagebezeichnungmitpseudonummer USING btree (endet);
CREATE INDEX ax_lagebezeichnungmitpseudonummer_endet ON alkis.ax_lagebezeichnungmitpseudonummer USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_lagebezeichnungmitpseudonummer_gml;
--CREATE UNIQUE INDEX ax_lagebezeichnungmitpseudonummer_gml ON alkis.ax_lagebezeichnungmitpseudonummer USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_lagebezeichnungmitpseudonummer_gml ON alkis.ax_lagebezeichnungmitpseudonummer USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_lagebezeichnungohnehausnummer_endet;
--CREATE INDEX ax_lagebezeichnungohnehausnummer_endet ON alkis.ax_lagebezeichnungohnehausnummer USING btree (endet);
CREATE INDEX ax_lagebezeichnungohnehausnummer_endet ON alkis.ax_lagebezeichnungohnehausnummer USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_lagebezeichnungohnehausnummer_gml;
--CREATE UNIQUE INDEX ax_lagebezeichnungohnehausnummer_gml ON alkis.ax_lagebezeichnungohnehausnummer USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_lagebezeichnungohnehausnummer_gml ON alkis.ax_lagebezeichnungohnehausnummer USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_lagefestpunkt_endet;
--CREATE INDEX ax_lagefestpunkt_endet ON alkis.ax_lagefestpunkt USING btree (endet);
CREATE INDEX ax_lagefestpunkt_endet ON alkis.ax_lagefestpunkt USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_lagefestpunkt_gml;
--CREATE UNIQUE INDEX ax_lagefestpunkt_gml ON alkis.ax_lagefestpunkt USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_lagefestpunkt_gml ON alkis.ax_lagefestpunkt USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_landschaft_endet;
--CREATE INDEX ax_landschaft_endet ON alkis.ax_landschaft USING btree (endet);
CREATE INDEX ax_landschaft_endet ON alkis.ax_landschaft USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_landschaft_gml;
--CREATE UNIQUE INDEX ax_landschaft_gml ON alkis.ax_landschaft USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_landschaft_gml ON alkis.ax_landschaft USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_landwirtschaft_endet;
--CREATE INDEX ax_landwirtschaft_endet ON alkis.ax_landwirtschaft USING btree (endet);
CREATE INDEX ax_landwirtschaft_endet ON alkis.ax_landwirtschaft USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_landwirtschaft_gml;
--CREATE UNIQUE INDEX ax_landwirtschaft_gml ON alkis.ax_landwirtschaft USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_landwirtschaft_gml ON alkis.ax_landwirtschaft USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_leitung_endet;
--CREATE INDEX ax_leitung_endet ON alkis.ax_leitung USING btree (endet);
CREATE INDEX ax_leitung_endet ON alkis.ax_leitung USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_leitung_gml;
--CREATE UNIQUE INDEX ax_leitung_gml ON alkis.ax_leitung USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_leitung_gml ON alkis.ax_leitung USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_meer_endet;
--CREATE INDEX ax_meer_endet ON alkis.ax_meer USING btree (endet);
CREATE INDEX ax_meer_endet ON alkis.ax_meer USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_meer_gml;
--CREATE UNIQUE INDEX ax_meer_gml ON alkis.ax_meer USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_meer_gml ON alkis.ax_meer USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_moor_endet;
--CREATE INDEX ax_moor_endet ON alkis.ax_moor USING btree (endet);
CREATE INDEX ax_moor_endet ON alkis.ax_moor USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_moor_gml;
--CREATE UNIQUE INDEX ax_moor_gml ON alkis.ax_moor USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_moor_gml ON alkis.ax_moor USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_namensnummer_endet;
--CREATE INDEX ax_namensnummer_endet ON alkis.ax_namensnummer USING btree (endet);
CREATE INDEX ax_namensnummer_endet ON alkis.ax_namensnummer USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_namensnummer_gml;
--CREATE UNIQUE INDEX ax_namensnummer_gml ON alkis.ax_namensnummer USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_namensnummer_gml ON alkis.ax_namensnummer USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_nationalstaat_endet;
--CREATE INDEX ax_nationalstaat_endet ON alkis.ax_nationalstaat USING btree (endet);
CREATE INDEX ax_nationalstaat_endet ON alkis.ax_nationalstaat USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_nationalstaat_gml;
--CREATE UNIQUE INDEX ax_nationalstaat_gml ON alkis.ax_nationalstaat USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_nationalstaat_gml ON alkis.ax_nationalstaat USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_naturumweltoderbodenschutzrecht_endet;
--CREATE INDEX ax_naturumweltoderbodenschutzrecht_endet ON alkis.ax_naturumweltoderbodenschutzrecht USING btree (endet);
CREATE INDEX ax_naturumweltoderbodenschutzrecht_endet ON alkis.ax_naturumweltoderbodenschutzrecht USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_naturumweltoderbodenschutzrecht_gml;
--CREATE UNIQUE INDEX ax_naturumweltoderbodenschutzrecht_gml ON alkis.ax_naturumweltoderbodenschutzrecht USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_naturumweltoderbodenschutzrecht_gml ON alkis.ax_naturumweltoderbodenschutzrecht USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_netzknoten_endet;
--CREATE INDEX ax_netzknoten_endet ON alkis.ax_netzknoten USING btree (endet);
CREATE INDEX ax_netzknoten_endet ON alkis.ax_netzknoten USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_netzknoten_gml;
--CREATE UNIQUE INDEX ax_netzknoten_gml ON alkis.ax_netzknoten USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_netzknoten_gml ON alkis.ax_netzknoten USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_nullpunkt_endet;
--CREATE INDEX ax_nullpunkt_endet ON alkis.ax_nullpunkt USING btree (endet);
CREATE INDEX ax_nullpunkt_endet ON alkis.ax_nullpunkt USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_nullpunkt_gml;
--CREATE UNIQUE INDEX ax_nullpunkt_gml ON alkis.ax_nullpunkt USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_nullpunkt_gml ON alkis.ax_nullpunkt USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_ortslage_endet;
--CREATE INDEX ax_ortslage_endet ON alkis.ax_ortslage USING btree (endet);
CREATE INDEX ax_ortslage_endet ON alkis.ax_ortslage USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_ortslage_gml;
--CREATE UNIQUE INDEX ax_ortslage_gml ON alkis.ax_ortslage USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_ortslage_gml ON alkis.ax_ortslage USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_person_endet;
--CREATE INDEX ax_person_endet ON alkis.ax_person USING btree (endet);
CREATE INDEX ax_person_endet ON alkis.ax_person USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_person_gml;
--CREATE UNIQUE INDEX ax_person_gml ON alkis.ax_person USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_person_gml ON alkis.ax_person USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_personengruppe_endet;
--CREATE INDEX ax_personengruppe_endet ON alkis.ax_personengruppe USING btree (endet);
CREATE INDEX ax_personengruppe_endet ON alkis.ax_personengruppe USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_personengruppe_gml;
--CREATE UNIQUE INDEX ax_personengruppe_gml ON alkis.ax_personengruppe USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_personengruppe_gml ON alkis.ax_personengruppe USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_platz_endet;
--CREATE INDEX ax_platz_endet ON alkis.ax_platz USING btree (endet);
CREATE INDEX ax_platz_endet ON alkis.ax_platz USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_platz_gml;
--CREATE UNIQUE INDEX ax_platz_gml ON alkis.ax_platz USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_platz_gml ON alkis.ax_platz USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_polder_endet;
--CREATE INDEX ax_polder_endet ON alkis.ax_polder USING btree (endet);
CREATE INDEX ax_polder_endet ON alkis.ax_polder USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_polder_gml;
--CREATE UNIQUE INDEX ax_polder_gml ON alkis.ax_polder USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_polder_gml ON alkis.ax_polder USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_punktkennunguntergegangen_endet;
--CREATE INDEX ax_punktkennunguntergegangen_endet ON alkis.ax_punktkennunguntergegangen USING btree (endet);
CREATE INDEX ax_punktkennunguntergegangen_endet ON alkis.ax_punktkennunguntergegangen USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_punktkennunguntergegangen_gml;
--CREATE UNIQUE INDEX ax_punktkennunguntergegangen_gml ON alkis.ax_punktkennunguntergegangen USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_punktkennunguntergegangen_gml ON alkis.ax_punktkennunguntergegangen USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_punktkennungvergleichend_endet;
--CREATE INDEX ax_punktkennungvergleichend_endet ON alkis.ax_punktkennungvergleichend USING btree (endet);
CREATE INDEX ax_punktkennungvergleichend_endet ON alkis.ax_punktkennungvergleichend USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_punktkennungvergleichend_gml;
--CREATE UNIQUE INDEX ax_punktkennungvergleichend_gml ON alkis.ax_punktkennungvergleichend USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_punktkennungvergleichend_gml ON alkis.ax_punktkennungvergleichend USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_punktortag_endet;
--CREATE INDEX ax_punktortag_endet ON alkis.ax_punktortag USING btree (endet);
CREATE INDEX ax_punktortag_endet ON alkis.ax_punktortag USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_punktortag_gml;
--CREATE UNIQUE INDEX ax_punktortag_gml ON alkis.ax_punktortag USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_punktortag_gml ON alkis.ax_punktortag USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_punktortau_endet;
--CREATE INDEX ax_punktortau_endet ON alkis.ax_punktortau USING btree (endet);
CREATE INDEX ax_punktortau_endet ON alkis.ax_punktortau USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_punktortau_gml;
--CREATE UNIQUE INDEX ax_punktortau_gml ON alkis.ax_punktortau USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_punktortau_gml ON alkis.ax_punktortau USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_punktortta_endet;
--CREATE INDEX ax_punktortta_endet ON alkis.ax_punktortta USING btree (endet);
CREATE INDEX ax_punktortta_endet ON alkis.ax_punktortta USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_punktortta_gml;
--CREATE UNIQUE INDEX ax_punktortta_gml ON alkis.ax_punktortta USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_punktortta_gml ON alkis.ax_punktortta USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_referenzstationspunkt_endet;
--CREATE INDEX ax_referenzstationspunkt_endet ON alkis.ax_referenzstationspunkt USING btree (endet);
CREATE INDEX ax_referenzstationspunkt_endet ON alkis.ax_referenzstationspunkt USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_referenzstationspunkt_gml;
--CREATE UNIQUE INDEX ax_referenzstationspunkt_gml ON alkis.ax_referenzstationspunkt USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_referenzstationspunkt_gml ON alkis.ax_referenzstationspunkt USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_regierungsbezirk_endet;
--CREATE INDEX ax_regierungsbezirk_endet ON alkis.ax_regierungsbezirk USING btree (endet);
CREATE INDEX ax_regierungsbezirk_endet ON alkis.ax_regierungsbezirk USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_regierungsbezirk_gml;
--CREATE UNIQUE INDEX ax_regierungsbezirk_gml ON alkis.ax_regierungsbezirk USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_regierungsbezirk_gml ON alkis.ax_regierungsbezirk USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_reservierung_endet;
--CREATE INDEX ax_reservierung_endet ON alkis.ax_reservierung USING btree (endet);
CREATE INDEX ax_reservierung_endet ON alkis.ax_reservierung USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_reservierung_gml;
--CREATE UNIQUE INDEX ax_reservierung_gml ON alkis.ax_reservierung USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_reservierung_gml ON alkis.ax_reservierung USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_schifffahrtsliniefaehrverkehr_endet;
--CREATE INDEX ax_schifffahrtsliniefaehrverkehr_endet ON alkis.ax_schifffahrtsliniefaehrverkehr USING btree (endet);
CREATE INDEX ax_schifffahrtsliniefaehrverkehr_endet ON alkis.ax_schifffahrtsliniefaehrverkehr USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_schifffahrtsliniefaehrverkehr_gml;
--CREATE UNIQUE INDEX ax_schifffahrtsliniefaehrverkehr_gml ON alkis.ax_schifffahrtsliniefaehrverkehr USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_schifffahrtsliniefaehrverkehr_gml ON alkis.ax_schifffahrtsliniefaehrverkehr USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_schiffsverkehr_endet;
--CREATE INDEX ax_schiffsverkehr_endet ON alkis.ax_schiffsverkehr USING btree (endet);
CREATE INDEX ax_schiffsverkehr_endet ON alkis.ax_schiffsverkehr USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_schiffsverkehr_gml;
--CREATE UNIQUE INDEX ax_schiffsverkehr_gml ON alkis.ax_schiffsverkehr USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_schiffsverkehr_gml ON alkis.ax_schiffsverkehr USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_schleuse_endet;
--CREATE INDEX ax_schleuse_endet ON alkis.ax_schleuse USING btree (endet);
CREATE INDEX ax_schleuse_endet ON alkis.ax_schleuse USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_schleuse_gml;
--CREATE UNIQUE INDEX ax_schleuse_gml ON alkis.ax_schleuse USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_schleuse_gml ON alkis.ax_schleuse USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_schutzgebietnachnaturumweltoderbodenschutzrecht_endet;
--CREATE INDEX ax_schutzgebietnachnaturumweltoderbodenschutzrecht_endet ON alkis.ax_schutzgebietnachnaturumweltoderbodenschutzrecht USING btree (endet);
CREATE INDEX ax_schutzgebietnachnaturumweltoderbodenschutzrecht_endet ON alkis.ax_schutzgebietnachnaturumweltoderbodenschutzrecht USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_schutzgebietnachnaturumweltoderbodenschutzrecht_gml;
--CREATE UNIQUE INDEX ax_schutzgebietnachnaturumweltoderbodenschutzrecht_gml ON alkis.ax_schutzgebietnachnaturumweltoderbodenschutzrecht USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_schutzgebietnachnaturumweltoderbodenschutzrecht_gml ON alkis.ax_schutzgebietnachnaturumweltoderbodenschutzrecht USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_schutzgebietnachwasserrecht_endet;
--CREATE INDEX ax_schutzgebietnachwasserrecht_endet ON alkis.ax_schutzgebietnachwasserrecht USING btree (endet);
CREATE INDEX ax_schutzgebietnachwasserrecht_endet ON alkis.ax_schutzgebietnachwasserrecht USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_schutzgebietnachwasserrecht_gml;
--CREATE UNIQUE INDEX ax_schutzgebietnachwasserrecht_gml ON alkis.ax_schutzgebietnachwasserrecht USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_schutzgebietnachwasserrecht_gml ON alkis.ax_schutzgebietnachwasserrecht USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_schutzzone_endet;
--CREATE INDEX ax_schutzzone_endet ON alkis.ax_schutzzone USING btree (endet);
CREATE INDEX ax_schutzzone_endet ON alkis.ax_schutzzone USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_schutzzone_gml;
--CREATE UNIQUE INDEX ax_schutzzone_gml ON alkis.ax_schutzzone USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_schutzzone_gml ON alkis.ax_schutzzone USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_schwere_endet;
--CREATE INDEX ax_schwere_endet ON alkis.ax_schwere USING btree (endet);
CREATE INDEX ax_schwere_endet ON alkis.ax_schwere USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_schwere_gml;
--CREATE UNIQUE INDEX ax_schwere_gml ON alkis.ax_schwere USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_schwere_gml ON alkis.ax_schwere USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_schwerefestpunkt_endet;
--CREATE INDEX ax_schwerefestpunkt_endet ON alkis.ax_schwerefestpunkt USING btree (endet);
CREATE INDEX ax_schwerefestpunkt_endet ON alkis.ax_schwerefestpunkt USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_schwerefestpunkt_gml;
--CREATE UNIQUE INDEX ax_schwerefestpunkt_gml ON alkis.ax_schwerefestpunkt USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_schwerefestpunkt_gml ON alkis.ax_schwerefestpunkt USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_seilbahnschwebebahn_endet;
--CREATE INDEX ax_seilbahnschwebebahn_endet ON alkis.ax_seilbahnschwebebahn USING btree (endet);
CREATE INDEX ax_seilbahnschwebebahn_endet ON alkis.ax_seilbahnschwebebahn USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_seilbahnschwebebahn_gml;
--CREATE UNIQUE INDEX ax_seilbahnschwebebahn_gml ON alkis.ax_seilbahnschwebebahn USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_seilbahnschwebebahn_gml ON alkis.ax_seilbahnschwebebahn USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_sicherungspunkt_endet;
--CREATE INDEX ax_sicherungspunkt_endet ON alkis.ax_sicherungspunkt USING btree (endet);
CREATE INDEX ax_sicherungspunkt_endet ON alkis.ax_sicherungspunkt USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_sicherungspunkt_gml;
--CREATE UNIQUE INDEX ax_sicherungspunkt_gml ON alkis.ax_sicherungspunkt USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_sicherungspunkt_gml ON alkis.ax_sicherungspunkt USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_sickerstrecke_endet;
--CREATE INDEX ax_sickerstrecke_endet ON alkis.ax_sickerstrecke USING btree (endet);
CREATE INDEX ax_sickerstrecke_endet ON alkis.ax_sickerstrecke USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_sickerstrecke_gml;
--CREATE UNIQUE INDEX ax_sickerstrecke_gml ON alkis.ax_sickerstrecke USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_sickerstrecke_gml ON alkis.ax_sickerstrecke USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_siedlungsflaeche_endet;
--CREATE INDEX ax_siedlungsflaeche_endet ON alkis.ax_siedlungsflaeche USING btree (endet);
CREATE INDEX ax_siedlungsflaeche_endet ON alkis.ax_siedlungsflaeche USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_siedlungsflaeche_gml;
--CREATE UNIQUE INDEX ax_siedlungsflaeche_gml ON alkis.ax_siedlungsflaeche USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_siedlungsflaeche_gml ON alkis.ax_siedlungsflaeche USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_skizze_endet;
--CREATE INDEX ax_skizze_endet ON alkis.ax_skizze USING btree (endet);
CREATE INDEX ax_skizze_endet ON alkis.ax_skizze USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_skizze_gml;
--CREATE UNIQUE INDEX ax_skizze_gml ON alkis.ax_skizze USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_skizze_gml ON alkis.ax_skizze USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_soll_endet;
--CREATE INDEX ax_soll_endet ON alkis.ax_soll USING btree (endet);
CREATE INDEX ax_soll_endet ON alkis.ax_soll USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_soll_gml;
--CREATE UNIQUE INDEX ax_soll_gml ON alkis.ax_soll USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_soll_gml ON alkis.ax_soll USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_sonstigervermessungspunkt_endet;
--CREATE INDEX ax_sonstigervermessungspunkt_endet ON alkis.ax_sonstigervermessungspunkt USING btree (endet);
CREATE INDEX ax_sonstigervermessungspunkt_endet ON alkis.ax_sonstigervermessungspunkt USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_sonstigervermessungspunkt_gml;
--CREATE UNIQUE INDEX ax_sonstigervermessungspunkt_gml ON alkis.ax_sonstigervermessungspunkt USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_sonstigervermessungspunkt_gml ON alkis.ax_sonstigervermessungspunkt USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_sonstigesbauwerkodersonstigeeinrichtung_endet;
--CREATE INDEX ax_sonstigesbauwerkodersonstigeeinrichtung_endet ON alkis.ax_sonstigesbauwerkodersonstigeeinrichtung USING btree (endet);
CREATE INDEX ax_sonstigesbauwerkodersonstigeeinrichtung_endet ON alkis.ax_sonstigesbauwerkodersonstigeeinrichtung USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_sonstigesbauwerkodersonstigeeinrichtung_gml;
--CREATE UNIQUE INDEX ax_sonstigesbauwerkodersonstigeeinrichtung_gml ON alkis.ax_sonstigesbauwerkodersonstigeeinrichtung USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_sonstigesbauwerkodersonstigeeinrichtung_gml ON alkis.ax_sonstigesbauwerkodersonstigeeinrichtung USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_sonstigesrecht_endet;
--CREATE INDEX ax_sonstigesrecht_endet ON alkis.ax_sonstigesrecht USING btree (endet);
CREATE INDEX ax_sonstigesrecht_endet ON alkis.ax_sonstigesrecht USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_sonstigesrecht_gml;
--CREATE UNIQUE INDEX ax_sonstigesrecht_gml ON alkis.ax_sonstigesrecht USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_sonstigesrecht_gml ON alkis.ax_sonstigesrecht USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_sportfreizeitunderholungsflaeche_endet;
--CREATE INDEX ax_sportfreizeitunderholungsflaeche_endet ON alkis.ax_sportfreizeitunderholungsflaeche USING btree (endet);
CREATE INDEX ax_sportfreizeitunderholungsflaeche_endet ON alkis.ax_sportfreizeitunderholungsflaeche USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_sportfreizeitunderholungsflaeche_gml;
--CREATE UNIQUE INDEX ax_sportfreizeitunderholungsflaeche_gml ON alkis.ax_sportfreizeitunderholungsflaeche USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_sportfreizeitunderholungsflaeche_gml ON alkis.ax_sportfreizeitunderholungsflaeche USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_stehendesgewaesser_endet;
--CREATE INDEX ax_stehendesgewaesser_endet ON alkis.ax_stehendesgewaesser USING btree (endet);
CREATE INDEX ax_stehendesgewaesser_endet ON alkis.ax_stehendesgewaesser USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_stehendesgewaesser_gml;
--CREATE UNIQUE INDEX ax_stehendesgewaesser_gml ON alkis.ax_stehendesgewaesser USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_stehendesgewaesser_gml ON alkis.ax_stehendesgewaesser USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_strasse_endet;
--CREATE INDEX ax_strasse_endet ON alkis.ax_strasse USING btree (endet);
CREATE INDEX ax_strasse_endet ON alkis.ax_strasse USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_strasse_gml;
--CREATE UNIQUE INDEX ax_strasse_gml ON alkis.ax_strasse USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_strasse_gml ON alkis.ax_strasse USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_strassenachse_endet;
--CREATE INDEX ax_strassenachse_endet ON alkis.ax_strassenachse USING btree (endet);
CREATE INDEX ax_strassenachse_endet ON alkis.ax_strassenachse USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_strassenachse_gml;
--CREATE UNIQUE INDEX ax_strassenachse_gml ON alkis.ax_strassenachse USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_strassenachse_gml ON alkis.ax_strassenachse USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_strassenverkehr_endet;
--CREATE INDEX ax_strassenverkehr_endet ON alkis.ax_strassenverkehr USING btree (endet);
CREATE INDEX ax_strassenverkehr_endet ON alkis.ax_strassenverkehr USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_strassenverkehr_gml;
--CREATE UNIQUE INDEX ax_strassenverkehr_gml ON alkis.ax_strassenverkehr USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_strassenverkehr_gml ON alkis.ax_strassenverkehr USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_strassenverkehrsanlage_endet;
--CREATE INDEX ax_strassenverkehrsanlage_endet ON alkis.ax_strassenverkehrsanlage USING btree (endet);
CREATE INDEX ax_strassenverkehrsanlage_endet ON alkis.ax_strassenverkehrsanlage USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_strassenverkehrsanlage_gml;
--CREATE UNIQUE INDEX ax_strassenverkehrsanlage_gml ON alkis.ax_strassenverkehrsanlage USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_strassenverkehrsanlage_gml ON alkis.ax_strassenverkehrsanlage USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_sumpf_endet;
--CREATE INDEX ax_sumpf_endet ON alkis.ax_sumpf USING btree (endet);
CREATE INDEX ax_sumpf_endet ON alkis.ax_sumpf USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_sumpf_gml;
--CREATE UNIQUE INDEX ax_sumpf_gml ON alkis.ax_sumpf USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_sumpf_gml ON alkis.ax_sumpf USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_tagebaugrubesteinbruch_endet;
--CREATE INDEX ax_tagebaugrubesteinbruch_endet ON alkis.ax_tagebaugrubesteinbruch USING btree (endet);
CREATE INDEX ax_tagebaugrubesteinbruch_endet ON alkis.ax_tagebaugrubesteinbruch USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_tagebaugrubesteinbruch_gml;
--CREATE UNIQUE INDEX ax_tagebaugrubesteinbruch_gml ON alkis.ax_tagebaugrubesteinbruch USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_tagebaugrubesteinbruch_gml ON alkis.ax_tagebaugrubesteinbruch USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_tagesabschnitt_endet;
--CREATE INDEX ax_tagesabschnitt_endet ON alkis.ax_tagesabschnitt USING btree (endet);
CREATE INDEX ax_tagesabschnitt_endet ON alkis.ax_tagesabschnitt USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_tagesabschnitt_gml;
--CREATE UNIQUE INDEX ax_tagesabschnitt_gml ON alkis.ax_tagesabschnitt USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_tagesabschnitt_gml ON alkis.ax_tagesabschnitt USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_testgelaende_endet;
--CREATE INDEX ax_testgelaende_endet ON alkis.ax_testgelaende USING btree (endet);
CREATE INDEX ax_testgelaende_endet ON alkis.ax_testgelaende USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_testgelaende_gml;
--CREATE UNIQUE INDEX ax_testgelaende_gml ON alkis.ax_testgelaende USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_testgelaende_gml ON alkis.ax_testgelaende USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_topographischelinie_endet;
--CREATE INDEX ax_topographischelinie_endet ON alkis.ax_topographischelinie USING btree (endet);
CREATE INDEX ax_topographischelinie_endet ON alkis.ax_topographischelinie USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_topographischelinie_gml;
--CREATE UNIQUE INDEX ax_topographischelinie_gml ON alkis.ax_topographischelinie USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_topographischelinie_gml ON alkis.ax_topographischelinie USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_transportanlage_endet;
--CREATE INDEX ax_transportanlage_endet ON alkis.ax_transportanlage USING btree (endet);
CREATE INDEX ax_transportanlage_endet ON alkis.ax_transportanlage USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_transportanlage_gml;
--CREATE UNIQUE INDEX ax_transportanlage_gml ON alkis.ax_transportanlage USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_transportanlage_gml ON alkis.ax_transportanlage USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_turm_endet;
--CREATE INDEX ax_turm_endet ON alkis.ax_turm USING btree (endet);
CREATE INDEX ax_turm_endet ON alkis.ax_turm USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_turm_gml;
--CREATE UNIQUE INDEX ax_turm_gml ON alkis.ax_turm USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_turm_gml ON alkis.ax_turm USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_unlandvegetationsloseflaeche_endet;
--CREATE INDEX ax_unlandvegetationsloseflaeche_endet ON alkis.ax_unlandvegetationsloseflaeche USING btree (endet);
CREATE INDEX ax_unlandvegetationsloseflaeche_endet ON alkis.ax_unlandvegetationsloseflaeche USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_unlandvegetationsloseflaeche_gml;
--CREATE UNIQUE INDEX ax_unlandvegetationsloseflaeche_gml ON alkis.ax_unlandvegetationsloseflaeche USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_unlandvegetationsloseflaeche_gml ON alkis.ax_unlandvegetationsloseflaeche USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_untergeordnetesgewaesser_endet;
--CREATE INDEX ax_untergeordnetesgewaesser_endet ON alkis.ax_untergeordnetesgewaesser USING btree (endet);
CREATE INDEX ax_untergeordnetesgewaesser_endet ON alkis.ax_untergeordnetesgewaesser USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_untergeordnetesgewaesser_gml;
--CREATE UNIQUE INDEX ax_untergeordnetesgewaesser_gml ON alkis.ax_untergeordnetesgewaesser USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_untergeordnetesgewaesser_gml ON alkis.ax_untergeordnetesgewaesser USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_vegetationsmerkmal_endet;
--CREATE INDEX ax_vegetationsmerkmal_endet ON alkis.ax_vegetationsmerkmal USING btree (endet);
CREATE INDEX ax_vegetationsmerkmal_endet ON alkis.ax_vegetationsmerkmal USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_vegetationsmerkmal_gml;
--CREATE UNIQUE INDEX ax_vegetationsmerkmal_gml ON alkis.ax_vegetationsmerkmal USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_vegetationsmerkmal_gml ON alkis.ax_vegetationsmerkmal USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_verband_endet;
--CREATE INDEX ax_verband_endet ON alkis.ax_verband USING btree (endet);
CREATE INDEX ax_verband_endet ON alkis.ax_verband USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_verband_gml;
--CREATE UNIQUE INDEX ax_verband_gml ON alkis.ax_verband USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_verband_gml ON alkis.ax_verband USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_vertretung_endet;
--CREATE INDEX ax_vertretung_endet ON alkis.ax_vertretung USING btree (endet);
CREATE INDEX ax_vertretung_endet ON alkis.ax_vertretung USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_vertretung_gml;
--CREATE UNIQUE INDEX ax_vertretung_gml ON alkis.ax_vertretung USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_vertretung_gml ON alkis.ax_vertretung USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_verwaltung_endet;
--CREATE INDEX ax_verwaltung_endet ON alkis.ax_verwaltung USING btree (endet);
CREATE INDEX ax_verwaltung_endet ON alkis.ax_verwaltung USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_verwaltung_gml;
--CREATE UNIQUE INDEX ax_verwaltung_gml ON alkis.ax_verwaltung USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_verwaltung_gml ON alkis.ax_verwaltung USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_verwaltungsgemeinschaft_endet;
--CREATE INDEX ax_verwaltungsgemeinschaft_endet ON alkis.ax_verwaltungsgemeinschaft USING btree (endet);
CREATE INDEX ax_verwaltungsgemeinschaft_endet ON alkis.ax_verwaltungsgemeinschaft USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_verwaltungsgemeinschaft_gml;
--CREATE UNIQUE INDEX ax_verwaltungsgemeinschaft_gml ON alkis.ax_verwaltungsgemeinschaft USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_verwaltungsgemeinschaft_gml ON alkis.ax_verwaltungsgemeinschaft USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_vorratsbehaelterspeicherbauwerk_endet;
--CREATE INDEX ax_vorratsbehaelterspeicherbauwerk_endet ON alkis.ax_vorratsbehaelterspeicherbauwerk USING btree (endet);
CREATE INDEX ax_vorratsbehaelterspeicherbauwerk_endet ON alkis.ax_vorratsbehaelterspeicherbauwerk USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_vorratsbehaelterspeicherbauwerk_gml;
--CREATE UNIQUE INDEX ax_vorratsbehaelterspeicherbauwerk_gml ON alkis.ax_vorratsbehaelterspeicherbauwerk USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_vorratsbehaelterspeicherbauwerk_gml ON alkis.ax_vorratsbehaelterspeicherbauwerk USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_wald_endet;
--CREATE INDEX ax_wald_endet ON alkis.ax_wald USING btree (endet);
CREATE INDEX ax_wald_endet ON alkis.ax_wald USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_wald_gml;
--CREATE UNIQUE INDEX ax_wald_gml ON alkis.ax_wald USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_wald_gml ON alkis.ax_wald USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_wasserlauf_endet;
--CREATE INDEX ax_wasserlauf_endet ON alkis.ax_wasserlauf USING btree (endet);
CREATE INDEX ax_wasserlauf_endet ON alkis.ax_wasserlauf USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_wasserlauf_gml;
--CREATE UNIQUE INDEX ax_wasserlauf_gml ON alkis.ax_wasserlauf USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_wasserlauf_gml ON alkis.ax_wasserlauf USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_wasserspiegelhoehe_endet;
--CREATE INDEX ax_wasserspiegelhoehe_endet ON alkis.ax_wasserspiegelhoehe USING btree (endet);
CREATE INDEX ax_wasserspiegelhoehe_endet ON alkis.ax_wasserspiegelhoehe USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_wasserspiegelhoehe_gml;
--CREATE UNIQUE INDEX ax_wasserspiegelhoehe_gml ON alkis.ax_wasserspiegelhoehe USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_wasserspiegelhoehe_gml ON alkis.ax_wasserspiegelhoehe USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_weg_endet;
--CREATE INDEX ax_weg_endet ON alkis.ax_weg USING btree (endet);
CREATE INDEX ax_weg_endet ON alkis.ax_weg USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_weg_gml;
--CREATE UNIQUE INDEX ax_weg_gml ON alkis.ax_weg USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_weg_gml ON alkis.ax_weg USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_wegpfadsteig_endet;
--CREATE INDEX ax_wegpfadsteig_endet ON alkis.ax_wegpfadsteig USING btree (endet);
CREATE INDEX ax_wegpfadsteig_endet ON alkis.ax_wegpfadsteig USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_wegpfadsteig_gml;
--CREATE UNIQUE INDEX ax_wegpfadsteig_gml ON alkis.ax_wegpfadsteig USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_wegpfadsteig_gml ON alkis.ax_wegpfadsteig USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_wirtschaftlicheeinheit_endet;
--CREATE INDEX ax_wirtschaftlicheeinheit_endet ON alkis.ax_wirtschaftlicheeinheit USING btree (endet);
CREATE INDEX ax_wirtschaftlicheeinheit_endet ON alkis.ax_wirtschaftlicheeinheit USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_wirtschaftlicheeinheit_gml;
--CREATE UNIQUE INDEX ax_wirtschaftlicheeinheit_gml ON alkis.ax_wirtschaftlicheeinheit USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_wirtschaftlicheeinheit_gml ON alkis.ax_wirtschaftlicheeinheit USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_wohnbauflaeche_endet;
--CREATE INDEX ax_wohnbauflaeche_endet ON alkis.ax_wohnbauflaeche USING btree (endet);
CREATE INDEX ax_wohnbauflaeche_endet ON alkis.ax_wohnbauflaeche USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_wohnbauflaeche_gml;
--CREATE UNIQUE INDEX ax_wohnbauflaeche_gml ON alkis.ax_wohnbauflaeche USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_wohnbauflaeche_gml ON alkis.ax_wohnbauflaeche USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_wohnplatz_endet;
--CREATE INDEX ax_wohnplatz_endet ON alkis.ax_wohnplatz USING btree (endet);
CREATE INDEX ax_wohnplatz_endet ON alkis.ax_wohnplatz USING btree (endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.ax_wohnplatz_gml;
--CREATE UNIQUE INDEX ax_wohnplatz_gml ON alkis.ax_wohnplatz USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX ax_wohnplatz_gml ON alkis.ax_wohnplatz USING btree (gml_id, endet DESC, beginnt DESC);
         
DROP INDEX IF EXISTS alkis.n_nutzung_pk;
--CREATE UNIQUE INDEX n_nutzung_pk ON alkis.n_nutzung USING btree (gml_id, beginnt);
CREATE UNIQUE INDEX n_nutzung_pk ON alkis.n_nutzung USING btree (gml_id, endet DESC, beginnt DESC);




-- Änderungen, die erforderlich waren um die Testdaten einzulesen

ALTER TABLE alkis.ax_lagebezeichnungohnehausnummer ALTER COLUMN gehoertzu DROP NOT NULL;
ALTER TABLE alkis.ax_lagebezeichnungmithausnummer ALTER COLUMN gehoertzu DROP NOT NULL;
ALTER TABLE alkis.ax_grenzpunkt ALTER COLUMN bestehtaus DROP NOT NULL;
ALTER TABLE alkis.ax_besonderertopographischerpunkt ALTER COLUMN bestehtaus DROP NOT NULL;
ALTER TABLE alkis.ax_besonderergebaeudepunkt ALTER COLUMN bestehtaus DROP NOT NULL;
ALTER TABLE alkis.ax_besondererbauwerkspunkt ALTER COLUMN bestehtaus DROP NOT NULL;
ALTER TABLE alkis.ax_schutzgebietnachnaturumweltoderbodenschutzrecht ALTER COLUMN bestehtaus DROP NOT NULL;
ALTER TABLE alkis.ax_boeschungkliff ALTER COLUMN bestehtaus DROP NOT NULL;
ALTER TABLE alkis.ax_aufnahmepunkt ALTER COLUMN bestehtaus DROP NOT NULL;
ALTER TABLE alkis.ax_sonstigervermessungspunkt ALTER COLUMN bestehtaus DROP NOT NULL;
ALTER TABLE alkis.ax_sicherungspunkt ALTER COLUMN bestehtaus DROP NOT NULL;
ALTER TABLE alkis.ax_schutzgebietnachwasserrecht ALTER COLUMN bestehtaus DROP NOT NULL;
ALTER TABLE alkis.ax_verwaltung ALTER COLUMN beziehtsichauf DROP NOT NULL;
ALTER TABLE alkis.ax_verwaltungsgemeinschaft ALTER COLUMN bestehtaus DROP NOT NULL;
ALTER TABLE alkis.ax_fortfuehrungsfall ALTER COLUMN inverszu_beziehtsichauf_ax_fortfuehrungsnachweisdeckblatt DROP NOT NULL;

END;
