Hola Kennedy3,
Si está buscando una manera de hacer esto manualmente, el siguiente enfoque (que puede programarse fácilmente) debería funcionar para usted. La siguiente fórmula copia el valor de "Nivel de cambio" en la nueva columna de fórmula hasta que se topa con una marca de tiempo con un nuevo "Nivel de cambio".
Supuestos: La Tabla 1 y la Tabla 2 tienen los mismos nombres de columna para Fecha;
En los pasos siguientes, la Tabla 1 tiene una columna denominada "Cambiar nivel"
Paso 1: use Tablas => Concatenar para agregar una tabla a la otra
Paso 2: Utilice Tablas => Ordenar para ordenar la nueva tabla por fecha
Paso 3: cree una columna Fórmula en la tabla resultante con la siguiente fórmula:
(En la fórmula anterior, la nueva columna de fórmula se llama "Columna 3")
Si no desea conservar la información de la Tabla 1 en la tabla resultante (es decir, si es solo una tabla de "búsqueda"), puede seleccionar todas las filas que no faltan de la columna "Cambiar nivel" y eliminarlas.
Espero que esto ayude…
Me he enfrentado a un problema similar al monitorear varios sensores en mi casa. Tengo 5 sensores en toda la casa, que miden temperatura, humedad e iluminación. Envían mediciones a un concentrador central (SmartThings) cada 8 minutos a menos que el valor no haya cambiado con respecto al valor anterior. También tengo un medidor de energía continuo, que mide la utilización de energía en la casa.
La forma en que he solucionado este problema es crear una tabla de datos JMP de "año de 5 minutos", que tiene muestras cada 5 minutos durante un año. Y luego intercalo los valores de mis 20 sensores en esta tabla de 5 minutos de un año usando un script. Entonces, si tengo una lectura en esa muestra en particular para un sensor, se registra; de lo contrario, falta un valor.
Año de 5 minutos:
Tengo otro script que me permite visualizar el "estado del sensor", básicamente una comprobación de "Falta". Esto me permite saber cuando tengo problemas con la red, problemas con los sensores, etc. Ha sido muy útil. Y también visualizar si mi unión está funcionando.
Básicamente, la estrategia fue emplear una tabla de muestreo maestra en el intervalo de tiempo más corto que tendría en mis mediciones (cada minutos) y unir cada sensor a esa mesa maestra.
Pienso en esto como "entrelazar" en lugar de "unir", y seguramente hay más de un resultado que podría ser deseable.
Saqué un código antiguo que creo que se acerca a lo que quieres. Además, incluso dentro del mundo de JSL habrá formas buenas y menos buenas de llegar a donde quieres estar. Entonces, como alternativa al enfoque de Eric, consulte a continuación. Estoy seguro de que podría hacerse más eficiente, y eso podría ser algo que a otros les gustaría intentar. . .
NombresDefaultToHere ( 1 ) ;
// Crea algunos datos de 'fecha' en dos tablas
nf = 100 ;
vals = j ( nf , 1 , EnteroAleatorio ( FechaDMA ( 1 , 1 , 2014 ) , FechaDMA ( 31 , 12 , 2014 ))) ;
dtFina = Nueva tabla ( "Fecha y hora en 2014 - Bien" ,
Nueva columna ( "Fecha" , Numérico , Continuo ,
Formato ( "ddMonyyyy h:m:s" , 22 , 0 ) ,
Formato de entrada ( "ddMonyyyy h:m:s" , 0 ) ,
Valores ( vals )
)
) ;
Carolina del Norte = 10 ;
vals = j ( Carolina del Norte , 1 , EnteroAleatorio ( FechaDMA ( 1 , 1 , 2014 ) , FechaDMA ( 31 , 12 , 2014 ))) ;
dtgrueso = Nueva tabla ( "Fecha y hora en 2014 - Grueso" ,
Nueva columna ( "Fecha" , Numérico , Continuo ,
Formato ( "ddMonyyyy h:m:s" , 22 , 0 ) ,
Formato de entrada ( "ddMonyyyy h:m:s" , 0 ) ,
Valores ( vals )
) ,
Nueva columna ( "Temperatura" , Numérico , Continuo , Fórmula ( AleatorioNormal ( 18 , 2 )))
) ;
dtFina << Clasificar ( Por ( : Fecha ) , Orden ( Ascendente ) , Reemplazar tabla ) ;
dtgrueso << Clasificar ( Por ( : Fecha ) , Orden ( Ascendente ) , Reemplazar tabla ) ;
// *********************************************** ************************************************** ****
// Intercalar los datos gruesos con los datos finos
// *********************************************** ************************************************** ****
// Agrega las columnas de dtCoarse a dtFine
Esperar ( 3 ) ;
norte = NCol ( dtFina ) ;
columnas = dtgrueso << obtener nombres de columnas ( "Cadena" ) ;
Para ( C = 1 , C <= NArtículos ( columnas ) , C ++,
tipo d = Columna ( dtgrueso , columnas [ C ]) << obtener tipo de datos ;
tipo m = Columna ( dtgrueso , columnas [ C ]) << getModeladoTipo ;
agregarCol = Expr. ( dtFina << Nueva columna ( columnas [ C ] , tipo d , tipo m , formatoTBD )) ;
Sustituir en ( agregarCol , Expr. ( formatoTBD ) , Columna ( dtgrueso , columnas [ C ]) << obtener formato ) ;
agregarCol ;
) ;
// *********************************************** ************************************************** ****
// ¡La lógica se basa en que las dos tablas estén ordenadas en orden ascendente!
// *********************************************** ************************************************** ****
multaDT = Columna ( dtFina , "Fecha" ) << obtenerValores ;
gruesoDT = Columna ( dtgrueso , "Fecha" ) << obtenerValores ;
si (
// Ningún momento en dtCoarse es posterior al primer momento en dtFine, por lo tanto, inserte valores en la primera fila de la última
máx. ( gruesoDT ) < mín. ( multaDT ) ,
Para ( C = 1 , C <= NArtículos ( columnas ) , C ++,
Columna ( dtFina , norte + C )[ 1 ] = Columna ( dtgrueso , columnas [ C ])[ Nfila ( dtgrueso )] ;
) ,
// Demás . . .
// pos contendrá las posiciones de las filas en dtFine en las que se deben insertar los valores en dtCoarse.
// (Nota: si un valor en pos es mayor que NRow(dtFine), no se agrega ninguna fila a este último y no se produce ningún error).
posición = LocOrdenado ( multaDT , gruesoDT ) ;
posición = posición + j ( Nfila ( posición ) , 1 , 1 ) ;
// Insertar valores en las celdas
Para ( pag = 1 , pag <= Nfila ( posición ) , pag ++,
Para ( C = 1 , C <= NArtículos ( columnas ) , C ++,
Columna ( dtFina , norte + C )[ posición [ pag ]] = Columna ( dtgrueso , columnas [ C ])[ pag ] ;
) ;
) ;
) ;
Hola, Kennedy3,
Creo que este es un problema común debido a que los sensores solo registran cambios en los niveles en lugar de registrar niveles incluso si no cambian a intervalos fijos, así que decidí pensarlo un poco.La única forma que conozco de hacer esto es con una consulta compuesta que podría ser prohibitivamente ineficiente para tablas grandes, o tal vez se podría idear una variación que podría ser más eficiente.
Aquí hay un ejemplo: digamos que dirijo un club de campo y estoy observando la relación entre el número de golfistas y la temperatura.Todo lo que tengo para los datos de temperatura es una tabla de la temperatura promedio semanal:
Para varios golfistas, tengo una estudiante de verano trabajando para mí en días aleatorios y le pedí que contara a los golfistas.Aquí están sus datos:
Tenga en cuenta que las fechas en las que contó a los golfistas no corresponden a las fechas de las lecturas promedio de temperatura alta.Lo que me gustaría hacer para cada fecha en la que contó a los golfistas es encontrar la lectura de temperatura para el comienzo de esa semana.Si uno las dos tablas con la condición "Semana <= TestDate", usando este 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;
Obtendré una tabla que se parece a esta:
Tenga en cuenta que cada TestDate ahora tiene varias semanas coincidentes.Pero si saco la fila que tiene la fecha de semana más grande que es menor que TestDate, esa será la semana que quiero.Puedo hacer eso con este 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;
y la tabla resultante se ve así:
Ahora viene la parte complicada.Necesito usar esa consulta como una subconsulta, uniendo las otras dos tablas para obtener el resultado que quiero.Aquí está el 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
;
El resultado es una tabla que tiene el número de golfistas y la temperatura media de la semana correspondiente:
Es un poco de trabajo llegar allí, pero personalmente no conozco otra forma de hacerlo.
Espero que esto ayude,
eric
