Client Capability Flags Override Server Feature Support
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
There is a mismatch of supported features between clients and servers, where a client may support a feature for querying a server, but the server's engine is not capable of handling it, or vice versa, leading to capability mismatches, especially exacerbated by older on-premise clients not updating to support new features supported by the server.
Innovation Solution
A computer system that obtains a feature support list from the server, determines the context of an operation, and uses a capability flag to override the server's feature support list, rendering appropriate dialogs for configuring operations based on whether the feature is supported in that context, allowing the client to utilize features actually supported by the server's engines.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If the server provides a feature support list indicating unsupported features, then the client can avoid using unsupported features, but the client cannot utilize features that are actually supported by the server's engine
Solution Approach 1:
The patent segments the feature support determination into two distinct levels: system-level feature support list (from server) and engine-level capability flags (from client). This segmentation allows the client to independently verify actual engine capabilities against the server's declared support, resolving the contradiction by enabling feature utilization when engine-level flags indicate support despite system-level indications of unsupported features.
Solution Approach 2:
The patent implements a feedback mechanism where the client's capability flags provide corrective information back to the feature selection process. When the client detects that its engine supports a feature (via capability flags) that the server's feature support list indicates as unsupported, the capability flags override the server's indication, allowing the client to utilize the feature. This feedback loop resolves the contradiction by prioritizing actual engine capabilities over declared system-level support.
2Reliability
If the client uses the server's feature support list to determine available features, then capability mismatches are avoided, but newer features supported by the server cannot be used by older clients
Solution Approach 1:
The patent applies preliminary action by having the client pre-determine its engine-level capabilities through capability flags before interacting with the server's feature support list. This preliminary assessment of actual engine capabilities allows older clients to identify and utilize newer features that their engines support, even when the server's feature support list (generated for newer clients) indicates those features as unsupported. The capability flags are established in advance to override system-level indications.
3Reliability
If the server engine supports a feature but the system-level feature support list indicates it is unsupported, then the engine can handle the feature, but the client cannot configure operations using that feature
Solution Approach 1:
The patent introduces capability flags as an intermediary mechanism between the server's feature support list and the client's feature configuration process. These capability flags act as a mediator that translates actual engine-level support into usable configuration options. When capability flags indicate engine support for a feature, they enable the client to configure operations using that feature, bridging the gap between engine capability and user-accessible configuration despite system-level indications of unsupported features.
Data Source
AI summary
Different server engines may be used to process queries from a client application. The different engines may have different capabilities and support different features. A server may only provide system level capabilities such that it will indicate that it is not capable of supporting a particular feature if not all of its engines are capable of supporting that feature. In order to use features actually supported, a client application may override the server's feature support information using a client library. The client application may render user interface dialogs supporting a particular feature based on the feature support information from the server as modified by the client library. The dialog may be used to query the server using the feature indicated as not being supported by the server at a system level.