IMD SolutionComputing LibraryShop main store

How-to

How to move Wonderware Historian data into Canary Historian

Edge computing and IIoT Published 7 min read

Short answer

Yes. Backfill Wonderware history by exporting CSV files or a SQL database that Canary consumes, run a parallel real-time collection path for the same tags, and verify record counts and values at the timestamp where imported history meets live data.

On this page
  1. Two workstreams, one tag map
  2. Fix the tag identity mapping first
  3. Export the history from the Wonderware side
  4. Size the backfill before you commit to a format
  5. Load the backfill into Canary
  6. Bring up the live collection path
  7. Verify continuity at the boundary
  8. What to decide, in one place
  9. Questions asked

Yes, and you do it as two coordinated moves rather than one transfer. The stored history leaves the Wonderware historian as CSV files or as a SQL database that Canary consumes, while a separate live collection path keeps the same tags current in Canary from the cutover onward. There is no direct historian-to-historian link to configure; what the two workstreams share is one frozen tag map and one boundary timestamp. Fix the map first, size the backfill with arithmetic before choosing a format, start the live path, load the history, then verify the join. At the worked example's scale — 150 tags at one sample per minute for one year — the history is 78,840,000 rows, about 4.7 GB of CSV, roughly 2 hours to load at the example's assumed 10,000 rows per second, and CSV is the right format; an order of magnitude more moves the decision to a SQL staging database. At cutover you accept a gap of no more than two sample intervals on at least 10 sampled tags, or one tag in twenty, whichever is more.

Two workstreams, one tag map #

Split the project on day one. The backfill moves values that already exist in the Wonderware archives; the live path moves current values off the plant. They fail differently — a backfill drops rows or mangles timestamps, a live path drops connectivity or stores a different resolution — so plan and verify them separately. The one thing they must share is the tag identity map: every tagname on the Wonderware side paired with exactly one Canary tag, written down before any data moves. The sequence is the same discipline that makes backfilling trend history from a plant historian succeed: extract, map, load, then prove the result against the source.

Fix the tag identity mapping first #

  1. Build the tag inventory from the historian itself. The documented Historian Database Export /Import Utility needs a client connection to the SQL Server the historian uses, so plan that machine and connection before export day; any query against the historian's own tag list serves the same purpose for building the inventory.
  2. Record four columns per tag: Wonderware tagname, target Canary tag, data type, and engineering units or scale factor. A tag that cannot be paired cleanly gets flagged now, not during the load.
  3. Mark each tag as backfill-only, live-only, or both. That marking sets the export volume and the collector scope, which is why it happens before any transfer.
  4. Freeze the map and change nothing during the move. If the Canary side needs a different naming structure, apply it after import with Virtual Views, which reorganize tags into asset models and adjust naming without touching the stored identities.

Export the history from the Wonderware side #

  1. Pick the interchange against the Canary import: CSV files or a SQL staging database. At the worked example's scale below, CSV is the right call; an order of magnitude beyond it, stage through SQL so you can load set-based and retry by time range.
  2. Export values as the source stored them. Do not resample or interpolate during export — verification later compares copies, and a resampled export can never match the source record for record.
  3. Chunk the export by tag and by time window. Point-and-range export tools work this way — the Historian Reader, for instance, exports one data point over one time range per run — so a failed run costs one chunk, not the year.
  4. Log every chunk: tagname, first timestamp, last timestamp, row count. That log becomes the acceptance document for the load and the verification.

Size the backfill before you commit to a format #

Worked example, one line of plant: 150 analog tags, one stored sample per minute, one year of history.

  • Samples per tag: 60 x 24 x 365 = 525,600 samples per tag-year
  • Total rows: 150 tags x 525,600 = 78,840,000 rows
  • CSV volume at an assumed 60 bytes per row: 78,840,000 x 60 B = 4,730,400,000 B, about 4.7 GB
  • Load time at an assumed 10,000 rows per second: 78,840,000 / 10,000 = 7,884 s, roughly 2 h 11 min

The row count is pure arithmetic on your inputs; the 60 bytes per row and the 10,000 rows per second are assumptions of this example, so measure both on your first exported chunk before extrapolating. The decision the numbers support: at 78.8 million rows, CSV is still the right tool — single-digit gigabytes, an afternoon of loading, cheap retries per chunk. Ten times that volume moves the decision to the SQL staging database, because restarting a failed multi-file CSV import is slower than re-running a range query.

Load the backfill into Canary #

  1. Import each chunk against the frozen tag map, oldest window first, and compare the loaded row count to the chunk log entry immediately, not after the whole backfill finishes.
  2. Preserve the original timestamps exactly. This is the same rule that keeps writing timestamped history back into a SCADA server honest: the value carries the time it happened, not the time it was imported.
  3. Keep the export files and the staging database until final verification passes; they are your retry medium and your cross-check.
  4. Note the last backfilled timestamp per tag. That value, not the calendar date you planned, is the real boundary you verify against.

Bring up the live collection path #

Canary-side guidance walks through historizing live data from an on-premises AVEVA System Platform and Historian, so the live path is configuration work, not custom code.

  1. Point the collector at the same tag list from the frozen map — the same identities, not a near-match.
  2. Start the collector before you load the backfill, and give it time to expose data-quality problems: dead tags, wrong scaling, values arriving as None in Canary rather than as numbers (see resolving None tag values in Canary for that failure mode).
  3. Fix one cutover timestamp in advance: the backfill owns everything at or before it, the collector owns everything after it. Running the old and new collection paths side by side across that boundary is the same pattern as running two historian connectors during a migration — overlap deliberately, then cut over deliberately.

Verify continuity at the boundary #

  1. Sample at least 10 tags, or one tag in twenty, whichever is more. For each, read the last record at or before the cutover and the first record after it.
  2. Accept a gap of no more than two sample intervals — two minutes at one sample per minute. Anything longer means the collector started late or the backfill stopped short, so re-export that window rather than accepting the hole. Pre-existing gaps in the source archive are a different failure; why a DeltaV historian backfill misses PI archive data covers how those arise on the archive side.
  3. Spot-check values across the boundary: the same tag at the same timestamp on both systems must be identical, because this is a copy. A mismatch means the export resampled, one side stores a different resolution, or the map paired the wrong tags — all three are findings, none is rounding.
  4. Reconcile row counts per tag against the export log exactly. A shortfall is a chunk that did not load, not noise.

Keep the Wonderware historian and the export files online until every check above passes: until then they are the plant's only complete history.

What to decide, in one place #

Situation Route Basis
History only, around the worked example's scale CSV export into the Canary import 78.8 million rows is about 4.7 GB and roughly 2 hours at the example's assumptions
History only, an order of magnitude larger SQL staging database set-based loads and retries by time range beat file restarts
History plus ongoing values Backfill and live collector in parallel with one fixed cutover timestamp the two paths share only the tag map and the boundary, so both stay verifiable

If you need both the history and the ongoing collection, run it in this order: freeze the tag map, start the live collector, export and load the backfill through the cutover timestamp, verify the boundary, and only then retire anything.

Questions asked

Is there a direct Wonderware-to-Canary migration tool?

No direct transfer path is documented between the two historians. The working route is an export into CSV files or a SQL database that the Canary side consumes, plus a separate live collector for current values, both driven from one frozen tag map. Anything that renames or merges tags during the move is a mapping decision to review, not part of the transfer.

How do I estimate backfill size and load time for my tag count?

Multiply tags by samples by time. At one sample per minute a tag accumulates 1,440 rows a day, so 150 tags for a year is 150 x 525,600 = 78,840,000 rows, about 4.7 GB of CSV and roughly 2 hours to load at the example's assumed rate. Row count and load time scale linearly: double the tags and you double both.

Should the live Canary collector start before the backfill loads?

Start it first. The collector fills the current minute while the backfill of past years runs for hours or days, so the new archive has no silent window and the handoff boundary stays short. If you load the backfill first and start the collector afterwards, every minute between the two exists nowhere in Canary.

What if backfill and live data overlap at the same timestamps?

Hold the split you fixed: the backfill owns timestamps at or before the cutover, the collector owns everything after. Then no timestamp is written twice. If an overlapping range is loaded anyway, no documented merge rule decides the winner for this pair, so delete the overlap from one side and reload it cleanly instead of waiting to see which write survives.

Keep reading

  • How-to

    Backfilling trend history from a plant historian

    Yes, you can backfill trend history from a plant historian into a SCADA server. Extract the stored records through the historian's native export or ODBC interface, map each source point to its destination object with original timestamps and quality, insert the batches through the destination's documented history methods, and prove the import by reading the interval back from the destination. A saved CSV is a bridge, not proof of import.

    Edge computing and IIoT

  • How-to

    Backfilling PI from an existing plant historian

    Split the historian-to-PI backfill into four independent stages — extract, intermediate store, external compression, destination load — and qualify throughput with a measured pilot. Rows divided by elapsed seconds, not tag count, sets the schedule: 12,000 tags from 2020 at 500 rows/s is about 203 days. Check the native Historian 2023 replication route before writing pipeline code.

    Edge computing and IIoT

  • How-to

    Export historian trend CSV at one-minute intervals

    Export the trend's recorded values and you get change-based events, about 17 minutes apart in this case, because the historian stores a value only when it changes. To get one row every minute, query the tag in the Query tool with regularly spaced retrieval at a 60-second interval and export that result; the grid comes from retrieval, not storage.

    Edge computing and IIoT