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)       
    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			self.Attribute.append( ("objnr", "VARCHAR(7)") )
58	ludwig	24	if ArtderTabelle =="F" or ArtderTabelle == "FP" :
59	ludwig	23	self.Attribute.append( ("objart", "INTEGER" ) )
60			self.Attribute.append( ("aktualitaet", "VARCHAR(2)"))
61			self.Attribute.append( ("edatum", "DATE"))
62	ludwig	24	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	ludwig	23	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	ludwig	24	elif ArtderTabelle == "GP":
72			self.Attribute.append( ("geom", "MDSYS.SDO_GEOMETRY") )
73			self.Attribute.append( ("winkel", "INTEGER") )
74	ludwig	23
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	ludwig	30
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	ludwig	23	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	ludwig	35	def eintragen_Attribute( Name, Komma_split_5, Art):
145	ludwig	23	"""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	ludwig	35	Attributlist = Komma_split_5.split(";")
153	ludwig	23	for n in range( len( Attributlist )/2):
154	ludwig	35	#print Name, Komma_split
155			if Attributlist[2*n+1] != "INTEGER":
156			Tabobj.append_Attribut( (Attributlist[2*n],
157	ludwig	23	"VARCHAR(" + Attributlist[2*n +1].strip()+")"))
158	ludwig	35	else:
159			Tabobj.append_Attribut( (Attributlist[2*n],
160			"INTEGER"))
161	ludwig	23
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	ludwig	30	Name = "f" + Komma_split[0]
178	ludwig	23	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	ludwig	24	tablist.append( Tab( Name+"_p" ,"FP"))
182	ludwig	23	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	ludwig	30	Name = "f" + Komma_split[0]
188	ludwig	35	# print Name
189	ludwig	23	if "n" in Komma_split[4]:
190	ludwig	35	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	ludwig	23	else:
206			Name = Komma_split[3]
207			if "n" in Komma_split[4]:
208	ludwig	35	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	ludwig	23
216	ludwig	30	SQL_Kom = ""
217			# Erzeugen der CREATE -Kommandos
218	ludwig	23	for tab in tablist:
219	ludwig	30	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	ludwig	23	try:
224	silke	41	ziel = open( sys.argv[2] , "w" )
225	ludwig	23	ziel.write(SQL_Kom)
226			ziel.close()
227	silke	41	except:
228			print SQL_Kom
229	ludwig	23
230
231