Creating a CORBA query is very similar to creating XML queries. Since the output of a CORBA request is mapped to a tree, exactly the same as with an XML request, defining a CORBA query is almost identical to the process for XML queries. The only difference is that each CORBA query has an additional request parameter specification (for overriding the parameter specifications in the data source).
EJB queries are very similar to CORBA queries, but the request parameters are converted to Java objects for EJB invocation. The output values of an EJB home finder method are then converted to a data tree using similar technology. Once the data tree is created from the Java objects, the same tree path selection and table mapping can be applied to the result.
Since EJB queries are very similar to CORBA queries, the following example will explain how to create a query in either of the two data sources.First, create a simple CORBA query using the ‘getAllAccounts’ request. The request does not expect any parameters.
When a CORBA object is developed, it is best to anticipate the parameters that will be used to retrieve information from the server. Although it is very easy to perform filtering in the query engine by post-processing, it is more efficient to implement the common filtering in the CORBA server itself. Most CORBA requests require some parameters in the invocation. For simple parameters, the easiest way to pass in the actual values is to define a variable for each parameter node.
The variables become part of the query variables. Users can use the standard variable entry screen to enter the variable values, or define the variable to get its value from a sub-query. In the example CORBA data source, we defined a variable, ‘ssn’, to serve as the parameter for the ‘getAccounts’ request. It should contain a social security number. The request searches for accounts owned by customers matching the social security number, and returns a list of accounts.
Explains the conditional expression grammar used by the platform and how it maps closely to SQL conditional syntax. Covers operators, comparison patterns, and case-sensitivity rules for names and variables. Presents practical examples of advanced conditionals to solve common filtering and selection problems. Shows how condition expressions can be embedded in report logic and data modeler rules to control result sets. Useful for developers and report designers who need predictable, SQL-like behavior when crafting dynamic conditions.
Describes table-level query controls available inside dashboard widgets that speed report composition. Demonstrates how table queries can be parameterized and configured to return exactly the columns and rows needed for a visualization. Includes examples that show tie-ins between table settings and dashboard interactivity like sorting and paging. Explains differences between server-side retrieval and client-side processing for large datasets. Practical guidance helps dashboard authors optimize table behavior for performance and clarity.
Shows how to view the SQL statements and the resulting execution plan a table will send to a database at runtime. Explains the dialog that displays both SQL issued to the source and post-retrieval operations performed by the worksheet. Demonstrates how examining the plan can reveal opportunities to push computation into the database or reduce transferred rows. Discusses practical techniques for controlling and tuning the SQL a visualization emits. Useful when diagnosing slow render times or unexpected data results.
Introduces a visual query tool intended to remove the need for manual SQL coding in many common scenarios. Describes how drag-and-drop elements and wizard dialogs let non-technical users construct complex queries safely. Explains the tool’s automatic optimization layer that produces efficient SQL for rapid retrieval. Highlights how the visual approach democratizes data access while preserving advanced options for power users. Emphasizes time-to-insight gains and reduced dependency on centralized IT for routine queries.
Details techniques for querying non-relational sources such as XML feeds and web services as if they were tabular data. Covers subtree selection, node filtering, and table construction when converting hierarchical data into rows and columns. Shows examples that map web-service responses into reportable datasets for dashboards and tables. Discusses pitfalls such as varying schema and strategies for robust extraction and reuse. Useful for integrating API-driven or document-oriented feeds into analytics workflows.
Explains how calculated fields and expressions can be used to derive new result columns from existing query output. Demonstrates syntax for inline expressions and formula-based transformations applied after data retrieval. Provides examples such as concatenating address parts or computing derived metrics for display. Describes binding derived values into table cells and using them for sorting, grouping, or formatting. Helps report authors reduce upstream ETL by performing lightweight transformations at the report layer.
Shows how report script code can execute queries programmatically and bind query results to report elements. Explains APIs such as `runQuery()` for invoking queries defined in registries or worksheets. Covers use cases where multiple distinct queries must be orchestrated and their results merged into a single visual output. Describes error handling and parameter passing in scripted flows to create robust automated report logic. Suitable for advanced automation and dynamic reporting scenarios driven by runtime conditions.
Discusses methods for controlling the SQL generated by dashboard tables and how to influence it for better performance. Provides examples of exposing SQL plan information and adjusting dataset definitions to change the queries emitted. Explains when to use cached views or live queries depending on data freshness and load considerations. Includes practical tips for limiting data transfer and avoiding unnecessary post-processing on the client side. Targets architects and implementers who must balance interactivity with backend scalability.
Compares the guided ‘New Query’ wizard with the ability to author free-form SQL strings for cases requiring custom control. Describes the derived query option that allows building queries on top of existing query definitions. Explains scenarios where the wizard suffices and cases where direct SQL entry is more productive. Highlights validation behaviors, variable binding, and how the system reconciles user-entered SQL with the data model. Useful for teams that need both governed, user-friendly querying and escape valves for advanced SQL.
Describes the lifecycle and mapping of user-supplied parameters from UI forms into query variables and replet parameters. Explains aliasing, type conversion, and how values are coerced back to the proper types before execution. Shows how parameter handling supports defaulting, validation, and secure binding to avoid injection risks. Demonstrates patterns for passing complex parameter sets into server-side queries for multi-tenant or embedded scenarios. Valuable for implementers designing parameterized report endpoints or embedded dashboards.
Presents a web-based query builder that enables users to design queries with drag-and-drop gestures inside a browser. Explains how the builder produces executable queries while enforcing data model constraints and security rules. Covers integration points for embedding the builder inside portals so users can craft ad-hoc datasets without direct database access. Describes how generated queries can be saved, scheduled, and reused by teams. Emphasizes usability for business users while retaining IT governance.
Explains how subqueries may be written and used within conditions and expressions, including ‘IN’ and scalar contexts. Demonstrates examples where subqueries provide filtering lists or derive dependent parameters for other query predicates. Describes how the Data Modeler supports SQL sub-query constructs and how those can be embedded into higher-level query definitions. Discusses performance considerations when subqueries are used versus joins or precomputed sets. Helps developers choose the right approach for correctness and efficiency.