Create a replay query

import io.deephaven.enterprise.database.SystemTableLogger
import io.deephaven.time.DateTimeUtils

// Store the replay date in a variable for clarity and reuse
replayDate = DateTimeUtils.today()
srcNamespace = "Market"
destNamespace = "MarketSim"
tableName = "Trade"

// Retrieve the table to replay
sourceTable = db.liveTable(srcNamespace, tableName)
    .where("Date=`${replayDate}`")
    .dropColumns("Date")

options = SystemTableLogger.newOptionsBuilder()
       .currentDateColumnPartition(true)
       .build()

// When logging incrementally, a Closeable is returned. You must retain this object to ensure liveness. Call `close()` to stop logging and release resources.
logHandle = SystemTableLogger.logTableIncremental(db, destNamespace, tableName, sourceTable, options)

// At this point as rows tick into "Market.Trade" they will be automatically logged back to "MarketSim.Trade"

from deephaven_enterprise import system_table_logger as stl
from deephaven import time

# It is good practice to use a variable to store the value of the Date clauses for your tables

replay_date = time.dh_today()
src_namespace = "Market"
dest_namespace = "MarketSim"
table_name = "Trade"

# Here, we retrieve the table we are going to replay
source_table = (
    db.live_table(src_namespace, table_name)
    .where(f"Date=`{replay_date}`")
    .drop_columns("Date")
)

# When logging incrementally, a Closeable is returned. You must retain this object to ensure liveness
# Call `close()` to stop logging and release resources
log_handle = stl.log_table_incremental(
    namespace=dest_namespace,
    table_name=table_name,
    table=source_table,
    column_partition=None,  # If the API does not support this, revert to original
)

# At this point as rows tick into "Market.Trade" they are automatically logged back to "MarketSim.Trade"

import io.deephaven.enterprise.database.SystemTableLogger
import io.deephaven.time.DateTimeUtils

import java.time.Instant
import java.util.stream.Collectors

// It is good practice to use a variable to store the value of the Date clauses for your tables.
replayDate = DateTimeUtils.today()
replayDateParts = replayDate.split("-")

srcNamespace = "Market"
destNamespace = "MarketSim"
tableName = "Trade"

// Compute the nanos of Epoch at midnight for the current day
dtMidnightToday = LocalDate.now().atStartOfDay(ZoneId.of("America/New_York")).toInstant().toEpochMilli()

// Compute the nanos of Epoch at midnight of the date you are replaying
dtMidnightSource = LocalDate.of(Integer.parseInt(replayDateParts[0]),
        Integer.parseInt(replayDateParts[1]),
        Integer.parseInt(replayDateParts[2]))
        .atStartOfDay(ZoneId.of("America/New_York")).toInstant().toEpochMilli()

// Here we retrieve the table we are going to replay
sourceTable = db.liveTable(srcNamespace, tableName)
        .where("Date=`$REPLAY_DATE`")
        .dropColumns("Date")

// Create a closure that will convert an Instant value from the source date, to the current date, maintaining the timestamp
convertDateToday = { dt -> dt == null ? null : Instant.ofEpochMilli(dt.toEpochMilli() - dtMidnightSource + dtMidnightToday) }

// convert the Instant columns to today's date
convertDateColumns = { Table t ->
    final String[] cols = t.getDefinition().getColumns().stream().filter({c -> "Timestamp" != c.getName() && c.getDataType() == Instant.class })
            .map({ c -> "${c.getName()} = (Instant) convertDateToday.call(${c.getName()})".toString() }).toArray(String[]::new)
    return t.updateView(cols)
}

sourceTable = convertDateColumns(sourceTable)

opts = SystemTableLogger.newOptionsBuilder()
        .currentDateColumnPartition(true)
        .build()

// When logging incrementally, a Closeable is returned. You must retain this object to ensure liveness. Call `close()` to stop logging and release resources.
lh = SystemTableLogger.logTableIncremental(db, destNamespace, tableName, sourceTable, opts)

// At this point, as rows tick into "Market.Trade" they are automatically logged back to "MarketSim.Trade"

from deephaven_enterprise import system_table_logger as stl
from deephaven import time as dh_time
from deephaven.table import Table
from datetime import datetime, time

# It is good practice to use a variable to store the value of the Date clauses for your tables
replay_date = "2024-08-09"
replay_date_time = datetime.strptime(replay_date, "%Y-%m-%d")
# Get the current date
current_date = datetime.now().date()

src_namespace = "Market"
dest_namespace = "MarketSim"
table_name = "Trade"

# Compute the millis of Epoch at midnight for the current day
midnight_time = int(datetime.combine(current_date, time(0, 0)).timestamp() * 1000)

# Compute the millis of Epoch at midnight of the date you are replaying
midnight_source = int(datetime.combine(replay_date_time, time(0, 0)).timestamp() * 1000)

# Here we retrieve the table we are going to replay
sourceTable = db.live_table(src_namespace, table_name)
    .where("Date=`%s`" % replay_date)
    .drop_columns("Date")

# Efficiently shift a java.time.Instant from the source date to today, preserving the time of day
def convertDateToday(dt):
    if dt is None:
        return None
    # Use Java time operations for efficiency
    millis = dt.toEpochMilli()
    # Compute the offset from midnight on the source date
    offset = millis - midnight_source
    # Apply that offset to midnight today
    return Instant.ofEpochMilli(midnight_time + offset)

# Convert all Instant columns (except 'Timestamp')# Function to convert all Instant columns in a table
def convert_date_columns(table):
    # Get all columns in the table
    cols = table.getColumnNames()
    # Find all Instant columns
    instant_cols = [col for col in cols if table.getColumn(col).getDataType() == Instant.class]

    # For each Instant column, apply our conversion
    for col in instant_cols:
        table = table.update(col, f"convert_date_today({col})")

    return table

# Apply the conversion to our source table
source_table = convert_date_columns(source_table)

# When logging incrementally, a Closeable is returned. You must retain this object to ensure liveness
# Call `close()` to stop logging and release resources
log_handle = stl.log_table_incremental(
    namespace=dest_namespace,
    table_name=table_name,
    table=source_table,
    column_partition=None
)

# At this point as rows tick into Market.Trade, they are automatically logged back to MarketSim.Trade