OCLps Example
No edit summary
No edit summary
Tag: 2017 source edit
 
(15 intermediate revisions by 3 users not shown)
Line 1: Line 1:


Here's a small model showing how to use the PSEval value - this could also be interesting if you're working with Associations.   
In this example, we look at a small model that stores articles with comments made by users. There may be a lot of comments on the article and below is a description of how to efficiently find "my" comments. "My" refers to the logged-in user.   


[[File:OCLps_Example_Image.png|frameless|397x397px]]
There are different approaches to improving the performance of retrieving the comment section for an article. These include selecting the article based on the self and the first comment, using the PSEval value to calculate the number of liked comments, and combining PSEval with OCL.   


This model shows a comment section for an article, stored in the database, as one table for the article, one table for the SysUsers, and one table for the comments. We select from the comments an article that points to the self. Because we want to increase the performance, we must decide whether we're going to show a list of articles or one article to load into the memory and sum up.
One of these methods is through the use of PSEvalValue. PSEvalValue provides a way to select and manipulate data in the database without loading it into memory.  


________________
To illustrate how PSEval works, let's consider a small model that involves three tables: Article, SysUser, and Comment.


and select the likes and then show the number. That would require the system to load every comment object into memory and then filter out the ones that have like, that are not null, and see how many they are.
[[File:OCLps_Example_Image.png|frameless|397x397px]]
 
________________
 
We decide to use the PSEval value and we want an integer. We say self.comments - this is basically the same as it would be in the OCL. We take the comments, select the ones that are liked and take the size of it. In this case, we are also subscribing to the article which means that this would be re-evaluated if the article changes. This will work well to show how many likes exist. If the user likes or unlikes, this value would not change.We will use PSVAL to get all the comments for this article into memory, but only the ones that have like on them. It would still load objects, but not all of them, only the liked ones up to 9,999 in this case, and then we would take the size of that. By loading the objects, we can take this size here after we have loaded the objects. 
 
Another alternative would be to combine OCLPS and PSEval with OCL. We first pick out the comment the user has made. Then we find all the comments and all the objects that have liked on it, except my comment object. and sum these up. We load all the objects except my own objects, and we add my own comment - liked status - manually. 
 
This part will be executed in OCLPS: 
 
(insert image) 
 
and this part will be in OCL:
 
(image).


The next variant would be to have this as an integer. We calculate the value of every comment except mine. In OCL, which is auto-subscribed, we calculate the liked form for only my comment.  
The link role allows for navigation from SysUser to Comment and vice versa. This model assumes that a single SysUser won't have excessive comments.


The effect of this will be that the UI will update when I like or unlike the article, but if someone else does it, it won't update until my session reloads. It will delay because it will only reload when this value is needed the next time. It's slightly off, but I don't think anyone will notice and it's a huge performance boost.
Suppose we want to display the number of likes that an article has received. One way to do this is to load every comment object into memory, filter out the ones that have a "like" and then count how many there are. However, this would be inefficient for articles with several comments. A better way is to use PSEvalValue to select only the comments that have a "like" and count them without loading them into memory.


Paragraph 2: To show how many likes an article has, three different implementations are presented. One of the implementations is to use the PSVAL value to calculate the number of comments that are liked, without loading all the objects. This is done by selecting the comments, taking the ones that are liked, and determining the size of the selection. By loading only the objects that have been liked, performance is improved.
However, using PSEvalValue has its limitations. If a user likes or unlikes a comment, the "like" count in the user interface will not update because nothing is triggering a re-evaluation of the data. One way to work around this is to use PSEval to get all the comments for an article but only the ones that have a "like" on them. This method still loads objects, but it only loads the ones with a "like" which can improve performance. PSEval can make querying large datasets much faster and more efficient.  


Paragraph 3: Another implementation is to combine OCLPS and PSEval with OCL. In this approach, the UI updates when the user likes or unlikes, but not when someone else does it. This slight delay is a performance boost and is unlikely to be noticed by users. By using OCLPS, the system loads all the comments except the user's own comments that have been liked and manually adds the user's own comment-liked status. The calculation of the liked form for the user's comment is done in OCL. This approach also provides a significant performance improvement.
=== Learn More in This Video ===
<html>
<div class="video">
  <div class="video__wrapper">
    <iframe src="https://www.youtube.com/embed/pAaB3IGr6mI?si=ui3HnMMuVGwLdMCW" title="YouTube video player" frameborder="0" allowfullscreen></iframe>
  </div>


In conclusion, the article highlights different approaches to improve the performance of a comment section in an article. These approaches include selecting the article based on the self and the first comment, using the PSVAL value to calculate the number of comments that are liked, and combining OCLPS and PSEval with OCL. The article provides detailed explanations for each approach and its impact on performance.
</html>


=== Watch the Video ===
[[Category:OCLPS]]
{{Edited|July|12|2024}}

Latest revision as of 05:43, 12 March 2024

In this example, we look at a small model that stores articles with comments made by users. There may be a lot of comments on the article and below is a description of how to efficiently find "my" comments. "My" refers to the logged-in user.

There are different approaches to improving the performance of retrieving the comment section for an article. These include selecting the article based on the self and the first comment, using the PSEval value to calculate the number of liked comments, and combining PSEval with OCL.

One of these methods is through the use of PSEvalValue. PSEvalValue provides a way to select and manipulate data in the database without loading it into memory.

To illustrate how PSEval works, let's consider a small model that involves three tables: Article, SysUser, and Comment.

OCLps Example Image.png

The link role allows for navigation from SysUser to Comment and vice versa. This model assumes that a single SysUser won't have excessive comments.

Suppose we want to display the number of likes that an article has received. One way to do this is to load every comment object into memory, filter out the ones that have a "like" and then count how many there are. However, this would be inefficient for articles with several comments. A better way is to use PSEvalValue to select only the comments that have a "like" and count them without loading them into memory.

However, using PSEvalValue has its limitations. If a user likes or unlikes a comment, the "like" count in the user interface will not update because nothing is triggering a re-evaluation of the data. One way to work around this is to use PSEval to get all the comments for an article but only the ones that have a "like" on them. This method still loads objects, but it only loads the ones with a "like" which can improve performance. PSEval can make querying large datasets much faster and more efficient.

Learn More in This Video

This page was edited 67 days ago on 03/12/2024. What links here