Business Intelligence Query Software That Is Easily Deployed and Easily Used

Are you looking for Business Intelligence Query Software that's:

What Options Do BI Developers Have for Working with Queries Using InetSoft's Style BI Product?

InetSoft has spent years refining its data mashup engine, which serves as the core of its BI architecture, allowing developers to define, manipulate, and optimize queries in multiple ways. The platform supports both power-user-level control and abstracted no-code experiences, meaning that developers of varying skill levels—from SQL experts to data analysts—can all work productively within the same environment. This article will explore the options BI developers have when working with queries in Style BI, touching on SQL editing, visual query building, mashup capabilities, parameterization, scripting, optimization tools, data modeling, integration, and deployment.

1. SQL Query Editing and Custom Queries

At its foundation, InetSoft's Style BI supports writing and executing raw SQL queries directly against supported data sources. Developers can access the SQL editor through the Data Worksheet or directly within the Data Block creation process. This is especially beneficial for power users and DBAs who want full control over the data retrieval logic.

Unlike some BI tools that overly abstract SQL or limit developer access to the underlying query logic, Style BI encourages developers to dig into SQL when needed. Complex subqueries, joins, unions, filters, and aggregations can all be written directly in SQL. In addition, because InetSoft uses a virtual data layer (data worksheet or semantic layer), developers can write source-specific SQL but still abstract business logic and reuse those results across many dashboards and reports.

Developers also have the option to leverage SQL for derived tables (virtual views), which don't exist in the source database but are computed at runtime. These derived tables are helpful for reusing logic or creating transformations without modifying the original source schema.

2. Visual Query Builder for Non-SQL Users

For developers who prefer a visual approach—or for those working with business stakeholders who need to define their own queries—Style BI offers a drag-and-drop visual query builder. This intuitive interface allows users to select tables, apply joins, drag fields into output, and apply filters or aggregations without writing a single line of SQL.

While visually simple, the tool is backed by the same powerful mashup engine that supports more complex scripting, so the result of a visually built query can be extended and refined using formulas, conditions, and expressions later on. This dual-layer approach (visual + scriptable) allows teams to collaborate more effectively across technical and non-technical roles.

For example, a business analyst might build an initial dataset visually and then pass it to a BI developer who can fine-tune the underlying logic using SQL or scripting as needed.

3. Data Mashup Layer: Combining Multiple Sources

One of Style BI's strongest features is its data mashup capability. Developers often need to work with multiple data sources—SQL databases, Excel files, cloud APIs, web services, NoSQL sources, and even streaming data. InetSoft's platform abstracts data sources into unified worksheets that can be combined or related through mashups.

Within the mashup layer, queries can be joined, unioned, filtered, and transformed—even across databases that don't natively interact. This is accomplished through virtual linking in the worksheet. Developers can use prebuilt connectors to pull from Salesforce, Google Analytics, MongoDB, Amazon Redshift, or virtually any JDBC/ODBC-compatible source, and then combine that data into a single report-ready dataset.

This mashup layer supports:

• Joins across heterogeneous sources (e.g., SQL + spreadsheet)
• Filtering and aggregation logic
• Hierarchies and calculated fields
• Reusable metadata definitions

For organizations dealing with fragmented data systems, this is a huge advantage—it eliminates the need for costly ETL pipelines or data warehouse consolidation for many use cases.

4. Formula Language and Expressions

Queries in Style BI are often extended using the platform's built-in formula language, which resembles Excel or standard expression syntax. Developers can create calculated fields, conditional logic, ranking functions, windowing operations, and more directly in the data worksheet or chart designer.

For example:

• IF(Sales > 100000, "High", "Normal") for conditional categorization
• RunningTotal(Sales) for cumulative sums
• DateDiff(ShipDate, OrderDate) for duration calculations

This scripting layer gives developers the flexibility to fine-tune datasets without altering the SQL source or adding complexity to the original query. It also promotes reuse and clarity because formulas are embedded at the visualization or worksheet level, rather than buried in SQL code.

5. Parameterization and Interactivity

A major aspect of query customization in Style BI is the use of parameters. These dynamic inputs allow users to filter data, modify queries, and control the scope of what is shown in real time. Developers can define parameters that:

• Filter SQL WHERE clauses
• Control which table or field is used
• Pass into API calls
• Toggle between different visualization states

Parameters can be exposed as dropdowns, date pickers, text boxes, or sliders within dashboards, allowing end-users to interactively change query results. Behind the scenes, Style BI rewrites the queries or re-renders visualizations as needed—without requiring the developer to hard-code multiple query versions.

This is particularly useful for building white-label applications or multi-tenant dashboards where different users need scoped access to different slices of data.

6. Caching, Scheduling, and Preprocessing Options

Style BI supports several backend options for query optimization and workload management. Developers can choose how and when queries are executed:

• Live querying: Always fetches fresh data from the source
• Cached views: Precomputed datasets that refresh on a schedule
• Push datasets: Data pushed in from external systems via API

For performance-intensive reports, BI developers can configure data blocks to refresh periodically—e.g., every 15 minutes, hourly, or nightly. This helps mitigate load on transactional databases while still delivering timely data.

Developers also have access to query logs and performance tools to help identify long-running queries, index suggestions, or bottlenecks, making the optimization process data-driven.

7. Reusable Data Models and Metadata

Another powerful feature for BI developers is the ability to create reusable data models. Style BI allows teams to define "data blocks" and "data worksheets" that encapsulate query logic, calculated fields, hierarchies, and metadata in one reusable package. These blocks can then be consumed by multiple dashboards, reports, or even embedded visualizations across different departments.

For example, a central "Customer Order Metrics" worksheet can be created once, and then used in marketing, sales, and finance dashboards—without each team needing to replicate the underlying queries.

This promotes governance, reduces redundancy, and ensures consistency across enterprise reporting. Developers can define access controls, version updates, and dependencies at the worksheet level, simplifying lifecycle management.

8. Integration with Custom Apps and APIs

For organizations embedding dashboards into web apps or creating external portals, Style BI supports dynamic query injection through its API. Developers can pass filters, parameters, and tokens into visualizations at runtime, effectively modifying the query behavior based on the logged-in user, device, or context.

This level of programmatic query control is invaluable for SaaS vendors and internal application teams that want to integrate BI deeply into their workflow without exposing query logic to the end user.

For example, a multi-tenant CRM tool can display dashboards with filtered data per customer account, without requiring separate dashboards or queries per tenant.

9. Security Filters and Row-Level Access

BI developers working in sensitive environments must often implement strict access controls. Style BI supports:

• Row-level security filters that modify the query automatically based on user role or metadata
• User attribute filters that map specific values to users (e.g., region, department, customer ID)

These rules can be embedded in the worksheet so that developers don't have to manually define query filters in each visualization. The system handles the query rewriting transparently, ensuring both data security and developer productivity.

10. Version Control and Deployment Options

Although Style BI is primarily a web-based platform, its enterprise version and open source version allow for exporting and versioning of data models and queries as XML or JSON. Developers can track changes to worksheets and queries via Git or integrate with CI/CD pipelines using scripts.

Deployment of dashboards and queries to staging vs. production environments can be automated using the platform's RESTful API, or manually promoted via export/import functionality.

This makes the platform friendly for professional software development teams who treat BI assets as part of a structured software lifecycle.