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)") )
        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 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()       
try:
    ziel   = open( sys.argv[2] , "w" ) 
    ziel.write(SQL_Kom)       
finally:    
    ziel.close()


1	# 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	Folientabellen haben die Namen f<foliennr><_p oder _l oder _f>
34	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	F für Folientabelle mit Linien- oder Flächengeometrie
51	FP für Folientablle mit Punktgeometrie
52	Z für Zusatzdatentabelle ohne Geometrie
53	G für Zusatzdatentabelle mit Geometrie
54	GP für Zusatzdatentabelle mit Punktgeometrie"""
55	self.Name = Name
56	self.Attribute = []
57	self.Attribute.append( ("objnr", "VARCHAR(7)") )
58	if ArtderTabelle =="F" or ArtderTabelle == "FP" :
59	self.Attribute.append( ("objart", "INTEGER" ) )
60	self.Attribute.append( ("aktualitaet", "VARCHAR(2)"))
61	self.Attribute.append( ("edatum", "DATE"))
62	self.Attribute.append( ("geom", "MDSYS.SDO_GEOMETRY") )
63	if ArtderTabelle == "FP" :
64	self.Attribute.append( ("winkel", "INTEGER"))
65	elif ArtderTabelle == 'Z' or ArtderTabelle =='G'or ArtderTabelle=="GP":
66	self.Attribute.append( ("artderinfo", "INTEGER") )
67	self.Attribute.append( ("kartentyp", "VARCHAR(2)" ))
68	self.Attribute.append( ("darstellungsart", "INTEGER" ))
69	if ArtderTabelle == "G":
70	self.Attribute.append( ("geom", "MDSYS.SDO_GEOMETRY") )
71	elif ArtderTabelle == "GP":
72	self.Attribute.append( ("geom", "MDSYS.SDO_GEOMETRY") )
73	self.Attribute.append( ("winkel", "INTEGER") )
74
75	def isin_Attribute(self, Attribut):
76	"""sucht self.Attribute nach den Attribut durch:
77	1 falls vorhanden
78	0 sonst"""
79	for (Attname,dummy) in self.Attribute:
80	if Attname == Attribut:
81	return 1
82	return 0
83
84	def append_Attribut(self, Atttupel):
85	"""fügt ein Attributtupel der Form ( Attributsnamen, Attributsart) in
86	self.Attribute ein, wenn noch nicht vorhanden."""
87	if not self.isin_Attribute( Atttupel[0]) and Atttupel[0] != "":
88	self.Attribute.append( Atttupel )
89
90	def get_Name(self):
91	"""Gibt self.Name zurück"""
92	return self.Name
93
94	def create_SQL(self):
95	"""erzeugt das CREATE-SQL-Kommando und gibt es zurück"""
96	SQL_Kom ="CREATE TABLE "
97	SQL_Kom += self.Name
98	SQL_Kom += "\n ( "
99	Komma =0
100	for (Attname, Attart) in self.Attribute: #Attname für Attributname
101	if Komma ==1: #Attart für Attributsart
102	SQL_Kom += ","
103	SQL_Kom += "\n "
104	SQL_Kom += Attname
105	SQL_Kom += " "
106	SQL_Kom += Attart
107	Komma =1
108	SQL_Kom += "\n ); \n"
109	return SQL_Kom
110
111	def erzeuge_Metadata_SQL(self):
112	"""erzeugt die in die METADATA -Insert-SQL-Befehle und den
113	Index für diese Tabelle.
114	Dies muss man aendern, falls man die Indizes anpassen will."""
115	SQL_Kom = ""
116	if self.Name[-2:] in ['_p','_l','_f' ]:
117	# Anlegen der Metadaten
118	SQL_Kom = "INSERT INTO USER_SDO_GEOM_METADATA VALUES (\n '"
119	SQL_Kom += self.Name
120	SQL_Kom += "',\n'geom',\n"
121	SQL_Kom += "MDSYS.SDO_DIM_ARRAY( \n"
122
123	SQL_Kom += " MDSYS.SDO_DIM_ELEMENT( 'X', 3345000, 3440000, 0.001 ), \n"
124	SQL_Kom += " MDSYS.SDO_DIM_ELEMENT( 'Y', 5682322, 5754034, 0.001 ) \n"
125	SQL_Kom += "), NULL ); \n"
126	# Erzeugen des Indexes
127	SQL_Kom += "CREATE INDEX "
128	SQL_Kom += self.Name
129	SQL_Kom += "_idx"
130	SQL_Kom += " ON "
131	SQL_Kom += self.Name
132	SQL_Kom += "(geom) INDEXTYPE IS MDSYS.SPATIAL_INDEX; \n"
133	return SQL_Kom
134
135
136	def name_in_tablist( Name):
137	"""Schaut ob Name in einer Tabelle Tab in tablist der Name ist.
138	Gibt dann Tab zurück"""
139	for tab in tablist:
140	if Name == tab.get_Name():
141	return tab
142	return 0
143
144	def eintragen_Attribute( Name, Komma_split_5, Art):
145	"""Trägt die Attribute in die Tabellen ein und legt die Tabellen an, falls
146	noch nicht vorhanden"""
147	if not name_in_tablist(Name):
148	Tabobj =Tab( Name , Art)
149	tablist.append( Tabobj )
150	else:
151	Tabobj = name_in_tablist( Name)
152	Attributlist = Komma_split_5.split(";")
153	for n in range( len( Attributlist )/2):
154	#print Name, Komma_split
155	if Attributlist[2*n+1] != "INTEGER":
156	Tabobj.append_Attribut( (Attributlist[2*n],
157	"VARCHAR(" + Attributlist[2*n +1].strip()+")"))
158	else:
159	Tabobj.append_Attribut( (Attributlist[2*n],
160	"INTEGER"))
161
162	# Initialisierung der tablist.
163	tablist =[]
164	try:
165	quelle = open( sys.argv[1] , "r" )
166	Konf_satz_liste = quelle.readlines()
167	finally:
168	quelle.close()
169	for Konf_satz in Konf_satz_liste:
170	if Konf_satz[0] =='#':
171	continue
172	Komma_split = Konf_satz.split(",")
173	if len(Komma_split) != 6:
174	print "warning: Die Konfigurationsdatei könnte falsch sein" + str(Komma_split)
175	continue
176	if Komma_split[1] =="" and Komma_split[2] =="":
177	Name = "f" + Komma_split[0]
178	if "n" in Komma_split[4] and not name_in_tablist(Name):
179	tablist.append( Tab( Name ,"F"))
180	if "p" in Komma_split[4] and not name_in_tablist(Name+"_p"):
181	tablist.append( Tab( Name+"_p" ,"FP"))
182	if "l" in Komma_split[4] and not name_in_tablist(Name +"_l"):
183	tablist.append( Tab( Name+"_l" ,"F"))
184	if "f" in Komma_split[4] and not name_in_tablist(Name +"_f"):
185	tablist.append( Tab( Name+"_f" ,"F"))
186	elif Komma_split[3] == "":
187	Name = "f" + Komma_split[0]
188	# print Name
189	if "n" in Komma_split[4]:
190	eintragen_Attribute( Name , "kartentyp;2" ,"F")
191	eintragen_Attribute( Name , "darstellungsart;INTEGER" ,"F")
192	eintragen_Attribute( Name ,Komma_split[5], "F")
193	if "p" in Komma_split[4]:
194	eintragen_Attribute( Name + "_p" , "kartentyp;2" ,"FP")
195	eintragen_Attribute( Name + "_p", "darstellungsart;INTEGER" ,"FP")
196	eintragen_Attribute( Name + "_p" ,Komma_split[5],"FP")
197	if "l" in Komma_split[4]:
198	eintragen_Attribute( Name + "_l" , "kartentyp;2" ,"F")
199	eintragen_Attribute( Name + "_l", "darstellungsart;INTEGER" ,"F")
200	eintragen_Attribute( Name + "_l" ,Komma_split[5],"F")
201	if "f" in Komma_split[4]:
202	eintragen_Attribute( Name + "_f" , "kartentyp;2" ,"F")
203	eintragen_Attribute( Name + "_f", "darstellungsart;INTEGER" ,"F")
204	eintragen_Attribute( Name + "_f" ,Komma_split[5],"F")
205	else:
206	Name = Komma_split[3]
207	if "n" in Komma_split[4]:
208	eintragen_Attribute( Name ,Komma_split[5], "Z")
209	if "p" in Komma_split[4]:
210	eintragen_Attribute( Name+"_p" ,Komma_split[5],"GP")
211	if "l" in Komma_split[4]:
212	eintragen_Attribute( Name+"_l" ,Komma_split[5],"G")
213	if "f" in Komma_split[4]:
214	eintragen_Attribute( Name+"_f" ,Komma_split[5],"G")
215
216	SQL_Kom = ""
217	# Erzeugen der CREATE -Kommandos
218	for tab in tablist:
219	SQL_Kom += tab.create_SQL()
220	# Erzeugen der Metadaten und Index -Komandos
221	for tab in tablist:
222	SQL_Kom += tab.erzeuge_Metadata_SQL()
223	try:
224	ziel = open( sys.argv[2] , "w" )
225	ziel.write(SQL_Kom)
226	finally:
227	ziel.close()
228
229
230