[jira] [Commented] (CASSANDRA-12829) DELETE query with an empty IN clause can delete more than expected
[
https://issues.apache.org/jira/browse/CASSANDRA-12829?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=15751913#comment-15751913
]
Benjamin Lerer commented on CASSANDRA-12829:
Thanks for the patch.
Committed into 3.0 at 9fc1ffb631a5a44bc11b55061288758e39a9d20a and merged into,
3.11, 3.X and trunk
> DELETE query with an empty IN clause can delete more than expected
> --
>
> Key: CASSANDRA-12829
> URL: https://issues.apache.org/jira/browse/CASSANDRA-12829
> Project: Cassandra
> Issue Type: Bug
> Components: CQL
> Environment: Arch Linux x64, kernel 4.7.6, Cassandra 3.9 downloaded
> from the website
>Reporter: Jason T. Bradshaw
>Assignee: Alex Petrov
>
> When deleting from a table with a certain structure and using an *in* clause
> with an empty list, the *in* clause with an empty list can be ignored,
> resulting in deleting more than is expected.
> *Setup:*
> {code}
> cqlsh> create table test (a text, b text, id uuid, primary key ((a, b), id));
> cqlsh> insert into test (a, b, id) values ('a', 'b',
> ----);
> cqlsh> insert into test (a, b, id) values ('b', 'c',
> ----);
> cqlsh> insert into test (a, b, id) values ('a', 'c',
> ----);
> cqlsh> select * from test;
> a | b | id
> ---+---+--
> a | c | ----
> b | c | ----
> a | b | ----
> (3 rows)
> {code}
> *Expected:*
> {code}
> cqlsh> delete from test where a = 'a' and b in ('a', 'b', 'c') and id in ();
> cqlsh> select * from test;
> a | b | id
> ---+---+--
> a | c | ----
> b | c | ----
> a | b | ----
> (3 rows)
> {code}
> *Actual:*
> {code}
> cqlsh> delete from test where a = 'a' and b in ('a', 'b', 'c') and id in ();
> cqlsh> select * from test;
> a | b | id
> ---+---+--
> b | c | ----
> (1 rows)
> {code}
> Instead of deleting nothing, as the final empty *in* clause would imply, it
> instead deletes everything that matches the first two clauses, acting as if
> the following query had been issued instead:
> {code}
> cqlsh> delete from test where a = 'a' and b in ('a', 'b', 'c');
> {code}
> This seems to be related to the presence of a tuple clustering key, as I
> could not reproduce it without one.
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
[jira] [Commented] (CASSANDRA-12829) DELETE query with an empty IN clause can delete more than expected
[
https://issues.apache.org/jira/browse/CASSANDRA-12829?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=15751847#comment-15751847
]
Benjamin Lerer commented on CASSANDRA-12829:
+1
> DELETE query with an empty IN clause can delete more than expected
> --
>
> Key: CASSANDRA-12829
> URL: https://issues.apache.org/jira/browse/CASSANDRA-12829
> Project: Cassandra
> Issue Type: Bug
> Components: CQL
> Environment: Arch Linux x64, kernel 4.7.6, Cassandra 3.9 downloaded
> from the website
>Reporter: Jason T. Bradshaw
>Assignee: Alex Petrov
>
> When deleting from a table with a certain structure and using an *in* clause
> with an empty list, the *in* clause with an empty list can be ignored,
> resulting in deleting more than is expected.
> *Setup:*
> {code}
> cqlsh> create table test (a text, b text, id uuid, primary key ((a, b), id));
> cqlsh> insert into test (a, b, id) values ('a', 'b',
> ----);
> cqlsh> insert into test (a, b, id) values ('b', 'c',
> ----);
> cqlsh> insert into test (a, b, id) values ('a', 'c',
> ----);
> cqlsh> select * from test;
> a | b | id
> ---+---+--
> a | c | ----
> b | c | ----
> a | b | ----
> (3 rows)
> {code}
> *Expected:*
> {code}
> cqlsh> delete from test where a = 'a' and b in ('a', 'b', 'c') and id in ();
> cqlsh> select * from test;
> a | b | id
> ---+---+--
> a | c | ----
> b | c | ----
> a | b | ----
> (3 rows)
> {code}
> *Actual:*
> {code}
> cqlsh> delete from test where a = 'a' and b in ('a', 'b', 'c') and id in ();
> cqlsh> select * from test;
> a | b | id
> ---+---+--
> b | c | ----
> (1 rows)
> {code}
> Instead of deleting nothing, as the final empty *in* clause would imply, it
> instead deletes everything that matches the first two clauses, acting as if
> the following query had been issued instead:
> {code}
> cqlsh> delete from test where a = 'a' and b in ('a', 'b', 'c');
> {code}
> This seems to be related to the presence of a tuple clustering key, as I
> could not reproduce it without one.
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
[jira] [Commented] (CASSANDRA-12829) DELETE query with an empty IN clause can delete more than expected
[
https://issues.apache.org/jira/browse/CASSANDRA-12829?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=15722593#comment-15722593
]
Alex Petrov commented on CASSANDRA-12829:
-
I've simplified the code as you suggested and fixed the inconsistency with
{{IN}}, it was related to the
fact we were only checking for {{> 1}} clustering. I've found same problem with
batch statements and for
partition keys and fixed it there, too. Tests are refactored as well.
|[3.0|https://github.com/ifesdjeen/cassandra/tree/12829-3.0]|[dtest|http://cassci.datastax.com/job/ifesdjeen-12829-3.0-dtest/]|[utest|http://cassci.datastax.com/job/ifesdjeen-12829-3.0-testall/]|
|[3.x|https://github.com/ifesdjeen/cassandra/tree/12829-3.x]|[dtest|http://cassci.datastax.com/job/ifesdjeen-12829-3.x-dtest/]|[utest|http://cassci.datastax.com/job/ifesdjeen-12829-3.x-testall/]|
|[trunk|https://github.com/ifesdjeen/cassandra/tree/12829-trunk]|[dtest|http://cassci.datastax.com/job/ifesdjeen-12829-trunk-dtest/]|[utest|http://cassci.datastax.com/job/ifesdjeen-12829-trunk-testall/]|
> DELETE query with an empty IN clause can delete more than expected
> --
>
> Key: CASSANDRA-12829
> URL: https://issues.apache.org/jira/browse/CASSANDRA-12829
> Project: Cassandra
> Issue Type: Bug
> Components: CQL
> Environment: Arch Linux x64, kernel 4.7.6, Cassandra 3.9 downloaded
> from the website
>Reporter: Jason T. Bradshaw
>Assignee: Alex Petrov
>
> When deleting from a table with a certain structure and using an *in* clause
> with an empty list, the *in* clause with an empty list can be ignored,
> resulting in deleting more than is expected.
> *Setup:*
> {code}
> cqlsh> create table test (a text, b text, id uuid, primary key ((a, b), id));
> cqlsh> insert into test (a, b, id) values ('a', 'b',
> ----);
> cqlsh> insert into test (a, b, id) values ('b', 'c',
> ----);
> cqlsh> insert into test (a, b, id) values ('a', 'c',
> ----);
> cqlsh> select * from test;
> a | b | id
> ---+---+--
> a | c | ----
> b | c | ----
> a | b | ----
> (3 rows)
> {code}
> *Expected:*
> {code}
> cqlsh> delete from test where a = 'a' and b in ('a', 'b', 'c') and id in ();
> cqlsh> select * from test;
> a | b | id
> ---+---+--
> a | c | ----
> b | c | ----
> a | b | ----
> (3 rows)
> {code}
> *Actual:*
> {code}
> cqlsh> delete from test where a = 'a' and b in ('a', 'b', 'c') and id in ();
> cqlsh> select * from test;
> a | b | id
> ---+---+--
> b | c | ----
> (1 rows)
> {code}
> Instead of deleting nothing, as the final empty *in* clause would imply, it
> instead deletes everything that matches the first two clauses, acting as if
> the following query had been issued instead:
> {code}
> cqlsh> delete from test where a = 'a' and b in ('a', 'b', 'c');
> {code}
> This seems to be related to the presence of a tuple clustering key, as I
> could not reproduce it without one.
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
[jira] [Commented] (CASSANDRA-12829) DELETE query with an empty IN clause can delete more than expected
[
https://issues.apache.org/jira/browse/CASSANDRA-12829?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=15708928#comment-15708928
]
Benjamin Lerer commented on CASSANDRA-12829:
{quote}
As regards {{IN}} restriction, it's all quite simple to fix. However, I see a
bit inconsistency. {{IN}} with just one value is simplified to {{EQ}} relation.
{{IN}} with more than 1 value or 0 values will remain {{IN}}. And because
{{IN}} restrictions are not supported with conditional deletions, currently
we'll disallow 0 and > 1 values, while 1 value will work just as {{EQ}}.
{quote}
{{IN}} restrictions with only one value are nearly always treated like {{EQ}}
at the CQL level. So, I think that it is fine.
> DELETE query with an empty IN clause can delete more than expected
> --
>
> Key: CASSANDRA-12829
> URL: https://issues.apache.org/jira/browse/CASSANDRA-12829
> Project: Cassandra
> Issue Type: Bug
> Components: CQL
> Environment: Arch Linux x64, kernel 4.7.6, Cassandra 3.9 downloaded
> from the website
>Reporter: Jason T. Bradshaw
>Assignee: Alex Petrov
>
> When deleting from a table with a certain structure and using an *in* clause
> with an empty list, the *in* clause with an empty list can be ignored,
> resulting in deleting more than is expected.
> *Setup:*
> {code}
> cqlsh> create table test (a text, b text, id uuid, primary key ((a, b), id));
> cqlsh> insert into test (a, b, id) values ('a', 'b',
> ----);
> cqlsh> insert into test (a, b, id) values ('b', 'c',
> ----);
> cqlsh> insert into test (a, b, id) values ('a', 'c',
> ----);
> cqlsh> select * from test;
> a | b | id
> ---+---+--
> a | c | ----
> b | c | ----
> a | b | ----
> (3 rows)
> {code}
> *Expected:*
> {code}
> cqlsh> delete from test where a = 'a' and b in ('a', 'b', 'c') and id in ();
> cqlsh> select * from test;
> a | b | id
> ---+---+--
> a | c | ----
> b | c | ----
> a | b | ----
> (3 rows)
> {code}
> *Actual:*
> {code}
> cqlsh> delete from test where a = 'a' and b in ('a', 'b', 'c') and id in ();
> cqlsh> select * from test;
> a | b | id
> ---+---+--
> b | c | ----
> (1 rows)
> {code}
> Instead of deleting nothing, as the final empty *in* clause would imply, it
> instead deletes everything that matches the first two clauses, acting as if
> the following query had been issued instead:
> {code}
> cqlsh> delete from test where a = 'a' and b in ('a', 'b', 'c');
> {code}
> This seems to be related to the presence of a tuple clustering key, as I
> could not reproduce it without one.
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
[jira] [Commented] (CASSANDRA-12829) DELETE query with an empty IN clause can delete more than expected
[
https://issues.apache.org/jira/browse/CASSANDRA-12829?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=15708951#comment-15708951
]
Alex Petrov commented on CASSANDRA-12829:
-
Yup, they're optimised away in {{SingleColumnRelation#newINRestriction}}. Great
then. Thanks!
> DELETE query with an empty IN clause can delete more than expected
> --
>
> Key: CASSANDRA-12829
> URL: https://issues.apache.org/jira/browse/CASSANDRA-12829
> Project: Cassandra
> Issue Type: Bug
> Components: CQL
> Environment: Arch Linux x64, kernel 4.7.6, Cassandra 3.9 downloaded
> from the website
>Reporter: Jason T. Bradshaw
>Assignee: Alex Petrov
>
> When deleting from a table with a certain structure and using an *in* clause
> with an empty list, the *in* clause with an empty list can be ignored,
> resulting in deleting more than is expected.
> *Setup:*
> {code}
> cqlsh> create table test (a text, b text, id uuid, primary key ((a, b), id));
> cqlsh> insert into test (a, b, id) values ('a', 'b',
> ----);
> cqlsh> insert into test (a, b, id) values ('b', 'c',
> ----);
> cqlsh> insert into test (a, b, id) values ('a', 'c',
> ----);
> cqlsh> select * from test;
> a | b | id
> ---+---+--
> a | c | ----
> b | c | ----
> a | b | ----
> (3 rows)
> {code}
> *Expected:*
> {code}
> cqlsh> delete from test where a = 'a' and b in ('a', 'b', 'c') and id in ();
> cqlsh> select * from test;
> a | b | id
> ---+---+--
> a | c | ----
> b | c | ----
> a | b | ----
> (3 rows)
> {code}
> *Actual:*
> {code}
> cqlsh> delete from test where a = 'a' and b in ('a', 'b', 'c') and id in ();
> cqlsh> select * from test;
> a | b | id
> ---+---+--
> b | c | ----
> (1 rows)
> {code}
> Instead of deleting nothing, as the final empty *in* clause would imply, it
> instead deletes everything that matches the first two clauses, acting as if
> the following query had been issued instead:
> {code}
> cqlsh> delete from test where a = 'a' and b in ('a', 'b', 'c');
> {code}
> This seems to be related to the presence of a tuple clustering key, as I
> could not reproduce it without one.
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
[jira] [Commented] (CASSANDRA-12829) DELETE query with an empty IN clause can delete more than expected
[
https://issues.apache.org/jira/browse/CASSANDRA-12829?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=15708858#comment-15708858
]
Alex Petrov commented on CASSANDRA-12829:
-
Thanks for noticing this. Turns out that my code did same thing, just was much
more complex to parse. Your suggestion is very good.
As regards {{IN}} restriction, it's all quite simple to fix. However, I see a
bit inconsistency. {{IN}} with just one value is simplified to {{EQ}} relation.
{{IN}} with more than 1 value or 0 values will remain {{IN}}. And because
{{IN}} restrictions are not supported with conditional deletions, currently
we'll disallow {{0}} and {{> 1}} values, while {{1}} value will work just as
{{EQ}}.
Do you think such behaviour would be acceptable? Are empty IN restrictions
actually useful or will just cause edge-cases and unclear behaviour?
> DELETE query with an empty IN clause can delete more than expected
> --
>
> Key: CASSANDRA-12829
> URL: https://issues.apache.org/jira/browse/CASSANDRA-12829
> Project: Cassandra
> Issue Type: Bug
> Components: CQL
> Environment: Arch Linux x64, kernel 4.7.6, Cassandra 3.9 downloaded
> from the website
>Reporter: Jason T. Bradshaw
>Assignee: Alex Petrov
>
> When deleting from a table with a certain structure and using an *in* clause
> with an empty list, the *in* clause with an empty list can be ignored,
> resulting in deleting more than is expected.
> *Setup:*
> {code}
> cqlsh> create table test (a text, b text, id uuid, primary key ((a, b), id));
> cqlsh> insert into test (a, b, id) values ('a', 'b',
> ----);
> cqlsh> insert into test (a, b, id) values ('b', 'c',
> ----);
> cqlsh> insert into test (a, b, id) values ('a', 'c',
> ----);
> cqlsh> select * from test;
> a | b | id
> ---+---+--
> a | c | ----
> b | c | ----
> a | b | ----
> (3 rows)
> {code}
> *Expected:*
> {code}
> cqlsh> delete from test where a = 'a' and b in ('a', 'b', 'c') and id in ();
> cqlsh> select * from test;
> a | b | id
> ---+---+--
> a | c | ----
> b | c | ----
> a | b | ----
> (3 rows)
> {code}
> *Actual:*
> {code}
> cqlsh> delete from test where a = 'a' and b in ('a', 'b', 'c') and id in ();
> cqlsh> select * from test;
> a | b | id
> ---+---+--
> b | c | ----
> (1 rows)
> {code}
> Instead of deleting nothing, as the final empty *in* clause would imply, it
> instead deletes everything that matches the first two clauses, acting as if
> the following query had been issued instead:
> {code}
> cqlsh> delete from test where a = 'a' and b in ('a', 'b', 'c');
> {code}
> This seems to be related to the presence of a tuple clustering key, as I
> could not reproduce it without one.
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
[jira] [Commented] (CASSANDRA-12829) DELETE query with an empty IN clause can delete more than expected
[
https://issues.apache.org/jira/browse/CASSANDRA-12829?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=15695706#comment-15695706
]
Benjamin Lerer commented on CASSANDRA-12829:
Thanks for the patch and sorry for the delay.
Your approach is working but if the query has an {{IN}} restriction on the
primary key the {{clusterings}} and the {{UpdateParameters}} will be computed
multiple times.
Replacing {{clusterings.isEmpty()}} by
{{!restrictions.hasClusteringColumnsRestriction()}} would have apparently been
enough to fix the problem. Did you have a reason for doing more changes? (I
just want to be sure that I did not miss anything).
While playing with the tests I noticed that conditional deletions with empty
{{IN}} restrictions on the clustering key were also broken.
The problem can be reproduced with the following test:
{code}
@Test
public void testEmptyInWithConditions() throws Throwable
{
createTable("CREATE TABLE %s (a int, b int, c int, d int, s int static,
PRIMARY KEY ((a,b), c))");
execute("INSERT INTO %s (a,b,c,d,s) VALUES (?,?,?,?,?)",1,1,1,1,1);
execute("INSERT INTO %s (a,b,c,d,s) VALUES (?,?,?,?,?)",1,1,2,2,1);
execute("INSERT INTO %s (a,b,c,d,s) VALUES (?,?,?,?,?)",1,1,3,3,1);
execute("DELETE FROM %s WHERE a = 1 AND b = 1 AND c IN () IF d = 1;");
assertRows(execute("SELECT * FROM %s"),
row(1,1,1,1,1),
row(1,1,2,1,2),
row(1,1,3,1,3));
}
{code}
On the test side, I think that the tests should be moved to {{UpdateTest}} and
{{DeleteTest}} as they clearly belongs there. It might also be good to add some
tests with empty {{IN}} conditions on the partition keys as well as some tests
with mutliple clustering columns.
> DELETE query with an empty IN clause can delete more than expected
> --
>
> Key: CASSANDRA-12829
> URL: https://issues.apache.org/jira/browse/CASSANDRA-12829
> Project: Cassandra
> Issue Type: Bug
> Components: CQL
> Environment: Arch Linux x64, kernel 4.7.6, Cassandra 3.9 downloaded
> from the website
>Reporter: Jason T. Bradshaw
>Assignee: Alex Petrov
>
> When deleting from a table with a certain structure and using an *in* clause
> with an empty list, the *in* clause with an empty list can be ignored,
> resulting in deleting more than is expected.
> *Setup:*
> {code}
> cqlsh> create table test (a text, b text, id uuid, primary key ((a, b), id));
> cqlsh> insert into test (a, b, id) values ('a', 'b',
> ----);
> cqlsh> insert into test (a, b, id) values ('b', 'c',
> ----);
> cqlsh> insert into test (a, b, id) values ('a', 'c',
> ----);
> cqlsh> select * from test;
> a | b | id
> ---+---+--
> a | c | ----
> b | c | ----
> a | b | ----
> (3 rows)
> {code}
> *Expected:*
> {code}
> cqlsh> delete from test where a = 'a' and b in ('a', 'b', 'c') and id in ();
> cqlsh> select * from test;
> a | b | id
> ---+---+--
> a | c | ----
> b | c | ----
> a | b | ----
> (3 rows)
> {code}
> *Actual:*
> {code}
> cqlsh> delete from test where a = 'a' and b in ('a', 'b', 'c') and id in ();
> cqlsh> select * from test;
> a | b | id
> ---+---+--
> b | c | ----
> (1 rows)
> {code}
> Instead of deleting nothing, as the final empty *in* clause would imply, it
> instead deletes everything that matches the first two clauses, acting as if
> the following query had been issued instead:
> {code}
> cqlsh> delete from test where a = 'a' and b in ('a', 'b', 'c');
> {code}
> This seems to be related to the presence of a tuple clustering key, as I
> could not reproduce it without one.
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
[jira] [Commented] (CASSANDRA-12829) DELETE query with an empty IN clause can delete more than expected
[
https://issues.apache.org/jira/browse/CASSANDRA-12829?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=15602967#comment-15602967
]
Alex Petrov commented on CASSANDRA-12829:
-
{{DELETE}} in this case removes the whole partition, since there's just one
clustering column and clustering list is empty.
{{UPDATE}} queries would also fail in this case with an exception:
{code}
java.lang.AssertionError: Invalid clustering for the table:
org.apache.cassandra.db.Clustering$2@633128cf
at
org.apache.cassandra.db.Clustering$Serializer.serialize(Clustering.java:130)
at
org.apache.cassandra.db.rows.UnfilteredSerializer.serialize(UnfilteredSerializer.java:183)
at
org.apache.cassandra.db.rows.UnfilteredSerializer.serialize(UnfilteredSerializer.java:132)
at
org.apache.cassandra.db.rows.UnfilteredSerializer.serialize(UnfilteredSerializer.java:120)
at
org.apache.cassandra.db.rows.UnfilteredRowIteratorSerializer.serialize(UnfilteredRowIteratorSerializer.java:137)
at
org.apache.cassandra.db.rows.UnfilteredRowIteratorSerializer.serialize(UnfilteredRowIteratorSerializer.java:92)
at
org.apache.cassandra.db.partitions.PartitionUpdate$PartitionUpdateSerializer.serialize(PartitionUpdate.java:790)
at
org.apache.cassandra.db.Mutation$MutationSerializer.serialize(Mutation.java:393)
at org.apache.cassandra.db.commitlog.CommitLog.add(CommitLog.java:249)
at org.apache.cassandra.db.Keyspace.apply(Keyspace.java:522)
at org.apache.cassandra.db.Keyspace.apply(Keyspace.java:425)
{code}
I've prepared a patch (CI pending) that handles empty clustering correctly.
This logic is slightly different from {{SELECT}} though.
> DELETE query with an empty IN clause can delete more than expected
> --
>
> Key: CASSANDRA-12829
> URL: https://issues.apache.org/jira/browse/CASSANDRA-12829
> Project: Cassandra
> Issue Type: Bug
> Components: CQL
> Environment: Arch Linux x64, kernel 4.7.6, Cassandra 3.9 downloaded
> from the website
>Reporter: Jason T. Bradshaw
>Assignee: Alex Petrov
>
> When deleting from a table with a certain structure and using an *in* clause
> with an empty list, the *in* clause with an empty list can be ignored,
> resulting in deleting more than is expected.
> *Setup:*
> {code}
> cqlsh> create table test (a text, b text, id uuid, primary key ((a, b), id));
> cqlsh> insert into test (a, b, id) values ('a', 'b',
> ----);
> cqlsh> insert into test (a, b, id) values ('b', 'c',
> ----);
> cqlsh> insert into test (a, b, id) values ('a', 'c',
> ----);
> cqlsh> select * from test;
> a | b | id
> ---+---+--
> a | c | ----
> b | c | ----
> a | b | ----
> (3 rows)
> {code}
> *Expected:*
> {code}
> cqlsh> delete from test where a = 'a' and b in ('a', 'b', 'c') and id in ();
> cqlsh> select * from test;
> a | b | id
> ---+---+--
> a | c | ----
> b | c | ----
> a | b | ----
> (3 rows)
> {code}
> *Actual:*
> {code}
> cqlsh> delete from test where a = 'a' and b in ('a', 'b', 'c') and id in ();
> cqlsh> select * from test;
> a | b | id
> ---+---+--
> b | c | ----
> (1 rows)
> {code}
> Instead of deleting nothing, as the final empty *in* clause would imply, it
> instead deletes everything that matches the first two clauses, acting as if
> the following query had been issued instead:
> {code}
> cqlsh> delete from test where a = 'a' and b in ('a', 'b', 'c');
> {code}
> This seems to be related to the presence of a tuple clustering key, as I
> could not reproduce it without one.
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
[jira] [Commented] (CASSANDRA-12829) DELETE query with an empty IN clause can delete more than expected
[
https://issues.apache.org/jira/browse/CASSANDRA-12829?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=15596448#comment-15596448
]
Jason T. Bradshaw commented on CASSANDRA-12829:
---
Additionally, this will still happen even when the second *where* clause uses
*=* instead of *in*:
{code}
cqlsh> delete from test where a = 'a' and b = 'c' and id in ();
cqlsh> select * from test;
a | b | id
---+---+--
b | c | ----
a | b | ----
(2 rows)
{code}
> DELETE query with an empty IN clause can delete more than expected
> --
>
> Key: CASSANDRA-12829
> URL: https://issues.apache.org/jira/browse/CASSANDRA-12829
> Project: Cassandra
> Issue Type: Bug
> Components: CQL
> Environment: Arch Linux x64, kernel 4.7.6, Cassandra 3.9 downloaded
> from the website
>Reporter: Jason T. Bradshaw
>
> When deleting from a table with a certain structure and using an *in* clause
> with an empty list, the *in* clause with an empty list can be ignored,
> resulting in deleting more than is expected.
> *Setup:*
> {code}
> cqlsh> create table test (a text, b text, id uuid, primary key ((a, b), id));
> cqlsh> insert into test (a, b, id) values ('a', 'b',
> ----);
> cqlsh> insert into test (a, b, id) values ('b', 'c',
> ----);
> cqlsh> insert into test (a, b, id) values ('a', 'c',
> ----);
> cqlsh> select * from test;
> a | b | id
> ---+---+--
> a | c | ----
> b | c | ----
> a | b | ----
> (3 rows)
> {code}
> *Expected:*
> {code}
> cqlsh> delete from test where a = 'a' and b in ('a', 'b', 'c') and id in ();
> cqlsh> select * from test;
> a | b | id
> ---+---+--
> a | c | ----
> b | c | ----
> a | b | ----
> (3 rows)
> {code}
> *Actual:*
> {code}
> cqlsh> delete from test where a = 'a' and b in ('a', 'b', 'c') and id in ();
> cqlsh> select * from test;
> a | b | id
> ---+---+--
> b | c | ----
> (1 rows)
> {code}
> Instead of deleting nothing, as the final empty *in* clause would imply, it
> instead deletes everything that matches the first two clauses, acting as if
> the following query had been issued instead:
> {code}
> cqlsh> delete from test where a = 'a' and b in ('a', 'b', 'c');
> {code}
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
