Closes the TODO entry "--pre-sql / --pre-sql-file (and
MYSCHEMA_PRE_SQL env vars)". Lets the operator run session-level
SQL on the connection right after connect() and before any diff
work — typical use is `SET FOREIGN_KEY_CHECKS=0`,
`SET sql_mode='TRADITIONAL'`, or
`SET explicit_defaults_for_timestamp=ON` to control how the server
interprets the upcoming DDL or catalog reads.

Design choices:

- Apply / plan only. dump is read-only and pre-SQL's typical use
  is DDL session setup; running it on dump would be confusing
  rather than useful.
- `--pre-sql` and `--pre-sql-file` are mutually exclusive — keeps
  the precedence rule trivial. Both have matching env vars
  (MYSCHEMA_PRE_SQL / MYSCHEMA_PRE_SQL_FILE).
- Multi-statement payload split via vitess'
  SplitStatementToPieces (same splitter parser/parser.go uses for
  desired SQL), so a chain like `SET a=1; SET b=2;` runs as two
  Exec calls in order. Splitting via vitess (rather than naive
  strings.Split on `;`) keeps `;` inside string literals from
  breaking the chain. MultiStatements stays disabled at the
  driver level — client.go's "single-statement-per-Exec" safety
  posture is unchanged.
- pre-SQL failure aborts the whole apply / plan before touching
  anything else. The error message includes the exact statement
  that failed (helpful when chaining several SETs).

Implementation: new PreSQLOption struct in options.go, embedded
in ApplyOptions / PlanOptions. New pre_sql.go holds runPreSQL +
loadPreSQL. apply.go / plan.go call runPreSQL right after
connect().

Test plan (10 sub-tests):

- TestApply_PreSQLString — inline payload runs.
- TestApply_PreSQLFile — file payload runs.
- TestApply/Plan_PreSQLBothSetError — mutually-exclusive contract.
- TestApply_PreSQLFailureSurfaces — bad SQL aborts apply with
  a "pre-sql" error.
- TestApply_PreSQLAppliesToSession — proves the SET runs on the
  connection apply uses (not a side channel).
- TestApply_PreSQLMultiStatement — three SETs in one payload
  exercise the vitess split path.
- TestApply_PreSQLNothingSet — neither flag = no-op.
- TestApply_PreSQLFileMissing — bad path errors with the path
  in the message.
- TestApply_PreSQLEmptyFile — whitespace-only file is a no-op.
- TestPlan_PreSQLString — same posture for plan.

Coverage: runPreSQL 88.9%, loadPreSQL 100%. Total project
coverage stays at 90.0%. Root myschema package 93.7%
(unchanged). The 11.1% gap on runPreSQL is the
parser-init / split-error defensive paths that need fault
injection to reach.

Doc updates:
- AGENTS.md "In scope (v1)" gains a paragraph for --pre-sql /
  --pre-sql-file matching the existing --alter-algorithm /
  --alter-lock entry style.
- TODO.md: --pre-sql line removed.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Round 1 review on PR #75 caught eight issues; this commit addresses
all of them.

1. (review #1) loadPreSQL treated any non-empty PreSQL string as
   "set", including whitespace-only values. Whitespace-only env
   var (`MYSCHEMA_PRE_SQL=`) would trigger the mutually-exclusive
   error against a legitimate --pre-sql-file, and skip the no-op
   short-circuit. Fix: TrimSpace both fields before deciding "set".

2. (review #2) loadPreSQL read --pre-sql-file with os.ReadFile,
   which doesn't support the repo's existing `-` for stdin
   convention used by parser.ReadSQLFile (the desired-SQL file
   args already accept it). Fix: route through parser.ReadSQLFile
   so `--pre-sql-file=-` works.

3. (review #3 + #4) runPreSQL was invoked AFTER connect(), so
   flag-validation errors (both flags set, missing file) could be
   masked by a downstream connection failure, and the client
   opened a DB connection it then threw away. Split into:
   - loadPreSQL: validate / read, no DB contact (called BEFORE connect)
   - execPreSQL: run on conn (called AFTER connect)
   apply.go and plan.go updated accordingly.

4. CLI-level mutual exclusion: tag both PreSQL and PreSQLFile with
   kong's `xor:"pre-sql"` so kong rejects the both-set case at
   parse time before our code sees it. The runtime check in
   loadPreSQL stays in place for programmatic API callers
   (Apply / Plan invoked from Go without going through kong).

5. (review #5 / #6 / #7 / #8) Test reshuffle. The original
   suite over-relied on success-only smoke tests that would have
   silently passed even if pre-SQL were skipped:
   - TestApply_PreSQLString and TestApply_PreSQLMultiStatement
     only checked NoError.
   - TestApply_PreSQLAppliesToSession claimed to be the
     "strongest behavioural pin" but probed nothing — the
     connection it would have probed is closed by Apply's defer.
   - TestPlan_PreSQLString same issue.
   Fix: load-bearing pins now feed INVALID pre-SQL and assert
   the apply / plan aborts with a wrapped "pre-sql" error
   containing the exact failing piece. The multi-statement
   split test now uses a payload with an invalid SECOND piece
   and asserts the error references that piece exactly (proves
   the split happened — without splitting, the driver would
   reject the whole concatenated string with a different error).

6. YAML migration: the new harness field `pre_sql` lets
   inline-payload tests live as testdata/apply/pre_sql_*.yml and
   testdata/plan/pre_sql_*.yml fixtures (3 + 1 = 4 new fixtures).
   File-related and programmatic-API tests stay in Go because
   the YAML harness has no `pre_sql_file` field (would need
   fixture-relative path handling, out of scope).

Coverage is unchanged at the package level; loadPreSQL stays at
100% and execPreSQL is exercised by all the real-execution paths.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

PR #75 round-2 review #3: --pre-sql-file=- and a `-` desired file
argument both read stdin; the second read would hit EOF and
silently truncate either the pre-SQL or the desired SQL. loadPreSQL
now takes the desired file list and fails fast with an explicit
error on the conflict, before any actual stdin read.

Reviews #1 / #2 (USE other_db redirect) deliberately NOT addressed
per direction "USEは拒否しない。ユーザー責任". Pre-SQL is
operator-trusted: myschema runs the SQL as-is without scrubbing,
so a stray USE, destructive DML, or session-state corruption is
the operator's responsibility. AGENTS.md gains a paragraph stating
this explicitly so future readers understand the trust model.

New regression: TestApply_PreSQLStdinConflict pins the stdin-conflict
detection. The pre-existing TestApply_PreSQLFile / FileMissing /
EmptyFile / BothSetError stay as Go tests; YAML harness still
covers the inline / failure / multi-statement paths.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

…comment

PR #75 round-3 review:

1. TestApply_PreSQLFile's docstring still claimed the file path was
   read via parser.ReadSQLFile and that stdin (-) "would work in
   principle". Both are no longer true — loadPreSQL switched back
   to os.ReadFile and rejects `-` outright. Re-word the comment to
   point at TestApply_PreSQLFileStdinRejected for the stdin pin.

2. PreSQLOption's kong tags (env vars + xor:"pre-sql" group) were
   not directly exercised — only the runtime check in loadPreSQL
   was. A future tag typo (e.g. mismatched xor group names on the
   two fields) would silently disable the CLI guard. Add two new
   options_test.go cases mirroring the existing
   TestDropPolicyKongParse* shape:

   - TestPreSQLOptionKongXor: passing both flags at the CLI must
     fail at parse time.
   - TestPreSQLOptionKongAcceptsEither: 3 sub-tests
     (--pre-sql alone, --pre-sql-file alone, neither set) confirm
     the xor group doesn't over-restrict.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>