You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@gora.apache.org by "Andrzej Bialecki (JIRA)" <ji...@apache.org> on 2010/11/05 15:56:43 UTC
[jira] Created: (GORA-12) Semantics of DataStore.delete*
Semantics of DataStore.delete*
------------------------------
Key: GORA-12
URL: https://issues.apache.org/jira/browse/GORA-12
Project: Gora
Issue Type: Bug
Reporter: Andrzej Bialecki
Assignee: Andrzej Bialecki
Behavior of delete* calls in DataStore is insufficiently defined. Some unit tests in DataStoreUtil seem to indicate that after a successful call to delete the subsequent queries should not return deleted items. Other tests indicate that an additional DataStore.flush() call is needed.
If we could rely on the latter assumption this would allow for some important optimizations in the implementations of DataStore - bulk updates that are visible only after an update transaction is finished are usually much less expensive to perform than equivalent multiple item by item transactions.
Therefore I propose to strengthen the meaning of delete* calls, so that their effects are guaranteed to be visible to get/execute ONLY after a subsequent flush() call.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] [Updated] (GORA-12) Semantics of DataStore.delete*
Posted by "Chris A. Mattmann (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/GORA-12?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Chris A. Mattmann updated GORA-12:
----------------------------------
Fix Version/s: (was: 0.3-incubating)
0.2-incubating
- schedule
> Semantics of DataStore.delete*
> ------------------------------
>
> Key: GORA-12
> URL: https://issues.apache.org/jira/browse/GORA-12
> Project: Gora
> Issue Type: Bug
> Components: storage
> Reporter: Andrzej Bialecki
> Assignee: Chris A. Mattmann
> Fix For: 0.2-incubating
>
> Attachments: GORA-12.patch
>
>
> Behavior of delete* calls in DataStore is insufficiently defined. Some unit tests in DataStoreUtil seem to indicate that after a successful call to delete the subsequent queries should not return deleted items. Other tests indicate that an additional DataStore.flush() call is needed.
> If we could rely on the latter assumption this would allow for some important optimizations in the implementations of DataStore - bulk updates that are visible only after an update transaction is finished are usually much less expensive to perform than equivalent multiple item by item transactions.
> Therefore I propose to strengthen the meaning of delete* calls, so that their effects are guaranteed to be visible to get/execute ONLY after a subsequent flush() call.
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] [Updated] (GORA-12) Semantics of DataStore.delete*
Posted by "Chris A. Mattmann (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/GORA-12?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Chris A. Mattmann updated GORA-12:
----------------------------------
Fix Version/s: (was: 0.1-incubating)
0.2-incubating
> Semantics of DataStore.delete*
> ------------------------------
>
> Key: GORA-12
> URL: https://issues.apache.org/jira/browse/GORA-12
> Project: Gora
> Issue Type: Bug
> Components: storage
> Reporter: Andrzej Bialecki
> Assignee: Andrzej Bialecki
> Fix For: 0.2-incubating
>
> Attachments: GORA-12.patch
>
>
> Behavior of delete* calls in DataStore is insufficiently defined. Some unit tests in DataStoreUtil seem to indicate that after a successful call to delete the subsequent queries should not return deleted items. Other tests indicate that an additional DataStore.flush() call is needed.
> If we could rely on the latter assumption this would allow for some important optimizations in the implementations of DataStore - bulk updates that are visible only after an update transaction is finished are usually much less expensive to perform than equivalent multiple item by item transactions.
> Therefore I propose to strengthen the meaning of delete* calls, so that their effects are guaranteed to be visible to get/execute ONLY after a subsequent flush() call.
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] Updated: (GORA-12) Semantics of DataStore.delete*
Posted by "Andrzej Bialecki (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/GORA-12?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Andrzej Bialecki updated GORA-12:
----------------------------------
Attachment: GORA-12.patch
Proposed changes to javadoc and tests. If no objections I'll commit shortly.
> Semantics of DataStore.delete*
> ------------------------------
>
> Key: GORA-12
> URL: https://issues.apache.org/jira/browse/GORA-12
> Project: Gora
> Issue Type: Bug
> Reporter: Andrzej Bialecki
> Assignee: Andrzej Bialecki
> Attachments: GORA-12.patch
>
>
> Behavior of delete* calls in DataStore is insufficiently defined. Some unit tests in DataStoreUtil seem to indicate that after a successful call to delete the subsequent queries should not return deleted items. Other tests indicate that an additional DataStore.flush() call is needed.
> If we could rely on the latter assumption this would allow for some important optimizations in the implementations of DataStore - bulk updates that are visible only after an update transaction is finished are usually much less expensive to perform than equivalent multiple item by item transactions.
> Therefore I propose to strengthen the meaning of delete* calls, so that their effects are guaranteed to be visible to get/execute ONLY after a subsequent flush() call.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] [Resolved] (GORA-12) Semantics of DataStore.delete*
Posted by "Chris A. Mattmann (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/GORA-12?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Chris A. Mattmann resolved GORA-12.
-----------------------------------
Resolution: Fixed
- patch applied in r1170035 and r1170037. Thanks Andrzej!
> Semantics of DataStore.delete*
> ------------------------------
>
> Key: GORA-12
> URL: https://issues.apache.org/jira/browse/GORA-12
> Project: Gora
> Issue Type: Bug
> Components: storage
> Reporter: Andrzej Bialecki
> Assignee: Chris A. Mattmann
> Fix For: 0.2-incubating
>
> Attachments: GORA-12.patch
>
>
> Behavior of delete* calls in DataStore is insufficiently defined. Some unit tests in DataStoreUtil seem to indicate that after a successful call to delete the subsequent queries should not return deleted items. Other tests indicate that an additional DataStore.flush() call is needed.
> If we could rely on the latter assumption this would allow for some important optimizations in the implementations of DataStore - bulk updates that are visible only after an update transaction is finished are usually much less expensive to perform than equivalent multiple item by item transactions.
> Therefore I propose to strengthen the meaning of delete* calls, so that their effects are guaranteed to be visible to get/execute ONLY after a subsequent flush() call.
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] Updated: (GORA-12) Semantics of DataStore.delete*
Posted by "Chris A. Mattmann (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/GORA-12?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Chris A. Mattmann updated GORA-12:
----------------------------------
Component/s: storage
Fix Version/s: 0.1-incubating
- classify and set fix version
> Semantics of DataStore.delete*
> ------------------------------
>
> Key: GORA-12
> URL: https://issues.apache.org/jira/browse/GORA-12
> Project: Gora
> Issue Type: Bug
> Components: storage
> Reporter: Andrzej Bialecki
> Assignee: Andrzej Bialecki
> Fix For: 0.1-incubating
>
> Attachments: GORA-12.patch
>
>
> Behavior of delete* calls in DataStore is insufficiently defined. Some unit tests in DataStoreUtil seem to indicate that after a successful call to delete the subsequent queries should not return deleted items. Other tests indicate that an additional DataStore.flush() call is needed.
> If we could rely on the latter assumption this would allow for some important optimizations in the implementations of DataStore - bulk updates that are visible only after an update transaction is finished are usually much less expensive to perform than equivalent multiple item by item transactions.
> Therefore I propose to strengthen the meaning of delete* calls, so that their effects are guaranteed to be visible to get/execute ONLY after a subsequent flush() call.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] [Assigned] (GORA-12) Semantics of DataStore.delete*
Posted by "Chris A. Mattmann (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/GORA-12?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Chris A. Mattmann reassigned GORA-12:
-------------------------------------
Assignee: Chris A. Mattmann (was: Andrzej Bialecki )
> Semantics of DataStore.delete*
> ------------------------------
>
> Key: GORA-12
> URL: https://issues.apache.org/jira/browse/GORA-12
> Project: Gora
> Issue Type: Bug
> Components: storage
> Reporter: Andrzej Bialecki
> Assignee: Chris A. Mattmann
> Fix For: 0.2-incubating
>
> Attachments: GORA-12.patch
>
>
> Behavior of delete* calls in DataStore is insufficiently defined. Some unit tests in DataStoreUtil seem to indicate that after a successful call to delete the subsequent queries should not return deleted items. Other tests indicate that an additional DataStore.flush() call is needed.
> If we could rely on the latter assumption this would allow for some important optimizations in the implementations of DataStore - bulk updates that are visible only after an update transaction is finished are usually much less expensive to perform than equivalent multiple item by item transactions.
> Therefore I propose to strengthen the meaning of delete* calls, so that their effects are guaranteed to be visible to get/execute ONLY after a subsequent flush() call.
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] Commented: (GORA-12) Semantics of DataStore.delete*
Posted by "Doğacan Güney (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/GORA-12?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12928696#action_12928696 ]
Doğacan Güney commented on GORA-12:
-----------------------------------
Ah, OK, I should have probably taken a look at your patch before asking for more time :)
Still, I agree with you that a well-documented and a consistent data model is very important... More important than having it more features (i.e I don't mind put not making data available immediately for now as long as it is a consistent behavior)
> Semantics of DataStore.delete*
> ------------------------------
>
> Key: GORA-12
> URL: https://issues.apache.org/jira/browse/GORA-12
> Project: Gora
> Issue Type: Bug
> Reporter: Andrzej Bialecki
> Assignee: Andrzej Bialecki
> Attachments: GORA-12.patch
>
>
> Behavior of delete* calls in DataStore is insufficiently defined. Some unit tests in DataStoreUtil seem to indicate that after a successful call to delete the subsequent queries should not return deleted items. Other tests indicate that an additional DataStore.flush() call is needed.
> If we could rely on the latter assumption this would allow for some important optimizations in the implementations of DataStore - bulk updates that are visible only after an update transaction is finished are usually much less expensive to perform than equivalent multiple item by item transactions.
> Therefore I propose to strengthen the meaning of delete* calls, so that their effects are guaranteed to be visible to get/execute ONLY after a subsequent flush() call.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] [Updated] (GORA-12) Semantics of DataStore.delete*
Posted by "Chris A. Mattmann (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/GORA-12?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Chris A. Mattmann updated GORA-12:
----------------------------------
Fix Version/s: (was: 0.2-incubating)
0.3-incubating
- push to 0.3
> Semantics of DataStore.delete*
> ------------------------------
>
> Key: GORA-12
> URL: https://issues.apache.org/jira/browse/GORA-12
> Project: Gora
> Issue Type: Bug
> Components: storage
> Reporter: Andrzej Bialecki
> Assignee: Andrzej Bialecki
> Fix For: 0.3-incubating
>
> Attachments: GORA-12.patch
>
>
> Behavior of delete* calls in DataStore is insufficiently defined. Some unit tests in DataStoreUtil seem to indicate that after a successful call to delete the subsequent queries should not return deleted items. Other tests indicate that an additional DataStore.flush() call is needed.
> If we could rely on the latter assumption this would allow for some important optimizations in the implementations of DataStore - bulk updates that are visible only after an update transaction is finished are usually much less expensive to perform than equivalent multiple item by item transactions.
> Therefore I propose to strengthen the meaning of delete* calls, so that their effects are guaranteed to be visible to get/execute ONLY after a subsequent flush() call.
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
[jira] Commented: (GORA-12) Semantics of DataStore.delete*
Posted by "Doğacan Güney (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/GORA-12?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12928636#action_12928636 ]
Doğacan Güney commented on GORA-12:
-----------------------------------
Can you give me a few days to review this change, Andrzej? I'll look it over this weekend.
> Semantics of DataStore.delete*
> ------------------------------
>
> Key: GORA-12
> URL: https://issues.apache.org/jira/browse/GORA-12
> Project: Gora
> Issue Type: Bug
> Reporter: Andrzej Bialecki
> Assignee: Andrzej Bialecki
> Attachments: GORA-12.patch
>
>
> Behavior of delete* calls in DataStore is insufficiently defined. Some unit tests in DataStoreUtil seem to indicate that after a successful call to delete the subsequent queries should not return deleted items. Other tests indicate that an additional DataStore.flush() call is needed.
> If we could rely on the latter assumption this would allow for some important optimizations in the implementations of DataStore - bulk updates that are visible only after an update transaction is finished are usually much less expensive to perform than equivalent multiple item by item transactions.
> Therefore I propose to strengthen the meaning of delete* calls, so that their effects are guaranteed to be visible to get/execute ONLY after a subsequent flush() call.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (GORA-12) Semantics of DataStore.delete*
Posted by "Andrzej Bialecki (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/GORA-12?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12928616#action_12928616 ]
Andrzej Bialecki commented on GORA-12:
---------------------------------------
Actually, the semantics of put() should be tightened the same way, too.
> Semantics of DataStore.delete*
> ------------------------------
>
> Key: GORA-12
> URL: https://issues.apache.org/jira/browse/GORA-12
> Project: Gora
> Issue Type: Bug
> Reporter: Andrzej Bialecki
> Assignee: Andrzej Bialecki
>
> Behavior of delete* calls in DataStore is insufficiently defined. Some unit tests in DataStoreUtil seem to indicate that after a successful call to delete the subsequent queries should not return deleted items. Other tests indicate that an additional DataStore.flush() call is needed.
> If we could rely on the latter assumption this would allow for some important optimizations in the implementations of DataStore - bulk updates that are visible only after an update transaction is finished are usually much less expensive to perform than equivalent multiple item by item transactions.
> Therefore I propose to strengthen the meaning of delete* calls, so that their effects are guaranteed to be visible to get/execute ONLY after a subsequent flush() call.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (GORA-12) Semantics of DataStore.delete*
Posted by "Doğacan Güney (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/GORA-12?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12929463#action_12929463 ]
Doğacan Güney commented on GORA-12:
-----------------------------------
+1 from me
> Semantics of DataStore.delete*
> ------------------------------
>
> Key: GORA-12
> URL: https://issues.apache.org/jira/browse/GORA-12
> Project: Gora
> Issue Type: Bug
> Reporter: Andrzej Bialecki
> Assignee: Andrzej Bialecki
> Attachments: GORA-12.patch
>
>
> Behavior of delete* calls in DataStore is insufficiently defined. Some unit tests in DataStoreUtil seem to indicate that after a successful call to delete the subsequent queries should not return deleted items. Other tests indicate that an additional DataStore.flush() call is needed.
> If we could rely on the latter assumption this would allow for some important optimizations in the implementations of DataStore - bulk updates that are visible only after an update transaction is finished are usually much less expensive to perform than equivalent multiple item by item transactions.
> Therefore I propose to strengthen the meaning of delete* calls, so that their effects are guaranteed to be visible to get/execute ONLY after a subsequent flush() call.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (GORA-12) Semantics of DataStore.delete*
Posted by "Andrzej Bialecki (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/GORA-12?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12928668#action_12928668 ]
Andrzej Bialecki commented on GORA-12:
---------------------------------------
Sure. This is mostly a doc change, and a change in unit tests - I didn't modify any stores yet.
> Semantics of DataStore.delete*
> ------------------------------
>
> Key: GORA-12
> URL: https://issues.apache.org/jira/browse/GORA-12
> Project: Gora
> Issue Type: Bug
> Reporter: Andrzej Bialecki
> Assignee: Andrzej Bialecki
> Attachments: GORA-12.patch
>
>
> Behavior of delete* calls in DataStore is insufficiently defined. Some unit tests in DataStoreUtil seem to indicate that after a successful call to delete the subsequent queries should not return deleted items. Other tests indicate that an additional DataStore.flush() call is needed.
> If we could rely on the latter assumption this would allow for some important optimizations in the implementations of DataStore - bulk updates that are visible only after an update transaction is finished are usually much less expensive to perform than equivalent multiple item by item transactions.
> Therefore I propose to strengthen the meaning of delete* calls, so that their effects are guaranteed to be visible to get/execute ONLY after a subsequent flush() call.
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.