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	# 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	self.Attribute.append(("ogr_fid", "INTEGER"))
59	if ArtderTabelle =="F" or ArtderTabelle == "FP" :
60	self.Attribute.append( ("objart", "INTEGER" ) )
61	self.Attribute.append( ("aktualitaet", "VARCHAR(2)"))
62	self.Attribute.append( ("edatum", "DATE"))
63	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	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	elif ArtderTabelle == "GP":
73	self.Attribute.append( ("geom", "MDSYS.SDO_GEOMETRY") )
74	self.Attribute.append( ("winkel", "INTEGER") )
75
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
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
124	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
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	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	def eintragen_Attribute( Name, Komma_split_5, Art):
176	"""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	Attributlist = Komma_split_5.split(";")
184	for n in range( len( Attributlist )/2):
185	#print Name, Komma_split
186	if Attributlist[2*n+1] != "INTEGER":
187	Tabobj.append_Attribut( (Attributlist[2*n],
188	"VARCHAR(" + Attributlist[2*n +1].strip()+")"))
189	else:
190	Tabobj.append_Attribut( (Attributlist[2*n],
191	"INTEGER"))
192
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	Name = "f" + Komma_split[0]
209	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	tablist.append( Tab( Name+"_p" ,"FP"))
213	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	Name = "f" + Komma_split[0]
219	# print Name
220	if "n" in Komma_split[4]:
221	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	else:
237	Name = Komma_split[3]
238	if "n" in Komma_split[4]:
239	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
247	SQL_Kom = ""
248	# Erzeugen der CREATE -Kommandos
249	for tab in tablist:
250	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	SQL_Kom += tab.erzeuge_Sequence_SQL()
255	SQL_Kom += tab.erzeuge_Trigger_SQL()
256	try:
257	ziel = open( sys.argv[2] , "w" )
258	ziel.write(SQL_Kom)
259	ziel.close()
260	except:
261	print SQL_Kom
262
263
264