edbsilon/Tabellen/auto_create_oracle.py

# Copyright (C)  2004 by Intevation GmbH
# Authors:
# Ludwig Reiter <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with the software for details.

"""Erzeugt automatisch CREATE-SQL-Kommandos aus dem Konfigurationsfile.
   Benötigt 2 Argumente : Quell-Konffile Ziel-SQLfile
   Beinhaltet Klasse Tab für Tabellen
           und Liste tablist für die verschiedenen Tabellenobjekte
   
   Liest eine Zeile des Konffiles und bearbeitet sie:
        Wenn Kommentar:
             nächste Zeile
        Wenn Folienspezifikation(d.h. nur Folie und Tabellenflags gesetzt):
             Wenn Folientabellen alle vorhanden
                nächste Zeile
             Sonst lege zusätzliche Tabellen an
               (d.h. Tab anlegen und in tablist appenden)
        Wenn BesondereInfospezifikation ohne Tabellenname:
             Gehe die Folientabellen in tabliste durch und lege die
               Attribute an, falls sie noch nicht vorhanden
        Wenn BesondereInfospezifikation mit Tabellenname:
             Wenn Tabelle noch nicht vorhanden:
                  Lege Tabelle an und appende sie in tablist
             Wenn Attribute noch nicht vorhanden:
                  Lege Attribute in der Tabelle an            
    Nach diesen Durchlauf müssten alle anzulegenden Tabellen mit ihren 
    Attributen in tablist als Tab-Objekte stehen
    Gehe tablist durch und erzeuge die SQL_Kommandos
    
    Folientabellen haben die Namen f<foliennr><_p oder _l oder _f>
    und mindestens die Attribute objnr, objart, aktualitaet, edatum, geom.
    
    anderen Tabellen haben mindestens die Attribute objnr, artderinfo,
    kartentyp, darstellungsart.
    """           
             
import sys    

class Tab:
    """Kontainer für den Tabellennamen und die Attribute + Art der Attribute
    einer Tabelle. Speichert dies solange bis alle Konfigurationsdateizeilen
    verarbeitet sind. Dann wird mit SQL_create die SQL -Create-Kommandos 
    erzeugt."""
    def __init__(self, Name, ArtderTabelle):
        """Name ist der Name der Tabelle
        ArtderTabelle gibt an was für eine Tabelle erzeugt werden soll:
           F für Folientabelle  mit Linien- oder Flächengeometrie
           FP für Folientablle mit Punktgeometrie
           Z für Zusatzdatentabelle ohne Geometrie
           G für Zusatzdatentabelle mit Geometrie
           GP für Zusatzdatentabelle mit Punktgeometrie"""
        self.Name = Name
        self.Attribute = []
        self.Attribute.append(("objnr", "VARCHAR(7)"))
        self.Attribute.append(("ogr_fid", "INTEGER"))
        if  ArtderTabelle =="F" or ArtderTabelle == "FP" :
            self.Attribute.append( ("objart", "INTEGER" ) )
            self.Attribute.append( ("aktualitaet", "VARCHAR(2)"))
            self.Attribute.append( ("edatum", "DATE"))
            self.Attribute.append( ("geom", "MDSYS.SDO_GEOMETRY") )
            if ArtderTabelle == "FP" :
                self.Attribute.append( ("winkel", "INTEGER"))      
        elif ArtderTabelle == 'Z' or ArtderTabelle =='G'or ArtderTabelle=="GP":
            self.Attribute.append( ("artderinfo", "INTEGER") )
            self.Attribute.append( ("kartentyp", "VARCHAR(2)" ))
            self.Attribute.append( ("darstellungsart", "INTEGER" ))
            if ArtderTabelle == "G":
                self.Attribute.append( ("geom", "MDSYS.SDO_GEOMETRY") )
            elif ArtderTabelle == "GP":
                self.Attribute.append( ("geom", "MDSYS.SDO_GEOMETRY") )
                self.Attribute.append( ("winkel", "INTEGER") )    
                
    def isin_Attribute(self, Attribut):
        """sucht self.Attribute nach den Attribut durch:
           1 falls vorhanden
           0 sonst"""
        for (Attname,dummy) in self.Attribute:
            if Attname == Attribut:
                return 1
        return 0                         
        
    def append_Attribut(self, Atttupel):
        """fügt ein Attributtupel der Form ( Attributsnamen, Attributsart) in
        self.Attribute ein, wenn noch nicht vorhanden."""
        if not self.isin_Attribute( Atttupel[0]) and Atttupel[0] != "":
            self.Attribute.append( Atttupel )     
        
    def get_Name(self):
        """Gibt self.Name zurück"""
        return self.Name        
        
    def create_SQL(self):
        """erzeugt das CREATE-SQL-Kommando und gibt es zurück"""
        SQL_Kom ="CREATE TABLE "
        SQL_Kom += self.Name
        SQL_Kom += "\n ( "
        Komma =0
        for (Attname, Attart) in  self.Attribute: #Attname für Attributname
            if Komma ==1:                         #Attart für Attributsart
                SQL_Kom += ","
            SQL_Kom += "\n     "
            SQL_Kom += Attname
            SQL_Kom += "     "
            SQL_Kom += Attart
            Komma =1
        SQL_Kom += "\n ); \n"                     
        return SQL_Kom
    
    def erzeuge_Metadata_SQL(self):
        """erzeugt die in die METADATA -Insert-SQL-Befehle und den
        Index für diese Tabelle.
        Dies muss man aendern, falls man die Indizes anpassen will."""
        SQL_Kom = ""
        if self.Name[-2:] in ['_p','_l','_f' ]:
            # Anlegen der Metadaten 
            SQL_Kom = "INSERT INTO USER_SDO_GEOM_METADATA VALUES (\n '"
            SQL_Kom += self.Name
            SQL_Kom += "',\n'geom',\n"
            SQL_Kom += "MDSYS.SDO_DIM_ARRAY( \n"

            SQL_Kom += "   MDSYS.SDO_DIM_ELEMENT( 'X', 3345000, 3440000, 0.001 ), \n"
            SQL_Kom += "   MDSYS.SDO_DIM_ELEMENT( 'Y', 5682322, 5754034, 0.001 ) \n"
            SQL_Kom += "), NULL ); \n"
            # Erzeugen des Indexes
            SQL_Kom += "CREATE INDEX "
            SQL_Kom += self.Name
            SQL_Kom += "_idx"
            SQL_Kom += " ON "
            SQL_Kom += self.Name
            SQL_Kom += "(geom) INDEXTYPE IS MDSYS.SPATIAL_INDEX; \n"
        return SQL_Kom           

    def erzeuge_Sequence_SQL(self):
        """Erzeugt eine Sequence, der die ID einer
        Tabelle automatisch weiterzählt"""

        seq_sql = """
CREATE SEQUENCE %s_seq
MINVALUE 1
MAXVALUE 999999999999999999999999999
START WITH 1
INCREMENT BY 1
CACHE 20;
     """

        return seq_sql %self.Name

    def erzeuge_Trigger_SQL(self):
        """Erzeugt eine Trigger, der die ID einer
        Tabelle automatisch weiterzählt"""

        trigger_sql = """
create trigger %(name)s_trigger
before insert on %(name)s
for each row
begin
    select %(name)s_seq.nextval into :new.ogr_fid from dual;
end;
/
        """

        return trigger_sql %{'name':self.Name}

def name_in_tablist( Name):
    """Schaut ob Name in einer Tabelle Tab in tablist der Name ist.
    Gibt dann Tab zurück"""
    for tab in tablist:
        if Name == tab.get_Name():
            return tab
    return 0                 
        
def eintragen_Attribute( Name, Komma_split_5, Art):
    """Trägt die Attribute in die Tabellen ein und legt die Tabellen an, falls
    noch nicht vorhanden"""   
    if not name_in_tablist(Name):
        Tabobj =Tab( Name , Art)
        tablist.append( Tabobj )
    else:
         Tabobj = name_in_tablist( Name)        
    Attributlist = Komma_split_5.split(";")
    for n in range( len( Attributlist )/2):
        #print Name, Komma_split
        if Attributlist[2*n+1] != "INTEGER":
            Tabobj.append_Attribut( (Attributlist[2*n],
                                 "VARCHAR(" + Attributlist[2*n +1].strip()+")"))               
        else:
            Tabobj.append_Attribut( (Attributlist[2*n],
                                 "INTEGER"))
        
# Initialisierung der tablist.        
tablist =[]
try: 
    quelle = open( sys.argv[1] , "r" )
    Konf_satz_liste = quelle.readlines()
finally:
    quelle.close()
for Konf_satz in Konf_satz_liste:
    if Konf_satz[0] =='#':
        continue
    Komma_split =  Konf_satz.split(",")    
    if len(Komma_split) != 6:
        print "warning: Die  Konfigurationsdatei könnte falsch sein" + str(Komma_split)
        continue    
    if Komma_split[1] =="" and Komma_split[2] =="": 
        Name = "f" + Komma_split[0]
        if "n" in Komma_split[4] and not name_in_tablist(Name):
            tablist.append( Tab( Name ,"F"))
        if "p" in Komma_split[4] and not name_in_tablist(Name+"_p"):
            tablist.append( Tab( Name+"_p" ,"FP")) 
        if "l" in Komma_split[4] and not name_in_tablist(Name +"_l"):
            tablist.append( Tab( Name+"_l" ,"F"))
        if "f" in Komma_split[4] and not name_in_tablist(Name +"_f"):
            tablist.append( Tab( Name+"_f" ,"F"))              
    elif Komma_split[3] == "":
        Name = "f" + Komma_split[0]
       # print Name
        if "n" in Komma_split[4]:
            eintragen_Attribute( Name , "kartentyp;2" ,"F")
            eintragen_Attribute( Name , "darstellungsart;INTEGER" ,"F")
            eintragen_Attribute( Name ,Komma_split[5], "F")
        if "p" in Komma_split[4]:
            eintragen_Attribute( Name + "_p" , "kartentyp;2" ,"FP")
            eintragen_Attribute( Name + "_p", "darstellungsart;INTEGER" ,"FP")
            eintragen_Attribute( Name + "_p" ,Komma_split[5],"FP")
        if "l" in Komma_split[4]:
            eintragen_Attribute( Name + "_l" , "kartentyp;2" ,"F")
            eintragen_Attribute( Name + "_l", "darstellungsart;INTEGER" ,"F")
            eintragen_Attribute( Name + "_l" ,Komma_split[5],"F")
        if "f" in Komma_split[4]:
            eintragen_Attribute( Name + "_f" , "kartentyp;2" ,"F")
            eintragen_Attribute( Name + "_f", "darstellungsart;INTEGER" ,"F")
            eintragen_Attribute( Name + "_f" ,Komma_split[5],"F")   
    else:
        Name =  Komma_split[3]
        if "n" in Komma_split[4]:
            eintragen_Attribute( Name ,Komma_split[5], "Z")
        if "p" in Komma_split[4]:
            eintragen_Attribute( Name+"_p" ,Komma_split[5],"GP")
        if "l" in Komma_split[4]:
            eintragen_Attribute( Name+"_l" ,Komma_split[5],"G")
        if "f" in Komma_split[4]:
            eintragen_Attribute( Name+"_f" ,Komma_split[5],"G")         
                  
SQL_Kom = ""
# Erzeugen der CREATE -Kommandos                  
for tab in tablist:
    SQL_Kom += tab.create_SQL() 
# Erzeugen der Metadaten und Index -Komandos
for tab in tablist:
    SQL_Kom += tab.erzeuge_Metadata_SQL()       
    SQL_Kom += tab.erzeuge_Sequence_SQL()
    SQL_Kom += tab.erzeuge_Trigger_SQL()
try:
    ziel = open( sys.argv[2] , "w" ) 
    ziel.write(SQL_Kom)       
    ziel.close()
except:
    print SQL_Kom


1	ludwig	23	# Copyright (C) 2004 by Intevation GmbH
2			# Authors:
3			# Ludwig Reiter <[email protected]>
4			#
5			# This program is free software under the GPL (>=v2)
6			# Read the file COPYING coming with the software for details.
7
8			"""Erzeugt automatisch CREATE-SQL-Kommandos aus dem Konfigurationsfile.
9			Benötigt 2 Argumente : Quell-Konffile Ziel-SQLfile
10			Beinhaltet Klasse Tab für Tabellen
11			und Liste tablist für die verschiedenen Tabellenobjekte
12
13			Liest eine Zeile des Konffiles und bearbeitet sie:
14			Wenn Kommentar:
15			nächste Zeile
16			Wenn Folienspezifikation(d.h. nur Folie und Tabellenflags gesetzt):
17			Wenn Folientabellen alle vorhanden
18			nächste Zeile
19			Sonst lege zusätzliche Tabellen an
20			(d.h. Tab anlegen und in tablist appenden)
21			Wenn BesondereInfospezifikation ohne Tabellenname:
22			Gehe die Folientabellen in tabliste durch und lege die
23			Attribute an, falls sie noch nicht vorhanden
24			Wenn BesondereInfospezifikation mit Tabellenname:
25			Wenn Tabelle noch nicht vorhanden:
26			Lege Tabelle an und appende sie in tablist
27			Wenn Attribute noch nicht vorhanden:
28			Lege Attribute in der Tabelle an
29			Nach diesen Durchlauf müssten alle anzulegenden Tabellen mit ihren
30			Attributen in tablist als Tab-Objekte stehen
31			Gehe tablist durch und erzeuge die SQL_Kommandos
32
33	ludwig	30	Folientabellen haben die Namen f<foliennr><_p oder _l oder _f>
34	ludwig	23	und mindestens die Attribute objnr, objart, aktualitaet, edatum, geom.
35
36			anderen Tabellen haben mindestens die Attribute objnr, artderinfo,
37			kartentyp, darstellungsart.
38			"""
39
40			import sys
41
42			class Tab:
43			"""Kontainer für den Tabellennamen und die Attribute + Art der Attribute
44			einer Tabelle. Speichert dies solange bis alle Konfigurationsdateizeilen
45			verarbeitet sind. Dann wird mit SQL_create die SQL -Create-Kommandos
46			erzeugt."""
47			def __init__(self, Name, ArtderTabelle):
48			"""Name ist der Name der Tabelle
49			ArtderTabelle gibt an was für eine Tabelle erzeugt werden soll:
50	ludwig	24	F für Folientabelle mit Linien- oder Flächengeometrie
51			FP für Folientablle mit Punktgeometrie
52	ludwig	23	Z für Zusatzdatentabelle ohne Geometrie
53	ludwig	24	G für Zusatzdatentabelle mit Geometrie
54			GP für Zusatzdatentabelle mit Punktgeometrie"""
55	ludwig	23	self.Name = Name
56			self.Attribute = []
57	silke	49	self.Attribute.append(("objnr", "VARCHAR(7)"))
58			self.Attribute.append(("ogr_fid", "INTEGER"))
59	ludwig	24	if ArtderTabelle =="F" or ArtderTabelle == "FP" :
60	ludwig	23	self.Attribute.append( ("objart", "INTEGER" ) )
61			self.Attribute.append( ("aktualitaet", "VARCHAR(2)"))
62			self.Attribute.append( ("edatum", "DATE"))
63	ludwig	24	self.Attribute.append( ("geom", "MDSYS.SDO_GEOMETRY") )
64			if ArtderTabelle == "FP" :
65			self.Attribute.append( ("winkel", "INTEGER"))
66			elif ArtderTabelle == 'Z' or ArtderTabelle =='G'or ArtderTabelle=="GP":
67	ludwig	23	self.Attribute.append( ("artderinfo", "INTEGER") )
68			self.Attribute.append( ("kartentyp", "VARCHAR(2)" ))
69			self.Attribute.append( ("darstellungsart", "INTEGER" ))
70			if ArtderTabelle == "G":
71			self.Attribute.append( ("geom", "MDSYS.SDO_GEOMETRY") )
72	ludwig	24	elif ArtderTabelle == "GP":
73			self.Attribute.append( ("geom", "MDSYS.SDO_GEOMETRY") )
74			self.Attribute.append( ("winkel", "INTEGER") )
75	ludwig	23
76			def isin_Attribute(self, Attribut):
77			"""sucht self.Attribute nach den Attribut durch:
78			1 falls vorhanden
79			0 sonst"""
80			for (Attname,dummy) in self.Attribute:
81			if Attname == Attribut:
82			return 1
83			return 0
84
85			def append_Attribut(self, Atttupel):
86			"""fügt ein Attributtupel der Form ( Attributsnamen, Attributsart) in
87			self.Attribute ein, wenn noch nicht vorhanden."""
88			if not self.isin_Attribute( Atttupel[0]) and Atttupel[0] != "":
89			self.Attribute.append( Atttupel )
90
91			def get_Name(self):
92			"""Gibt self.Name zurück"""
93			return self.Name
94
95			def create_SQL(self):
96			"""erzeugt das CREATE-SQL-Kommando und gibt es zurück"""
97			SQL_Kom ="CREATE TABLE "
98			SQL_Kom += self.Name
99			SQL_Kom += "\n ( "
100			Komma =0
101			for (Attname, Attart) in self.Attribute: #Attname für Attributname
102			if Komma ==1: #Attart für Attributsart
103			SQL_Kom += ","
104			SQL_Kom += "\n "
105			SQL_Kom += Attname
106			SQL_Kom += " "
107			SQL_Kom += Attart
108			Komma =1
109			SQL_Kom += "\n ); \n"
110			return SQL_Kom
111	ludwig	30
112			def erzeuge_Metadata_SQL(self):
113			"""erzeugt die in die METADATA -Insert-SQL-Befehle und den
114			Index für diese Tabelle.
115			Dies muss man aendern, falls man die Indizes anpassen will."""
116			SQL_Kom = ""
117			if self.Name[-2:] in ['_p','_l','_f' ]:
118			# Anlegen der Metadaten
119			SQL_Kom = "INSERT INTO USER_SDO_GEOM_METADATA VALUES (\n '"
120			SQL_Kom += self.Name
121			SQL_Kom += "',\n'geom',\n"
122			SQL_Kom += "MDSYS.SDO_DIM_ARRAY( \n"
123	silke	49
124	ludwig	30	SQL_Kom += " MDSYS.SDO_DIM_ELEMENT( 'X', 3345000, 3440000, 0.001 ), \n"
125			SQL_Kom += " MDSYS.SDO_DIM_ELEMENT( 'Y', 5682322, 5754034, 0.001 ) \n"
126			SQL_Kom += "), NULL ); \n"
127			# Erzeugen des Indexes
128			SQL_Kom += "CREATE INDEX "
129			SQL_Kom += self.Name
130			SQL_Kom += "_idx"
131			SQL_Kom += " ON "
132			SQL_Kom += self.Name
133			SQL_Kom += "(geom) INDEXTYPE IS MDSYS.SPATIAL_INDEX; \n"
134			return SQL_Kom
135	silke	49
136			def erzeuge_Sequence_SQL(self):
137			"""Erzeugt eine Sequence, der die ID einer
138			Tabelle automatisch weiterzählt"""
139
140			seq_sql = """
141			CREATE SEQUENCE %s_seq
142			MINVALUE 1
143			MAXVALUE 999999999999999999999999999
144			START WITH 1
145			INCREMENT BY 1
146			CACHE 20;
147			"""
148
149			return seq_sql %self.Name
150
151			def erzeuge_Trigger_SQL(self):
152			"""Erzeugt eine Trigger, der die ID einer
153			Tabelle automatisch weiterzählt"""
154
155			trigger_sql = """
156			create trigger %(name)s_trigger
157			before insert on %(name)s
158			for each row
159			begin
160			select %(name)s_seq.nextval into :new.ogr_fid from dual;
161			end;
162			/
163			"""
164
165			return trigger_sql %{'name':self.Name}
166
167	ludwig	23	def name_in_tablist( Name):
168			"""Schaut ob Name in einer Tabelle Tab in tablist der Name ist.
169			Gibt dann Tab zurück"""
170			for tab in tablist:
171			if Name == tab.get_Name():
172			return tab
173			return 0
174
175	ludwig	35	def eintragen_Attribute( Name, Komma_split_5, Art):
176	ludwig	23	"""Trägt die Attribute in die Tabellen ein und legt die Tabellen an, falls
177			noch nicht vorhanden"""
178			if not name_in_tablist(Name):
179			Tabobj =Tab( Name , Art)
180			tablist.append( Tabobj )
181			else:
182			Tabobj = name_in_tablist( Name)
183	ludwig	35	Attributlist = Komma_split_5.split(";")
184	ludwig	23	for n in range( len( Attributlist )/2):
185	ludwig	35	#print Name, Komma_split
186			if Attributlist[2*n+1] != "INTEGER":
187			Tabobj.append_Attribut( (Attributlist[2*n],
188	ludwig	23	"VARCHAR(" + Attributlist[2*n +1].strip()+")"))
189	ludwig	35	else:
190			Tabobj.append_Attribut( (Attributlist[2*n],
191			"INTEGER"))
192	ludwig	23
193			# Initialisierung der tablist.
194			tablist =[]
195			try:
196			quelle = open( sys.argv[1] , "r" )
197			Konf_satz_liste = quelle.readlines()
198			finally:
199			quelle.close()
200			for Konf_satz in Konf_satz_liste:
201			if Konf_satz[0] =='#':
202			continue
203			Komma_split = Konf_satz.split(",")
204			if len(Komma_split) != 6:
205			print "warning: Die Konfigurationsdatei könnte falsch sein" + str(Komma_split)
206			continue
207			if Komma_split[1] =="" and Komma_split[2] =="":
208	ludwig	30	Name = "f" + Komma_split[0]
209	ludwig	23	if "n" in Komma_split[4] and not name_in_tablist(Name):
210			tablist.append( Tab( Name ,"F"))
211			if "p" in Komma_split[4] and not name_in_tablist(Name+"_p"):
212	ludwig	24	tablist.append( Tab( Name+"_p" ,"FP"))
213	ludwig	23	if "l" in Komma_split[4] and not name_in_tablist(Name +"_l"):
214			tablist.append( Tab( Name+"_l" ,"F"))
215			if "f" in Komma_split[4] and not name_in_tablist(Name +"_f"):
216			tablist.append( Tab( Name+"_f" ,"F"))
217			elif Komma_split[3] == "":
218	ludwig	30	Name = "f" + Komma_split[0]
219	ludwig	35	# print Name
220	ludwig	23	if "n" in Komma_split[4]:
221	ludwig	35	eintragen_Attribute( Name , "kartentyp;2" ,"F")
222			eintragen_Attribute( Name , "darstellungsart;INTEGER" ,"F")
223			eintragen_Attribute( Name ,Komma_split[5], "F")
224			if "p" in Komma_split[4]:
225			eintragen_Attribute( Name + "_p" , "kartentyp;2" ,"FP")
226			eintragen_Attribute( Name + "_p", "darstellungsart;INTEGER" ,"FP")
227			eintragen_Attribute( Name + "_p" ,Komma_split[5],"FP")
228			if "l" in Komma_split[4]:
229			eintragen_Attribute( Name + "_l" , "kartentyp;2" ,"F")
230			eintragen_Attribute( Name + "_l", "darstellungsart;INTEGER" ,"F")
231			eintragen_Attribute( Name + "_l" ,Komma_split[5],"F")
232			if "f" in Komma_split[4]:
233			eintragen_Attribute( Name + "_f" , "kartentyp;2" ,"F")
234			eintragen_Attribute( Name + "_f", "darstellungsart;INTEGER" ,"F")
235			eintragen_Attribute( Name + "_f" ,Komma_split[5],"F")
236	ludwig	23	else:
237			Name = Komma_split[3]
238			if "n" in Komma_split[4]:
239	ludwig	35	eintragen_Attribute( Name ,Komma_split[5], "Z")
240			if "p" in Komma_split[4]:
241			eintragen_Attribute( Name+"_p" ,Komma_split[5],"GP")
242			if "l" in Komma_split[4]:
243			eintragen_Attribute( Name+"_l" ,Komma_split[5],"G")
244			if "f" in Komma_split[4]:
245			eintragen_Attribute( Name+"_f" ,Komma_split[5],"G")
246	ludwig	23
247	ludwig	30	SQL_Kom = ""
248			# Erzeugen der CREATE -Kommandos
249	ludwig	23	for tab in tablist:
250	ludwig	30	SQL_Kom += tab.create_SQL()
251			# Erzeugen der Metadaten und Index -Komandos
252			for tab in tablist:
253			SQL_Kom += tab.erzeuge_Metadata_SQL()
254	silke	49	SQL_Kom += tab.erzeuge_Sequence_SQL()
255			SQL_Kom += tab.erzeuge_Trigger_SQL()
256	ludwig	23	try:
257	silke	41	ziel = open( sys.argv[2] , "w" )
258	ludwig	23	ziel.write(SQL_Kom)
259			ziel.close()
260	silke	41	except:
261			print SQL_Kom
262	ludwig	23
263
264