Hallo Kennedy3,
Wenn Sie nach einer Möglichkeit suchen, dies manuell zu tun, sollte der folgende Ansatz (der leicht per Skript erstellt werden kann) für Sie funktionieren. Die folgende Formel kopiert den Wert von „Änderungsstufe“ in der neuen Formelspalte nach unten, bis er auf einen Zeitstempel mit einer neuen „Änderungsstufe“ stößt.
Annahmen: Tabelle 1 und Tabelle 2 haben die gleichen Spaltennamen für Datum;
In den folgenden Schritten enthält Tabelle 1 eine Spalte mit dem Namen „Änderungsebene“.
Schritt 1: Verwenden Sie Tables => Concatenate, um eine Tabelle an die andere anzuhängen
Schritt 2: Verwenden Sie Tabellen => Sortieren, um die neue Tabelle nach Datum zu sortieren
Schritt 3: Erstellen Sie in der resultierenden Tabelle eine Formelspalte mit der folgenden Formel:
(In der Formel oben heißt die neue Formelspalte „Spalte 3“)
Wenn Sie die Informationen aus Tabelle 1 nicht in der resultierenden Tabelle behalten möchten (z. B. wenn es sich nur um eine „Nachschlagetabelle“ handelt), können Sie alle nicht fehlenden Zeilen aus der Spalte „Änderungsebene“ auswählen und löschen.
Hoffe das hilft…
Ich hatte ein ähnliches Problem bei der Überwachung verschiedener Sensoren in meinem Zuhause. Ich habe im ganzen Haus 5 Sensoren, die Temperatur, Luftfeuchtigkeit und Beleuchtung messen. Sie senden alle 8 Minuten Messwerte an einen zentralen Hub (SmartThings), es sei denn, der Wert hat sich gegenüber dem vorherigen Wert nicht geändert. Ich habe auch einen kontinuierlichen Stromzähler, der den Stromverbrauch im Haus misst.
Ich bin mit diesem Problem umgegangen, indem ich eine JMP-Datentabelle „Jahr mit 5 Minuten“ erstellt habe, die ein Jahr lang alle 5 Minuten Stichproben enthält. Und dann verschachtele ich die Werte meiner 20 Sensoren mithilfe eines Skripts in diese 5-Minuten-Jahrestabelle. Wenn ich also einen Messwert für eine bestimmte Probe für einen Sensor habe, wird dieser aufgezeichnet, andernfalls fehlt ein Wert.
Jahr von 5 Minuten:
Ich habe ein anderes Skript, mit dem ich den „Sensorzustand“ visualisieren kann – im Grunde eine „IsMissing“-Prüfung. Dadurch erhalte ich Bescheid, wenn ich Netzwerkprobleme, Sensorprobleme usw. habe. Das hat mir sehr geholfen. Und visualisieren Sie auch, ob mein Join funktioniert.
Im Grunde bestand die Strategie darin, eine Master-Abtasttabelle in dem kürzesten Zeitintervall zu verwenden, das ich für meine Messungen zur Verfügung hatte (alle Minuten), und jeden Sensor mit dieser Master-Tabelle zu verbinden.
Ich betrachte dies als „Interleaving“ und nicht als „Joining“, und es gibt sicherlich mehr als ein Ergebnis, das wünschenswert sein könnte.
Ich habe einen alten Code ausgegraben, der meiner Meinung nach Ihren Wünschen nahe kommt. Auch in der Welt von JSL wird es gute und weniger gute Möglichkeiten geben, dorthin zu gelangen, wo Sie sein möchten. Als Alternative zu Erics Ansatz sehen Sie sich bitte unten an. Ich bin mir sicher, dass es effizienter gemacht werden könnte, und das könnte etwas sein, was andere gerne ausprobieren würden. . .
NamesDefaultToHere ( 1 ) ;
// Einige Datumsdaten in zwei Tabellen erstellen
nf = 100 ;
vals = J ( nf , 1 , RandomInteger ( DateDMY ( 1 , 1 , 2014 ) , DateDMY ( 31 , 12 , 2014 ))) ;
dtFine = NeueTabelle ( „Datum und Uhrzeit im Jahr 2014 – in Ordnung“ ,
Neue Spalte ( "Datum" , Numerisch , Kontinuierlich ,
Format ( „ddMonyyyy h:m:s“ , 22 , 0 ) ,
Eingabeformat ( „ddMonyyyy h:m:s“ , 0 ) ,
Werte ( vals )
)
) ;
nc = 10 ;
vals = J ( nc , 1 , RandomInteger ( DateDMY ( 1 , 1 , 2014 ) , DateDMY ( 31 , 12 , 2014 ))) ;
dtGrob = NeueTabelle ( „Datum und Uhrzeit im Jahr 2014 – grob“ ,
Neue Spalte ( "Datum" , Numerisch , Kontinuierlich ,
Format ( „ddMonyyyy h:m:s“ , 22 , 0 ) ,
Eingabeformat ( „ddMonyyyy h:m:s“ , 0 ) ,
Werte ( vals )
) ,
Neue Spalte ( "Temperatur" , Numerisch , Kontinuierlich , Formel ( ZufälligNormal ( 18 , 2 )))
) ;
dtFine << Sortieren ( Von ( : Datum ) , Befehl ( Aufsteigend ) , Tabelle ersetzen ) ;
dtGrob << Sortieren ( Von ( : Datum ) , Befehl ( Aufsteigend ) , Tabelle ersetzen ) ;
// ********************************************** ************************************************** ****
// Die groben Daten mit den feinen Daten verschachteln
// ********************************************** ************************************************** ****
// Die Spalten von dtCoarse zu dtFine hinzufügen
Warten ( 3 ) ;
N = NCol ( dtFine ) ;
Spalten = dtGrob << getColumnNames ( „Zeichenfolge“ ) ;
Für ( C = 1 , C <= NItems ( Spalten ) , C ++,
dtype = Spalte ( dtGrob , Spalten [ C ]) << getDataType ;
mtyp = Spalte ( dtGrob , Spalten [ C ]) << getModelingType ;
addCol = Ausdruck ( dtFine << Neue Spalte ( Spalten [ C ] , dtype , mtyp , formatTBD )) ;
SubstituteInto ( addCol , Ausdruck ( formatTBD ) , Spalte ( dtGrob , Spalten [ C ]) << getFormat ) ;
addCol ;
) ;
// ********************************************** ************************************************** ****
// Die Logik basiert darauf, dass die beiden Tabellen in aufsteigender Reihenfolge sortiert werden!
// ********************************************** ************************************************** ****
feinDT = Spalte ( dtFine , "Datum" ) << getValues ;
grobDT = Spalte ( dtGrob , "Datum" ) << getValues ;
Wenn (
// Keine Zeit in dtCoarse ist später als die früheste Zeit in dtFine, also fügen Sie in letzterer Werte in die erste Zeile ein
Max ( grobDT ) < Mindest ( feinDT ) ,
Für ( C = 1 , C <= NItems ( Spalten ) , C ++,
Spalte ( dtFine , N + C )[ 1 ] = Spalte ( dtGrob , Spalten [ C ])[ NRow ( dtGrob )] ;
) ,
// Anders . . .
// pos enthält die Positionen der Zeilen in dtFine, an denen die Werte in dtCoarse eingefügt werden sollen.
// (Hinweis: Wenn ein Wert in pos größer als NRow(dtFine) ist, wird diesem keine Zeile hinzugefügt und es entsteht kein Fehler.)
Pos = LocSorted ( feinDT , grobDT ) ;
Pos = Pos + J ( NRow ( Pos ) , 1 , 1 ) ;
// Werte in Zellen einfügen
Für ( P = 1 , P <= NRow ( Pos ) , P ++,
Für ( C = 1 , C <= NItems ( Spalten ) , C ++,
Spalte ( dtFine , N + C )[ Pos [ P ]] = Spalte ( dtGrob , Spalten [ C ])[ P ] ;
) ;
) ;
) ;
Hallo, Kennedy3,
Ich denke, dass dies ein häufiges Problem ist, da Sensoren nur Pegeländerungen aufzeichnen und nicht, selbst wenn sie in festen Intervallen unverändert bleiben, also beschloss ich, ein wenig darüber nachzudenken.Die einzige Möglichkeit, die ich kenne, ist eine zusammengesetzte Abfrage, die für große Tabellen möglicherweise übermäßig ineffizient ist, oder vielleicht könnten Sie sich eine Variante einfallen lassen, die effizienter sein könnte.
Hier ist ein Beispiel: Nehmen wir an, ich leite einen Country Club und schaue mir den Zusammenhang zwischen der Anzahl der Golfer und der Temperatur an.Alles, was ich an Temperaturdaten habe, ist eine Tabelle der durchschnittlichen wöchentlichen Temperatur:
Was die Anzahl der Golfer betrifft, habe ich eine Sommerstudentin, die an zufälligen Tagen für mich arbeitet, und ich ließ sie die Golfer zählen.Hier sind ihre Daten:
Beachten Sie, dass die Daten, an denen sie Golfer zählte, nicht mit den Daten für die durchschnittlichen Hochtemperaturwerte übereinstimmen.Ich möchte für jedes Datum, an dem sie Golfer gezählt hat, den Temperaturwert für den Beginn dieser Woche ermitteln.Wenn ich die beiden Tabellen mit der Bedingung „Woche <= Testdatum“ verbinde, verwende ich diese SQL:
SELECT t2.TestDate, t1.Week
FROM dbo.Golfers t2
LEFT OUTER JOIN dbo.AvgHighTemps t1
ON ( t1.Week <= t2.TestDate )
ORDER BY t2.TestDate ASC;
Ich bekomme eine Tabelle, die so aussieht:
Beachten Sie, dass jedes TestDate jetzt mehrere übereinstimmende Wochen hat.Aber wenn ich die Zeile mit dem größten Wochendatum herausziehe, das kleiner als das Testdatum ist, ist das die Woche, die ich möchte.Ich kann das mit diesem SQL machen:
SELECT t2.TestDate, MAX(t1.Week) AS Week
FROM dbo.AvgHighTemps t1
FULL OUTER JOIN dbo.Golfers t2
ON ( t2.TestDate >= t1.Week )
GROUP BY t2.TestDate
ORDER BY t2.TestDate ASC;
und die resultierende Tabelle sieht so aus:
Jetzt kommt der knifflige Teil.Ich muss diese Abfrage als Unterabfrage verwenden und die beiden anderen Tabellen damit verknüpfen, um das gewünschte Ergebnis zu erhalten.Hier ist die SQL:
SELECT t1.Week, t1.AvgHighTemp, t2.TestDate, t2.NGolfers
FROM (
SELECT t1.TestDate, MAX(t2.Week) as TempWeek
FROM dbo.Golfers t1
LEFT OUTER JOIN dbo.AvgHighTemps t2
ON ( t2.Week <= t1.TestDate )
GROUP BY t1.TestDate
) tempFinder
RIGHT OUTER JOIN dbo.AvgHighTemps t1
ON t1.Week = tempFinder.TempWeek
RIGHT OUTER JOIN dbo.Golfers t2
ON t2.TestDate = tempFinder.TestDate
;
Das Ergebnis ist eine Tabelle mit der Anzahl der Golfer und der Durchschnittstemperatur für die entsprechende Woche:
Das ist ein bisschen Arbeit, um dorthin zu gelangen, aber ich persönlich kenne keinen anderen Weg, dies zu tun.
Hoffe das hilft,
Eric
