migcheck 0.1.2__py3-none-any.whl

migcheck/__main__.py

@@ -0,0 +1,240 @@
+"""Checks that a release's migrations don't break the release before it.
+
+During a rolling deploy, or after a rollback, the previous release runs
+against the new schema. migcheck records the queries the previous release
+makes, then replays them against its schema and against the new one. A query
+that works on the old schema and fails on the new one breaks production.
+"""
+
+import argparse
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
+from collections import defaultdict
+
+from .mysql import MySQL
+from .postgres import Postgres
+
+ADAPTERS = {"postgres": Postgres, "mysql": MySQL}
+# Marks migcheck's pull request comment, so a later run can update it.
+MARKER = "<!-- migcheck -->"
+MARKDOWN = None
+
+
+def main():
+    parser = argparse.ArgumentParser(prog="migcheck", description=(__doc__ or "").splitlines()[0])
+    parser.add_argument("--repo", default=".", help="git repository to check (default: .)")
+    parser.add_argument("--base", required=True, help="ref of the release running in production")
+    parser.add_argument("--head", required=True, help="ref of the release being deployed")
+    parser.add_argument("--migrate", required=True, help="shell command that applies migrations to $DATABASE_URL")
+    parser.add_argument("--workload", required=True, help="shell command that exercises the app against $DATABASE_URL, such as its test suite")
+    parser.add_argument("--db", choices=ADAPTERS, default="postgres", help="database the app uses (default: postgres)")
+    defaults = " or ".join(a.default_image for a in ADAPTERS.values())
+    parser.add_argument("--image", help=f"database Docker image (default: {defaults})")
+    parser.add_argument("--head-name", help="name to show for --head in the result, such as \"this pull request\"")
+    parser.add_argument("--markdown", metavar="PATH", help="also write the result as Markdown to PATH, for a pull request comment")
+    args = parser.parse_args()
+    global MARKDOWN
+    MARKDOWN = args.markdown
+
+    repo = os.path.abspath(args.repo)
+    workdir = tempfile.mkdtemp(prefix="migcheck-")
+    base_dir = os.path.join(workdir, "base")
+    head_dir = os.path.join(workdir, "head")
+    adapter = ADAPTERS[args.db]
+    db = adapter(args.image or adapter.default_image)
+    try:
+        _git(repo, "worktree", "add", "--detach", "-q", base_dir, args.base)
+        _git(repo, "worktree", "add", "--detach", "-q", head_dir, args.head)
+
+        step(f"Starting {db.image}")
+        db.start()
+
+        step(f"Applying {args.base} migrations")
+        db.create_db("mc_template")
+        _sh(args.migrate, base_dir, db.url("mc_template"))
+
+        step(f"Recording {args.base} workload queries")
+        db.create_db("mc_capture", template="mc_template")
+        db.record()
+        # Failing tests still issue queries, so a failing workload is a warning.
+        workload_exit = _sh(args.workload, base_dir, db.url("mc_capture"), check=False)
+        statements = db.statements(exclude={"mc_template"})
+        if not statements:
+            fail("the workload ran no queries, so there is nothing to check")
+
+        step(f"Applying {args.head} migrations")
+        db.create_db("mc_old", template="mc_template")
+        db.create_db("mc_new", template="mc_template")
+        _sh(args.migrate, head_dir, db.url("mc_new"))
+
+        step(f"Replaying {len(statements)} statements against both schemas")
+        old = db.replay("mc_old", statements)
+        new = db.replay("mc_new", statements)
+    except Exception as e:  # Exit code 1 means a query breaks, so nothing else may use it.
+        fail(f"{type(e).__name__}: {e}")
+    finally:
+        db.stop()
+        for d in (base_dir, head_dir):
+            if os.path.isdir(d):
+                _git(repo, "worktree", "remove", "--force", d)
+        shutil.rmtree(workdir, ignore_errors=True)
+
+    sys.exit(report(db, args.base, args.head, statements, old, new, workload_exit, args.head_name))
+
+
+def report(db, base, head, statements, old, new, workload_exit, head_name=None):
+    """Prints the result, writes it as Markdown if requested, and returns the exit code."""
+    head_md = head_name or f"`{head}`"
+    head = head_name or head
+    skipped = sum(1 for state, _ in old if state)
+    if skipped == len(statements):
+        fail(
+            f"all {skipped} statements fail on {base}'s own schema, so there is nothing to compare. "
+            f"First error: [{old[0][0]}] {old[0][1]}"
+        )
+    roots, knock_on = _classify(db, statements, old, new)
+    count = sum(len(v) for v in roots.values())
+    note = ""
+    if workload_exit:
+        note = f"The workload exited with code {workload_exit}. If it stopped early, this result covers only the queries it ran."
+
+    print()
+    if skipped:
+        print(f"Skipped {skipped} statements that also fail on {base}'s schema.")
+    if not roots:
+        print(f"PASS: all {len(statements) - skipped} statements from {base} still work after {head}'s migrations.")
+    else:
+        print(f"FAIL: {count} statements from {base} break after {head}'s migrations.\n")
+        for (state, msg), stmts in roots.items():
+            print(f"  [{state}] {msg}")
+            print(f"      {len(stmts)} statements in {_blocks(stmts)} transactions. Examples:")
+            for sql in _examples(stmts, 160):
+                print(f"      {sql}")
+            print()
+        if knock_on:
+            print("  Later failures in the same transactions, likely caused by the errors above:")
+            for (state, msg), n in knock_on.items():
+                print(f"      [{state}] {msg} ({n})")
+            print()
+        print(f"{base} fails during a rolling deploy of {head}, and after a rollback to {base}.")
+    if note:
+        print(f"\nNote: {note}")
+
+    if MARKDOWN:
+        md = [MARKER]
+        if not roots:
+            md.append("### migcheck: PASS")
+            md.append("")
+            md.append(f"All {len(statements) - skipped:,} statements from `{base}` still work after {head_md}'s migrations.")
+        else:
+            md.append("### migcheck: FAIL")
+            md.append("")
+            md.append(
+                f"{count:,} statements from `{base}` break after {head_md}'s migrations. "
+                f"`{base}` fails during a rolling deploy of {head_md}, and after a rollback to `{base}`."
+            )
+            for (state, msg), stmts in roots.items():
+                md.append("")
+                md.append(f"**`{state}` {_md_escape(msg)}**")
+                md.append(f"{len(stmts):,} statements in {_blocks(stmts):,} transactions. Examples:")
+                md.append("")
+                md.append("```sql")
+                md.extend(_examples(stmts, 500))
+                md.append("```")
+            if knock_on:
+                md.append("")
+                md.append("<details><summary>Later failures in the same transactions, likely caused by the errors above</summary>")
+                md.append("")
+                for (state, msg), n in knock_on.items():
+                    md.append(f"- `{state}` {_md_escape(msg)} ({n:,})")
+                md.append("")
+                md.append("</details>")
+        if skipped:
+            md.append("")
+            md.append(f"Skipped {skipped:,} statements that also fail on `{base}`'s schema.")
+        if note:
+            md.append("")
+            md.append(f"> [!NOTE]\n> {note}")
+        _write_markdown(md)
+    return 1 if roots else 0
+
+
+def _classify(db, statements, old, new):
+    """Splits the statements that break into root causes and knock-on errors.
+
+    The first break in a transaction is a root cause. A later integrity error
+    in the same transaction usually follows from it, such as a foreign key to
+    a row whose insert failed. A foreign key error after any earlier break is
+    also a knock-on, because apps often commit each request separately, so the
+    failed insert and the reference to it can sit in different transactions.
+    """
+    roots = defaultdict(list)
+    knock_on = defaultdict(int)
+    broken_blocks = set()
+    for s, (old_state, _), (new_state, new_msg) in zip(statements, old, new):
+        if old_state is not None or new_state is None:
+            continue
+        key = (new_state, new_msg)
+        follows_break = s.block in broken_blocks and db.is_integrity_error(new_state)
+        if key not in roots and (follows_break or (broken_blocks and db.is_foreign_key_error(new_state))):
+            knock_on[key] += 1
+            continue
+        broken_blocks.add(s.block)
+        roots[key].append(s)
+    return roots, knock_on
+
+
+def _blocks(stmts):
+    return len({s.block for s in stmts})
+
+
+def _examples(stmts, width):
+    examples = dict.fromkeys(" ".join(s.sql.split())[:width] for s in stmts)
+    return list(examples)[:3]
+
+
+def _md_escape(text):
+    return text.replace("<", "&lt;").replace("*", "\\*").replace("_", "\\_").replace("`", "'")
+
+
+def _write_markdown(lines):
+    with open(MARKDOWN, "w") as f:
+        f.write("\n".join(lines) + "\n")
+
+
+def fail(msg):
+    """Exits with code 2, which means migcheck couldn't compare."""
+    print(f"migcheck: {msg}", file=sys.stderr)
+    if MARKDOWN:
+        _write_markdown([MARKER, "### migcheck: couldn't compare", "", "```", msg, "```"])
+    sys.exit(2)
+
+
+def step(msg):
+    print(f"==> {time.strftime('%H:%M:%S')} {msg}", file=sys.stderr)
+
+
+def _git(repo, *args):
+    subprocess.run(["git", "-C", repo, *args], check=True)
+
+
+def _sh(cmd, cwd, url, check=True):
+    proc = subprocess.run(
+        cmd, shell=True, cwd=cwd, env={**os.environ, "DATABASE_URL": url},
+        capture_output=True, text=True,
+    )
+    if proc.returncode != 0 and not check:
+        print(f"migcheck: warning: command exited with {proc.returncode}: {cmd}", file=sys.stderr)
+        sys.stderr.write(proc.stderr[-2000:])
+    elif proc.returncode != 0:
+        sys.stderr.write(proc.stdout + proc.stderr)
+        fail(f"command failed in {cwd}: {cmd}")
+    return proc.returncode
+
+
+if __name__ == "__main__":
+    main()

migcheck/common.py

@@ -0,0 +1,23 @@
+"""Types and helpers that the database adapters share."""
+
+import subprocess
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Statement:
+    sql: str
+    # Statements from one workload transaction share a block. Replay rolls
+    # back a block's effects if the workload rolled back that transaction,
+    # the way a test runner discards each test's data.
+    block: int
+    keep: bool
+    # [table, id] for each row the statement inserted, in insert order.
+    ids: list = field(default_factory=list)
+
+
+def run(cmd, stdin=None):
+    proc = subprocess.run(cmd, input=stdin, capture_output=True, text=True)
+    if proc.returncode != 0:
+        raise RuntimeError(f"{' '.join(cmd[:4])}... failed:\n{proc.stderr.strip()}")
+    return proc.stdout

migcheck/mysql.py

@@ -0,0 +1,338 @@
+"""MySQL adapter.
+
+Runs a throwaway MySQL server in Docker, records the workload with the
+general query log, and talks to the server with the mysql client inside the
+container, so the host needs only Docker.
+"""
+
+import bisect
+import re
+from collections import Counter
+import subprocess
+import time
+import uuid
+
+from .common import Statement
+from .common import run as _run
+
+DEFAULT_IMAGE = "mysql:8.4"
+PASSWORD = "migcheck"
+LOG_FILE = "/tmp/general.log"
+SYSTEM_DBS = {"mysql", "information_schema", "performance_schema", "sys"}
+
+# A general log entry starts with a timestamp, the connection ID, and the
+# command. A statement's own newlines continue it on the following lines.
+ENTRY = re.compile(rb"^\d{4}-\d\d-\d\dT[\d:.]+Z?\t\s*(\d+) ([A-Za-z ]+?)\t(.*)$", re.DOTALL)
+CONNECT_DB = re.compile(r" on (\S+) using ")
+
+TXN_BEGIN = re.compile(r"^\s*(BEGIN|START\s+TRANSACTION)\b(?!\s*;?\s*\S)", re.IGNORECASE)
+TXN_COMMIT = re.compile(r"^\s*COMMIT\b", re.IGNORECASE)
+TXN_ROLLBACK = re.compile(r"^\s*ROLLBACK\b(?!\s+(WORK\s+)?TO\b)", re.IGNORECASE)
+AUTOCOMMIT = re.compile(
+    r"^\s*SET\s+(?:SESSION\s+|@@(?:SESSION\.)?)?autocommit\s*=\s*(\S+?)\s*;?\s*$", re.IGNORECASE
+)
+USE = re.compile(r"^\s*USE\s+`?([^`\s;]+)`?\s*;?\s*$", re.IGNORECASE)
+# Statements that only make sense in the client's own session. Replay issues
+# its own transaction control. SQL-level PREPARE and EXECUTE are dropped
+# because the general log also records the statement each EXECUTE runs.
+SESSION_ONLY = re.compile(
+    r"^\s*(XA|LOCK\s+TABLES?|UNLOCK\s+TABLES?|PREPARE|EXECUTE|DEALLOCATE|SET\s+TRANSACTION)\b", re.IGNORECASE
+)
+# Schema changes come from test runners building their database, not from the
+# app's runtime queries. They commit any open transaction.
+DDL = re.compile(r"^\s*(CREATE|ALTER|DROP|RENAME|GRANT|REVOKE)\b", re.IGNORECASE)
+# Test runners empty tables between tests by name. On the new schema a listed
+# table can be gone, or a new table can reference one and block the TRUNCATE,
+# so replay empties the table only if it exists, ignoring foreign keys.
+TRUNCATE = re.compile(r"^\s*TRUNCATE\s+(?:TABLE\s+)?((?:`[^`]+`|[\w$]+)(?:\.(?:`[^`]+`|[\w$]+))?)\s*;?\s*$", re.IGNORECASE)
+ERROR = re.compile(r"^ERROR (\d+) \(\w+\) at line (\d+): (.*)$")
+
+INTEGRITY_ERRORS = {"1022", "1048", "1062", "1169", "1216", "1217", "1364", "1451", "1452", "1557", "1586", "3819"}
+FOREIGN_KEY_ERRORS = {"1216", "1217", "1451", "1452"}
+
+REPLAY_SETUP = """\
+DROP PROCEDURE IF EXISTS _migcheck_truncate;
+DELIMITER //
+CREATE PROCEDURE _migcheck_truncate(name varchar(64))
+BEGIN
+  IF EXISTS (SELECT 1 FROM information_schema.tables WHERE table_schema = DATABASE() AND table_name = name) THEN
+    SET @_migcheck_fk = @@foreign_key_checks, foreign_key_checks = 0;
+    SET @_migcheck_sql = CONCAT('TRUNCATE TABLE `', REPLACE(name, '`', '``'), '`');
+    PREPARE _migcheck_stmt FROM @_migcheck_sql;
+    EXECUTE _migcheck_stmt;
+    DEALLOCATE PREPARE _migcheck_stmt;
+    SET foreign_key_checks = @_migcheck_fk;
+  END IF;
+END//
+DELIMITER ;
+"""
+
+
+class MySQL:
+    name = "MySQL"
+    default_image = DEFAULT_IMAGE
+
+    def __init__(self, image=DEFAULT_IMAGE):
+        self.image = image
+        self.container = None
+        self.port = None
+
+    def start(self):
+        self.container = f"migcheck-{uuid.uuid4().hex[:8]}"
+        _run([
+            "docker", "run", "-d", "--rm", "--name", self.container,
+            "-e", f"MYSQL_ROOT_PASSWORD={PASSWORD}",
+            "-p", "127.0.0.1::3306",
+            self.image,
+            f"--general-log-file={LOG_FILE}",
+            "--max-allowed-packet=1G",
+            "--skip-log-bin",
+            "--skip-name-resolve",
+            "--innodb-flush-log-at-trx-commit=0",
+            "--innodb-doublewrite=OFF",
+        ])
+        mapping = _run(["docker", "port", self.container, "3306/tcp"])
+        self.port = int(mapping.splitlines()[0].rsplit(":", 1)[1])
+        # The image's init step runs a socket-only server first, so a TCP
+        # check waits for the real one.
+        for _ in range(120):
+            check = subprocess.run(self._client("-h", "127.0.0.1", "-e", "SELECT 1"), capture_output=True)
+            if check.returncode == 0:
+                return
+            time.sleep(0.5)
+        raise RuntimeError("MySQL did not become ready in 60 seconds")
+
+    def stop(self):
+        if self.container:
+            subprocess.run(["docker", "rm", "-f", self.container], capture_output=True)
+            self.container = None
+
+    def url(self, db):
+        return f"mysql://root:{PASSWORD}@127.0.0.1:{self.port}/{db}"
+
+    def create_db(self, name, template=None):
+        """Creates a database. MySQL has no template databases, so a
+        template's tables and rows are copied with mysqldump."""
+        _run(self._client("-e", f"CREATE DATABASE `{name}`"))
+        if template:
+            _run(["docker", "exec", "-e", f"MYSQL_PWD={PASSWORD}", self.container, "sh", "-c",
+                  "set -o pipefail; mysqldump -uroot --single-transaction --routines --triggers --events "
+                  f"--hex-blob --no-tablespaces --set-gtid-purged=OFF {template} | mysql -uroot {name}"])
+
+    def record(self):
+        """Starts recording statements. The log stays off until the workload
+        runs, so setup statements don't appear in it."""
+        _run(self._client("-e", "SET GLOBAL general_log = ON"))
+
+    @staticmethod
+    def is_integrity_error(state):
+        return state in INTEGRITY_ERRORS
+
+    @staticmethod
+    def is_foreign_key_error(state):
+        return state in FOREIGN_KEY_ERRORS
+
+    def statements(self, exclude):
+        """Returns the statements the workload ran against any database not in
+        `exclude`.
+
+        Test runners often create their own database, such as Django's
+        test_<name>, so this doesn't filter on a single name.
+        """
+        self._stop_recording()
+        # The log can be far larger than the statements kept from it, so read
+        # it as a stream instead of loading it whole.
+        assert self.container
+        proc = subprocess.Popen(["docker", "exec", self.container, "cat", LOG_FILE], stdout=subprocess.PIPE)
+        assert proc.stdout is not None
+        statements = parse_log(proc.stdout, exclude)
+        if proc.wait() != 0:
+            raise RuntimeError(f"reading the MySQL log failed with exit code {proc.returncode}")
+        return statements
+
+    def replay(self, db, statements):
+        """Runs each statement in order and returns a list of (error code, message).
+
+        A statement that succeeds keeps its effects until the end of its
+        block, so later statements see the rows earlier ones wrote. MySQL
+        rolls back a failing statement on its own, and replay continues. Both
+        entries are None on success.
+        """
+        script, starts = build_script(statements)
+        assert self.container
+        proc = subprocess.run(
+            ["docker", "exec", "-i", "-e", f"MYSQL_PWD={PASSWORD}", self.container, "sh", "-c",
+             f"mysql -uroot --force --binary-mode --max-allowed-packet=1G --default-character-set=utf8mb4 {db} >/dev/null"],
+            input=script, capture_output=True,
+        )
+        results = parse_errors(proc.stderr.decode("utf-8", "replace"), starts, len(statements))
+        if proc.returncode not in (0, 1):
+            raise RuntimeError(f"mysql exited with code {proc.returncode}:\n{proc.stderr.decode(errors='replace')[-2000:]}")
+        return results
+
+    def _stop_recording(self):
+        # The log records this statement before it takes effect. Connecting
+        # to a system database keeps it out of the workload, because
+        # parse_log skips everything sent to those.
+        _run(self._client("-D", "mysql", "-e", "SET GLOBAL general_log = OFF"))
+
+    def _client(self, *args):
+        assert self.container
+        return ["docker", "exec", "-e", f"MYSQL_PWD={PASSWORD}", self.container, "mysql", "-uroot", *args]
+
+
+class _Session:
+    def __init__(self):
+        self.db = None
+        self.autocommit = True
+        self.block = None  # the open transaction's block, if any
+
+
+def parse_log(log, exclude):
+    """Returns the statements in a general query log, read from the binary
+    line stream `log`, that ran against any database not in `exclude`."""
+    exclude = SYSTEM_DBS | set(exclude)
+    blocks = []  # [keep, [sql, ...]] in the order transactions started
+    sessions = {}  # connection ID -> _Session
+
+    def close(session, keep):
+        if session.block is not None:
+            session.block[0] = keep
+            session.block = None
+
+    def add(session, sql):
+        if session.db in exclude:
+            return
+        if session.block is None and not session.autocommit:
+            session.block = [True, []]
+            blocks.append(session.block)
+        if session.block is not None:
+            session.block[1].append(sql)
+        else:
+            blocks.append([True, [sql]])
+
+    for conn, command, arg in _entries(log):
+        session = sessions.setdefault(conn, _Session())
+        if command == "Connect":
+            m = CONNECT_DB.search(arg)
+            session.db = m.group(1) if m else None
+        elif command == "Init DB":
+            session.db = arg.strip()
+        elif command == "Quit":
+            # A transaction still open at disconnect never committed.
+            close(sessions.pop(conn), False)
+        elif command in ("Query", "Execute"):
+            sql = arg.strip()
+            if m := AUTOCOMMIT.match(sql):
+                session.autocommit = m.group(1).strip("'\"").upper() in ("1", "ON", "TRUE")
+                if session.autocommit:
+                    close(session, True)
+            elif TXN_BEGIN.match(sql):
+                close(session, True)
+                session.block = [True, []]
+                blocks.append(session.block)
+            elif TXN_COMMIT.match(sql):
+                close(session, True)
+            elif TXN_ROLLBACK.match(sql):
+                close(session, False)
+            elif m := USE.match(sql):
+                session.db = m.group(1)
+            elif DDL.match(sql):
+                close(session, True)
+            elif SESSION_ONLY.match(sql):
+                pass
+            elif m := TRUNCATE.match(sql):
+                # TRUNCATE commits any open transaction and can't be undone.
+                close(session, True)
+                autocommit, session.autocommit = session.autocommit, True
+                add(session, _lenient_truncate(m.group(1)))
+                session.autocommit = autocommit
+            else:
+                add(session, sql)
+    # A transaction still open when the workload exits never committed.
+    for session in sessions.values():
+        close(session, False)
+    return [
+        Statement(sql, i, keep)
+        for i, (keep, sqls) in enumerate(b for b in blocks if b[1])
+        for sql in sqls
+    ]
+
+
+def build_script(statements):
+    """Returns the replay script for `statements` and the script line each
+    statement starts on."""
+    parts = [REPLAY_SETUP]
+    line = 1 + REPLAY_SETUP.count("\n")
+    starts = []  # first script line of each statement
+    sizes = Counter(s.block for s in statements)
+    current = None
+    in_txn = False
+    end_txn = ""
+    for s in statements:
+        if s.block != current:
+            if in_txn:
+                parts.append(end_txn)
+                line += 1
+            current = s.block
+            # A block with one statement runs on its own, as the
+            # workload's autocommit statements did.
+            in_txn = sizes[s.block] > 1 or not s.keep
+            end_txn = "COMMIT;\n" if s.keep else "ROLLBACK;\n"
+            if in_txn:
+                parts.append("START TRANSACTION;\n")
+                line += 1
+        starts.append(line)
+        # The terminator goes on its own line so a trailing comment can't
+        # swallow it.
+        text = s.sql.rstrip().rstrip(";") + "\n;\n"
+        parts.append(text)
+        line += text.count("\n")
+    if in_txn:
+        parts.append(end_txn)
+    return "".join(parts).encode("utf-8", "surrogateescape"), starts
+
+
+def parse_errors(stderr, starts, count):
+    """Maps the mysql client's errors back to statements and returns a list
+    of (error code, message), with both entries None on success."""
+    results: list[tuple[str | None, str | None]] = [(None, None)] * count
+    for raw in stderr.splitlines():
+        m = ERROR.match(raw)
+        if not m:
+            continue
+        at = int(m.group(2))
+        i = bisect.bisect_right(starts, at) - 1
+        if i < 0:
+            raise RuntimeError(f"replay setup failed: {raw}")
+        if results[i][0] is None:
+            results[i] = (m.group(1), m.group(3))
+    return results
+
+
+def _entries(log):
+    """Yields (connection ID, command, argument) for each general log entry."""
+    entry = None
+    for raw in log:
+        m = ENTRY.match(raw)
+        if m:
+            if entry:
+                yield _decode(entry)
+            entry = [m.group(1), m.group(2), m.group(3)]
+        elif entry:
+            entry[2] += raw
+    if entry:
+        yield _decode(entry)
+
+
+def _decode(entry):
+    conn, command, arg = entry
+    # Statements can carry binary values that aren't valid UTF-8.
+    # surrogateescape keeps those bytes intact through to replay.
+    return int(conn), command.decode().strip(), arg.decode("utf-8", "surrogateescape").removesuffix("\n")
+
+
+def _lenient_truncate(name):
+    """Rewrites a TRUNCATE to call _migcheck_truncate, which replay defines."""
+    table = name.split(".")[-1].strip("`")
+    return "CALL _migcheck_truncate('" + table.replace("\\", "\\\\").replace("'", "''") + "')"