Don't deprecate `mysqli::ping` in 8.4

[nickdnk]

Description

Hello

I just saw that ping is being deprecated (https://www.php.net/manual/en/mysqli.ping.php) in 8.4 because "The reconnect feature has not been available as of PHP 8.2.0, making this function obsolete." - which isn't entirely true.

If you run MySQL + PHP in Roadrunner, FrankenPHP or Swoole, your script will continue to run and your connection will (or can) remain open between requests. The best way to check if the connection is still valid when receiving a request is to ping it, i.e:

if (self::$instance) {
    try {
        // Attempt to ping static connection.
        self::$instance->ping();

        // If this works, we can continue with this connection.
        return self::$instance;
    } catch (mysqli_sql_exception) {
       // with MYSQLI_REPORT_STRICT, it throws if it fails
    }
}

// If no static var exists or if it was reset; create a new one
self::$instance = self::getInstance(); // this just creates new mysqli of course.

return self::$instance;

I don't care about the reconnection logic, because I am doing that myself, but without ping() I don't know how to validate the connection.

Is there a better way to handle this scenario? Or does the fact that I use ping mean I could just as well reconnect every time anyway, from a speed/performance perspective?

[kamil-tekiela]

Maybe I should have mentioned in the changelog also that for all these cases where ping() was used incorrectly (i.e. not to reconnect but to check if the connection is alive) then you should replace it with a simple dummy query and see if it succeeds. Something like DO 1 should suffice. ping() is not needed to check if connection is alive.

[nickdnk]

Can you clarify why this is "incorrect"?

I looked at https://dev.mysql.com/doc/c-api/8.0/en/mysql-ping.html which I assume is what PHP uses under the hood. It says "Checks whether the connection to the server is working." - so why would ping not be useful for this? This is exactly what I want it to do, and I also do want it to throw an exception if this is not the case ("If the connection is down and auto-reconnect is disabled, mysql_ping() returns an error.").

Edit: I guess I'm having a hard time understanding why you would deprecate a feature in the mysqli driver that isn't deprecated in the underlying C API, like for example https://dev.mysql.com/doc/c-api/8.0/en/mysql-connect.html is.

[kamil-tekiela]

You are twisting my words. I didn't say it's not useful. I said it's not the correct usage of this function.

The page in MySQL docs you linked to doesn't end on that first sentence. Read the rest of the paragraph:

... If the connection has gone down and auto-reconnect is enabled an attempt to reconnect is made. If the connection is down and auto-reconnect is disabled, mysql_ping() returns an error.

When the connection is down, this function attempts to reconnect when possible else it will error out. It does not tell you whether the connection is down or up by design, only as a side effect.

Since we do not support reconnect in PHP, the mysqli_ping() function is essentially the same as mysqli_query('DO 1'). Of course, it will also trigger an exception, but that's the best you can do. In a perfect world, we would have a true ping function that returns a boolean.

There's more to this topic and it has already been discussed previously. Please see #11945 (comment)

I guess I'm having a hard time understanding why you would deprecate a feature in the mysqli driver that isn't deprecated in the underlying C API, like for example https://dev.mysql.com/doc/c-api/8.0/en/mysql-connect.html is.

Because mysqlnd is not libmysql. These are two different drivers. Mysqlnd tries to be as similar to libmysql as much aspossible, but they were never identical. Mysqlnd never supported reconnect and mysqli_ping only worked properly when PHP was compiled with libmysql.

[kamil-tekiela]

For posterity:

With no offence to any fellow developers, but if you are doing something like this you are already doing something wrong:

try {
    $mysqli->ping();
} catch (mysqli_sql_exception) {
    // Establish new connection
}

The code above leads to one of two things:

1. You know exactly at which point in your code the connection may be down
2. You execute this before every single mysqli function

If 1 is true then why not just destroy the old object and create a new connection?

If 2 is true then you are suffering a serious performance penalty for something that may rarely happen. A MySQL connection rarely drops. If yours is dropping often then you need to debug and fix whatever the root cause for that may be. Is it timeout on the MySQL server, some network issue, or maybe something else? Instead of using a try-catch, it's better to let the code error out and have PHP log the error message so you can investigate the issue.

Checking if mysqli connection is alive is probably never needed. After all, PDO doesn't have a method to do so and it's the preferred extension to connect to databases.

[kamil-tekiela]

I have decided not to change anything in the changelog entry. We may mention this in the upgrading guide, but I would rather that people truly reconsider what they were using this function for rather than blindly replace it with something else.

As for the titular request, an RFC would be required to undo the deprecation with clear reasoning as to why that function must remain in PHP.

[nickdnk]

You are twisting my words. I didn't say it's not useful. I said it's not the correct usage of this function.

I didn't twist your words at all. I didn't say you said it wasn't useful. I asked why you said it was "incorrect use" and why it wouldn't be a useful function, and you said :

"..for all these cases where ping() was used incorrectly (i.e. not to reconnect but to check if the connection is alive).."

Why is this "incorrect"? Can you give an example of what you would consider "correct" use of ping() then?

When the connection is down, this function attempts to reconnect when possible else it will error out. It does not tell you whether the connection is down or up by design, only as a side effect.

I would argue it's the other way around. The auto-connect is a "side-effect", which you used to be able to enable - not a default feature. This auto-connect is now deprecated in both MySQL and PHP, so I'm not trying to argue for putting that back in. But ping()'s current, non-deprecated form just returns an error if the server is not up, which is exactly what I want it to do. What the original intention of the function was, I can't say, but the current implementation does just that; checks if the connection is up.

Since we do not support reconnect in PHP, the mysqli_ping() function is essentially the same as mysqli_query('DO 1'). Of course, it will also trigger an exception, but that's the best you can do. In a perfect world, we would have a true ping function that returns a boolean.

Yes, it can be used to achieve the same practical thing, but it's not really the same: One runs a query, the other checks if the connection is up and the server is responding. I have trouble understanding what exactly you think is gained from this deprecation. I have benchmarked them out of curiosity, and they perform exactly the same (within the margin of error), so you could argue that this problem can be solved with DO 1, sure, but it's kind of a weird way to solve a problem that was already solved with ping.

With no offence to any fellow developers, but if you are doing something like this you are already doing something wrong:

Not really. There are many cases where you don't want to (or let's say can't easily) implement reconnection logic for every initial query, as it may come at a later point in your application logic (say post auth, post input validation or whenever). It really depends on the application, and especially on how you use/instantiate the connection object. And this is why I have this function in the mysqli bootstrap; because I assume that when a request is received that needs database access, the application will have access to the connection or it will know it should create one. With regard to the "just create a new connection" approach, which certainly is a viable option as well, I'd like to mention that creating a new mysqli connection is 4-5 times slower than calling ping() on an existing connection -- I benchmarked that too -- excluding DNS resolution, which may be required very frequently if you have very short TTL (say if you have a hot standby DB), so since my application does not easily support the case of handling reconnection automatically on the first query, why would I not just ping instead?

[kamil-tekiela]

I would argue it's the other way around. The auto-connect is a "side-effect", which you used to be able to enable - not a default feature.

Perhaps you are right, but that's not how it was implemented.

the current implementation does just that; checks if the connection is up.

So does every other operation. It's the prerequisite for every function to succeed. There's nothing unique about mysqli_ping() in that regard.

it's not really the same: One runs a query, the other checks if the connection is up and the server is responding.

No, they are not the same. But they are almost the same for the goal you are trying to achieve. One sends a query and the other sends a COM_PING command. Either one of them will throw an error if the connection is down.

I have trouble understanding what exactly you think is gained from this deprecation

Well, I hoped that people would stop implementing automatic and custom reconnection.

I can't respond to the last paragraph as I can't understand what you are saying there.

---

You say that the purpose of mysqli_ping() wasn't to reconnect, but it's exactly what you are trying to use it for. Whether it's done automatically by the driver or manually in your code, it's rarely a good idea. I admit I do not understand your use case, but I doubt that your reason for it is good.

Us arguing about it here won't change much. If you want to keep this function in PHP, you need to create an RFC for the removal of the deprecation in PHP 8.5. You need to explain why this function must remain in PHP, why there is no other way to achieve the same, and what negative impact removing mysqli_ping() has. You need to convince the voters to undo it, because it was a group decision after all. But I must warn you that I doubt you have a strong case.