Two log streams per run, a color-coded console mirror, automatic numbered backups, and engine-notice routing that differs by platform. Everything a CI pipeline needs from a deploy tool.
By the SchemaSmith Team · Last reviewed
Good logs are the difference between a quick diagnosis and a long night.
All CLI tools use Apache Log4Net. Each tool ships with an embedded Log4Net configuration that is loaded automatically at startup — there's nothing to configure.
Each tool writes two log files per run. SchemaQuench writes a third, SchemaQuench - Failures.log, which stays empty unless a run has failures; see Failure triage roll-up. Every SchemaQuench run also writes a deployment summary report, by default to the same directory, as a matched pair, SchemaQuench - Summary.json and SchemaQuench - Summary.md, carrying the run's outcome, exit code, duration, per-target results, and verified object counts. Read the report format on your platform's SchemaQuench reference: SQL Server, PostgreSQL, MySQL, or MariaDB.
| Tool | Progress log | Error log |
|---|---|---|
| SchemaQuench | SchemaQuench - Progress.log |
SchemaQuench - Errors.log |
| SchemaTongs | SchemaTongs - Progress.log |
SchemaTongs - Errors.log |
| DataTongs | DataTongs - Progress.log |
DataTongs - Errors.log |
| SchemaShears | SchemaShears - Progress.log |
SchemaShears - Errors.log |
The progress log receives all informational output: the startup banner, active configuration, per-object progress, and completion status. Everything written to the progress log also appears on the console in real time.
The error log receives only error-level entries (such as a refused run, a lost connection or, on SQL Server, the engine's own errors) and does not echo to the console.
Most of what reaches the errors log is the same on every engine. Each entry carries its full exception: a run refused before it starts (an unrecognized argument, a missing or unreadable settings file, a package that cannot load, a failed validation or product script, a version check, a refused target); a connection that could not be opened or that dropped mid-run; a database or schema discovery that failed, a Target filter rejection, or a folder ShouldApplyExpression that threw; an unhandled exception; and, with WriteDebugSql on, one line per failed script naming its error and its debug file. What differs is the engine's own error text for a failed statement:
SQL Server: every error the engine raises on the deploy connection — a failed script, a failed quench step — also lands in the errors log with its message and line number (at Line: N), as well as in the progress log. It's the fastest place to read what went wrong.
PostgreSQL, MySQL, and MariaDB: the engine's error text for a failed script or quench step is in the progress log and the failure roll-up, under Unable to quench '<path>': … or FAILED to quench:; on PostgreSQL it leads with the SQLSTATE. It reaches the errors log only through the WriteDebugSql line above. The SQL itself is never in either log.
Both the progress and error logs are overwritten at the start of each run. Previous runs are preserved through the backup rotation described below.
The console is a live mirror of the progress log, not a separate channel. Watching the console while a quench runs lets you follow startup, per-object progress, and completion in real time without tailing a file. Log4Net colorizes the console stream by level so trouble catches your eye the moment it appears:
| Level | Console color |
|---|---|
| Informational | Green |
| Warning | Yellow |
| Error | Red |
When a script fails, you see a short error summary on the console and in the progress
log (red, so it's hard to miss): Unable to quench '<path>': <engine error>,
along with a pointer to the resolved SQL — Resolved SQL written to: with
WriteDebugSql on, or a Rerun with --WriteDebugSql hint with it off.
That's enough to know what failed and where to look.
The SQL itself never goes to a log: with WriteDebugSql on it is in the
debug file, and the error log gets one line per failed script naming the error and
that file. The error log also carries, on every engine, the failures that stop a run
before or outside a script — a refused argument or setting, a connection that
could not be opened or was lost, a database or schema discovery that failed, a
validation or version check — each with its full exception. On SQL Server it
additionally receives every error the engine raises on the deploy connection with its
line number (at Line: N), which the progress log does not carry. See
Working a failed deployment to trace one end to end.
On multi-target runs the log stays greppable: every schema-template iteration prefixes
its lines with [Schema: <name>], and a many-database fan-out uses
[server].[database]. Filter the progress log to one prefix to isolate a
single tenant's sequence end to end.
CI agents that capture stdout get the progress stream for free. If your pipeline step only saves stdout, you still have a readable transcript of successes and error summaries; archive the error log separately to keep each failure's full exception and, on SQL Server, the engine's line-numbered errors.
By default, logs are written to the tool's executable directory. Override this with
--LogPath:
SchemaQuench --LogPath:C:\Logs
SchemaTongs --LogPath:C:\Logs\schemasmith
DataTongs --LogPath:D:\BuildLogs
schemaquench --LogPath:/var/log/schemasmith
schematongs --LogPath:/var/log/schemasmith
datatongs --LogPath:/var/log/buildlogs
Immediately after loading configuration, every tool logs the resolved command-line switches followed by its complete active configuration to the progress log. This includes the tool name and version number, every switch passed on the command line, and every configuration key and its value (with sensitive values masked). This makes it straightforward to verify both the effective command line and the settings that were in effect for any given run.
Sensitive switches are scrubbed the same way configuration values are — a
--Target__Password=... or --ConnectionString=... renders its
value as *** while the switch name still prints, honoring the same
LogHygiene rules.
Any value whose name matches the built-in sensitive-name set — Password,
Pwd, Secret, ApiKey, Token,
ConnectionString, Credential (case-insensitive, substring match)
— is replaced with *** while its name still prints, so you can confirm
the setting exists without exposing it. An embedded Password= /
Pwd= inside a connection-string value is stripped even when the surrounding
name isn't sensitive. A value shaped like scheme://user:secret@host/path also has its
password replaced with ***, regardless of setting name. All other values are
logged as-is — both exceptions match on value shape, not the name of the setting.
You can tune what gets scrubbed — add exact names or patterns, or opt a false
positive back out — and suppress token logging entirely via the LogHygiene
settings block. See
Sensitive value masking
in the configuration reference.
2026-03-06 09:14:01,234 - SchemaQuench
2026-03-06 09:14:01,235 - Version: 5.2.1.0
2026-03-06 09:14:01,236 - Command line:
2026-03-06 09:14:01,237 - ConfigFile: production.json
2026-03-06 09:14:01,238 - Target__Server: sql-prod-01
2026-03-06 09:14:01,239 - Target__Password: ***
2026-03-06 09:14:01,240 - Configuration:
2026-03-06 09:14:01,241 - Server: sql-prod-01
2026-03-06 09:14:01,242 - User: schemasmith
2026-03-06 09:14:01,243 - Password: ***
2026-03-06 09:14:01,244 - VerboseLogging: false
When a tool finishes (whether successfully or after an error), it backs up its log files before the process exits:
--LogPath value, or the executable directory if not specified).<ToolName>.0001. If that directory already exists, it increments: .0002, .0003, and so on.<ToolName> - *.log into the new subdirectory.The base log files in the log directory are not deleted after backup. Each run overwrites the base files and writes a copy into a new numbered subdirectory. This preserves the history of every run while keeping the base files current with the latest.
Example after three SchemaQuench runs:
C:\Tools\
SchemaQuench - Progress.log (latest run)
SchemaQuench - Errors.log (latest run)
SchemaQuench.0001\ (first run backup)
SchemaQuench.0002\ (second run backup)
SchemaQuench.0003\ (third run backup)
When a run finishes with one or more failures, SchemaQuench writes a third log alongside the progress and error logs — SchemaQuench - Failures.log — that answers which targets failed at a glance. A deployment fans out to many (server, database, schema) targets in parallel and shares one interleaved progress log; the roll-up pulls every failure back into one consolidated, phase-grouped list, so a single failure among many parallel targets isn't buried in one stream.
Each entry names the failed scope, along with the engine error, the resolved-SQL artifact path (or, with WriteDebugSql off, the hint to rerun with it), and a captured tail of the lines leading up to it. A scope is one of:
[server].[database] [Schema: <name>]Before / After product script — [server]Validate phaseA loud *** FAILED banner also marks each failure live in the progress stream, so you can grep *** FAILED to jump straight to the failed scopes; the roll-up block echoes to the console at the end of the run.
A failed user script reads with the same detail as a mechanical failure. The Error: line carries the specific per-script error — Unable to quench '<path>': <error>, with a (+N more) tail when several scripts in the scope failed — and the Debug SQL: line points at that script's resolved-SQL artifact (with debug SQL off, it carries the rerun hint instead), so the roll-up sends you straight to the offending script and the SQL it produced. From there, working a failed deployment covers reading the artifact and reproducing the error.
The roll-up is always on and adds nothing to a clean run — no banner, no roll-up block, an empty Failures.log. FailureContextLines controls how many lines of lead-up context each failure captures. The default is 25; set it to 0 to disable context capture entirely, and the roll-up still lists the failed scopes and their errors.
schemaquench --FailureContextLines=40
A failed quench leaves a log entry telling you what broke, and — with debug SQL on — a .sql artifact file holding the exact SQL that the server rejected. Here's how to move from "deployment failed" to "I know what's wrong and I can fix it."
SchemaQuench - Progress.log) first ends Rerun with --WriteDebugSql to write the resolved SQL of this step to <ArtifactPath>. Re-run with --WriteDebugSql (or WriteDebugSql: true in the settings file), then search the log for Resolved SQL written to:. Every script surface — user and migration scripts, generated quench DDL (table, index, foreign-key, view, and table-JSON steps), product-level Before/After scripts, validation scripts, and data-delivery merges — reports its failure the same way, so one search string finds every kind of failure in the log.
Unable to quench 'Before/01-seed.sql': Invalid column name 'Region'.
Resolved SQL written to: C:\logs\SchemaQuench - Failed 01-seed prod.App.sql
Artifacts land in the ArtifactPath directory (default: the working directory you ran SchemaQuench from), not the log directory — deliberately, so zipping your logs for a support ticket doesn't sweep up raw SQL that may contain expanded sensitive values..sql file. It opens with two comment lines, one naming the product, server, database, schema and the run that wrote it, and one saying it holds real values; then comes every batch the engine received, separated by GO. The batch SchemaQuench attempted last is marked:
-- >>> FAILING BATCH (#2) >>>
ALTER TABLE [dbo].[Orders] ADD [Region] NVARCHAR(50) NOT NULL ...
GO
The marker is a best-effort hint — the engine marks the last batch it attempted, usually (but not always) the one that caused the error. The values are real and fully expanded (tokens resolved, connection-string parameters substituted), which is exactly what you need to reproduce the failure.{{Token}} instead of the expanded value — a misspelled token, a token out of scope for this script's slot (a {{SchemaName}} token in a product-level script, say), or a token that was never defined.ScrubArtifacts, which used to mask the SQL, is deprecated and ignored. See Failure artifacts in the configuration reference.With WriteDebugSql on, each generated step SchemaQuench runs against your target database is written as it runs, one .sql file each — the same artifact the Resolved SQL written to: line points at when that step fails. Generated procedures cover missing tables and columns, modified tables, indexes, foreign keys, materialized views, indexed views, and the table-JSON parse step. Debug files follow the pattern SchemaQuench - <operation> <server>.<database>.sql:
SchemaQuench - Quench Missing Tables And Columns prod.NW.sql
SchemaQuench - Quench Modified Tables prod.NW.sql
SchemaQuench - Quench Indexes prod.NW.sql
SchemaQuench - Quench Foreign Keys prod.NW.sql
SchemaQuench - Quench Materialized Views prod.NW.sql
SchemaQuench - Quench Indexed Views prod.NW.sql
SchemaQuench - Parse Table Json prod.NW.sql
Only the current failure's files are kept. When a run starts on a target, it deletes the files an earlier run wrote for the same product, server, database and schema, and when it finishes cleanly it deletes its own. It reads the owner from each file's first line, so it never deletes a file it did not write. Operations that don't apply to your platform (indexed views on PostgreSQL, materialized views on MySQL) produce no file. Debug files land in the ArtifactPath directory (default: current working directory) — --LogPath controls the progress and error logs, not artifact or debug SQL.
SchemaSmith surfaces the database engine's informational output — notices, prints, and server-side status messages — into the progress log so you can see what the engine is telling you. The wiring differs per platform because each driver exposes that stream differently.
PRINT output and severity-10-or-lower errors arrive through the
InfoMessage event. By default SchemaSmith promotes only
severity-above-10 errors and RAISERROR ... WITH STATE 100
notifications to the progress log; set VerboseLogging: true to
include every PRINT and informational message.
RAISE NOTICE and RAISE WARNING output arrives
through the Npgsql Notice event. SchemaSmith's own routines' notices
always land in the progress log; a notice raised by your own script or function
lands there only with VerboseLogging: true, as PRINT does on
SQL Server. SchemaSmith filters out the "... does not exist, skipping" and
"... already exists, skipping" notices that
DROP ... IF EXISTS and CREATE ... IF NOT EXISTS
produce during normal runs, so your log stays readable.
The MySQL connector doesn't fire info-message events for long-running stored
procedures, so SchemaSmith uses a table-based status channel. A
SchemaSmith_StatusMessages table in the target database (created
automatically during kindling) holds per-session progress rows; the generated
quench procedures INSERT into it as they work, and a background
poller on a separate connection reads the new rows every 200ms and writes them
to the progress log. SessionId is scoped to
CONNECTION_ID() so concurrent runs don't cross-talk, and the
monitor deletes its rows on shutdown. There's no VerboseLogging
dial on MySQL — what you see is whatever the procedures chose to publish.
The MySQL connector, which MariaDB also uses, doesn't fire info-message events for long-running stored
procedures, so SchemaSmith uses a table-based status channel. A
SchemaSmith_StatusMessages table in the target database (created
automatically during kindling) holds per-session progress rows; the generated
quench procedures INSERT into it as they work, and a background
poller on a separate connection reads the new rows every 200ms and writes them
to the progress log. SessionId is scoped to
CONNECTION_ID() so concurrent runs don't cross-talk, and the
monitor deletes its rows on shutdown. There's no VerboseLogging
dial on MariaDB — what you see is whatever the procedures chose to publish.
VerboseLogging is a SchemaQuench setting. It governs informational output from
your own scripts: PRINT and low-severity messages on SQL Server,
RAISE NOTICE and RAISE WARNING on PostgreSQL. SchemaSmith's own progress
messages always appear. MySQL and MariaDB scripts' informational output is not logged, so the
setting has no effect there.
The same logical problem — an orphaned foreign key, a duplicate value, a null in a required column — surfaces differently on each engine. The error text differs, the numeric code differs, and even which log file carries the detail differs. Use this table to recognize the same fault across platforms.
SQL Server usually prints the message (the number isn't always shown); PostgreSQL prints the SQLSTATE literally; MySQL and MariaDB print the classic MySQL-family error message.
| Failure | SQL Server | PostgreSQL | MySQL | MariaDB |
|---|---|---|---|---|
| Foreign-key violation (orphan) | 547 | 23503 | 1452 | 1452 |
| NOT NULL violation | 515 | 23502 | 1048 | 1048 |
| Duplicate / unique-key | 1505 (index build) / 2601 / 2627 | 23505 | 1062 | 1062 |
| String or binary truncation | 8152 | 22001 | 1406 | 1406 |
| Type / conversion mismatch | 245 / 8115 | 22P02 | 1366 | 1366 |
| Deadlock (retried automatically) | 1205 | 40P01 | 1213 | 1213 |
MariaDB reports through the same channel as MySQL — the SchemaSmith_StatusMessages sidecar table polled on a second connection — and uses MySQL-compatible error codes.
For the hands-on method — locating the failing phase, reading the artifact it leaves behind, and choosing a recovery — see working a failed deployment.
SchemaSmith recognizes a deadlock by its code on every engine, so a server running in another language is classified the same way, and falls back to the word deadlock in the message only when the code is missing. It re-runs the operation with a jittered backoff, up to 20 attempts, so a transient lock collision resolves itself rather than failing the deploy.
| Code | Condition | Recommended action |
|---|---|---|
0 |
Normal completion. Also a run with no arguments on an install nobody has configured: the tool prints which settings file it read and the settings to fill in, and runs nothing | None — the operation succeeded. A pipeline step whose settings never arrived passes the same way without deploying anything, so give a pipeline its settings through SmithySettings_ environment variables or --ConfigFile, either of which skips that screen and makes a missing value fail the run. |
1 |
Finished, but did not produce everything asked: SchemaQuench downgraded a feature the target lacks, under UnsupportedFeaturePolicy: warn (listed in the deployment summary); DataTongs skipped a table (it does not exist in the source, has no key columns, or its KeyColumns are malformed), left out a column whose type cannot be delivered, did not write a merge script because the MySQL source is older than 8.0, or could not wire a script's data token; SchemaTongs left an object out of the package (an invalid or skipped script, an encrypted module, an empty definition) |
The skipped tables or objects and the reason for each are in the progress log (and, for DataTongs, the error log). Fix the cause and re-run. |
2 |
Failed, for a reason you can fix: a command-line argument was not recognized, a required setting is missing (such as the platform), the package cannot be loaded, a validation script, product script or version check failed, a target was refused, or a TemplateTargets rule was broken. Also: SchemaQuench — one or more database quenches failed; SchemaTongs — one or more tables failed to extract; DataTongs — one or more tables failed to extract; SchemaShears — the patch request cannot be built (missing source or manifest, output already exists, unknown drop category). And a run with no arguments, no SmithySettings_ environment variables and no settings file in the current directory or the tool's folder: the tool names both places it looked and runs nothing |
Check the progress and error logs for what failed and why. Fix the cause and re-run. |
3 |
Unhandled exception — a defect in the tool | An unexpected error occurred. The exception is logged to both the progress and error logs before exit. Please report it with the log contents. |
4 |
Log backup failure | The tool completed its main work but couldn't back up the log files. Check directory permissions and disk space in the log directory. The base log files may still be readable even though the backup failed. |
Pre-flight checks that fail before any deployment — a --TestConnection
failure, a server below the product's MinimumVersion floor, or a
--PreviewTargets run that finds a required template with zero targets
— also exit 2, so a readiness gate in CI can treat any non-zero exit
the same way.
--ExitNonZeroOnWarning (or the ExitNonZeroOnWarning setting) turns a 0 into a 1 when the run logged a warning; every other code is unchanged.
A deploy says what it is doing in plain sentences, and the one you are searching for is usually the one that explains why the run did less, or more, than you expected. This is the index: the lines a user is most likely to grep for, the engines that write them, what each means, and where the behavior behind it is documented. The strings are quoted as the tools write them (<…> marks a value), so a search for the fixed part finds the line.
| Message | Engine | What it means | Read more |
|---|---|---|---|
Not recognized: <argument>. Nothing was run. | All | An argument the tool will never read — a misspelled switch, or a value written with a space instead of : or =. Exit 2. | CLI Switch Format |
Configuration key '<key>' is not read by <Tool> and will have no effect. Check for a typo. | All | A settings key in a section the tool owns that it does not recognize. The run continues. | Unrecognized settings are reported |
FAILED: <message> | All | The run stopped for a reason you can fix — a failed validation or product script, a version check, a refused target. Exit 2. | Exit Codes |
EXCEPTION - See the error log: | All | An unhandled exception, a defect in the tool. Exit 3; please report it. | Exit Codes |
*** FAILED [Template:<name>] *** | All | A target failed. Grep for it to find each failed scope; the roll-up lists them together. | Failure triage roll-up |
Unable to quench '<path>': <error> | All | A script failed with the engine's error. | Debug SQL files |
Resolved SQL written to: <file> / Rerun with --WriteDebugSql to write the resolved SQL of this step to <directory>. | All | Where the failed step's token-expanded SQL is, or how to get it. | Debug SQL files |
Could not write debug SQL artifact '<name>': <error> / Could not write resolved-SQL artifact for '<path>': <error> | All | The debug file could not be written (usually ArtifactPath is not writable). The step itself is unaffected. | ArtifactPath |
Lost connection to <server> … — the server stopped responding mid-deploy | All | The connection dropped during the run; nothing applied is rolled back. | Working a failed deployment |
Would APPLY: <path> / Would SKIP (unchanged): <path> | All | The WhatIf plan for a script: it would run, or it is unchanged since its last apply and would be left alone. | SchemaQuench reference: WhatIf mode |
Unchanged, not re-run: <path> | All | The object script's text and the module the server renders are both as they were after the last apply, so it was not re-run. | SchemaQuench reference: Unchanged object scripts |
Could not record the script stamp, so object scripts will run again next time: <error> | All | The deploy login cannot write SchemaSmith's ScriptStamp table; the script applied, but every object script runs again on the next deploy. Logged once per target. | SchemaQuench reference: Unchanged object scripts |
Skipping (previously quenched) <path> | All | A run-once migration script already recorded for this database and slot. | SchemaQuench reference: Migration script tracking |
Skipping (previously quenched per checkpoint) <path> | All | A resumed run skipping a script its checkpoint shows as done. | SchemaQuench reference: Checkpoint and resume |
Skipped (ShouldNotApply): <path> | All | The script raised the SHOULD NOT APPLY sentinel; it is recorded as done and not run again. | Runtime sentinel skip |
Cannot read which <slot> scripts have already run from <table>. / Cannot read or record which <slot> scripts have already run: | All | The deploy login lacks SELECT (SQL Server: SELECT and INSERT) on CompletedMigrationScripts; nothing in the slot was run. | Datafix role grants |
The script applied, but could not be recorded as run, so the next deploy would run it again: | All | The script's data change stands, but its tracking row could not be inserted; the script is reported as failed. | Datafix role grants |
Skipping folder '<folder>' … — ShouldApplyExpression evaluated false | All | A folder gate turned the folder off for this target (or, for a product-level folder, this server). | Folder-level gates |
Skipping data delivery for <table> — ShouldApplyExpression evaluated false | All | A DataDelivery gate evaluated false for this target. | Data Delivery |
Invalid baseline for this release | All | The template's or product's BaselineValidationScript returned false; the deploy stops. | SchemaQuench reference: Database quench sequence |
PostgreSQL: Skipping <feature> on <object> (downgraded). SQL Server, MySQL and MariaDB word their own line, naming the feature and the objects, with downgraded in it: Temporal tracking skipped (requires SQL Server 2016 - downgraded): <objects>, Skipping VECTOR index (requires MariaDB 11.7, MySQL unsupported - downgraded): <objects>. MariaDB's two sequence lines leave the word out: Skipping sequence <name>: sequences require MariaDB 10.3 … and Sequence <name> declares type <type>, which requires MariaDB 11.5 … | All | Under UnsupportedFeaturePolicy: warn the object was emitted without a feature the target version lacks. The summary lists each one; exit 1. | SchemaQuench reference: Engine version compatibility |
Re-baselined <n> recorded expression(s): … / Re-baselined <n> recorded materialized view definition(s) … | All; the materialized-view line PostgreSQL only | After an engine upgrade the stored canonical text of recorded expressions was refreshed. No object was changed. | SchemaQuench reference: Expression change detection |
Handing table <name> to SchemaSmith.CustomTableDrop (no longer in product) (MySQL and MariaDB: SchemaSmith_CustomTableDrop) | All | A drop-by-absence was routed to your custom drop hook instead of a plain DROP TABLE. | Drop control: recyclebin |
Partitioned table(s) skipped by drop-by-absence guard; drop manually or mark PreventDrop. | MySQL and MariaDB | A table no longer in the package is partitioned. The modified-tables step fails with this error rather than drop it by absence: drop it yourself, or mark it PreventDrop. | DropTablesRemovedFromProduct |
Drop index not declared for this deploy: <table>.<index> | MySQL and MariaDB | An index on a managed table that the package does not declare for this target — removed from the product, or never declared — is being dropped. | DropIndexesRemovedFromProduct, DropUnknownIndexes |
… (not covered by OnlineApply) | SQL Server, PostgreSQL | A change OnlineApply has no form for on that engine ran as written, under Prefer or Require too. | SchemaQuench reference: OnlineApply |
… (online, after this pass) | PostgreSQL | A CONCURRENTLY statement that runs on its own once the step that needs it has finished. | SchemaQuench reference: OnlineApply |
PreventDrop is ENABLED — this environment will skip every drop-by-absence … | All | The no-drop protection tier is on; suppressed drops are listed in the summary. | PreventDrop |
<object> was dropped for a column change and this run did not re-create it, so its grants were not put back. | SQL Server | A schema-bound module was dropped under DropSchemaBoundDependents and no script in the run recreated it. | DropSchemaBoundDependents |
Transient contention from a parallel iteration; retrying (attempt <n> of 20) | All | A convergence procedure was a deadlock or lock-timeout victim and is being re-run. | Per-platform error codes |
Live progress from the database is unavailable (<reason>); its messages are logged after each step instead. / The database's step messages cannot be read (<reason>); this run's log has none of them. | MySQL and MariaDB | The status-message poller could not open its second connection, or the status table could not be read at all. | Engine notices |
Deployment summary written: <path> / Could not write deployment summary: <error> | All | Where the run's Summary.json and Summary.md went, or why they could not be written (the run is unaffected). | SchemaQuench reference: Deployment summary report |
ScrubArtifacts is deprecated and does nothing … | All | A deprecated setting is still in the settings file. Remove it. | ScrubArtifacts |
Free schema-as-code for SQL Server, PostgreSQL, MySQL, and MariaDB.
The source is on GitHub for anyone to read.
Get Started on GitHub