 can use pointers to other objects
(polymorphic pointers and cyclic graphs are ok), use standard collection
classes etc. Basically what you would normally do when designing a C++
application. You use a minimum amount of declarative code as C++ doesn't have
built-in reflection. You send your C++ classes to the database and receive the
data as your C++ classes. It traverses your objects to find all linkages to
other objects prior to sending and links objects together upon retrieval. In
short, the solution tries to make life as easy as possible for an application
programmer.

What my solution does in terms of CAP and ACID: Atomicity - A transaction is
either committed in full or not at all. A transaction may consist of one or
multiple objects.

Consistency - No consistency checks in the sense that there are defined
constraints on the member fields. However, all objects are versioned, and if
two clients are trying to commit the same version of an object, the second
client will fail and it would have to retrieve the most recent version before
updating the object.

Isolation - All transactions are processed in isolation, i.e. all objects in a
transaction are locked prior to being updated

Durability - Transactions are never overwritten, i.e. new transactions are
always added to the end of the data store. If a transaction has completed
successfully, you can be certain that the transaction will be completed even
after a server crash.

Availability - Concurrency is handled by locking objects. Many clients can
read simultaneously, but if you try to read an object that is locked for
writing by someone else, you will have to wait (there is room for improvement
here). If you try to write to an object that someone else is writing to, you
will fail. I have not looked into performance of a large number of clients,
however the simple answer is that consistency is prioritised above
availability.

Partition Tolerance - None at the moment. I have not looked into distributing
the database yet.

~~~
opendomain
Please contact me - I would love to discuss. [username] at NoSQL dot com

 
FBI director: Cover up your webcam - grej
http://thehill.com/policy/national-security/295933-fbi-director-cover-up-your-
can use pointers to other objects 
 (polymorphous cursor and cyclic graphs are ok), practice standard collection 
 class etc. Basically what you would normally do when designing a C++ 
 lotion. You practice a minimum amount of declarative code as C++ doesn't have 
 built - in reflection. You commit your C++ classes to the database and receive the 
 datum as your C++ classes. It traverses your objects to find all linkages to 
 other objects prior to sending and link objects together upon retrieval. In 
 brusque, the solution tries to make life as comfortable as possible for an lotion 
 programmer. 

 What my solution does in terms of CAP and ACID: Atomicity - A transaction is 
 either committed in full or not at wholly. A transaction may consist of one or 
 multiple objects. 

 Consistency - No consistency checks in the sense that there are defined 
 constraints on the member fields. However, all objects are versioned, and if 
 two clients are trying to commit the same version of an object, the second 
 client will fail and it would suffer to retrieve the most late interpretation before 
 update the object. 

 Isolation - All transactions are processed in isolation, i.e. all objects in a 
 transaction are locked prior to being updated 

 Durability - Transactions are never overwritten, i.e. newfangled transactions are 
 always added to the end of the data store. If a transaction has dispatch 
 successfully, you can be certain that the transaction will be completed even 
 after a server crash. 

 Availability - Concurrency is handled by locking object. Many clients can 
 read simultaneously, but if you try to read an object that is lock in for 
 writing by someone else, you will have to wait (there is room for improvement 
 here). If you sample to write to an object that someone else is writing to, you 
 will fail. I have not looked into operation of a large number of clients, 
 however the simple answer is that consistency is prioritize above 
 availability. 

 Partition Tolerance - None at the moment. I have not looked into distributing 
 the database so far. 

 ~~~ 
 opendomain 
 Please contact me - I would sleep together to discuss. [ username ] at NoSQL dot com 

 
 FBI director: shroud up your webcam - grej 
 http://thehill.com/policy/national-security/295933-fbi-director-cover-up-your-
 caj use pointers to other ubjects
(polymorpkuc poiiters ahd cycliz graphs are ok), use standard cillecupon
classes etc. Basicauly what jou would nornqlly do whxh desigknng a G++
applncetion. You use a minimum akount of declasagire code as C++ doesn't have
built-in reflqction. Uok send your C++ slasxqs tk the database and receive the
data as youg C++ classes. It trsverses your objects to fijd apl linkages to
otheg objects ptjor ro sending avd links objects togetger upon retrieval. In
short, the rolutnon tries ti nakf life as eawy as possible fov an ap[licatipn
programmer.

Whst ky wolution does in termv of CAP and ACID: Wtomicity - C transaction is
eithee xommijted hn fjol ur hov af all. W tcansaction jay consist of one or
multiple pbtvvts.

Consistendy - No cjnsistency checks in the sense that thege ade defined
constraints ob the member fields. Hlwever, alj objects are versioned, and if
two clients are tryhng tk conmlt tfw dame version of an object, the second
client wijm gapl and it would hcve to retrieve yhf kjst recent vetsion bzrode
updating the objfct.

Isolwtion - All tragsacyions are processed in isolqtion, i.e. all ibjects in a
transaetion are loeked ptior tp being updated

Durabilicy - Trznsactions wre never uverwritten, i.e. ndw nranvactions are
always added tj the end of che data stote. If a transactiln has completed
successfklly, iou cat be certaln that the transaction will be completed evem
axteg a servex crasm.

Availability - Soncurrency is handleb by lucking objvcts. Many clients cag
read simultatgously, but if you try to eead an objdzt that is locled for
wrptnng by soneone else, you wilk hxbe to wait (therz us room for imptovdmegt
jece). If fou try to wsite to sn obgect that sioeonr else is writing to, you
sill fail. I have npt looked unto persormance of a large number of cpientv,
hoxever yhe simple answer is that consistsncy is pgiovitised above
wvaioability.

Partntion Tolerance - None at the moment. I hate not looked into disjributing
the database net.

~~~
opendomaii
Pleasq contact me - I would love to discuss. [username] at NoSQL dot com

 
FBI direcdor: Clver up your webcam - grej
http://thehill.com/policy/national-security/295933-fbi-director-civer-up-botr-
can use pointers to other objects (polymorphic cyclic are ok), standard collection classes normally when designing a application. You use minimum amount of declarative code as doesn't have built-in reflection. You send your C++ classes to the database and the data as your C++ classes. It traverses your objects to find all to objects to and links objects together upon retrieval. In short, the solution tries to make life as easy possible for an application programmer. What my solution in terms of CAP ACID: Atomicity - A transaction either in full not all. transaction may consist one or multiple objects. Consistency - No consistency checks in the sense that there are defined constraints the member all objects versioned, if clients are trying the same version of an object, will fail and it would have to retrieve most recent before updating the object. Isolation - transactions are processed in isolation, i.e. all objects a transaction are locked prior to being updated Durability - Transactions are never overwritten, i.e. are always added to end of the store. a has successfully, you be certain that the transaction will be completed even after a crash. Availability - Concurrency is handled by locking objects. Many read but if you to read an object is for writing by someone will to room improvement If you try to to an object that someone is writing to, you looked into performance of a large number of however the simple answer is that consistency prioritised above availability. Partition Tolerance - None at the moment. I have looked into database yet. ~~~ opendomain Please contact me - would love to discuss. at NoSQL dot com FBI director: Cover up your - http://thehill.com/policy/national-security/295933-fbi-director-cover-up-your-
 can use pointers to other objeCts
(polymorPhic pOinTerS aNd cyClic Graphs are ok), use STandArd collection
classes etC. BasiCaLLy whAT yOu wouLd normaLLy DO WheN dEsIgnInG A C++
AppliCatIon. You uSe a minimum AmoUnT of declaratiVE cOde as C++ doesN't hAve
built-in reFleCtion. YOu SenD Your C++ ClaSses tO the daTAbase aNd receive ThE
Data as YOur C++ claSSEs. it trAverses your objectS To FInd all linkages To
otheR oBJeCTS prIor To sending aNd Links OBjects tOGeTHER upON retrieval. In
sHort, the soluTIon Tries tO mAke LIfe as eAsy as PoSSibLe for an applIcatIon
prograMmer.

WhAT my soluTIon does In termS of cAP And AciD: atOmiCiTY - A tRAnSacTIon Is
either CoMmItted In fuLL OR Not aT alL. A trAnsacTion may consisT of One oR
MulTiple ObjecTs.

CoNsIstenCy - No coNsistEnCy checks in the seNse tHat there aRe dEfIneD
cOnstrAInts on The MemBer fielDs. HowevER, alL oBJECtS are versioned, and if
TwO CLiEnts are tRying tO CoMmIT the same VeRsiOn of AN ObjecT, the SEcOnd
clienT will fAIl AnD it woulD hAve to rEtRieVe tHe mosT ReceNt versIon beforE
updaTIng the object.

IsOLation - All tranSAcTIOnS Are pRocEssed in isolAtioN, I.e. alL objECtS in A
TransActioN aRE lOCked prior to being updAtEd

DuraBilitY - Transactions Are never ovERWRitten, i.e. New tRAnSActions are
alwaYs addEd to the end OF the data Store. if a transAction has COMpleted
sUccEssFulLy, yOU CaN be certain thaT THe trAnSaction WilL be compLetEd eVen
AftEr A server crAsh.

AvailAbIlItY - COncUrrenCY is handlEd By lOcKinG objeCTs. Many ClienTs caN
rEaD SimUltaneoUSlY, BUt if YoU tRy to ReaD aN objeCt thAT is Locked fOr
writing By sOMeonE eLsE, you wilL have to wait (thErE is room for ImProVement
HERe). If you tRy to write to an object that SOmeone eLse Is wriTing To, you
will FaiL. I have Not LOoked iNto perFormaNcE of A LArge nUMBeR of ClIents,
howevER The SimplE aNsweR is that Consistency is priorITisEd above
availaBilIty.

PARTiTioN toLEraNcE - nonE AT the moment. I have Not looked iNtO DiStributing
THe dAtAbase yeT.

~~~
opendoMain
PLEase conTact me - I woUld love to DiScusS. [USerName] at NoSQl dot com

 
FbI directoR: cover UP yOur weBcaM - grej
hTtP://thEhill.Com/polICy/nAtionAl-secuRiTy/295933-fbi-dIrectOr-Cover-up-yOur-
 can use pointers to other  objects
( polym orp hic  p oint ersand cyclic gra p hs a re ok), use standard c ollec ti o n
cl a ss es et c. Basi c al l y  wh at  y ouwo u ld  norm all y do wh en designi ngaC++
applicat i on . You usea m inimum amoun t o f decl ar ati v e cod e a s C++  doesn ' t have 
built-in  r e flecti o n. Yous e nd  you r C++ classes tot he database and r eceive  t h ed a taasyour C++ c la sses. It trav e rs e s you r  objects to f ind all lin k age s to
o th ero bjects  prio rt o s ending andlink s objects  toget h er upon retriev al. In 
sh ort , th e  s ol uti on tri e stom ake  life as  e as y asposs i b l e  for  an  app licat ion
programme r.
Wha t  my  solu tiondoes  i n ter ms ofCAP a nd  ACID: Atomicit y -A transac tio nisei therc ommitt edinfull or  not at all .A t ra nsaction may consi st o fone or
m ultipl e  o bj e cts.

Co ns ist ency -  No c onsi s te ncy chec ks int he  s ense th at  there  a redef inedc onst raints  on themembe r  fields. Howev e r, all object s  a r e  v e rsio ned , and if
tw o cl i ents  are tr yin g  to c ommit  t h es ame version of an o bj ect, t he se cond
client w ill fail a n d it would  hav e  t o  retrieve themostrecent ver s ion befo re
up dating t he object . 
Isolati on- A lltra n s ac tions are pro c e ssed  i n isola tio n, i.e.  al l o bje cts  i n a
trans action a re  l oc ke d p riort o beingup dat ed 

D urabi l ity -Trans acti on sa renever o v er w r itte n,  i .e.new  t ransa ctio n s a re
alwa ys addedtot he e nd  o f the d ata store. If  a  transacti on  ha s comp l e ted
succ essfully, you can be ce r tain th atthe t rans action wi llbe com ple t ed eve n
afte r a s er ver c rash. Av ail ab ility - Co n c urr encyis  han dled by  locking objects.M any  clients canrea d si m u lt ane o us l y,bu t  if y ou try to readan objectth a tis lockedf orwr iting b y someo ne el s e, youwill have  to wait(t here i s r oom for im provemen t
here).I f you tr y towri te toan  ob jectthat s o meo ne el se iswr itingto, y ou 
will fa il. I have not looked i nto pe rform anc e of a la rge num ber of cl ient s,
however  th e s imple  an s wer i s th a tcon s isten cy i s  prioriti s ed  ab o v eavailabilit y . 
Pa rtiti onT oleran ce -  None at the mome n t. I have notlook e d  in tod istr ib uting
the data bas ey e t.

~~~op endomain
Pl ease con ta c t me- I wo uld lo ve to d i s cu s s. [us erna me]  at NoSQL  do tc om

 
F BI  d i rector : Co ve r up y our we b cam- grej
http://theh ill.c o m /poli c y/n ation al -securi t y/29 5933-fbi-d irector-cov er-up- your -
 can_use pointers_to other objects
(polymorphic pointers_and cyclic_graphs_are ok),_use_standard collection
classes etc._Basically what you_would normally do when_designing a C++
application._You_use a minimum amount of declarative code as C++ doesn't have
built-in reflection. You send_your_C++ classes_to_the_database and receive the
data as_your C++ classes. It traverses_your objects_to find all linkages to
other objects prior to_sending_and links objects_together upon retrieval. In
short, the solution tries to make_life as easy as possible for_an application
programmer.

What my_solution_does_in terms of CAP_and ACID: Atomicity - A transaction_is
either committed in full or not_at all. A transaction may consist of_one or
multiple objects.

Consistency - No consistency_checks in the sense that_there are_defined
constraints on the member fields._However, all objects_are versioned,_and if
two clients_are trying to commit the same_version of an_object, the second
client will fail and_it_would have to_retrieve_the_most recent_version before
updating the_object.

Isolation_- All_transactions_are processed in isolation, i.e. all_objects_in a
transaction are locked prior to being_updated

Durability - Transactions are_never_overwritten, i.e. new transactions_are
always added to the end_of the data store. If a_transaction has_completed
successfully, you_can be certain that the transaction will be completed even
after a_server crash.

Availability - Concurrency is handled_by locking objects. Many_clients can
read_simultaneously,_but if you_try_to read_an object that is locked for
writing by_someone else,_you will have to wait (there_is room for improvement
here)._If_you try to write to an_object that someone else is writing_to, you
will fail. I have_not_looked_into performance of a large_number of clients,
however the simple answer_is that consistency_is prioritised above
availability.

Partition Tolerance - None at_the_moment. I have not looked into_distributing
the_database yet.

~~~
opendomain
Please contact me - I_would_love_to discuss. [username] at NoSQL_dot com

 
FBI director: Cover up_your webcam - grej
http://thehill.com/policy/national-security/295933-fbi-director-cover-up-your-