Should SQLite distinguish between +0.0 and -0.0 on output?

classic Classic list List threaded Threaded
67 messages Options
1234
Reply | Threaded
Open this post in threaded view
|

Re: Should SQLite distinguish between +0.0 and -0.0 on output?

Richard Hipp-3
On 6/12/19, Thomas Kurz <[hidden email]> wrote:
>> For an SQL engine, the next-best-thing to strict binary IEEE754 is not
> sloppy binary IEEE754, its probably strict decimal IEEE754.
>
> That would be a *really great* improvement!

It would also be a file format change, rendering about 1e12 existing
database files obsolete.

--
D. Richard Hipp
[hidden email]
_______________________________________________
sqlite-users mailing list
[hidden email]
http://mailinglists.sqlite.org/cgi-bin/mailman/listinfo/sqlite-users
Reply | Threaded
Open this post in threaded view
|

Re: Should SQLite distinguish between +0.0 and -0.0 on output?

Warren Young
In reply to this post by Richard Hipp-3
On Jun 12, 2019, at 10:45 AM, Richard Hipp <[hidden email]> wrote:
>
> On 6/12/19, James K. Lowden <[hidden email]> wrote:
>> 1.  Prior art.  I can't think of a single programming language that
>> displays -0.0 without jumping through hoops.
>
> Prints -0.0 as "-0.0" or just "-0":  glibc, Tcl, Python, Javascript

Chrome’s JS engine (V8, shared with Node.js) does it both ways, depending on context:

> a = -0.0;
-0
> console.log(a)
-0
> JSON.stringify(a)
"0”
> JSON.stringify( { a: a} )
"{"a":0}”
> alert(a)
Says “0”


Two different versions of Perl (5.16.3 on CentOS 7 and 5.18.4 on macOS 10.14.5) prints “0” via all three paths I’ve tried: print(), say(), and Data::Dumper.


Clang on macOS agrees with your glibc result, for both printf() and cout.
_______________________________________________
sqlite-users mailing list
[hidden email]
http://mailinglists.sqlite.org/cgi-bin/mailman/listinfo/sqlite-users
Reply | Threaded
Open this post in threaded view
|

Re: Should SQLite distinguish between +0.0 and -0.0 on output?

Warren Young
In reply to this post by James K. Lowden
On Jun 12, 2019, at 10:02 AM, James K. Lowden <[hidden email]> wrote:
>
> On Wed, 12 Jun 2019 09:35:13 -0400
> Richard Hipp <[hidden email]> wrote:
>
>> Question:  Should SQLite be enhanced to show -0.0 as "-0.0"?  
>
> 2.  Math.  Negative zero is not a mathematical concept.

The best kind of correct: http://mathworld.wolfram.com/Zero.html
_______________________________________________
sqlite-users mailing list
[hidden email]
http://mailinglists.sqlite.org/cgi-bin/mailman/listinfo/sqlite-users
Reply | Threaded
Open this post in threaded view
|

Re: Should SQLite distinguish between +0.0 and -0.0 on output?

Thomas Kurz
In reply to this post by Richard Hipp-3
> It would also be a file format change, rendering about 1e12 existing
database files obsolete.

Maybe, but maybe there could be some clever implementation which doesn't break compatibility. I don't know about the exact internals of how SQlite stores values in the file. But I think there must be some identifier that tells whether a value is binary, integer, or float. Wouldn't it be possible to store both values, binary float and decimal float, in such a way that older versions would just read the binary float and ignore the additional data? Then, newer versions could read either, according on whether PRAGMA DECIMAL_MATH=TRUE is set or not.

Just an idea, don't know whether this would be feasible or not.

_______________________________________________
sqlite-users mailing list
[hidden email]
http://mailinglists.sqlite.org/cgi-bin/mailman/listinfo/sqlite-users
Reply | Threaded
Open this post in threaded view
|

Re: Should SQLite distinguish between +0.0 and -0.0 on output?

Dominique Pellé
In reply to this post by James K. Lowden
James K. Lowden <[hidden email]> wrote:

> On Wed, 12 Jun 2019 09:35:13 -0400
> Richard Hipp <[hidden email]> wrote:
>
> > Question:  Should SQLite be enhanced to show -0.0 as "-0.0"?
>
> No.
>
> 1.  Prior art.  I can't think of a single programming language that
> displays -0.0 without jumping through hoops.

I disagree. I think most languages distinguish between
+0.0 and -0.0, +inf, -inf and Nan. At least c, c++, Java,
Tcl and probably many others have +0.0 and -0.0. Even my
text editor Vim knows about +0.0 and -0.0, +inf, -inf and NaN.

In Vim:
:echo 1.0 / -0.0
-inf
:echo 1.0 / 0.0
inf

In tclsh:

% expr 1.0 / -0.0
-Inf
% expr 1.0 / 0.0
Inf

> 2.  Math.  Negative zero is not a mathematical concept.

It's about IEEE 754 which is widely used, and not about
math i.e. real numbers.

> 3.  Utility.  There is none.  The user is only inconvenienced.

There can be uses for it.  +0.0 or -0.0 can result
in different outcomes when doing intermediate
computations.  If SQLite deviates from IEEE 754, it's
likely to cause issues.

I think that a database should be generic enough and not
assume that users don't need -0.0.  SQLite is written in C
and all all C functions which use double already understand
+0.0 and -0.0. So I assume that there is hardly any
overhead in supporting -0.0 in SQLite.

Regards
Dominique
_______________________________________________
sqlite-users mailing list
[hidden email]
http://mailinglists.sqlite.org/cgi-bin/mailman/listinfo/sqlite-users
Reply | Threaded
Open this post in threaded view
|

Re: Should SQLite distinguish between +0.0 and -0.0 on output?

David Raymond
In reply to this post by Thomas Kurz
https://www.sqlite.org/fileformat2.html#record_format

The storage type of each record is given by an integer. And in the current format, all non-negative integers are used.

To me of course that begs the question: Are negative serial types an option? That would of course mean a full 9 bytes per field just to hold the type (it's a varint) so it's an annoying overhead, but is it an option?

Versions earlier than the one that implements this wouldn't be able to read it. But then we've already had additions like "without rowid" where any old version of the library isn't going be able to understand a new database with a without rowid table. And if a new database doesn't use the new negative serial types then the resulting file is still perfectly readable by older versions.

I suppose the issue though is that rules are already in place for determining the affinity of a column and those rules currently give a value for <anything>, so if you create a new type of "decimal(a, b)" then an old version, instead of saying "I don't know what that is" will say "ok, that's numeric and I internally store it as a float" and give bad results instead of no results.

I suppose then you could then expand on the "without rowid" model, and designate new features at the end of the create table text so that old versions don't <think> they know what to do and would give an error...

create table foo (field1 numeric(5, 2) primary key) without rowid with numeric with someNewFeature;

An old database where someone had already declared something as "decimal(5,2)" wouldn't have the "with decimal" in the create table text, so you could still keep the historical affinity and not mix it up with something intended for the new "decimal" type.

...but that gets ugly and complicated quick.

Anyway, sorry for my rambling, I'll go hide in a corner now.


-----Original Message-----
From: sqlite-users <[hidden email]> On Behalf Of Thomas Kurz
Sent: Wednesday, June 12, 2019 1:05 PM
To: SQLite mailing list <[hidden email]>
Subject: Re: [sqlite] Should SQLite distinguish between +0.0 and -0.0 on output?

> It would also be a file format change, rendering about 1e12 existing
database files obsolete.

Maybe, but maybe there could be some clever implementation which doesn't break compatibility. I don't know about the exact internals of how SQlite stores values in the file. But I think there must be some identifier that tells whether a value is binary, integer, or float. Wouldn't it be possible to store both values, binary float and decimal float, in such a way that older versions would just read the binary float and ignore the additional data? Then, newer versions could read either, according on whether PRAGMA DECIMAL_MATH=TRUE is set or not.

Just an idea, don't know whether this would be feasible or not.

_______________________________________________
sqlite-users mailing list
[hidden email]
http://mailinglists.sqlite.org/cgi-bin/mailman/listinfo/sqlite-users
_______________________________________________
sqlite-users mailing list
[hidden email]
http://mailinglists.sqlite.org/cgi-bin/mailman/listinfo/sqlite-users
Reply | Threaded
Open this post in threaded view
|

Re: Should SQLite distinguish between +0.0 and -0.0 on output?

jm cuaz
In reply to this post by Richard Hipp-3
 > what should SQLite do when the application asks it to convert

 > a -0.0 value into text. It is only the binary-to-text conversion

> routine that is at question here.

A possible solution could be a new function,
- something like abszero() or trimzero() - acting only on +/- 0.0
and suppressing any sign before the value, combined with the new
rule that binary-to-text conversion retrieve data exactly as it
is stored (and maybe improving hosts langage interoperability).
This could permit any desired behaviour.

Personally, if I want to do binary-to-text conversion of numbers,
it is my duty to consider there could be some "artifacts" to deal
with, resulting from the representation standard.

If binary-to-text conversion preserves any sign before 0.0 value,
it might conciliate different intents to permit (for example) :

CAST(trimzero(somecolumn) AS TEXT) if no sign is wanted for textual
representation of 0.0

(don't kwow if it's a so good solution however)

Best regards

-jm




---
L'absence de virus dans ce courrier électronique a été vérifiée par le logiciel antivirus Avast.
https://www.avast.com/antivirus
_______________________________________________
sqlite-users mailing list
[hidden email]
http://mailinglists.sqlite.org/cgi-bin/mailman/listinfo/sqlite-users
Reply | Threaded
Open this post in threaded view
|

Re: Should SQLite distinguish between +0.0 and -0.0 on output?

Simon Slavin-3
On 12 Jun 2019, at 9:23pm, Jean-Marie CUAZ <[hidden email]> wrote:

> A possible solution could be a new function,
> - something like abszero() or trimzero() - acting only on +/- 0.0

Another would be a PRAGMA which sets whether the two values are converted to text iodentically or differently.
_______________________________________________
sqlite-users mailing list
[hidden email]
http://mailinglists.sqlite.org/cgi-bin/mailman/listinfo/sqlite-users
Reply | Threaded
Open this post in threaded view
|

Re: Should SQLite distinguish between +0.0 and -0.0 on output?

James K. Lowden
In reply to this post by Keith Medcalf
On Wed, 12 Jun 2019 10:28:20 -0600
"Keith Medcalf" <[hidden email]> wrote:

> Python 3.7.3 (v3.7.3:ef4ec6ed12, Mar 25 2019, 22:22:05) [MSC v.1916
> 64 bit (AMD64)] on win32 Type "help", "copyright", "credits" or
> "license" for more information.
> >>> a = -0.0
> >>> b = 0.0
> >>> print(a,b)
> -0.0 0.0
>
> Really difficult hoops to jump through are they not?

        $ printf "%f\n" -0.0
        -0.000000

A poor choice of words.  What I meant was, what kind of computation
would lead to a value in memory representing -0,0?  I don't remember
ever coming across one.  

Just because we can print -0.0 doesn't mean it's meaningful.  

#include <stdio.h>

int main() {
  if( -0.0 == 0.0 ) {
    printf("all zeros are zero\n");
    return 0;
  }

  printf("minus zero is real\n");
  return 1;
}

make negzero && ./negzero
cc     negzero.c   -o negzero
all zeros are zero

--jkl
_______________________________________________
sqlite-users mailing list
[hidden email]
http://mailinglists.sqlite.org/cgi-bin/mailman/listinfo/sqlite-users
Reply | Threaded
Open this post in threaded view
|

Re: Should SQLite distinguish between +0.0 and -0.0 on output?

James K. Lowden
In reply to this post by Richard Hipp-3
On Wed, 12 Jun 2019 12:57:22 -0400
Richard Hipp <[hidden email]> wrote:

> On 6/12/19, Thomas Kurz <[hidden email]> wrote:
> >> For an SQL engine, the next-best-thing to strict binary IEEE754 is
> >> not
> > sloppy binary IEEE754, its probably strict decimal IEEE754.
> >
> > That would be a *really great* improvement!
>
> It would also be a file format change, rendering about 1e12 existing
> database files obsolete.

Is that necessarily the case?  Could blob types be "overloaded" somehow,
such that existing code sees a blob and new code recognizes said blob
as decimal numeric?  

For example, if the first two bytes of the expansion area of the
database header (at offset 72) were 0x0bcd (say), then record type 44
could represent a 128-bit decimal encoding [16 bytes = (44 -12)/2].
Existing programs wouldn't examine the expansion area, and would
interpret the field as a blob.  New programs would interpret type 44 as
decimal or blob, depending on the CREATE TABLE definition.  

--jkl
_______________________________________________
sqlite-users mailing list
[hidden email]
http://mailinglists.sqlite.org/cgi-bin/mailman/listinfo/sqlite-users
Reply | Threaded
Open this post in threaded view
|

Re: Should SQLite distinguish between +0.0 and -0.0 on output?

Simon Slavin-3
In reply to this post by James K. Lowden
On 12 Jun 2019, at 10:28pm, James K. Lowden <[hidden email]> wrote:

> what kind of computation
> would lead to a value in memory representing -0,0?

Here's the classic answer.  It's not very impressive or convincing because it just kicks the can further down the road.

Suppose you have a system like IEEE754 which represents positive infinity and negative infinity as two different values.  At some point you calculate a

    a <-- 20.0 / c

where c is zero.  The answer is positive or negative infinity depending on whether c is positive or negative zero.

Now, you could answer that they're both infinity and the answer doesn't matter because you can't calculate with infinity.  But suppose later you do

    IF a > 4 THEN …

or

    z = a + [-ve infinity]

Keeping different values for the two zeros may allow you to answer these questions correctly.  Without that you cannot know the answer.

This is one of the reasons I asked whether SQLite was going to distinguish between +inf and -inf, and have NaN values.  So if SQLite already shows +inf and -inf differently as text, it should do the same thing for the two zeros.
_______________________________________________
sqlite-users mailing list
[hidden email]
http://mailinglists.sqlite.org/cgi-bin/mailman/listinfo/sqlite-users
Reply | Threaded
Open this post in threaded view
|

Re: Should SQLite distinguish between +0.0 and -0.0 on output?

Donald Shepherd
In reply to this post by Richard Hipp-3
On Thu, 13 Jun 2019 at 01:28, Richard Hipp <[hidden email]> wrote:

> On 6/12/19, Jonathan Brandmeyer <[hidden email]> wrote:
> > IMO, when acting as a storage engine, SQLite should be good to the last
> > bit.
>
> That is already the case, and has been for 17 years.  The question at
> hand is what should SQLite do when the application asks it to convert
> a -0.0 value into text.  It is only the binary-to-text conversion
> routine that is at question here.  If you are reading back your
> database content using sqlite3_column_double(), you get back
> bit-for-bit exactly what you put in.
>

Strictly speaking this isn't true - if using the C interface to pass in
-0.0 it used to get returned as 0.0 due to the optimization where
"SQLite converts
integer floating point values to actual integers for storage (because that
takes up less space on disk) and then converts back to double upon
retrieval. That round-trip would change -0.0 into +0.0." (2015) That may
have changed in recent years as I haven't explicitly tested it once I
worked around this behaviour by storing some double values as BLOBs.

Similarly passing in a bit representation of NaNs will not get you
bit-for-bit exactly what you put in, as SQLite discards it on the return
trip (also from 2015, though this code is still present so I assume the
behaviour is the same):

sqlite3_bind_double calls sqlite3VdbeMemSetDouble which has a specific
check against NaN.  My assumption is that this is what results in NaNs not
round tripping and instead coming back out as SQLITE_NULL:

SQLITE_PRIVATE void sqlite3VdbeMemSetDouble(Mem *pMem, double val){
  sqlite3VdbeMemSetNull(pMem);
  if( !sqlite3IsNaN(val) ){
    pMem->u.r = val;
    pMem->flags = MEM_Real;
  }
}
_______________________________________________
sqlite-users mailing list
[hidden email]
http://mailinglists.sqlite.org/cgi-bin/mailman/listinfo/sqlite-users
Reply | Threaded
Open this post in threaded view
|

Re: Should SQLite distinguish between +0.0 and -0.0 on output?

Richard Hipp-3
In reply to this post by James K. Lowden
On 6/12/19, James K. Lowden <[hidden email]> wrote:
> what kind of computation
> would lead to a value in memory representing -0,0?

  0.0/-1.0

--
D. Richard Hipp
[hidden email]
_______________________________________________
sqlite-users mailing list
[hidden email]
http://mailinglists.sqlite.org/cgi-bin/mailman/listinfo/sqlite-users
Reply | Threaded
Open this post in threaded view
|

Re: Should SQLite distinguish between +0.0 and -0.0 on output?

Jonathan Brandmeyer
In reply to this post by David Raymond
On Wed, Jun 12, 2019 at 12:02 PM David Raymond <[hidden email]>
wrote:

> https://www.sqlite.org/fileformat2.html#record_format
>
> The storage type of each record is given by an integer. And in the current
> format, all non-negative integers are used.
>

Ouch.  Yes, an additional data type was closer to what I had in mind.


> -----Original Message-----
> From: sqlite-users <[hidden email]> On
> Behalf Of Thomas Kurz
> Sent: Wednesday, June 12, 2019 1:05 PM
> To: SQLite mailing list <[hidden email]>
> Subject: Re: [sqlite] Should SQLite distinguish between +0.0 and -0.0 on
> output?
>
> > It would also be a file format change, rendering about 1e12 existing
> database files obsolete.
>
_______________________________________________
sqlite-users mailing list
[hidden email]
http://mailinglists.sqlite.org/cgi-bin/mailman/listinfo/sqlite-users
Reply | Threaded
Open this post in threaded view
|

Re: Should SQLite distinguish between +0.0 and -0.0 on output?

Jonathan Brandmeyer
In reply to this post by Richard Hipp-3
Regarding additional uses for the sign of zero:

Branch Cuts for Complex Elementary Functions, or Much Ado About
Nothing's Sign Bit in The State of the Art in Numerical Analysis,
(eds. Iserles and Powell), Clarendon Press, Oxford, 1987.

https://people.freebsd.org/~das/kahan86branch.pdf



On Wed, Jun 12, 2019 at 4:40 PM Richard Hipp <[hidden email]> wrote:

>
> On 6/12/19, James K. Lowden <[hidden email]> wrote:
> > what kind of computation
> > would lead to a value in memory representing -0,0?
>
>   0.0/-1.0
>
> --
> D. Richard Hipp
> [hidden email]
> _______________________________________________
> sqlite-users mailing list
> [hidden email]
> http://mailinglists.sqlite.org/cgi-bin/mailman/listinfo/sqlite-users



--
Jonathan Brandmeyer
Vice President of Software Engineering
PlanetiQ
_______________________________________________
sqlite-users mailing list
[hidden email]
http://mailinglists.sqlite.org/cgi-bin/mailman/listinfo/sqlite-users
Reply | Threaded
Open this post in threaded view
|

Re: [EXTERNAL] Re: Should SQLite distinguish between +0.0 and -0.0 on output?

Hick Gunter
In reply to this post by James K. Lowden
> 2.  Math.  Negative zero is not a mathematical concept.

-0.0 is "too close to distinguish from, but definitely left of true zero", which may be significant in some context


___________________________________________
 Gunter Hick | Software Engineer | Scientific Games International GmbH | Klitschgasse 2-4, A-1130 Vienna | FN 157284 a, HG Wien, DVR: 0430013 | (O) +43 1 80100 - 0

May be privileged. May be confidential. Please delete if not the addressee.
_______________________________________________
sqlite-users mailing list
[hidden email]
http://mailinglists.sqlite.org/cgi-bin/mailman/listinfo/sqlite-users
Reply | Threaded
Open this post in threaded view
|

Re: Should SQLite distinguish between +0.0 and -0.0 on output?

Dominique Devienne
In reply to this post by Richard Hipp-3
On Wed, Jun 12, 2019 at 6:45 PM Richard Hipp <[hidden email]> wrote:

> On 6/12/19, James K. Lowden <[hidden email]> wrote:
> > 1.  Prior art.  I can't think of a single programming language that
> > displays -0.0 without jumping through hoops.
>
> Prints -0.0 as "-0.0" or just "-0":  glibc, Tcl, Python, Javascript
>
> Prints -0.0 as "0.0" or "0": PostgreSQL, MySQL, Oracle, SqlServer
>

Since I didn't know if Richard knew about NUMBER vs BINARY_DOUBLE in Oracle,
the latter being supposed to store IEEE doubles, I tried, and I can't see
to input a -0.0
in either using SQL*PLUS. I guess I would have to write a small test with
OCI to know
if at least like SQLite either is able to preserve the sign.

But in terms of to-text rendering, I'm not getting a -0.0 back for sure,
like Richard.
And the SIGN() function does not show the numbers as negative, although
there is
some weirdness is that it returns a different result for NUMBER and
BINARY_DOUBLE
which I didn't investigate.

FWIW :). --DD

Oracle Database 12c Enterprise Edition Release 12.1.0.1.0 - 64bit Production
With the Partitioning, OLAP, Advanced Analytics and Real Application
Testing options

SQL> create table testfp (fpnum number, fpieee binary_double);

Table created.

SQL> insert into testfp values (0.0, 0.0);

1 row created.

SQL> insert into testfp values (-0.0, -0.0);

1 row created.

SQL> select * from testfp;

     FPNUM     FPIEEE
---------- ----------
         0          0
         0          0

SQL> insert into testfp values (-0.0, cast(-0.0 as binary_double));

1 row created.

SQL> select * from testfp;

     FPNUM     FPIEEE
---------- ----------
         0          0
         0          0
         0          0

SQL> select sign(fpnum), sign(fpieee) from testfp;

SIGN(FPNUM) SIGN(FPIEEE)
----------- ------------
          0            1
          0            1
          0            1

SQL> insert into testfp values (-1.0, -1.0);

1 row created.

SQL> select sign(fpnum), sign(fpieee) from testfp;

SIGN(FPNUM) SIGN(FPIEEE)
----------- ------------
          0            1
          0            1
          0            1
         -1           -1

SQL> insert into testfp values (-1.0*0, -1.0*0);

1 row created.

SQL> select sign(fpnum), sign(fpieee) from testfp;

SIGN(FPNUM) SIGN(FPIEEE)
----------- ------------
          0            1
          0            1
          0            1
         -1           -1
          0            1

SQL> select * from testfp
  2  ;

     FPNUM     FPIEEE
---------- ----------
         0          0
         0          0
         0          0
        -1  -1.0E+000
         0          0

SQL>
_______________________________________________
sqlite-users mailing list
[hidden email]
http://mailinglists.sqlite.org/cgi-bin/mailman/listinfo/sqlite-users
Reply | Threaded
Open this post in threaded view
|

Re: [SPAM?] Re: [EXTERNAL] Re: Should SQLite distinguish between +0.0 and -0.0 on output?

Richard Damon
In reply to this post by Hick Gunter
On 6/13/19 1:29 AM, Hick Gunter wrote:
>> 2.  Math.  Negative zero is not a mathematical concept.
> -0.0 is "too close to distinguish from, but definitely left of true zero", which may be significant in some context
>
Except by the rules of IEEE (as I understand them)

-0.0 < 0.0 is FALSE, so -0.0 is NOT "definitely left of true zero"


--
Richard Damon

_______________________________________________
sqlite-users mailing list
[hidden email]
http://mailinglists.sqlite.org/cgi-bin/mailman/listinfo/sqlite-users
Reply | Threaded
Open this post in threaded view
|

Re: [SPAM?] Re: [EXTERNAL] Re: Should SQLite distinguish between +0.0 and -0.0 on output?

Doug Currie-2
>
>
> Except by the rules of IEEE (as I understand them)
>
> -0.0 < 0.0 is FALSE, so -0.0 is NOT "definitely left of true zero"
>

Except that 0.0 is also an approximation to zero, not "true zero."

Consider that 1/-0.0 is -inf whereas 1/0.0 is +int

e
_______________________________________________
sqlite-users mailing list
[hidden email]
http://mailinglists.sqlite.org/cgi-bin/mailman/listinfo/sqlite-users
Reply | Threaded
Open this post in threaded view
|

Re: [SPAM?] Re: [EXTERNAL] Re: Should SQLite distinguish between +0.0 and -0.0 on output?

R Smith-2
On 2019/06/13 4:44 PM, Doug Currie wrote:
>>
>> Except by the rules of IEEE (as I understand them)
>>
>> -0.0 < 0.0 is FALSE, so -0.0 is NOT "definitely left of true zero"
>>
> Except that 0.0 is also an approximation to zero, not "true zero."
>
> Consider that 1/-0.0 is -inf whereas 1/0.0 is +int


I do not know if this is the result case in any of the programming
languages, but in Mathematical terms that is just not true.

1/0.0 --> Undefined, doesn't exist, cannot be computed, Should error
out. Anything returning +Inf or -Inf is plain wrong.
I posit the same holds true for 1/-0.0



_______________________________________________
sqlite-users mailing list
[hidden email]
http://mailinglists.sqlite.org/cgi-bin/mailman/listinfo/sqlite-users
1234