Mailing-List: contact user-help@cassandra.apache.org; run by ezmlm
Precedence: bulk
Reply-To: user@cassandra.apache.org
Received-SPF: pass (nike.apache.org: domain of sylvain@datastax.com designates
 209.85.160.43 as permitted sender)
MIME-Version: 1.0
In-Reply-To: <8D1BD6A2-D023-4179-8B7C-7B7BBC1D77C8@expedia.com>
References: <8D1BD6A2-D023-4179-8B7C-7B7BBC1D77C8@expedia.com>
Date: Wed, 5 Mar 2014 11:03:07 +0100
Message-ID: 
 <CAKkz8Q1ujSNOXfLL69ecy-ARQr9dWwemz=f5yg+i_Kmv0WEFtQ@mail.gmail.com>
Subject: Re: Question regarding java DowngradingConsistencyRetryPolicy
From: Sylvain Lebresne <sylvain@datastax.com>
To: "user@cassandra.apache.org" <user@cassandra.apache.org>
Content-Type: multipart/alternative; boundary=047d7b5d3610a1927604f3d9206b

--047d7b5d3610a1927604f3d9206b
Content-Type: text/plain; charset=ISO-8859-1

Let me first note that the DataStax Java driver has a dedicated mailing
list:
https://groups.google.com/a/lists.datastax.com/forum/#!forum/java-driver-user,
it would better to use that list for driver specific questions in the
future.

But to answer your question, a SIMPLE write is any write (INSERT, UPDATE,
DELETE) that is not in a batch. Concretely, if you do:
  session.execute("INSERT INTO ...");
it's a SIMPLE write.

--
Sylvain


On Tue, Mar 4, 2014 at 7:21 PM, HAITHEM JARRAYA <a-hjarraya@expedia.com>wrote:

> Hi All,
>
> I might be missing something and I would like some clarification on this.
> We are using the java driver with the Downgrading Retry policy, we see in
> our logs that are only the reads are retried.
>
> In the code and the docs, it says that the write method will retry a
> maximum of one retry, when the WriteType is UNLOGGED_BATCH or BATCH_LOG.
> My question is, when a write is considered as SIMPLE?
>
> Thanks,
>
> Haithem
>
>     /**
>      * Defines whether to retry and at which consistency level on a write
> timeout.
>      * <p>
>      * This method triggers a maximum of one retry. If {@code writeType ==
>      * WriteType.BATCH_LOG}, the write is retried with the initial
>      * consistency level. If {@code writeType == WriteType.UNLOGGED_BATCH}
>      * and at least one replica acknowledged, the write is retried with a
>      * lower consistency level (with unlogged batch, a write timeout can
>      * <b>always</b> mean that part of the batch haven't been persisted at
>      * all, even if {@code receivedAcks > 0}). For other {@code writeType},
>      * if we know the write has been persisted on at least one replica, we
>      * ignore the exception. Otherwise, an exception is thrown.
>      *
>      * @param statement the original query that timed out.
>      * @param cl the original consistency level of the write that timed
> out.
>      * @param writeType the type of the write that timed out.
>      * @param requiredAcks the number of acknowledgments that were
> required to
>      * achieve the requested consistency level.
>      * @param receivedAcks the number of acknowledgments that had been
> received
>      * by the time the timeout exception was raised.
>      * @param nbRetry the number of retry already performed for this
> operation.
>      * @return a RetryDecision as defined above.
>      */
>     @Override
>     public RetryDecision onWriteTimeout(Statement statement,
> ConsistencyLevel cl, WriteType writeType, int requiredAcks, int
> receivedAcks, int nbRetry) {
>         if (nbRetry != 0)
>             return RetryDecision.rethrow();
>
>         switch (writeType) {
>             case SIMPLE:
>             case BATCH:
>                 // Since we provide atomicity there is no point in retrying
>                 return RetryDecision.ignore();
>             case UNLOGGED_BATCH:
>                 // Since only part of the batch could have been persisted,
>                 // retry with whatever consistency should allow to persist
> all
>                 return maxLikelyToWorkCL(receivedAcks);
>             case BATCH_LOG:
>                 return RetryDecision.retry(cl);
>         }
>         // We want to rethrow on COUNTER and CAS, because in those case
> "we don't know" and don't want to guess
>         return RetryDecision.rethrow();
>     }
>
>
>

--047d7b5d3610a1927604f3d9206b
Content-Type: text/html; charset=ISO-8859-1
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr">Let me first note that the DataStax Java driver has a dedi=
cated mailing list:=A0<a href=3D"https://groups.google.com/a/lists.datastax=
.com/forum/#!forum/java-driver-user">https://groups.google.com/a/lists.data=
stax.com/forum/#!forum/java-driver-user</a>, it would better to use that li=
st for driver specific questions in the future.<div>
<br></div><div>But to answer your question, a SIMPLE write is any write (IN=
SERT, UPDATE, DELETE) that is not in a batch. Concretely, if you do:</div><=
div>=A0 session.execute(&quot;INSERT INTO ...&quot;);</div><div>it&#39;s a =
SIMPLE write.</div>
<div><br></div><div>--</div><div>Sylvain</div></div><div class=3D"gmail_ext=
ra"><br><br><div class=3D"gmail_quote">On Tue, Mar 4, 2014 at 7:21 PM, HAIT=
HEM JARRAYA <span dir=3D"ltr">&lt;<a href=3D"mailto:a-hjarraya@expedia.com"=
 target=3D"_blank">a-hjarraya@expedia.com</a>&gt;</span> wrote:<br>
<blockquote class=3D"gmail_quote" style=3D"margin:0 0 0 .8ex;border-left:1p=
x #ccc solid;padding-left:1ex">Hi All,<br>
<br>
I might be missing something and I would like some clarification on this. W=
e are using the java driver with the Downgrading Retry policy, we see in ou=
r logs that are only the reads are retried.<br>
<br>
In the code and the docs, it says that the write method will retry a maximu=
m of one retry, when the WriteType is UNLOGGED_BATCH or BATCH_LOG.<br>
My question is, when a write is considered as SIMPLE?<br>
<br>
Thanks,<br>
<br>
Haithem<br>
<br>
=A0 =A0 /**<br>
=A0 =A0 =A0* Defines whether to retry and at which consistency level on a w=
rite timeout.<br>
=A0 =A0 =A0* &lt;p&gt;<br>
=A0 =A0 =A0* This method triggers a maximum of one retry. If {@code writeTy=
pe =3D=3D<br>
=A0 =A0 =A0* WriteType.BATCH_LOG}, the write is retried with the initial<br=
>
=A0 =A0 =A0* consistency level. If {@code writeType =3D=3D WriteType.UNLOGG=
ED_BATCH}<br>
=A0 =A0 =A0* and at least one replica acknowledged, the write is retried wi=
th a<br>
=A0 =A0 =A0* lower consistency level (with unlogged batch, a write timeout =
can<br>
=A0 =A0 =A0* &lt;b&gt;always&lt;/b&gt; mean that part of the batch haven=
9;t been persisted at<br>
=A0 =A0 =A0* all, even if {@code receivedAcks &gt; 0}). For other {@code wr=
iteType},<br>
=A0 =A0 =A0* if we know the write has been persisted on at least one replic=
a, we<br>
=A0 =A0 =A0* ignore the exception. Otherwise, an exception is thrown.<br>
=A0 =A0 =A0*<br>
=A0 =A0 =A0* @param statement the original query that timed out.<br>
=A0 =A0 =A0* @param cl the original consistency level of the write that tim=
ed out.<br>
=A0 =A0 =A0* @param writeType the type of the write that timed out.<br>
=A0 =A0 =A0* @param requiredAcks the number of acknowledgments that were re=
quired to<br>
=A0 =A0 =A0* achieve the requested consistency level.<br>
=A0 =A0 =A0* @param receivedAcks the number of acknowledgments that had bee=
n received<br>
=A0 =A0 =A0* by the time the timeout exception was raised.<br>
=A0 =A0 =A0* @param nbRetry the number of retry already performed for this =
operation.<br>
=A0 =A0 =A0* @return a RetryDecision as defined above.<br>
=A0 =A0 =A0*/<br>
=A0 =A0 @Override<br>
=A0 =A0 public RetryDecision onWriteTimeout(Statement statement, Consistenc=
yLevel cl, WriteType writeType, int requiredAcks, int receivedAcks, int nbR=
etry) {<br>
=A0 =A0 =A0 =A0 if (nbRetry !=3D 0)<br>
=A0 =A0 =A0 =A0 =A0 =A0 return RetryDecision.rethrow();<br>
<br>
=A0 =A0 =A0 =A0 switch (writeType) {<br>
=A0 =A0 =A0 =A0 =A0 =A0 case SIMPLE:<br>
=A0 =A0 =A0 =A0 =A0 =A0 case BATCH:<br>
=A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 // Since we provide atomicity there is no p=
oint in retrying<br>
=A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 return RetryDecision.ignore();<br>
=A0 =A0 =A0 =A0 =A0 =A0 case UNLOGGED_BATCH:<br>
=A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 // Since only part of the batch could have =
been persisted,<br>
=A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 // retry with whatever consistency should a=
llow to persist all<br>
=A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 return maxLikelyToWorkCL(receivedAcks);<br>
=A0 =A0 =A0 =A0 =A0 =A0 case BATCH_LOG:<br>
=A0 =A0 =A0 =A0 =A0 =A0 =A0 =A0 return RetryDecision.retry(cl);<br>
=A0 =A0 =A0 =A0 }<br>
=A0 =A0 =A0 =A0 // We want to rethrow on COUNTER and CAS, because in those =
case &quot;we don&#39;t know&quot; and don&#39;t want to guess<br>
=A0 =A0 =A0 =A0 return RetryDecision.rethrow();<br>
=A0 =A0 }<br>
<br>
<br>
</blockquote></div><br></div>

--047d7b5d3610a1927604f3d9206b--