Undocumented behaviour for Schema::findTables() when an underscore is used

Ooh... nice find. It looks like we have explicit code to support % and _

See

    // Convert the table expression from its SQL LIKE syntax to a regular
    // expression and escape the delimiter that will be used for matching.
    $table_expression = str_replace(['%', '_'], ['.*?', '.'], preg_quote($table_expression, '/'));
    $tables = preg_grep('/^' . $table_expression . '$/i', $tables);

So I think this issue should improve the documentation - which is currently:

   * @param string $table_expression
   *   An SQL expression, for example "cache_%" (without the quotes).

I think this needs to document that both _ and % are treated as wildcards and it should document their meaning.

Resolved CSpell errors.

All nits.

1. +++ b/core/lib/Drupal/Core/Database/Schema.php
   @@ -180,7 +180,13 @@ public function tableExists($table) {
   +   *   An SQL expression, for example "foo_%bar" (without the quotes). Both '_'
   

   Nit: Sometimes the comment uses double quotes, sometimes single quotes

2. +++ b/core/lib/Drupal/Core/Database/Schema.php
   @@ -180,7 +180,13 @@ public function tableExists($table) {
   +   *   any character, one occurrence) and '%' with '.*?' (hint: any character,
   

   Better "any character, exactly one occurence" or "any character, a single occurence"?

3. +++ b/core/lib/Drupal/Core/Database/Schema.php
   @@ -180,7 +180,13 @@ public function tableExists($table) {
   +   *   any character, one occurrence) and '%' with '.*?' (hint: any character,
   +   *   multiple occurrences, lazy quantifier) before executing the regular
   

   does "any character,
   multiple occurrences, lazy quantifier" mean "any characters, zero or more occurences"?

4. +++ b/core/lib/Drupal/Core/Database/Schema.php
   @@ -180,7 +180,13 @@ public function tableExists($table) {
   +   *   like "foo_bar", "foo__bar", "foo1bar", "fooWhateverBar", etc.
   

   It would really help if you can give an example of the difference between the % and _ matching. Also it's kind of confusing that the matches also contain the underscore.

How's this:

+   *   An SQL expression, for example 'foo%bar' (without the quotes). Both '_'
+   *   and '%' are treated as wildcards, where '_' is replaced with '.' (
+   *   any character, exactly one occurrence) and '%' with '.*?' (any character,
+   *   zero or more occurrences) before executing the regular
+   *   expression looking for matching tables names. So 'foo%bar' matches
+   *   table names like ''foobar', 'fooXbar', 'fooXBAR',  or 'fooXXXbar'; whereas 
+   *   'foo_bar' matches 'fooXbar' and 'fooXBAR' but not 'foobar' or 'fooXXXbar'.

The test looks great, this will be RTBC once the comment grammar is fixed.

A bit more nitpicking :)

1. +++ b/core/lib/Drupal/Core/Database/Schema.php
   @@ -180,7 +180,13 @@ public function tableExists($table) {
   +   *   An SQL expression, for example "foo_%bar" (without the quotes). Both '_'
   +   *   and '%' are treated as wildcard, where '_' are replaced with '.' (hint:
   +   *   any character, one occurrence) and '%' with '.*?' (hint: any character,
   +   *   multiple occurrences, lazy quantifier) before executing the regular
   +   *   expression looking for matching tables names. So the "foo_%bar" example
   +   *   will translate to "foo..*?bar" regular expression matching table names
   +   *   like "foo_bar", "foo__bar", "foo1bar", "fooWhateverBar", etc.
   

   I'm very much in favour of 'more is more' for documentation!

   But I find the use of 'hint' here confusing.

   Also, explaining these in terms regexp syntax doesn't seem right here, when it's much simpler to say that these are wildcards used by the MySQL LIKE operator.

> The only reason why I put the hint is because searching on the web for "regular expression ?" doesn't tell you what the "?" stands for.

Yup, what I meant is that writing 'hint:' reads weirdly.

> There $table_expression argument is not used in SQL LIKE. Schema::findTables() method first load all the tables in the running database and then a regular expression extract the matching results

Right, but that's an implementation detail.

What this function does is: 'You can use SQL LIKE wildcards to work with table names'. We're in the domain of SQL queries, so it makes sense that this function uses SQL wildcards. We should document like that as well.

The reason the function's code converts them to regex is that you can't actually use wildcards with table names in SQL. But this function is allowing you to pretend that you can.

https://dev.mysql.com/doc/refman/8.0/en/pattern-matching.html

SQL pattern matching enables you to use _ to match any single character and % to match an arbitrary number of characters (including zero characters). In MySQL, SQL patterns are case-insensitive by default.

Therefore I suggest:

Finds all tables that match the specified table name pattern.

@param string $table_expression
A case-insensitive pattern against which table names are compared. Both '_' and '%' are treated like wildcards in MYSQL LIKE expressions, where '_' matches any single character and '%' matches an arbitrary number of characters (including zero characters). So 'foo%bar' matches table names like ''foobar', 'fooXbar', 'fooXBAR',  or 'fooXXXbar'; whereas 'foo_bar' matches 'fooXbar' and 'fooXBAR' but not 'foobar' or 'fooXXXbar'.

#21 -- yup, perfect!

(Well, I think it's capitalised MySQL ;)

+++ b/core/lib/Drupal/Core/Database/Schema.php
@@ -180,7 +180,12 @@ public function tableExists($table) {
+   *   like ''foobar', 'fooXBar', 'fooXBaR',  or 'fooXxBar'; whereas 'foo_bar'

Nit: double apostrophe

I think we're there, trusting the apostrophe can be fixed on commit.

Updated patch will address #24 & failed tests looks unrelated.

Committed 79925d2 and pushed to 10.0.x. Thanks!
Committed and pushed e9294d88bf to 9.4.x and 467d4fd1b3 to 9.3.x. Thanks!