SmartClient 13.1: Union DataSource, client-server filtering, and advanced fetching
With the release of SmartClient 13.1, we’re introducing several interesting new features. These features help developers with complex data queries, optimize data fetching, and enable faster performance with large datasets.
In this post, we’ll explore three key additions:
- The ability to Fetch Only Needed Data
- Union DataSource,
- Flexible Client/Server Filtering
Fetching only needed data
Fetching unnecessary data is one of the most common performance bottlenecks in data-driven applications. You can now fetch only the data needed for the current operation. No need to load entire datasets.
The new fetchFields feature allows your grids to request only the fields currently visible to the user or necessary for declarative features like hilites or formulas. Instead of pulling all the data from the server at once, the grid dynamically fetches the fields it actually needs, when it needs them.
Generally, you can just turn this feature on (by declaring fetchFields:"visible") and you’re set. However, if your application logic uses fields that aren’t shown to the user, you will need to list those in fetchFields.
As you can see in the showcase sample, when you apply the highlight (Highlight G8 Countries), the grid recognizes that it needs the extra field and fetches it.
A related feature, dataSourceField.outputWhen, is another way of adjusting whether a given field is fetched by default – use it to mark expensive fields, such as long text columns, so they aren’t fetched unless the user is actually looking for that specific data!
For detailed documentation, visit ListGrid.fetchFields and DataSourceField.outputWhen.
Union DataSource
Managing data from multiple sources can often be complex. This is often common in legacy systems with similar data stored in multiple tables. The Union DataSource allows you to merge the output of multiple DataSources into a unified view—like SQL’s UNION operator.
You can easily simplify situations where entities are stored in different tables, but you need to work with them together. For example, let’s say you have Contractors and Employees in separate tables – when you just want to see all your staff. UnionDataSource solves that problem immediately.
See how this works in the Union DataSource Showcase here.
Flexible client/server filtering
SmartClient has always been known for its powerful client-side filtering that makes applications incredibly fast. So many operations that would have required a server trip in other technologies are handled right in the browser instead!
Of course, there are cases where server-side filtering is necessary—especially when dealing with specialized or custom filtering logic, like fuzzy logic or algorithms that can’t be replicated on the client side.
In the latest release, we’ve made it possible to implement mixed filtering. Setting DataSourceField.filterOn:"server" tells SmartClient that criteria on that specific field will always require server filtering. The SmartClient filtering system will continue using client-side filtering for all other fields. You get instantaneous response and also reduce server load—but for that one field, SmartClient will ask the server to do the filtering.
Just another instance of SmartClient getting things exactly right so that your app has the maximum performance possible.
Learn more about the new mixed filtering feature here.
Faster clientOnly DataSources for high-volume In-browser testing
SmartClient’s clientOnly DataSources has long enabled developers to perform in-browser data management with a full SQL-like experience directly in the client. In this release, we’ve improved clientOnly DataSources by introducing automatic indexing so that they perform well even if you push them hard. This dramatically improves performance even for high-volume data operations and makes them ideal for testing and smaller data sets.
This is great when you’re trying to test a high-data-volume app, and the actual server isn’t ready yet – you can still test! And hopefully the actual server will be in the ballpark of what we can do just in the browser. Even heavy data operations remain efficient and responsive within the browser. It also provides a realistic benchmark—often very close to production server performance—so that developers can begin testing long before server integration.
Conclusion
SmartClient 13.1 is packed with features that incredibly improve data management and client-server efficiency. So you can go ahead to integrate multiple data sources with the Union DataSource, optimize your grid performance by fetching only visible data, or fine-tuning your application’s filtering logic with flexible client/server filtering. SmartClient continuously delivers applications that are faster, smarter, and easier to maintain.
In our next blog, we’ll explore two powerful new features in SmartClient 13.1: Cypress integration and Search Locators.
