fix: require end of input when parsing a single statement

[MoshiCoCo]

Problem

Statement() — the production behind CCJSqlParserUtil.parse(String), parse(Reader), parse(InputStream) and parseAST() — silently returns a truncated AST when the input holds more than one statement, instead of reporting a parse error.

Since ST_SEMICOLON matches blank line runs as well as ";":

<ST_SEMICOLON : ( ";" | ("\n\n\n") | "\n/\n" | "\ngo\n" ) >

this is reachable from ordinary formatted SQL that contains no semicolon at all:

// two statements as far as the lexer is concerned
CCJSqlParserUtil.parse("SELECT a FROM dual WHERE x = ?\n\n\n AND y = ?");
// -> SELECT a FROM dual WHERE x = ?   (no exception, tail dropped)

CCJSqlParserUtil.parse("SELECT a FROM dual; SELECT b FROM dual");
// -> SELECT a FROM dual               (no exception, tail dropped)

Downstream tools that parse a statement and then reuse the original metadata are broken by this. A concrete case from a production MyBatis stack: PageHelper's DefaultCountSqlParser calls newParser(reader).Statement() to rewrite a paged query into its count query, and ExecutorUtil.executeAutoCount keeps the original parameterMappings. A mapper whose dynamic SQL renders three consecutive newlines (for example an XML comment block that MyBatis strips, leaving the newlines behind) is truncated at that point, so the count statement ends up with fewer ? placeholders than mappings — Parameter index out of range, or, when the dropped tail has no placeholders, a silently wrong row count.

Root cause

Regression from 063d2442 ("feat: return any UnsupportedStatement content", first shipped in jsqlparser-5.0), which replaced the terminator of Statement() with a choice:

- [ <ST_SEMICOLON> ] <EOF>
+ ( <ST_SEMICOLON> | <EOF> )

Consuming a separator became an alternative to reaching EOF, so the end-of-input validation was lost. Statements() kept its trailing <EOF> and was unaffected.

Fix

src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt, both branches of Statement():

  ]
+ <EOF>
  )
  |
  (
      (stm = SingleStatement() | stm = Block())
-     ( <ST_SEMICOLON> | <EOF> )
+     ( <ST_SEMICOLON> )* <EOF>
  )

Trailing separators stay legal (any number of them, so "…;", "…\n\n\n" and "… -- done" still parse), while any unconsumed statement is now reported. This restores the contract that 4.9 and earlier had.

Compatibility

• Statements() and SingleStatement() are untouched. Walking a script statement by statement remains the incremental API's job, which is what CCJSqlParserUtil.streamStatements already uses.
• The UnsupportedStatement support added by 063d2442 is preserved — that alternative is guarded by its own LOOKAHEAD and stays reachable.
• Behaviour change: input with trailing content now throws instead of returning a partial statement. Callers that want "first statement only" should use SingleStatement().

Tests

• CCJSqlParserUtilTest#testParseRejectsUnconsumedInput (new): rejects newline- and semicolon-separated input through parse(String), parse(InputStream), parseAST and a direct Statement() call; still accepts trailing separators and comments; parseStatements keeps splitting correctly.
• SqlRoutineBodyBoundaryTest: the case that asserted the lenient behaviour (directStatementParserLeavesFollowingStatementAvailable) is rewritten to drive the parser with SingleStatement(). This preserves its original intent — verifying that a routine body ends where the following statement begins — and additionally asserts the separators in between.
• Full suite: Tests run: 9093, Failures: 0, Errors: 0, Skipped: 25.