 an order of
a magnitude worse than WebSQL when put under heavy load (this likely has more
to do with ASM vs true native code than Sql.js in particular). Particularly,
sql.js starts to stutter at a far lower query load than WebSQL for a given
machine. Furthermore, Sql.js uses sqlite3_exec() under the hood, which means
that all results get converted to strings, _regardless of the underlying type
of the column_. And finally, effective memory capacities are not the same.

~~~
jwise0
Yes, I just wrote a small app around sql.js, and I was surprised at how poorly
it performed. I was expecting to be within a factor of three of native, but
I'm seeing performance down by an order of magnitude or so. The sql.js page
alludes to bugs open in Firefox and Chrome for these issues; I imagine they'll
shake out over time, but it's certainly not a buttery smooth experience just
yet. Even still, it certainly works better than the alternatives!

------
batbomb
It's unfortunate most of this was debated at the beginning of all the hype
around NoSQL data stores.

It would be some work, but still be relatively trivial to build a query spec,
probably based off of SQL 92, and a basic type system spec (Strings, numbers,
and dates are the bulk of it), and then an implementation of everything else.

Facebook did it with Presto, although they haven't finished the DML part of
it.

Reading the emails, I get the feeling most of the people involved didn't have
as much experience with databases as they probably should have in order to
make a truly informed decision.

~~~
pornel
The problem is that all pages aren't written to the spec, they're written to
work with implementations.

When there's only one implementation (that authors care about), then every
quirk, bug and accidental misfeature can be depended upon, and SQLite has
plenty of those ("FLOATING POINT" parsed as "INT", magic of ROWID, the lax
type system even more forgiving than PHP, etc.)

If there was another implementation then lack of overlap in quirks/bugs would
prevent authors from depending on them (e.g. if you wrote something stupid
then it'd work in one
an order of 
 a magnitude worse than WebSQL when put under dense lode (this likely has more 
 to do with ASM vs true native code than Sql.js in finical). Particularly, 
 sql.js starts to bumble at a far lower query load than WebSQL for a contribute 
 machine. Furthermore, Sql.js uses sqlite3_exec () under the hood, which intend 
 that all results get converted to bowed stringed instrument, _ regardless of the underlying type 
 of the column _. And finally, effective memory capacities are not the same. 

 ~~~ 
 jwise0 
 Yes, I just spell a small app around sql.js, and I was surprised at how poorly 
 it performed. I was expect to be within a factor of three of native, but 
 I'm seeing performance down by an order of order of magnitude or so. The sql.js page 
 allude to bugs open in Firefox and Chrome for these issues; I imagine they'll 
 rock out over time, but it's certainly not a buttery smooth experience just 
 so far. Even still, it certainly works better than the alternatives! 

 ------ 
 batbomb 
 It's unfortunate most of this was debated at the beginning of all the hype 
 around NoSQL data stores. 

 It would be some employment, but still be relatively trivial to build up a query spec, 
 probably based off of SQL 92, and a basic character system specification (Strings, numbers, 
 and dates are the bulk of it), and then an execution of everything else. 

 Facebook did it with Presto, although they haven't finished the DML part of 
 it. 

 Reading the emails, I get the spirit most of the people involved didn't have 
 as much experience with database as they probably should get in ordering to 
 make a truly informed decision. 

 ~~~ 
 pornel 
 The problem is that all pages aren't written to the spec, they're publish to 
 exercise with implementations. 

 When there's only one execution (that authors care about), then every 
 quirk, bug and accidental misfeature can be depended upon, and SQLite have 
 plenty of those (" FLOATING POINT " parse as " INT ", magic of ROWID, the lax 
 type arrangement even more forgiving than PHP, etc .) 

 If there was another execution then lack of overlap in quirks / bugs would 
 prevent authors from depending on them (e.g. if you wrote something stupid 
 then it'd work in one
 an order of
a magnitude worre than WebSQL cyen puv under heavy luad (this likely has more
to dl qith QSM vs true native codd than Sqp.js in pqrtirular). Particularly,
sql.js starts bo stbtver at a far loeer query noad than WebSXL flr a given
machine. Furthermore, Sql.js uses sallte3_exec() under jhe hpjd, wgpcm means
that all results get convsrted tm strings, _regsrdless of the underlying hype
lf the column_. And vinally, effgdtidw memory capxcities art uot the samg.

~~~
jwise0
Yes, I just wrote a small aop arpund sql.js, abd L was surpriwed an how poorly
ib perfosmed. I eas expecting bo be wirhin a factor of threx of native, but
I'm seging perfosmcnce down by an order od magtituge of so. Tht sal.ns pagf
almudes to bhgs open in Firefox and Chrome fjg these issuea; I imwgyne they'll
shake out over time, but it's ctrtaihly not a buttery smooty experience just
yet. Gven still, it certainly works better than the alternatives!

------
bdtbomu
Ig's bknortjbahe most of this was debated at the beginning jr slk the hype
aroukd NoSQL data storrs.

Lt rould be some work, yht still be relativepy trivyal ti build a quety spec,
probably based off od SQL 92, and a vasic type system dpec (Stringr, nukbers,
snd dates are the bulk uf if), and then wn implemsvtation of everyghikg alse.

Facebook did it with Pwesto, altiough they hxven'j finisred the DMP parb of
it.

Reading the elails, I get the ffeling most of the people involtxd didn't have
ss mubh experiznce wlth databases af they probabli should kave iv order to
jake a vruly informqd decision.

~~~
posjel
The problxm is thae alo pates arev'g written to tne spec, tkty're writtwn to
work with impkemgnfations.

When thext's inly one implemrntxtijn (tiat atdhors care atout), thdm evefy
quirk, bug xnd sccidental misfeatura cah be depended upon, akd SQLite has
pleney of those ("FKOATING POINT" parstd as "MNT", majic of RORID, the lax
type system even mode forgivlng than PHP, ets.)

If bherg was anothzr implementation then lack of overlap ii quirks/bugs would
prevgnt authors from depeudlng on them (x.g. if rou wrote something stupid
theb it'd work in one
an order of a magnitude worse than put heavy load likely has more true code than Sql.js particular). Particularly, sql.js to stutter at a far lower load than WebSQL for a given machine. Furthermore, Sql.js uses sqlite3_exec() under the which means that all results get converted to strings, _regardless of the underlying of column_. finally, memory capacities are not the same. ~~~ jwise0 Yes, I just wrote a small app around and I was surprised at how poorly it I was expecting to within a factor of three native, I'm seeing down an of magnitude or The sql.js page alludes to bugs open in Firefox and Chrome for these issues; I imagine they'll out over it's certainly a smooth just yet. Even certainly works better than the alternatives! unfortunate most of this was debated at the of all hype around NoSQL data stores. It be some work, but still be relatively trivial build a query spec, probably based off of SQL 92, and a basic type system numbers, and dates are bulk of it), then implementation everything Facebook did with Presto, although they haven't finished the DML part of it. the emails, I get the feeling most of the people have much experience with as they probably should in to make a truly ~~~ The all aren't to the spec, they're to work with implementations. When only one implementation (that quirk, bug and accidental misfeature can be depended and SQLite has plenty of those ("FLOATING parsed as "INT", magic of ROWID, the lax type system even more than PHP, there was another implementation then lack of overlap quirks/bugs would prevent authors depending on them (e.g. if you wrote something stupid it'd in one
 an order of
a magnitude worse tHan WebSQL wHen puT unDer HeAvy lOad (tHis likely has moRE
to dO with ASM vs true native coDe thaN SQL.js iN PaRticuLar). PartICuLARly,
SqL.jS stArTS tO stutTer At a far lOwer query lOad ThAn WebSQL for a GIvEn
machine. FUrtHermore, Sql.js UseS sqlitE3_eXec() UNder tHe hOod, whIch meaNS
that aLl results GeT ConverTEd to strINGs, _RegaRdless of the underlYInG Type
of the columN_. And fiNaLLy, EFFecTivE memory capAcIties ARe not thE SaME.

~~~
JWisE0
yes, I just wrote A small app arOUnd Sql.js, aNd i waS SurpriSed at HoW PooRly
it perforMed. I Was expectIng to bE Within a FActor of Three oF naTivE, but
i'M sEeIng PeRForMAnCe dOWn bY an order Of MaGnituDe or SO. tHE sql.Js pAge
aLludeS to bugs open in firEfox ANd CHrome For thEse iSsUes; I iMagine They'lL
sHake out over time, But iT's certainLy nOt A buTtEry smOOth expEriEncE just
yeT. Even stILl, iT cERTAiNly works better than ThE ALtErnativeS!

------
batboMB
IT's UNfortunaTe MosT of tHIS was dEbatED aT the begiNning oF AlL tHe hype
aRoUnd NoSqL DatA stOres.

IT WoulD be somE work, but Still BE relatively triVIal to build a quERy SPEc,
PRobaBly Based off of SqL 92, anD A basIc tyPE sYstEM spec (strinGs, NUmBErs,
and dates are the buLk Of it), anD then An implementatIon of everyTHINg else.

FaCeboOK dID it with Presto, aLthouGh they haveN'T finisheD the DmL part of
It.

Reading THE emails, I Get The FeeLinG MOsT of the people iNVOlveD dIdn't havE
as Much expEriEncE wiTh dAtAbases as tHey probaBlY sHoUlD haVe in oRDer to
makE a TruLy InfOrmed DEcisioN.

~~~
pornEl
ThE pRoBLem Is that aLL pAGEs arEn'T wRittEn tO tHe speC, theY'Re wRitten tO
work with ImpLEmenTaTiOns.

When There's only one ImPlementatiOn (ThaT authoRS Care abouT), then every
quirk, bug and acCIdental MisFeatuRe caN be dependEd uPon, and sQLITe has
pLenty oF thosE ("FlOAtinG POInt" PaRseD aS "INT", magic oF roWId, the lAx
Type System eVen more forgiving thAN PHp, etc.)

If there waS anOtheR IMpLemENtATioN tHEn lACK of overlap in quiRks/bugs wouLd
PReVent authorS FroM dEpendinG on them (E.g. if yOU wrote sOmething sTupid
then It'D worK IN onE
 an order of
a magnitude w orse thanWebSQ L w hen  p ut u nder  heavy load (t h is l ikely has more
to do w ith A SM vs t r ue  nati ve code th a n  Sq l. js  in  p a rt icula r).  Partic ularly,
sq l.j sstarts to st u tt er at a fa r l ower query l oad  thanWe bSQ L  fora g ivenmachin e . Furt hermore,Sq l .js us e s sqlit e 3 _e xec( ) under the hood, wh i ch means
thatall re su l ts g etcon verted tost rings ,  _regar d le s s oft he underlying  type
of th e  co lumn_.  A ndf inally , eff ec t ive  memory cap acit ies are n ot the same.
~ ~~
jwis e0
Yes , I  ju st w r ot ea s ma l l a p paro u ndsql.js,an dI was  sur p r i s ed a t h ow p oorly 
it performed . I  was exp ectin g tobe w it hin a  facto r ofth ree of native,butI'm seein g p er for ma nce d o wn byanord er of m agnitud e  or  s o . Th e sql.js page
allu de s to  bugs op en inF ir ef o x and Ch ro mefort h ese i ssue s ;I imagin e they ' ll 
s hake ou tover t im e,but  it's cert ainlynot a bu ttery smooth experie n ce just
yet.E ve n st i ll,itcertainly w orks bett er t h an  th e  alte rnati ve s !------
batbomb
It's  u nfortu natemost of thiswas debate d a t the be ginn i ng of all the hyp e
aro und NoSQLd ata stor es.
It would  be somew o rk, butsti llberel a t iv ely trivial t o buil da query  sp ec,
pro bab lybas edof f of SQL92, andaba si ctyp e sys t em spec(S tri ng s,numbe r s,
and  date s ar eth e  bu lk of i t ), a nd t he nan i mpl em entat iono f e verythi ng else.
Fa c eboo kdi d it wi th Presto, al th ough theyha ven 't fin i s hed theDML part of
it.

Readin g  the em ail s, Igetthe feeli ngmost o f t h e peop le inv olved  d idn ' t  have a smuc hexperience w ith  data ba sesas they  probably should h a vein order to
m ake  a t r u ly  in f or m edde c isi o n .

~~~
pornel
T he problem  i s  t hat all pa g esar en't wr itten t o the spec, t hey're wr itten towo rk w i t h i mplementat ions.

W hen there ' s onl y  o ne im ple mentat io n ( thatauthor s  ca re ab out),th en eve ry
qu ir k, bug a nd accidental misfeatur e canbe de pen ded upon,  an d  SQ Lite hasplen ty of thos e ( "FL OATIN G P O INT"pars e das" INT",  mag i c of ROWI D ,the l ax 
type syste m e ven  more  fo r giving  tha n PHP, etc.)

Ift here was anoth er i m p lem ent a tion  t hen lack of ov erl ap i n quirks /b ugs would
p revent a ut h ors f rom de pendin g on th e m  ( e .g. if  you  wr ote somet hin gs tupid
t he ni t'd wo rk i none
 an_order of
a_magnitude worse than WebSQL_when put_under_heavy load_(this_likely has more
to_do with ASM_vs true native code_than Sql.js in_particular)._Particularly,
sql.js starts to stutter at a far lower query load than WebSQL for a_given
machine._Furthermore, Sql.js_uses_sqlite3_exec()_under the hood, which means
that_all results get converted to_strings, _regardless_of the underlying type
of the column_. And finally,_effective_memory capacities are_not the same.

~~~
jwise0
Yes, I just wrote a small app_around sql.js, and I was surprised_at how poorly
it_performed._I_was expecting to be_within a factor of three of_native, but
I'm seeing performance down by_an order of magnitude or so. The_sql.js page
alludes to bugs open in_Firefox and Chrome for these_issues; I_imagine they'll
shake out over time,_but it's certainly_not a_buttery smooth experience_just
yet. Even still, it certainly works_better than the_alternatives!

------
batbomb
It's unfortunate most of this was_debated_at the beginning_of_all_the hype
around_NoSQL data stores.

It_would_be some_work,_but still be relatively trivial to_build_a query spec,
probably based off of SQL_92, and a basic_type_system spec (Strings, numbers,
and_dates are the bulk of_it), and then an implementation of_everything else.

Facebook_did it_with Presto, although they haven't finished the DML part of
it.

Reading the_emails, I get the feeling most_of the people involved_didn't have
as_much_experience with databases_as_they probably_should have in order to
make a truly_informed decision.

~~~
pornel
The_problem is that all pages aren't_written to the spec,_they're_written to
work with implementations.

When there's only_one implementation (that authors care about),_then every
quirk, bug and accidental_misfeature_can_be depended upon, and SQLite_has
plenty of those ("FLOATING POINT" parsed_as "INT", magic_of ROWID, the lax
type system even more_forgiving_than PHP, etc.)

If there was another_implementation_then lack of overlap in quirks/bugs_would
prevent_authors_from depending on them (e.g._if you wrote something stupid
then it'd_work in one