Bonjour Kennedy3,
Si vous cherchez un moyen de le faire manuellement, l'approche suivante (qui peut facilement être scriptée) devrait fonctionner pour vous. La formule ci-dessous copie la valeur de « Change Level » dans la nouvelle colonne de formule jusqu'à ce qu'elle rencontre un horodatage avec un nouveau « Change Level ».
Hypothèses : le tableau 1 et le tableau 2 ont les mêmes noms de colonnes pour la date ;
Dans les étapes ci-dessous, le tableau 1 comporte une colonne nommée « Modifier le niveau »
Étape 1 : Utilisez Tables => Concaténer pour ajouter une table à l'autre
Étape 2 : Utilisez Tables => Trier pour trier le nouveau tableau par date
Étape 3 : Créez une colonne Formule dans le tableau résultant avec la formule suivante :
(Dans la formule ci-dessus, la nouvelle colonne de formule s'appelle « Colonne 3 »)
Si vous ne souhaitez pas conserver les informations du tableau 1 dans le tableau résultant (c'est-à-dire s'il s'agit simplement d'un tableau de « recherche »), vous pouvez sélectionner toutes les lignes non manquantes de la colonne « Modifier le niveau » et les supprimer.
J'espère que cela t'aides…
J'ai rencontré un problème similaire lors de la surveillance de divers capteurs dans ma maison. J'ai 5 capteurs dans toute la maison qui mesurent la température, l'humidité et l'éclairage. Ils envoient des mesures à un hub central (SmartThings) toutes les 8 minutes, sauf si la valeur n'a pas changé par rapport à la valeur précédente. J'ai également un wattmètre continu, qui mesure la consommation d'énergie dans la maison.
La façon dont j'ai résolu ce problème consiste à créer une table de données JMP "année de 5 minutes", qui contient des échantillons toutes les 5 minutes pendant un an. Et puis j'entrelace les valeurs de mes 20 capteurs dans ce tableau annuel de 5 minutes à l'aide d'un script. Donc, si j'ai une lecture sur cet échantillon particulier pour un capteur, elle est enregistrée, sinon il y a une valeur manquante.
Année de 5 minutes :
J'ai un autre script, qui me permet de visualiser la « santé du capteur » – essentiellement une vérification « IsMissing ». Cela me permet de savoir quand j'ai des problèmes de réseau, des problèmes de capteurs, etc. Cela a été très utile. Et visualisez également si ma jointure fonctionne.
Donc, fondamentalement, la stratégie consistait à utiliser une table d'échantillonnage principale à l'intervalle de temps le plus court que j'aurais dans mes mesures (toutes les minutes) et à joindre chaque capteur à cette table principale.
Je considère cela comme un « entrelacement » plutôt que comme une « adhésion », et il y a sûrement plus d'un résultat qui pourrait être souhaitable.
J'ai déterré un vieux code qui, je pense, est proche de ce que vous voulez. De plus, même dans le monde de JSL, il y aura de bons et de moins bons moyens d’arriver là où vous voulez être. Ainsi, comme alternative à l'approche d'Eric, veuillez voir ci-dessous. Je suis sûr que cela pourrait être rendu plus efficace, et cela pourrait être quelque chose que d'autres pourraient aimer essayer. . .
NomsDefaultToHere ( 1 ) ;
// Créez des données 'date' dans deux tables
nf = 100 ;
vals = J. ( nf , 1 , Entier aléatoire ( DateDMY ( 1 , 1 , 2014 ) , DateDMY ( 31 , 12 , 2014 ))) ;
dtFine = NouveauTableau ( "Date et heures en 2014 - Très bien" ,
NouvelleColonne ( "Date" , Numérique , Continu ,
Format ( "jjMonyyyy h:m:s" , 22 , 0 ) ,
Format d'entrée ( "jjMonyyyy h:m:s" , 0 ) ,
Valeurs ( vals )
)
) ;
NC = dix ;
vals = J. ( NC , 1 , Entier aléatoire ( DateDMY ( 1 , 1 , 2014 ) , DateDMY ( 31 , 12 , 2014 ))) ;
dtCoarse = NouveauTableau ( "Date et heures en 2014 - Grossier" ,
NouvelleColonne ( "Date" , Numérique , Continu ,
Format ( "jjMonyyyy h:m:s" , 22 , 0 ) ,
Format d'entrée ( "jjMonyyyy h:m:s" , 0 ) ,
Valeurs ( vals )
) ,
NouvelleColonne ( "Température" , Numérique , Continu , Formule ( AléatoireNormal ( 18 , 2 )))
) ;
dtFine << Trier ( Par ( : Date ) , Commande ( Ascendant ) , RemplacerTable ) ;
dtCoarse << Trier ( Par ( : Date ) , Commande ( Ascendant ) , RemplacerTable ) ;
// *********************************************** ************************************************** ****
// Entrelacer les données grossières avec les données fines
// *********************************************** ************************************************** ****
// Ajoute les colonnes de dtCoarse à dtFine
Attendez ( 3 ) ;
n = sous-officier ( dtFine ) ;
cols = dtCoarse << getColumnNames ( "Chaîne" ) ;
Pour ( c = 1 , c <= NArticles ( cols ) , c ++,
type = Colonne ( dtCoarse , cols [ c ]) << getDataType ;
typem = Colonne ( dtCoarse , cols [ c ]) << getModelingType ;
ajouterCol = Expr ( dtFine << NouvelleColonne ( cols [ c ] , type , typem , formatà déterminer )) ;
RemplacerDans ( ajouterCol , Expr ( formatà déterminer ) , Colonne ( dtCoarse , cols [ c ]) << obtenirFormat ) ;
ajouterCol ;
) ;
// *********************************************** ************************************************** ****
// La logique repose sur le tri des deux tables par ordre croissant !
// *********************************************** ************************************************** ****
bienDT = Colonne ( dtFine , "Date" ) << obtenir des valeurs ;
grossierDT = Colonne ( dtCoarse , "Date" ) << obtenir des valeurs ;
si (
// Aucune heure dans dtCoarse n'est postérieure à l'heure la plus ancienne dans dtFine, donc insérez des valeurs dans la première ligne de cette dernière
Max. ( grossierDT ) < Min. ( bienDT ) ,
Pour ( c = 1 , c <= NArticles ( cols ) , c ++,
Colonne ( dtFine , n + c )[ 1 ] = Colonne ( dtCoarse , cols [ c ])[ NRangée ( dtCoarse )] ;
) ,
// Autre . . .
// pos contiendra les positions des lignes de dtFine auxquelles les valeurs de dtCoarse doivent être insérées.
// (Remarque : si une valeur dans pos est supérieure à NRow(dtFine), aucune ligne n'est ajoutée à cette dernière et aucune erreur ne résulte).
position = LocTrié ( bienDT , grossierDT ) ;
position = position + J. ( NRangée ( position ) , 1 , 1 ) ;
// Insère des valeurs dans les cellules
Pour ( p = 1 , p <= NRangée ( position ) , p ++,
Pour ( c = 1 , c <= NArticles ( cols ) , c ++,
Colonne ( dtFine , n + c )[ position [ p ]] = Colonne ( dtCoarse , cols [ c ])[ p ] ;
) ;
) ;
) ;
Salut, Kennedy3,
Je pense qu'il s'agit d'un problème courant en raison des capteurs qui enregistrent uniquement les changements de niveaux plutôt que d'enregistrer les niveaux même s'ils sont inchangés à intervalles fixes, j'ai donc décidé d'y réfléchir un peu.La seule façon dont je sais comment procéder est d'utiliser une requête composée qui pourrait être d'une inefficacité prohibitive pour les grandes tables, ou peut-être pourriez-vous proposer une variante qui pourrait être plus efficace.
Voici un exemple : disons que je dirige un country club et que j'examine la relation entre le nombre de golfeurs et la température.Tout ce que j'ai comme données de température est un tableau de la température hebdomadaire moyenne :
Pour ce qui est du nombre de golfeurs, j'ai une étudiante d'été qui travaille pour moi des jours aléatoires et je lui ai demandé de compter les golfeurs.Voici ses données :
A noter que les dates où elle a compté les golfeurs ne correspondent pas aux dates des relevés de températures moyennes élevées.Ce que j'aimerais faire pour chaque date à laquelle elle a compté les golfeurs, c'est trouver la température du début de cette semaine.Si je joins les deux tables avec la condition "Week <= TestDate", en utilisant ce 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;
J'obtiendrai un tableau qui ressemble à ceci :
Notez que chaque TestDate a désormais plusieurs semaines correspondantes.Mais si je retire la ligne qui a la plus grande date de semaine inférieure à TestDate, ce sera la semaine que je veux.Je peux le faire avec ce SQL :
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;
et le tableau résultant ressemble à ceci :
Vient maintenant la partie délicate.Je dois utiliser cette requête comme sous-requête, en y joignant les deux autres tables, pour obtenir le résultat souhaité.Voici le 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
;
Le résultat est un tableau qui présente le nombre de golfeurs et la température moyenne pour la semaine correspondante :
C'est un peu de travail pour y arriver, mais personnellement, je ne connais pas d'autre moyen de le faire.
J'espère que cela t'aides,
Éric
