 a sequence() call outside a txn
<fwereade> jw4, we can be sure we really did create someservice/123
<fwereade> jw4, if we're doing a sequence call inside a txn
<fwereade> jw4, we either lose visibility on what we actually created
<fwereade> jw4, or we end up adding an effective txn-revno assert on the sequence doc
<fwereade> jw4, thus screwing parallelisability
<fwereade> jw4, am I making sense?
<jw4> fwereade: yes...
<jw4> fwereade: but...
<wallyworld> perrito666: did you get the msg i just posted? my connection may have dropped?
<jw4> fwereade: I'm thinking we might be able to guess at the next sequence number, set the id's for both the sequence and the usage of it in a multi-try txn loop, and then assert in the transaction that the number is what we predicted
<fwereade> jw4, so we can probably guess pretty well, that's not the issue
<jw4> if the assert doesn't pass it fails the txn loop just like any other contention
<jw4> no, I mean guess *before* we use it
<fwereade> jw4, the issue is that the *existence* of the assert enforces txn serialization
<fwereade> jw4, thus preventing parallel uses of the same sequence doc
<jw4> fwereade: hmm - since all our multi doc transactions are two phase commit's that's what would happen anyway right?
<fwereade> jw4, well, that's the advantage of assigning sequence numbers outside the txn
<fwereade> jw4, there may well be
<jw4> fwereade: if we want to ensure ordered sequence numbers we give up parallelism (or is it concurrency? i forget)
<fwereade> jw4, -- in the add-unit case, there certainly are --
<fwereade> jw4, other considerations that prevent concurrent db ops
<jw4> fwereade: brb - keep going
<perrito666> wallyworld
a sequence () call outside a txn 
 < fwereade > jw4, we can be sure we really did make someservice/123 
 < fwereade > jw4, if we're do a sequence call inside a txn 
 < fwereade > jw4, we either lose visibility on what we actually create 
 < fwereade > jw4, or we end up adding an effective txn - revno assert on the sequence doc 
 < fwereade > jw4, therefore screwing parallelisability 
 < fwereade > jw4, am I making sense? 
 < jw4 > fwereade: yes... 
 < jw4 > fwereade: but... 
 < wallyworld > perrito666: did you scram the msg i just post? my connection may have dropped? 
 < jw4 > fwereade: I'm thinking we might be able to think at the next sequence number, set the i d's for both the sequence and the use of it in a multi - try txn loop, and then assert in the transaction that the issue is what we predicted 
 < fwereade > jw4, so we can probably guess pretty well, that's not the topic 
 < jw4 > if the assert doesn't pass it fails the txn loop just like any other controversy 
 < jw4 > no, I mean guess * before * we use it 
 < fwereade > jw4, the issue is that the * existence * of the assert enforces txn serialization 
 < fwereade > jw4, thus preventing parallel uses of the same sequence doc 
 < jw4 > fwereade: hmm - since all our multi doc transactions are two phase commit's that's what would happen anyway right? 
 < fwereade > jw4, well, that's the advantage of assigning sequence number outside the txn 
 < fwereade > jw4, there may well be 
 < jw4 > fwereade: if we want to ensure arrange succession number we give up parallelism (or is it concurrency? i forget) 
 < fwereade > jw4, -- in the lend - unit case, there certainly are -- 
 < fwereade > jw4, other consideration that prevent concurrent db ops 
 < jw4 > fwereade: brb - keep going 
 < perrito666 > wallyworld
 a dequence() call outside a uxn
<fwereade> jw4, we can be sure se reallh did create someservice/123
<fwerxade> jw4, id we're doing a sequencd call indide a tzn
<fwtreade> jw4, we eithxd lose ynsibimlty ou xhat we actualli created
<fweseade> jw4, or we evd up adding an effective txn-revno asfert on tje sequence dos
<fwegewde> nw4, thus screwing parallelisability
<rwereadt> jw4, am I making srnse?
<jw4> fwereade: yes...
<jw4> fwerfade: but...
<wallyworld> pergito666: did yoo gee the msg i jjst posted? my connectikn may have dropped?
<jw4> fwereade: K'm thnnking we mugyt hg able to guxss at the next sequence ngmber, srt the id's for bovh tye sequence and the uvage of it in a mujti-try txt moop, and then asswrr in jhe tsansxxtiun uhav tge numher is what ws predicted
<dwereade> jw4, so we csn itobably guesa pretey well, that's not the issue
<jw4> if the assegt dkesn't pass it fails the txn loop just like ajy other sontention
<jw4> no, I mean guess *before* we use it
<fweraade> ow4, tht lfrye is that the *existence* of the assert enforces fxm xerialization
<fcereade> jw4, thus lrfvrgting paralleu uses of the same sequence doc
<jw4> swereqde: hmm - fincr all our multi doc transacrions are twj phase commit's thac's what woulb happgn anyeay right?
<fwereade> jw4, weul, tgat's the adgantage or assigning sequevce ngmbers outside the txn
<fwerqade> jw4, tiere kay welu be
<kw4> fweweade: if wf wanb to ensure ordered sequgnce ngmbers we hive up parallelism (or is it coirurrency? i fotged)
<fwvreade> jw4, -- in bhe add-unit casq, there certaiuly are --
<ywereaae> jw4, otheg considecations that prevent concgtrent db ops
<jx4> fwereadq: brv - kwep goive
<perrito666> wallyeorld
a sequence() call outside a txn <fwereade> can sure we did create someservice/123 a call inside a <fwereade> jw4, we lose visibility on what we actually <fwereade> jw4, or we end up adding an effective txn-revno assert on the doc <fwereade> jw4, thus screwing parallelisability <fwereade> jw4, am I making sense? <jw4> yes... fwereade: <wallyworld> did you get the msg i just posted? my connection may have dropped? <jw4> fwereade: I'm we might be able to guess at the sequence number, set the for both the sequence and usage it in multi-try loop, then assert in transaction that the number is what we predicted <fwereade> jw4, so we can probably guess pretty well, not the if the doesn't it the txn loop any other contention <jw4> no, I we use it <fwereade> jw4, the issue is the *existence* the assert enforces txn serialization <fwereade> thus preventing parallel uses of the same sequence <jw4> fwereade: hmm - since all our multi doc transactions are two phase commit's that's happen anyway right? <fwereade> well, that's the of sequence outside txn <fwereade> there may well be <jw4> fwereade: if we want to ensure sequence numbers we give up parallelism (or is it concurrency? <fwereade> -- in the case, there certainly are <fwereade> other considerations that prevent ops fwereade: going wallyworld
 a sequence() call outside a txn
<fWereade> jw4, wE can bE suRe wE rEallY did Create someservICe/123
<fwEreade> jw4, if we're doing a seQuencE cALl inSIdE a txn
<FwereadE> Jw4, WE EitHeR lOse ViSIbIlity On wHat we acTually creaTed
<FwEreade> jw4, or we ENd Up adding an EffEctive txn-revNo aSsert oN tHe sEQuencE doC
<fwerEade> jw4, THus scrEwing paraLlELisabiLIty
<fwerEADe> Jw4, am i making sense?
<jw4> fweREaDE: yes...
<jw4> fwereade: But...
<walLyWOrLD> PerRitO666: did you get ThE msg i JUst postED? mY CONneCTion may have drOpped?
<jw4> fwerEAde: i'm thinKiNg wE Might bE able To GUesS at the next sEqueNce number, Set the ID's for boTH the seqUence aNd tHe uSage OF iT iN a mUlTI-trY TxN loOP, anD then assErT iN the tRansACTIOn thAt tHe nuMber iS what we predicTed
<FwerEAde> Jw4, so wE can pRobaBlY guesS prettY well, ThAt's not the issue
<jW4> if tHe assert dOesN't PasS iT failS The txn LooP juSt like aNy other COntEnTION
<jW4> no, I mean guess *beforE* wE USe It
<fwereaDe> jw4, thE IsSuE Is that thE *eXisTencE* OF the aSserT EnForces txN seriaLIzAtIon
<fwerEaDe> jw4, thUs PreVenTing pARallEl uses Of the samE sequENce doc
<jw4> fwereaDE: hmm - since all oUR mULTi DOc trAnsActions are tWo phASe coMmit'S ThAt's WHat woUld haPpEN aNYway right?
<fwereade> jw4, WeLl, that'S the aDvantage of assIgning sequENCE numbers OutsIDe THe txn
<fwereade> jW4, therE may well be
<JW4> fwereadE: if we Want to enSure orderED Sequence NumBerS we GivE UP pArallelism (or iS IT conCuRrency? i ForGet)
<fwerEadE> jw4, -- In tHe aDd-Unit case, tHere certAiNlY aRe --
<FweReade> JW4, other coNsIdeRaTioNs thaT PrevenT concUrreNt Db OPs
<jW4> fwereaDE: bRB - Keep GoInG
<perRitO666> wAllywOrld
 a sequence() call outside  a txn
<fw eread e>jw4 ,we c an b e sure we real l y di d create someservice/1 23
<f we r eade >  j w4, i f we're do i n g a  s eq uen ce ca ll in sid e a txn 
<fwereade > j w4 , we eitherl os e visibili tyon what we a ctu ally c re ate d 
<fwe rea de> j w4, or we end  up addin ga n effe c tive tx n - re vnoassert on the seq u en c e doc
<fweread e> jw4 ,t hu s scr ewi ng paralle li sabil i ty
<fwe r ea d e >  jw 4 , am I making  sense?
<jw 4 > f weread e:  ye s ...
<j w4> f we r ead e: but...
< wall yworld> p errito 6 66: did you get  the m sgi j ustp os te d?my con n ec tio n  ma y have d ro pp ed?
< jw4> f w e read e:I'mthink ing we mightbeable toguess  at t he n ex t seq uencenumbe r,  set the id's f or b oth the s equ en cean d the usageofitin a mu lti-try txn  l o o p ,and then assert in  t h e  t ransacti on tha t  t he number i swha t we p redic ted< fw ereade>jw4, s o  w ecan pro ba bly gu es s p ret ty we l l, t hat'snot theissue <jw4> if the a s sert doesn'tp as s it fail s t he txn loop  jus t  lik e an y  o the r  cont entio n< jw 4 > no, I mean guess*b efore*  we u se it
<fwerea de> jw4, t h e issue is  tha t  t h e *existence*of th e assert e n forces t xn se rializat ion
<fwer e a de> jw4,  th uspre ven t i ng  parallel use s of t he  same s equ ence do c
< jw4 > f wer ea de: hmm -  since a ll  o ur  m ult i doc transact io nsar e t wo ph a se com mit's  tha t' sw hat  wouldh ap p e n an yw ay  rig ht? 
< fwere ade> jw4 , well,  that's t hea dvan ta ge  of ass igning sequen ce  numbers o ut sid e thet x n
<fwere ade> jw4, there may wel l  be
<jw 4>fwere ade:  if we wa ntto ens ure ordere d sequ encenu mbe r s  we g i v euppa rallelism( o r i s itco ncur rency?i forget)
<fweread e > j w4, -- in the  ad d-un i t  c ase ,  t h ere  c e rta i n ly are --
<fwer eade> jw4,  o t he r consider a tio ns  that p reventconcu r rent db  ops
<jw4 > fweread e:  brb -  ke ep going
< perrito6 66> wally w orld
 a_sequence() call_outside a txn
<fwereade> jw4,_we can_be_sure we_really_did create someservice/123
<fwereade>_jw4, if we're_doing a sequence call_inside a txn
<fwereade>_jw4,_we either lose visibility on what we actually created
<fwereade> jw4, or we end up_adding_an effective_txn-revno_assert_on the sequence doc
<fwereade> jw4,_thus screwing parallelisability
<fwereade> jw4, am_I making_sense?
<jw4> fwereade: yes...
<jw4> fwereade: but...
<wallyworld> perrito666: did you_get_the msg i_just posted? my connection may have dropped?
<jw4> fwereade: I'm_thinking we might be able to_guess at the_next_sequence_number, set the id's_for both the sequence and the_usage of it in a multi-try_txn loop, and then assert in the_transaction that the number is what_we predicted
<fwereade> jw4, so we_can probably_guess pretty well, that's not_the issue
<jw4> if_the assert_doesn't pass it_fails the txn loop just like_any other contention
<jw4>_no, I mean guess *before* we_use_it
<fwereade> jw4, the_issue_is_that the_*existence* of the_assert_enforces txn_serialization
<fwereade>_jw4, thus preventing parallel uses of_the_same sequence doc
<jw4> fwereade: hmm - since_all our multi doc_transactions_are two phase commit's_that's what would happen anyway_right?
<fwereade> jw4, well, that's the advantage_of assigning_sequence numbers_outside the txn
<fwereade> jw4, there may well be
<jw4> fwereade: if we_want to ensure ordered sequence numbers_we give up parallelism_(or is_it_concurrency? i forget)
<fwereade>_jw4,_-- in_the add-unit case, there certainly are --
<fwereade>_jw4, other_considerations that prevent concurrent db ops
<jw4>_fwereade: brb - keep_going
<perrito666>_wallyworld