ubuntuusers.de

Hallo zusammen,

zum Anfang schon mal Danke für die hoffentlich Hilfe. Ich bin mit dem Thema ein absoluter Neuling, brauche aber dringend Hilfe.

Folgende Situation: Ich habe einen Ubuntu Server welcher nur über die Shell bedient wird auf diesem läuft MySQL.

Problem ich habe in MySQL eine Datenbank in diese Datenbank befindet sich eine undefinierte Anzahl von Tabellen. Diese Tabellen enthalten zwei Spalten eine mit einen Datum und Uhrzeit Typ datetime uns sieht so aus 2014-01-01 00:13:36 und eine mit einem Wert Typ Dezimal(10,5) . Außerdem Setzt sich der Tabellenname immer aus zwei Teilen zusammen = "Standort-Sensor" immer getrennt durch den Bindestrich.

es gibt mehrere Standorte und es kommen immer neue dazu weshalb die Anzahl der Tabellen variabel ist.

Jetzt habe ich die Herausforderung das ich die Daten der großen Datenbank aufteilen muss.

Und zwar nach folgendem Schema

Neue DB darin die Tabellen

• Standort_Jahr_alles –> Erhält folgende Felder Zeitstempel , Sensorname, Wert Dabei sollen einfach die Rohdaten verschoben werden.

• Standort_Jahr_Stunde –> Erhält folgende Felder Zeitstempel , Sensorname, Wert Dabei sollen jeweils der Mittelwert der einzelnen Stunden erzeugt werden.

• Standort_Jahr_Tag –> Erhält folgende Felder Zeitstempel , Sensorname, Wert Dabei sollen jeweils der Mittelwert der einzelnen Tage erzeugt werden.

• Standort_Jahr_Woche –> Erhält folgende Felder Zeitstempel , Sensorname, Wert Dabei sollen jeweils der Mittelwert der einzelnen Wochen erzeugt werden.

Die Hauptdatenbank wir jede Nacht von den Standorten aus gefüttert so das die Scripte danach per Cron den Rest erledigen sollen Da ich weis wann ein neuer Standort hinzukommt kann ich die passenden Tabellen manuell anlegen.

Dazu benötige ich eure Hilfe wenn ich nur ein Grundscript hätte denke ich den Rest bekomme ich hin dank meiner Ahnungslosigkeit fehlt mir aber jeder Anfang. Sollten Noch mehr Infos benötigt werden fragt mich einfach.

Und noch mal DANKE DANKE DANKE.

da es sich irgendwie um ein größeres "problem" handelt würde ich evtl nicht nur mit reinem bash & sql arbeiten sondern eine scriptspachre wie perl / python verwenden. Persöhnlich würde ich python nehmen aber jeder hat seine eigenen Geschmäcker. In Python gibt es eine schöne MySQL Bilbiothek: https://pypi.python.org/pypi/MySQL-python/ mit der ich auch schon das eine oder andere script erstellt habe, zudem findet man dazu recht viel beispielanwendungen im netz.

Ich denke dass es eher an dir liegt mit welchem Werkzeug du an das Problem rangehen möchtest (perl python bash java ruby....).

viel Erfolg 👍

Hallo Danke für deine aufmunternden Worte,

da ich teile des Problems bereits von einem "Vorgänger" geerbt habe würde ich gerne bei bash bleiben damit ich nicht mischen muss und mich in noch etwa einarbeiten muss.

Cracymike schrieb:

es gibt mehrere Standorte und es kommen immer neue dazu weshalb die Anzahl der Tabellen variabel ist.

Das solltet ihr dringend ändern! Offenbar sind Standort und Sensor *Daten* und gehören damit (vermutlich als Relation) in einen Messwert-Tupel mit hinein!

Tabellen dynamisch anlegen zeugt immer von schlechtem Design - und verursacht Probleme 😉

Wir werden denn die Daten von den Standorten übertragen? Per Webservice-Aufruf o.ä.? Wenn ja, kann man an der Stelle ja leicht ansetzen...

Relationales Datenbankdesign und SQL solltest Du für diese Aufgabe kennen. Um das zu lernen ist das gerade die richtige Aufgabe.

Je früher Du es lernst umso mehr hast Du davon.

Und Lysander kann ich nur zustimmen.

Lysander schrieb:

Cracymike schrieb:

es gibt mehrere Standorte und es kommen immer neue dazu weshalb die Anzahl der Tabellen variabel ist.

Das solltet ihr dringend ändern! Offenbar sind Standort und Sensor *Daten* und gehören damit (vermutlich als Relation) in einen Messwert-Tupel mit hinein!

Tabellen dynamisch anlegen zeugt immer von schlechtem Design - und verursacht Probleme 😉

Das war auch mein erster Gedanke. Wenn man das Schema "repariert", dann sind das nur noch Views. Falls die Datenmenge, die da konsolidiert wird groß ist, dann bietet sich auch ein "Materialized View" an, wie ihn PostgreSQL z.B. hat. In MySQL ist das etwas schwieriger - da gibt es das Feature schlicht nicht.

Wir werden denn die Daten von den Standorten übertragen? Per Webservice-Aufruf o.ä.? Wenn ja, kann man an der Stelle ja leicht ansetzen...

Wichtig wäre auch zu wissen, wie die Zugriffsmuster sind: wie oft werden SELECTS auf die aggregierten Daten losgelassen?

Und überhaupt: herzlich willkommen hier auf ubuntuusers.de!

Hallo,

also die Messwerte werden an den Standorten nur in .txt Dateien abgelegt diese werden vom Server geholt via VPN Tunnel und dann in die Datenbank eingelesen. Da es an jedem Standort unterschiedliche Sensoren und Anzahl gibt existiert eine Datenbank für jedes Jahr und in diese werden die Werte einfach hineingeschrieben Findet das Script eine neue .txt wird die Tabelle dafür angelegt und gefüllt.

Die Standortdaten habe ich auch in einer Tabelle verfügbar dort wo die Zugangspunkte für das VPN mit gespeichert sind nur die Sensoren werden halt Dynamisch erzeugt weil dies nicht Standard sind.

Die Abfragehäufigkeit wird am ende sehr überschaubar sein nur 3 Nutzer abfrage soll in Excel erfolgen und wird dort graphisch dargestellt. Vorteil ist hier auch das immer nur ein Standort abgefragt werden soll Theoretisch könnte ich auch mit nur einer Tabelle leben in der alle Daten ohne Aggregation landen nur währe dann das auswerten von Jahren einfach zu heftig.

Eventuell noch zur Info die Daten werden eventbasiert gesammelt das heist es kann durchaus sein das einzelne Sensoren nur einmal pro Woche einen Wert liefern andere dies aber 3 x pro Sekunde tun.

Gruß Mike

Danke für das willkommen.

Cracymike schrieb:

also die Messwerte werden an den Standorten nur in .txt Dateien abgelegt diese werden vom Server geholt via VPN Tunnel und dann in die Datenbank eingelesen. Da es an jedem Standort unterschiedliche Sensoren und Anzahl gibt existiert eine Datenbank für jedes Jahr und in diese werden die Werte einfach hineingeschrieben Findet das Script eine neue .txt wird die Tabelle dafür angelegt und gefüllt.

Und genau das ist in doppelter Hinsicht Mist! Wieso Datenbanken auf ein "Jahr" beschränken? Das kann man aus Performance- / Platzgründengründen "manuell" Zu Beginn eines Jahres machen, indem man die alten Daten dumpt und danach aus der DB entfernt.

Aber pro Datei eine neue Tabelle ist echt Schrott! Da wäre es ja weniger umständlich, *direkt* aus den Textdateien die Infos zusammen zu sammeln 😀

Du solltest genau da ansetzen! Entwirf ein Schema, welches Standorte, Sensoren und Messdaten abbilden kann und baue das Script so um, dass die Daten in die *eine* Messdatentabelle eingetragen werden; natürlich mit den richtigen Bezügen zu Standort und Sensor. Das sollte nicht so schwierig sein.

Danach musst Du auf dem Schema nur noch Views erstellen und fertig ist das Thema. (Ok, geeignete Indizes erstellen bliebt sicherlich noch oder ggf. auch eine andere Data-Mining-Strategie, falls die Berechnungen on the fly zu lange dauern.

OK

besteht dann die Chance das ihr mir mit dem anpassen des Scriptes helft bin gerne bereit es hier zu Posten ?

Gruß Mike

Lysander schrieb:

Cracymike schrieb:

also die Messwerte werden an den Standorten nur in .txt Dateien abgelegt diese werden vom Server geholt via VPN Tunnel und dann in die Datenbank eingelesen. Da es an jedem Standort unterschiedliche Sensoren und Anzahl gibt existiert eine Datenbank für jedes Jahr und in diese werden die Werte einfach hineingeschrieben Findet das Script eine neue .txt wird die Tabelle dafür angelegt und gefüllt.

Und genau das ist in doppelter Hinsicht Mist! Wieso Datenbanken auf ein "Jahr" beschränken? Das kann man aus Performance- / Platzgründengründen "manuell" Zu Beginn eines Jahres machen, indem man die alten Daten dumpt und danach aus der DB entfernt.

Oder man nutzt Partitionierung (gibt es auch in PostgreSQL).

Aber pro Datei eine neue Tabelle ist echt Schrott! Da wäre es ja weniger umständlich, *direkt* aus den Textdateien die Infos zusammen zu sammeln 😀

Du solltest genau da ansetzen! Entwirf ein Schema, welches Standorte, Sensoren und Messdaten abbilden kann und baue das Script so um, dass die Daten in die *eine* Messdatentabelle eingetragen werden; natürlich mit den richtigen Bezügen zu Standort und Sensor. Das sollte nicht so schwierig sein.

So aus der kalten Hose hätte mein Design folgende Tabellen

• Sensor (id, location, name / type oder was man sonst noch so wissen muss über einen Sensor)

• Messwert (timestamp, sensor_id (FK), value) ggf. noch berechnete Werte für z.B. Jahr oder Jahr-Monat.

Index auf (timestamp, sensor_id) oder (sensor_id, timestamp) - je nach Zugriffsmuster und Selektivität.

Danach musst Du auf dem Schema nur noch Views erstellen und fertig ist das Thema. (Ok, geeignete Indizes erstellen bliebt sicherlich noch oder ggf. auch eine andere Data-Mining-Strategie, falls die Berechnungen on the fly zu lange dauern.

"Zu lange" dürfte es bei drei Abfragen eigentlich eher nicht geben. 😬

@rklm Ich wollte dem OP ja nicht alles wegnehmen 😎 Aber klar, so grob ist das wohl der Ansatz. Evtl. könnte man noch "Standort" in eine eigene Tabelle auslagern; offenbar besteht ja zwischen Standort und Sensor eine 1:n-Beziehung.

@cracymike Naja, vermutlich ist das eher ein Neu-Design - zumindest des Kernlements des Tabellen-Befüllens. Denn da wurde im bestehenden Script ja offenbar quasi nichts groß geparst oder aufbereitet (Foreign Key-IDs setzen usw.). Genau das müsste jetzt aber ja passieren.

So sieht das aktuelle script aus welches die Daten holt und in die Datenbank schreibt

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264

#!/bin/bash

# holt Messdaten aller Maschinen ab
###################################
NO_OF_DAYS_BACK=3
SQLPWD=??????
ERROR=`mktemp`
echo "no" > $ERROR

echo "##############################################################"
echo "# starting import process at : `date`"
echo "##############################################################"
# konfigurierte Maschinen ermitteln
###################################
SQL="SELECT name FROM \`connection-config\` ORDER BY name"
MACHINES=`mysql --skip-column-names machines -uroot -p$SQLPWD -e "$SQL"`
RETURN=$?
if [ $RETURN -ne 0 ]; then
	echo "error reading machines from database. aborting ..."
	echo "##############################################################"
	echo "# error occured at : `date`"
	echo "# all processes finished at : `date`"
	echo "##############################################################"
	echo "yes" > $ERROR
	exit 1
fi
# Abarbeitung aller konfigurierten Maschinen
############################################
echo "$MACHINES" | while read MACHINE; do
	echo "processing machine : $MACHINE"
# Maschinenkonfiguration lesen
##############################
	SQL="SELECT share FROM \`connection-config\` WHERE name = '$MACHINE'"
	SHARE=`mysql --skip-column-names machines -uroot -p$SQLPWD -e "$SQL"`
	RETURN=$?
	if [ $RETURN -ne 0 ]; then
		echo "error reading machine '$MACHINE' configuration (share). trying next machine ..."
		echo "##############################################################"
		echo "# error occured at : `date`"
		echo "##############################################################"
		echo "yes" > $ERROR
		continue
	fi
	SQL="SELECT user FROM \`connection-config\` WHERE name = '$MACHINE'"
	USER=`mysql --skip-column-names machines -uroot -p$SQLPWD -e "$SQL"`
	RETURN=$?
	if [ $RETURN -ne 0 ]; then
		echo "error reading machine '$MACHINE' configuration (user). trying next machine ..."
		echo "##############################################################"
		echo "# error occured at : `date`"
		echo "##############################################################"
		echo "yes" > $ERROR
		continue
	fi
	SQL="SELECT password FROM \`connection-config\` WHERE name = '$MACHINE'"
	PASSWORD=`mysql --skip-column-names machines -uroot -p$SQLPWD -e "$SQL"`
	RETURN=$?
	if [ $RETURN -ne 0 ]; then
		echo "error reading machine '$MACHINE' configuration (password). trying next machine ..."
		echo "##############################################################"
		echo "# error occured at : `date`"
		echo "##############################################################"
		echo "yes" > $ERROR
		continue
	fi
# starte VPN
############
	/etc/init.d/openvpn start ovpn-$MACHINE-client >/dev/null
	RETURN=$?
	if [ $RETURN -ne 0 ]; then
		echo "error starting VPN '$MACHINE'. trying next machine ..."
		echo "##############################################################"
		echo "# error occured at : `date`"
		echo "##############################################################"
		echo "yes" > $ERROR
		continue
	fi
# mounten der Freigabe
######################
	mount -o user=$USER,passwd=$PASSWORD $SHARE /mnt
	RETURN=$?
	if [ $RETURN -ne 0 ]; then
		echo "error mounting machines '$MACHINE' share '$SHARE'. trying next machine ..."
		echo "##############################################################"
		echo "# error occured at : `date`"
		echo "##############################################################"
		echo "yes" > $ERROR
		continue
	fi
# Messdatenpfade ermitteln
##########################
	SQL="SELECT path FROM \`datafiles-$MACHINE\`ORDER BY id"
	DATAPATHS=`mysql --skip-column-names machines -uroot -p$SQLPWD -e "$SQL"`
	RETURN=$?
	if [ $RETURN -ne 0 ]; then
		echo "error reading machine '$MACHINE' measurement data paths. trying next machine ..."
		echo "##############################################################"
		echo "# error occured at : `date`"
		echo "##############################################################"
		echo "yes" > $ERROR
		continue
	fi
# Abarbeiten aller definierten Messdatenpfade
#############################################
	echo "$DATAPATHS" | while read DATAPATH; do
		echo "   catching $DATAPATH"
# Übertragen der Messdaten
##########################

########## START neuer Teil ##########
        # Source-Path
        SPATH=/mnt/$DATAPATH
        # build list of files to copy
        # Zählvariable auf Anzahl der Tage
        DAY=$NO_OF_DAYS_BACK
        # Kopierliste leer
        f2cp=""
        while [ $DAY -gt 0 ]; do
            # hänge neue "Wildcard+Datum" vor die Liste
            f2cp="$SPATH/*$(date -d"$DAY days ago" +%Y_%m_%d.txt) $f2cp"
            # Variable decrementieren
            DAY=$(($DAY-1))
        done
########## ENDE neuer Teil ##########
        TMPDIR=`mktemp -d`
######## hier altes Kopieren auskommentiert ####
#        cp -r /mnt/$DATAPATH $TMPDIR
######## hier neuer Kopierbefehl ####
        cp -r $f2cp $TMPDIR
######## ab hier wie bisher weiter ####
		RETURN=$?
		if [ $RETURN -ne 0 ]; then
			echo "error copying machine '$MACHINE' measurement data from '$DATAPATH'. trying next path ..."
			echo "##############################################################"
			echo "# error occured at : `date`"
			echo "##############################################################"
			echo "yes" > $ERROR
			continue
		fi
# erste und letzte Datenzeile prüfen ob
# Jahreswechsel innerhalb der Datei stattfindet
# in dem Fall zerlegen in 2 Dateien
###############################################
		find $TMPDIR -type f -iname '*.txt' -print | while read "FULLFILE"; do
			FIRSTYEAR=`head -n1 "$FULLFILE" | awk -F. '{ print $3 }' | awk '{ print $1 }'`
			LASTYEAR=`tail -n1 "$FULLFILE" | awk -F. '{ print $3 }' | awk '{ print $1 }'`
			if [ $FIRSTYEAR -ne $LASTYEAR ]; then
				grep ".$FIRSTYEAR " "$FULLFILE" > "$FULLFILE".$FIRSTYEAR.txt
				grep ".$LASTYEAR " "$FULLFILE" > "$FULLFILE".$LASTYEAR.txt
				rm -f "$FULLFILE"
			fi
		done
# Bearbeiten aller Messdatendateien
###################################
		find $TMPDIR -type f -iname '*.txt' -print | while read "FULLFILE"; do
			FILENAME=`basename "$FULLFILE"`
			echo "    importing $FILENAME"
			SENSOR=`echo "$FILENAME" | awk '{ print $1 }'`
			YEAR=`head -n1 "$FULLFILE" | awk -F. '{ print $3 }' | awk '{ print $1 }'`
# Messdatenbank anlegen, wenn nötig
###################################
			SQL="CREATE DATABASE IF NOT EXISTS \`measurement-$YEAR\`;"
			mysql -uroot -p$SQLPWD -e "$SQL"
			RETURN=$?
			if [ $RETURN -ne 0 ]; then
				echo "error creating measurement database for year '$YEAR'. aborting ..."
				echo "##############################################################"
				echo "# error occured at : `date`"
				echo "# all processes finished at : `date`"
				echo "##############################################################"
				echo "yes" > $ERROR
				umount -f /mnt
				/etc/init.d/openvpn stop ovpn-$MACHINE-config
				exit 1
			fi
# Messdatentabelle anlegen, wenn nötig
######################################
			SQL="CREATE TABLE IF NOT EXISTS \`$MACHINE-$SENSOR\` (\`timestamp\` datetime NOT NULL, \`value\` decimal(10,5) NOT NULL, PRIMARY KEY (\`timestamp\`)) ENGINE=InnoDB DEFAULT CHARSET=latin1;"
			mysql measurement-$YEAR -uroot -p$SQLPWD -e "$SQL"
			RETURN=$?
			if [ $RETURN -ne 0 ]; then
				echo "error creating machine '$MACHINE' measurement data table '$SENSOR'. trying next data file ..."
				echo "##############################################################"
				echo "# error occured at : `date`"
				echo "##############################################################"
				echo "yes" > $ERROR
				continue
			fi
# Messdaten in MySQL-CSV-Format bringen
# (TAB einfügen als Feldtrenner)
# (Zeitstempel ind DATETIME-Fomat wandeln)
# (Dateinamen in Tabellennamen ändern)
##########################################
			cat "$FULLFILE" | sed -e "s%\([0-9]\+\)[.:]\([0-9]\+\)[.:]\([0-9]\+\)[ \t]\+\([0-9:.]\+\)[\t]\+\([0-9]*\)[,.]\([0-9]*\)%\3-\2-\1 \4	\5.\6%" > $TMPDIR/$MACHINE-$SENSOR.mysqlimport
			RETURN=$?
			if [ $RETURN -ne 0 ]; then
				echo "error formating machine '$MACHINE' measurement data '$SENSOR'. trying next data file ..."
				echo "##############################################################"
				echo "# error occured at : `date`"
				echo "##############################################################"
				echo "yes" > $ERROR
				continue
			fi
# Daten importieren
# (bei identischen Zeitstempeln, gewinnt der letzte Eintrag)
############################################################
			mysqlimport -s --replace -uroot -p$SQLPWD -L measurement-$YEAR $TMPDIR/$MACHINE-$SENSOR.mysqlimport
			RETURN=$?
			if [ $RETURN -ne 0 ]; then
				echo "error importing machine '$MACHINE' measurement data '$SENSOR'. trying next data file ..."
				echo "##############################################################"
				echo "# error occured at : `date`"
				echo "##############################################################"
				echo "yes" > $ERROR
				continue
			fi
		done
# temporären Pfad wieder löschen
################################
		rm -fr $TMPDIR
		RETURN=$?
		if [ $RETURN -ne 0 ]; then
			echo "error cleaning TMP dir '$TMPDIR'. Please clean manually."
			echo "##############################################################"
			echo "# error occured at : `date`"
			echo "##############################################################"
			echo "yes" > $ERROR
		fi
	done
# Mountpunkt wieder lösen
#########################
	umount /mnt
	RETURN=$?
	if [ $RETURN -ne 0 ]; then
		echo "error umounting machines '$MACHINE' share '$SHARE'."
		echo "##############################################################"
		echo "# error occured at : `date`"
		echo "##############################################################"
		echo "yes" > $ERROR
		umount -f /mnt
	fi
# VPN beenden
#############
	/etc/init.d/openvpn stop ovpn-$MACHINE-client >/dev/null
	RETURN=$?
	if [ $RETURN -ne 0 ]; then
		echo "error stooping VPN to machine '$MACHINE'. This should not happen."
		echo "##############################################################"
		echo "# error occured at : `date`"
		echo "##############################################################"
		echo "yes" > $ERROR
	fi
done
echo "##############################################################"
echo "# all processes finished at : `date`"
echo "##############################################################"
ERRORTXT=`cat $ERROR`
rm -f $ERROR
if [ "$ERRORTXT" = "yes" ];
then
	exit 1
else
	exit 0
fi

So ich mich jetzt mal mit dem Script und euren Vorschlägen beschäftig.

Dank der Kommentare im Script bin ich zwar in der Lage zu erkennen wann das Script was macht würde jetzt aber beim Verändern der Daten und beim Import in die Datenbank noch sehr viel Hilfe bei der Anpassung benötigen.

Dazu würde ich gern die Grundfunktion des Scripts beibehalten, Sprich das verbinden mit den Standorten und und das Herunterladen der .txt Dateien, wird wenn ich das richtig verstanden habe aus den .txt Dateien eine .csv generiert. An dieser Stelle würde ich das erste mal eingreifen und der .csv ein neues Design geben. Bis jetzt wid ja in der DB Mesurement-Jahr die entsprechende Tabelle gesucht und wenn diese nicht existiert erstellt und danach der Inhalt der .txt/.csv importiert. Nach euren Vorschlägen sollte es jetzt ja so sein das ich von den "Jahres Datenbanken" weg gehe hin zu einer einzigen, was ich einen guten Vorschlag finde. Deshalb sollten wir vermutlich die .csv mit folgendem Inhalt erzeugen :

• Standort

• Sensor

• Zeitstempel

• Value

Und diese dann in eine "Universaltabelle" importieren.

Was ich jetzt nicht weis, kann man innerhalb eines Importes dann auch die Daten Transformieren um bei der Gelegenheit gleich auch die entsprechenden

• Stunden

• Tag

• Wochen

Tabellen zu erzeugen.

Was auf jeden Fall weiterhin Dynamisch erfolge muss ist das einlesen der Sensoren da hier keine feste Definition existiert. Und auch beim hinzufügen neuer Sensoren häufig "die Kommunikation" fehlschlägt:-).

Vielen Dank fürs zuhören.

Cracymike schrieb:

Was ich jetzt nicht weis, kann man innerhalb eines Importes dann auch die Daten Transformieren um bei der Gelegenheit gleich auch die entsprechenden

• Stunden

• Tag

• Wochen

Tabellen zu erzeugen.

Unser Punkt ist ja gerade, das Schema so zu ändern, dass man keine neuen Tabellen erzeugen muss.

Was auf jeden Fall weiterhin Dynamisch erfolge muss ist das einlesen der Sensoren da hier keine feste Definition existiert. Und auch beim hinzufügen neuer Sensoren häufig "die Kommunikation" fehlschlägt:-).

Wie gesagt, dafür braucht es keine neuen Tabellen.

Ciao

robert