My goal is to query a DB data context using LINQ with dynamic query criteria. I am aware that one way to access an object using its field name is by converting it to an IDictionary, using C# reflection API.

Is using reflection a good idea, or should expression trees be preferred? How fast would my queries be using them both?

Is querying objects (LINQ) using expression trees faster than using reflection? How much?

 I have a unique requirement where i need to flush the data of one of the column in database and set the value as 0 using optimized JPA query.

Optimized JPA Query to Flush the column value to 0

Suppose I have loaded to frontend (React) first page of data. Now I can sort it by one of parameter. Is it any better way than make next request to backend (Spring) and fetch again data which is partially doubled?

Maybe there exist kind of cache tool to don't pull all object if the service already have it.

When working with paginated data and sorting in a frontend (React) application, you have a few options to efficiently sort the data without fetching the entire dataset again from the backend (Spring). Here are a couple of approaches you can consider:

If the amount of data on the frontend is manageable and doesn't significantly impact performance, you can sort the data directly on the frontend without making an additional backend request.

You can use JavaScript array methods like sort() to sort the data based on the selected parameter.

Keep track of the sorting state in the frontend and update the displayed data accordingly when the user selects a different sorting option.

This approach is suitable when the paginated data on the frontend is small and can be sorted quickly without causing performance issues.

If you have a large dataset on the backend and sorting on the frontend is not feasible, you can request a partial dataset from the backend based on the sorting parameter.

Modify your backend API to support sorting and partial data retrieval. You can add query parameters to your API endpoint to specify the sorting parameter and the range of data to be retrieved (e.g., start index and page size).

Update your backend service to handle the sorting and retrieve only the required data based on the sorting parameter. This way, you avoid fetching duplicate data.

On the frontend, when the user selects a sorting option, make a request to the backend with the appropriate sorting parameter and retrieve the next page of sorted data.

This approach reduces the amount of data transferred between the frontend and backend, as you only fetch the necessary subset of data.

Another option is to offload the sorting operation entirely to the backend by implementing server-side sorting.

Modify your backend API to accept the sorting parameter and perform the sorting operation on the server side.

When the user selects a sorting option, request the backend with the selected sorting parameter. The backend will handle the sorting and return the sorted paginated data.

This approach ensures that the frontend receives the correctly sorted data without duplications or additional sorting logic on the frontend. However, it may add processing load to the backend.

The choice between these approaches depends on factors such as the size of the dataset, performance requirements, and the trade-offs between frontend and backend processing. Consider the specific needs of your application and its scalability requirements when deciding on the most suitable approach.

How to efficiently sort paginated data?

I would like to perform measurements relating to Pods (restart times, deployment times, rollback times,etc) in a namespace of K8s cluster.
Is there a Jenkins tool that allows you to automate this process and extract a report and publish it? 

K8s & Jenkins: tool to monitor some metrics

My team is developing a new service oriented product with a web front-end. In discussions about what technologies we will use we have settled on running a JBoss application server, and Flex frontend (with possible desktop deployment using Adobe AIR), and web services to interface the client and server.

We've reached an impasse when it comes to which server technology to use for our business logic. The big argument is between EJB3 and Spring, with our biggest concerns being scalability and performance, and also maintainability of the code base.

What are the arguments for or against EJB3 vs Spring?

Where can I find good benchmark information?

Should I use EJB3 or Spring for my business layer?

I need to fetch 200k facts in unmarried JPA choose query inside 5 seconds. I am selecting one column that's already listed. Currently, it's far taking extra than five minutes. Is it possible to choose over 100k of statistics in 5 seconds?

This is not possible with hibernate or normal native query since it has to create hundreds of thousands of objects on the java side and results need to be sent over the network (Serialization & de-serialization). You could do the below steps for fine-tuning,

1) On the DB side you could change the index method default to is binary tree instead set it as the "HASH" method.

2) Use Parallel threads to retrieve the results in paginated mode (Use native SQL).

Hope it gives some input for further fine-tuning.

performance

Trending Blogposts on performance

Popular Discussions on performance

openIs querying objects (LINQ) using expression trees faster than using reflection? How much?

1

0

0

openOptimized JPA Query to Flush the column value to 0

0

0

0

openHow to efficiently sort paginated data?

1

1

0

openK8s & Jenkins: tool to monitor some metrics

2

0

0

openShould I use EJB3 or Spring for my business layer?

1

0

0

openFetch 200k records in single JPA select query within 5 seconds

1

1

0

PRODUCTS

QUICK LINKS

LEGAL