-
Notifications
You must be signed in to change notification settings - Fork 23.6k
New issue
Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.
By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.
Already on GitHub? Sign in to your account
Lua to Redis integer conversion loses precision #1118
Comments
Lua's numbers are IEE 754 floating point doubles. Which means only exact precision for integers up to +/- 2**53. This is expected behavior. |
@josiahcarlson I am confused. You and I are saying the same thing yet you think this is not a bug? If you read the spec, it shows loss of precision for 2^53 - 1 (within the range that IEEE 754 specifies) by default and it also shows how the loss of precision can be avoided by actually writing out all the digits of the number represented in Lua. Further, there are many more integers outside this range which can be represented precisely (but not in a continuous range) in IEEE 754 which will not be correctly passed from Lua to Redis. |
I misread late at night. You are right, the format specifier should be updated. For some reason, I thought that maybe you were expecting integers outside the +/- 2**53 range to be exactly represented in Lua. My mistake, you're right :) |
I have this issue too. |
Hello, checking this issue right now, report ASAP. |
The default lua number-to-string conversion routine called by Looks like we need to modify the conversion from a one-line if (lua_isnumber(lua, -1))
custom format a string from double returned by lua_tonumber(lua, -1)
else
use lua_tolstring() |
Exactly Matt, that's my fix: diff --git a/src/scripting.c b/src/scripting.c
index 4b485d9..2a7f1b9 100644
--- a/src/scripting.c
+++ b/src/scripting.c
@@ -233,12 +233,22 @@ int luaRedisGenericCommand(lua_State *lua, int raise_error
char *obj_s;
size_t obj_len;
- obj_s = (char*)lua_tolstring(lua,j+1,&obj_len);
- if (obj_s == NULL) break; /* Not a string. */
+ if (lua_isnumber(lua,j+1)) {
+ /* We can't use lua_tolstring() for number -> string conversion
+ * since Lua uses a format specifier that loses precision. */
+ char dbuf[64];
+ lua_Number num = lua_tonumber(lua,j+1);
+
+ obj_len = snprintf(dbuf,sizeof(dbuf),"%.17g",(double)num);
+ obj_s = dbuf;
+ } else {
+ obj_s = (char*)lua_tolstring(lua,j+1,&obj_len);
+ if (obj_s == NULL) break; /* Not a string. */
+ }
/* Try to use a cached object. */
- if (j < LUA_CMD_OBJCACHE_SIZE && cached_objects[j] &&
- cached_objects_len[j] >= obj_len)
+ if (j < LUA_CMD_OBJCACHE_SIZE && cached_objects[j] &&
+ cached_objects_len[j] >= obj_len)
{
char *s = cached_objects[j]->ptr;
struct sdshdr *sh = (void*)(s-(sizeof(struct sdshdr))); Do you people like it? The OP's test passes now. |
Looks good! Though, it may be unsafe to keep a reference to |
Thanks @mattsta, yep, the reference will no longer be valid, but exactly like with lua_tostring that is subject to the Lua GC. The code path will use the value only in the context of the code that follows, that never calls Lua nor rewrites the |
…ommand(). The lua_to*string() family of functions use a non optimal format specifier when converting integers to strings. This has both the problem of the number being converted in exponential notation, which we don't use as a Redis return value when floating point numbers are involed, and, moreover, there is a loss of precision since the default format specifier is not able to represent numbers that must be represented exactly in the IEEE 754 number mantissa. The new code handles it as a special case using a saner conversion. This fixes issue #1118.
Oh, I meant we're saving the pointer to |
@mattsta oh, right! That's bad. Fixing, thank you. I'm not 100% sure of ANSI C guarantees or not that a stack allocated thing is in scope as long as the function did not returned. Should be only a matter of visibility AFAIK but I'm not 100% sure so better to fix. |
…ommand(). The lua_to*string() family of functions use a non optimal format specifier when converting integers to strings. This has both the problem of the number being converted in exponential notation, which we don't use as a Redis return value when floating point numbers are involed, and, moreover, there is a loss of precision since the default format specifier is not able to represent numbers that must be represented exactly in the IEEE 754 number mantissa. The new code handles it as a special case using a saner conversion. This fixes issue #1118.
…ommand(). The lua_to*string() family of functions use a non optimal format specifier when converting integers to strings. This has both the problem of the number being converted in exponential notation, which we don't use as a Redis return value when floating point numbers are involed, and, moreover, there is a loss of precision since the default format specifier is not able to represent numbers that must be represented exactly in the IEEE 754 number mantissa. The new code handles it as a special case using a saner conversion. This fixes issue #1118.
Can't find a definitive answer after 5 minutes of Google, and anyway, simpler obvious code is better, so changed the scope of dbuf :-) Closing the issue, thank you @ssimeonov good bug report about a non obvious issue. |
Hi. For exemple: 127.0.0.1:6379> eval 'return redis.call("set", "key", "12039611435714932082")' 0 127.0.0.1:6379> eval 'return redis.call("set", "key", "12039611435714932092")' 0 notice that different integer values have same float representation |
Can confirm bug using Redis 2.8.10 . This should be a test. |
Lua uses 64-bit doubles for all numbers, so, sadly, we can't represent an exact 64-bit value in Lua. Even in a Lua REPL: > f = 12039611435714932082
> =string.format("%f", f)
12039611435714932736.000000 Lua can only operate on exact integers less than about 2^52, so for Lua<->Redis interop, there's not much we can do here. The next version of Lua (5.3) has an exactly 64-bit Integer type, but it's still undergoing development. |
@mattsta You don't understand. There is no passing of a number, there is a passing of a string to the Redis call. |
Ah, I see. Reading comprehension fail on my part. This bug was introduced by the fix to the main issue of this thread: 768994b You can see we first try to convert every argument to a Lua number, which, sadly, a string full of numbers is the same as a number to Lua. I'm not sure we can have the previous fix and this fix together without modifying how Lua handles formatting numbers. |
I think that changing condition if (lua_isnumber(lua,j+1)) to if (lua_isnumber(lua, j+1) && !lua_isstring(lua, j+1)) would help |
Before 127.0.0.1:6379> eval 'return redis.call("set", "key", "12039611435714932082")' 0
OK
127.0.0.1:6379> get key
"1.2039611435714933e+19"
127.0.0.1:6379> eval 'return redis.call("set", "key", 2^53-1)' 0
OK
127.0.0.1:6379> get key
"9007199254740991" So, it currently works for the originally problem in this thread, but fails for the regression. After adding 127.0.0.1:6379> eval 'return redis.call("set", "key", "12039611435714932082")' 0
OK
127.0.0.1:6379> get key
"12039611435714932082"
127.0.0.1:6379> eval 'return redis.call("set", "key", 2^53-1)' 0
OK
127.0.0.1:6379> get key
"9.007199254741e+15" Now it works for the regression but fails for the original problem in this thread. Some Lua definitions:
The problem: When you call |
|
Using: if (lua_isnumber(lua, j+1) && !luaReallyIsString(lua, j+1)) { 127.0.0.1:6379> eval 'return redis.call("set", "key", "12039611435714932082")' 0
OK
127.0.0.1:6379> get key
"12039611435714932082"
127.0.0.1:6379> eval 'return redis.call("set", "key", 2^53-1)' 0
OK
127.0.0.1:6379> get key
"9007199254740991"
127.0.0.1:6379> Looks good and I'll add a test for the regression and throw a PR up. Thanks for making the solution, @josiahcarlson; and thanks everybody else for doing a few rounds of "why is this broken!" |
The new check-for-number behavior of Lua arguments broke users who use large strings of just integers. The Lua number check would convert the string to a number, but that breaks user data because Lua numbers have limited precision compared to an arbitrarily precise number wrapped in a string. Regression fixed and new test added. Fixes redis#1118 again.
It is likely a bit faster to do the luaReallyIsString() call before the isnumber call. |
Good call. It'll save potential unnecessary number conversion work we may throw away. |
The new check-for-number behavior of Lua arguments broke users who use large strings of just integers. The Lua number check would convert the string to a number, but that breaks user data because Lua numbers have limited precision compared to an arbitrarily precise number wrapped in a string. Regression fixed and new test added. Fixes redis#1118 again.
Thanks people, merging tomorrow morning and releasing 2.8.11 at the same time. |
I finally read the thread, isn't the following a more straightforward fix? diff --git a/src/scripting.c b/src/scripting.c
index 2796477..c968adb 100644
--- a/src/scripting.c
+++ b/src/scripting.c
@@ -234,7 +234,7 @@ int luaRedisGenericCommand(lua_State *lua, int raise_error)
size_t obj_len;
char dbuf[64];
- if (lua_isnumber(lua,j+1)) {
+ if (lua_type(lua,j+1) == LUA_TNUMBER) {
/* We can't use lua_tolstring() for number -> string conversion
* since Lua uses a format specifier that loses precision. */
lua_Number num = lua_tonumber(lua,j+1); |
Yeah, that looks even better. It removes any possibility of converting strings into numbers, so we don't need to check for string types anymore. |
Exactly, I don't think there are any non-string-type -> number conversion rules in Lua, so probably the code is functionally equivalent, however the smaller patch is more clear in the intent, that is, enter the branch only if it's really a number. Matt, I'm using the test from your PR, what is the best way to change stuff like that? I may:
Please teach some Gittetiquette ;-) |
Ok just read Matt is going to bed (the power of Twitter), I'll handle this. Thanks! |
It is more straightforward to just test for a numerical type avoiding Lua's automatic conversion. The code is technically more correct now, however Lua should automatically convert to number only if the original type is a string that "looks like a number", and not from other types, so practically speaking the fix is identical AFAIK.
The new check-for-number behavior of Lua arguments broke users who use large strings of just integers. The Lua number check would convert the string to a number, but that breaks user data because Lua numbers have limited precision compared to an arbitrarily precise number wrapped in a string. Regression fixed and new test added. Fixes #1118 again.
It is more straightforward to just test for a numerical type avoiding Lua's automatic conversion. The code is technically more correct now, however Lua should automatically convert to number only if the original type is a string that "looks like a number", and not from other types, so practically speaking the fix is identical AFAIK.
Fix applied. Rant: Lua API is not perfect in this regard. The lack of a true integer type distinct from float was already a pain point, shared with Javascript, but given the "we break old stuff" philosophy of Lua (that I like) it's shame it was not fixed at some point much earlier. However even with this type system, the API could be much better, without explicit conversions if not via specially named APIs like |
Indeed, automatic coercion should go away, although, to be fair, the manual indicates it. There is some talk of taking the upcoming 5.3 release as an oportunity to remove it (the manual says it may be removed ).
|
The new check-for-number behavior of Lua arguments broke users who use large strings of just integers. The Lua number check would convert the string to a number, but that breaks user data because Lua numbers have limited precision compared to an arbitrarily precise number wrapped in a string. Regression fixed and new test added. Fixes #1118 again.
It is more straightforward to just test for a numerical type avoiding Lua's automatic conversion. The code is technically more correct now, however Lua should automatically convert to number only if the original type is a string that "looks like a number", and not from other types, so practically speaking the fix is identical AFAIK.
Hello, i am working on windows machine. And redis version 3.2.100 for windows latest pre release version. And I have same problem. Can you help me? |
b6a052fe0 Helper for setting TCP_USER_TIMEOUT socket option (redis#1188) 3fa9b6944 Add RedisModule adapter (redis#1182) d13c091e9 Fix wincrypt symbols conflict 5d84c8cfd Add a test ensuring we don't clobber connection error. 3f95fcdae Don't attempt to set a timeout if we are in an error state. aacb84b8d Fix typo in makefile. 563b062e3 Accept -nan per the RESP3 spec recommendation. 04c1b5b02 Fix colliding option values 4ca8e73f6 Rework searching for openssl cd208812f Attempt to find the correct path for openssl. 011f7093c Allow specifying the keepalive interval e9243d4f7 Cmake static or shared (redis#1160) 1cbd5bc76 Write a version file for the CMake package (redis#1165) 6f5bae8c6 fix typo acd09461d CMakeLists.txt: respect BUILD_SHARED_LIBS 97fcf0fd1 Add sdevent adapter ccff093bc Bump dev version for the next release cycle. c14775b4e Prepare for v1.1.0 GA f0bdf8405 Add support for nan in RESP3 double (redis#1133) 991b0b0b3 Add an example that calls redisCommandArgv (redis#1140) a36686f84 CI updates (redis#1139) 8ad4985e9 fix flag reference 7583ebb1b Make freeing a NULL redisAsyncContext a no op. 2c53dea7f Update version in dev branch. f063370ed Prepare for v1.1.0-rc1 2b069573a CI fixes in preparation of release e1e9eb40d Add author information to release-drafter template. afc29ee1a Update for mingw cross compile ceb8a8815 fixed cpp build error with adapters/libhv.h 3b15a04b5 Fixup of PR734: Coverage of hiredis.c (redis#1124) c245df9fb CMake corrections for building on Windows (redis#1122) 9c338a598 Fix PUSH handler tests for Redis >= 7.0.5 6d5c3ee74 Install on windows fixes (redis#1117) 68b29e1ad Add timeout support to libhv adapter. (redis#1109) 722e3409c Additional include directory given by pkg-config (redis#1118) bd9ccb8c4 Use __attribute__ when building with clang on windows 5392adc26 set default SSL certificate directory 560e66486 Minor refactor d756f68a5 Add libhv example to our standard Makefile a66916719 Add adapters/libhv 855b48a81 Fix pkgconfig for hiredis_ssl 79ae5ffc6 Fix protocol error (redis#1106) 61b5b299f Use a windows specific keepalive function. (redis#1104) fce8abc1c Introduce .close method for redisContextFuncs cfb6ca881 Add REDIS_OPT_PREFER_UNSPEC (redis#1101) cc7c35ce6 Update documentation to explain redisConnectWithOptions. bc8d837b7 fix heap-buffer-overflow (redis#957) ca4a0e850 uvadapter: reduce number of uv_poll_start calls 35d398c90 Fix cmake config path on Linux. CMake config files were installed to `/usr/local/share/hiredis`, which is not recognizable by `find_package()`. I'm not sure why it was set that way. Given the commit introducing it is for Windows, I keep that behavior consistent there, but fix the rest. 10c78c6e1 Add possibility to prefer IPv6, IPv4 or unspecified 1abe0c828 fuzzer: No alloc in redisFormatCommand() when fail 329eaf9ba Fix heap-buffer-overflow issue in redisvFormatCommad eaae7321c Polling adapter requires sockcompat.h 0a5fa3dde Regression test for off-by-one parsing error 9e174e8f7 Add do while(0) protection for macros 4ad99c69a Rework asSleep to be a generic millisleep function. 75cb6c1ea Do store command timeout in the context for redisSetTimeout (redis#593) c57cad658 CMake: remove dict.c form hiredis_sources 8491a65a9 Add Github Actions CI workflow for hiredis: Arm, Arm64, 386, windows. (redis#943) 77e4f09ea Merge pull request redis#964 from afcidk/fix-createDoubleObject 9219f7e7c Merge pull request redis#901 from devnexen/illumos_test_fix 810cc6104 Merge pull request redis#905 from sundb/master df8b74d69 Merge pull request redis#1091 from redis/ssl-error-ub-fix 0ed6cdec3 Fix some undefined behaviour 507a6dcaa Merge pull request redis#1090 from Nordix/subscribe-oom-error b044eaa6a Copy error to redisAsyncContext when finding subscribe cb e0200b797 Merge pull request redis#1087 from redis/const-and-non-const-callback 6a3e96ad2 Maintain backward compatibiliy withour onConnect callback. e7afd998f Merge pull request redis#1079 from SukkaW/drop-macos-10.15-runner 17c8fe079 Merge pull request redis#931 from kristjanvalur/pr2 b808c0c20 Merge pull request redis#1083 from chayim/ck-drafter 367a82bf0 Merge pull request redis#1085 from stanhu/ssl-improve-options-setting 71119a71d Make it possible to set SSL verify mode dd7979ac1 Merge pull request redis#1084 from stanhu/sh-improve-ssl-docs c71116178 Improve example for SSL initialization in README.md 5c9b6b571 Release drafter a606ccf2a CI: use recommended `vmactions/freebsd-vm@v0` 0865c115b Merge pull request redis#1080 from Nordix/readme-corrections f6cee7142 Fix README typos 06be7ff31 Merge pull request redis#1050 from smmir-cent/fix-cmake-version 7dd833d54 CI: bump macos runner version f69fac769 Drop `const` on redisAsyncContext in redisConnectCallback Since the callback is now re-entrant, it can call apis such as redisAsyncDisconnect() 005d7edeb Support calling redisAsyncDisconnect from the onConnected callback, by deferring context deletion 6ed060920 Add async regression test for issue redis#931 eaa2a7ee7 Merge pull request redis#932 from kristjanvalur/pr3 2ccef30f3 Add regression test for issue redis#945 4b901d44a Initial async tests 31c91408e Polling adapter and example 8a15f4d65 Merge pull request redis#1057 from orgads/static-name 902dd047f Merge pull request redis#1054 from kristjanvalur/pr08 c78d0926b Merge pull request redis#1074 from michael-grunder/kristjanvalur-pr4 2b115d56c Whitespace 1343988ce Fix typos 47b57aa24 Add some documentation on connect/disconnect callbacks and command callbacks a890d9ce2 Merge pull request redis#1073 from michael-grunder/kristjanvalur-pr1 f246ee433 Whitespace, style 94c1985bd Use correct type for getsockopt() 5e002bc21 Support failed async connects on windows. 5d68ad2f4 Merge pull request redis#1072 from michael-grunder/fix-redis7-unit-tests f4b6ed289 Fix tests so they work for Redis 7.0 95a0c1283 Merge pull request redis#1058 from orgads/win64 eedb37a65 Fix warnings on Win64 47c3ecefc Merge pull request redis#1062 from yossigo/fix-push-notification-order e23d91c97 Merge pull request redis#1061 from yossigo/update-redis-apt 34211ad54 Merge pull request redis#1063 from redis/fix-windows-tests 9957af7e3 Whitelist hiredis repo path in cygwin b455b3381 Handle push notifications before or after reply. aed9ce446 Use official repository for redis package. d7683f35a Merge pull request redis#1047 from Nordix/unsubscribe-handling 7c44a9d7e Merge pull request redis#1045 from Nordix/sds-updates dd4bf9783 Use the same name for static and shared libraries ff57c18b9 Embed debug information in windows static lib, rather than create a .pdb file 8310ad4f5 fix cmake version 7123b87f6 Handle any pipelined unsubscribe in async b6fb548fc Ignore pubsub replies without a channel/pattern 00b82683b Handle overflows as errors instead of asserting 64062a1d4 Catch size_t overflows in sds.c 066c6de79 Use size_t/long to avoid truncation c6657ef65 Merge branch 'redis:master' into master 50cdcab49 Fix potential fault at createDoubleObject fd033e983 Remove semicolon after do-while in _EL_CLEANUP 664c415e7 Illumos test fixes, error message difference fot bad hostname test. git-subtree-dir: deps/hiredis git-subtree-split: b6a052fe0959dae69e16b9d74449faeb1b70dbe1
The latest Lua can handle 64 bit integer. Like it can detect a number is of integer or float. So tonumber(999999999999999999) return the exact number (18 of 9s) |
Lua has a single number type that follows the IEEE 754 binary64 specification, which allows for 52 bits of precision. This makes the continuous range of positive integers that can be represented without loss of precision [1, (2^53) - 1].
When converting numbers from Lua to Redis, Redis uses default stringification which outputs in scientific notation with limited precision. This has the effect of losing precision for large integers, violating the Redis promise in the scripting documentation:
This conversion between data types is designed in a way that if a Redis type is converted into a Lua type, and then the result is converted back into a Redis type, the result is the same as of the initial value.
Because Redis has to stringify numbers in decimal notation, some precision loss for non-integer floating point numbers is to be expected. (The scripting documentation should probably be updated to point this out.) However, losing precision for integers that can be represented exactly in IEEE 754 is a bug that can have significant impact and can be very difficult to track down. The larger the integers, the larger the precision loss.
To reproduce, put the following in an Rspec suite:
This will generate the following HMSET command:
It will fail with the following message:
The suggested fix is to check whether a number is an integer and, in that case, stringify using full precision as opposed to scientific notation.
The text was updated successfully, but these errors were encountered: