wakr70
commented
8 months ago Hallo Mathias,
hab mich etwas mit dem Script gespielt und folgendes programmiert, kannt du mal bitte drüberschauen, bin absolute Groovy-Anfänger!
Hab auf einen Spielsystem mal das so in die Config genommen:
database.tasks.DelCompr.enable=true
database.tasks.DelCompr.cron="0 0 3 ? * SUN"
database.tasks.DelCompr.script={
// Datenreihen löschen und komprimieren, V1.0
// min, max, first, last or avg as value for compression
def config = [
["DutyCycle.VALUE" ,360, 10, 60*60*1, "max" ], // stündlichen Max Wert nach 10 Tagen und nach 370 Tagen löschen
["*.CARRIER_SENSE_LEVEL" , 360, 10, 60*60*1, "max" ], // stündlichen Max Wert nach 10 Tagen und nach 370 Tagen löschen
["*.DUTY_CYCLE_LEVEL" , 360, 10, 60*60*1, "max" ], // stündlichen Max Wert nach 10 Tagen und nach 370 Tagen löschen
["*HUMIDITY" ,1000, 30, 60*60*2, "avg" ], // 2 Stunden Durchschnitt nach 30 Tagen und nach 1000 Tagen löschen
["*TEMPERATURE" ,1000, 30, 60*60*2, "avg" ], // 2 Stunden Durchschnitt nach 30 Tagen und nach 1000 Tagen löschen
["*4.VALVE_STATE" ,1000, 30, 60*60*3, "avg" ], // 3 Stunden Durchschnitt nach 30 Tagen und nach 1000 Tagen löschen
["*.ENERGY_COUNTER" ,1000, 30, 60*60*2, "first" ], // 2 Stunden bei Zähler immer den 1. Wert nehmen nach 30 Tagen und nach 1000 Tagen löschen
["*.POWER" ,1000, 30, 60*60*2, "max" ], // 2 Stunden max nach 30 Tagen und nach 1000 Tagen löschen
["*.POWER_STATUS" , 730, 30, 60*60*2, "avg" ], // 2 Stunden max nach 30 Tagen und nach 1000 Tagen löschen
["*.FREQUENCY_STATUS" , 730, 10, 60*60*3, "avg" ], // 3 Stunden Durschnitt nach 10 Tagen und nach 720 Tagen löschen
["*.CURRENT_STATUS" , 730, 10, 60*60*3, "avg" ], // 3 Stunden Durschnitt nach 10 Tagen und nach 720 Tagen löschen
["*.VOLTAGE_STATUS" , 730, 10, 60*60*3, "avg" ], // 3 Stunden Durschnitt nach 10 Tagen und nach 720 Tagen löschen
["*.ENERGY_COUNTER_OVERFLOW" ,730, 10, 60*60*3, "avg" ],
]
// Testlauf durchführen? Bei einem Testlauf wird die Datenbank nicht verändert.
// (Ja: true, Nein: false)
def testRun = true
// *** Skript ***
def dateFormat = "yyyy-MM-dd HH:mm" // standard Timestamp Format
// 24 Bits für Flag berechnen
def int bit24 = Math.pow(2,23) // 8388608;
// wildcards in regex umbauen
config.each { dptxt ->
def txtResult = new StringBuffer()
dptxt[0].each { ch ->
switch (ch) {
case '*':
// Single '*' matches single dir/file; Double '*' matches sequence of zero or more dirs/files
txtResult << /[^\/]*/
break
case '?':
// Any character except the normalized file separator ('/')
txtResult << /[^\/]/
break
case ['$', '|', '[', ']', '(', ')', '.', ':', '{', '}', '\\', '^', '+']:
txtResult << '\\' + ch
break
default: txtResult << ch
}
}
dptxt[0] = txtResult
// println dptxt[0]
}
def comprFactor=0
def dpCount=[]
def summeDel=0
def summeComp=0
def summetotal=0
def lastDPState
database.dataPoints.sort{ it.displayName }.each { dp ->
// check dp.displayName wird in config gefunden
def found=null
def delBegin=null
def delEnd=null
def komprBegin=null
def cntNew
// Datenpunkt in Liste über REGEX suchen
config.find { con ->
if (dp.displayName==~con[0]) {
// println con[0] + " -> " + dp.displayName // check REGEX Regeln
found = con
// beim ersten gefunden, merken und Schleife verlassen
return true // break
}
}
if (found) {
// Datenlöschung *******
if (found[1] > 10) {
cntNew=0
// Löschzeitraum bestimmen
delBegin=database.getFirstTimestamp(dp)
delEnd=new Date()-found[1] // found[1] = 2 spalte aus der Konfiguration Tabelle am Anfang
if (testRun) {
cntNew=database.getCount(dp, delBegin , delEnd)
if (cntNew>0) println "$dp.displayName: $cntNew werden gelöscht! von: " + delBegin.format(dateFormat) + " bis: " + delEnd.format(dateFormat) + " (Testlauf)"
} else {
cntNew=database.deleteTimeSeries(dp, delBegin , delEnd)
if (cntNew>0) println "$dp.displayName: $cntNew gelöscht! von: " + delBegin.format(dateFormat) + " bis: " + delEnd.format(dateFormat)
}
summeDel=summeDel+cntNew
}
// Datenkomprimierung ******
if (found[2] > 5) {
// Komprimierungs Zeitraum bestimmen
if (delEnd) {
komprBegin=delEnd
} else {
komprBegin=database.getFirstTimestamp(dp)
}
def komprEnd=new Date()-found[2] // von Konfigurationtalle Tage bis zum Komprimierung
comprFactor = 1000*found[3] // Sekunden von Konfigurationtabelle * 1000 auf Millisekungen
def comprValue = found[4] // von Konfigurationtalle "AVG", "MIN", "MAX", ...
def cnt
// Zeitreihe holen
def ts=database.getTimeSeriesRaw(dp, komprBegin, komprEnd)
// erste Zeitreihe ohne komprimierung finden
def komprBeg = komprEnd
ts.find { pv ->
if (!(pv.state&bit24)) {
komprBeg = pv.timestamp // neues Beginndatum ermittelt, keine Behandlung von bereits komprimierten Datensätzen
return true // break
}
}
//println "Erste Timestamp ohne KompFlag: $komprBeg"
// Zeitreihe holen neu ohne bereits komprimierte
ts=database.getTimeSeriesRaw(dp, komprBeg , komprEnd)
cnt=ts.size
// Statistik berechnen
def duration=komprEnd.time - komprBeg.time
def min=Double.POSITIVE_INFINITY
def max=Double.NEGATIVE_INFINITY
def integr=0
def intsum=0
def intwert=0
def anzahl=0
def summe=0
def lastTime=0
def thisTime=0
def firstValue=0
def lastValue=0
def avg=0
def previous
def comprPosible=false
// neue komprimierte Zeitreihe erstellen
def timeSeries=new TimeSeries(dp)
ts.each { pv ->
// Datum runden für die Komprimierung, immer das gleiche
thisTime=new Date( ( ( Math.floor(pv.timestamp.time/comprFactor)*comprFactor) as long) )
if (thisTime!=lastTime) {
if (lastTime!=0) {
duration=lastTime.time - thisTime.time
// Durchnitt ist Integral/Zeitbereichslänge in Millisekunden.
// def avg=integr/duration
avg = Math.round(summe / anzahl * 10) / 10
if (intsum!=0) intwert = Math.round(integr / intsum * 10) / 10
// println lastTime.format(dateFormat) + " Anzahl: $anzahl, Minimum: $min, Maximum: $max, Integral: $intwert, Durchschnitt: $avg, Duration: $duration, First: $firstValue, Last: $lastValue"
switch(comprValue) {
case "min":
timeSeries.add(new ProcessValue(lastTime, min, bit24|lastDPState ))
break;
case "max":
timeSeries.add(new ProcessValue(lastTime, max, bit24|lastDPState ))
break;
case "first":
timeSeries.add(new ProcessValue(lastTime, firstValue, bit24|lastDPState ))
break;
case "last":
timeSeries.add(new ProcessValue(lastTime, lastValue, bit24|lastDPState ))
break;
case "avg":
timeSeries.add(new ProcessValue(lastTime, avg, bit24|lastDPState ))
break;
case "integral":
timeSeries.add(new ProcessValue(lastTime, avg, bit24|lastDPState ))
break;
}
if (anzahl>1) comprPosible=true
}
min=pv.value
max=pv.value
anzahl=0
summe=0
integr=0
intsum=0
intwert=pv.value
firstValue=pv.value
lastDPState=pv.state
lastTime=thisTime
}
if (pv.value<min) min=pv.value
if (pv.value>max) max=pv.value
if (previous!=null) {
// Teilintegral berechnen: Messwert*Millisekunden
integr+=previous.value*(pv.timestamp.time-previous.timestamp.time)
intsum+=(pv.timestamp.time-previous.timestamp.time)
}
lastValue=pv.value
anzahl=anzahl+1
summe=summe+pv.value
previous=pv
}
if (lastTime!=0) {
duration=lastTime.time - thisTime.time
// Durchnitt ist Integral/Zeitbereichslänge in Millisekunden.
// def avg=integr/duration
avg = Math.round(summe / anzahl * 10) / 10
if (intsum!=0) intwert = Math.round(integr / intsum * 10) / 10
// println lastTime.format(dateFormat) + " Anzahl: $anzahl, Minimum: $min, Maximum: $max, Integral: $intwert, Durchschnitt: $avg, Duration: $duration, First: $firstValue, Last: $lastValue"
switch(comprValue) {
case "min":
timeSeries.add(new ProcessValue(lastTime, min, bit24|lastDPState ))
break;
case "max":
timeSeries.add(new ProcessValue(lastTime, max, bit24|lastDPState ))
break;
case "first":
timeSeries.add(new ProcessValue(lastTime, firstValue, bit24|lastDPState ))
break;
case "last":
timeSeries.add(new ProcessValue(lastTime, lastValue, bit24|lastDPState ))
break;
case "avg":
timeSeries.add(new ProcessValue(lastTime, avg, bit24|lastDPState ))
break;
case "integral":
timeSeries.add(new ProcessValue(lastTime, avg, bit24|lastDPState ))
break;
}
if (anzahl>1) comprPosible=true
}
if (comprPosible) {
println "$dp.displayName: Konfig " + komprBegin.format(dateFormat) + " bis: " + komprEnd.format(dateFormat) + " Zeitraum Sek: $comprFactor Wert: $comprValue"
cntNew=0
if (testRun) {
println "$dp.displayName: komprimiert! $cnt -> $timeSeries.size von: " + komprBeg.format(dateFormat) + " bis: " + komprEnd.format(dateFormat) + " (Testlauf)"
cntNew=timeSeries.size
} else {
println "$dp.displayName: komprimiert! $cnt -> $timeSeries.size von: " + komprBeg.format(dateFormat) + " bis: " + komprEnd.format(dateFormat)
cntNew=database.replaceTimeSeries(dp, timeSeries, komprBeg, komprEnd)
}
summeComp=summeComp+(cnt-cntNew)
summetotal=summetotal+cnt
}
}
}
}
println "Summe Datenzeilen gelöscht: $summeDel"
println "Summe Datenzeilen komprimiert: $summeComp von $summetotal"
}
mdzio
Hallo Matthias, durch die Scripts ist viel möglich geworden, danke nochmals für diese Erweiterung und Öffnung.
Trotzdem würde ich es begrüssen wenn sich Historian auch für die Altdaten Behandlung einige Funktionen beinhalten würde.
Hier nur mal einige Ideen.
Wöchentlicher oder Täglicher Job das automatisch übernimmt die Datenlöschung und die Datenkomprimierung.
3 zusätzliche Felder in der Datenpunktkonfiguration.
Wenn man jetzt noch einen Monatlichen um 03:00 -compact einplannen könnte dann wäre keine Wartung mehr nötig.
Was meinst du dazu ?
LG wak