com.smartgwt.client.docs

Interface ServerSummaries

public interface ServerSummaries

Server Summaries

In Smart GWT, "summarization" refers to applying functions to DataSource fields to obtain summary records calculated from the values of multiple DataSource records.

For example, by applying an "average" function to a DataSourceField representing the dollar value of an order, you can calculate the average dollar amount of a set of orders.

Client-side calculation of summary records is a listGrid feature. Server Summaries is a feature of the Smart GWT Server allowing similar summaries to be computed server-side, generally by the database engine itself.

See also the related feature which allows a single field to receive a value summarized from several related records, DataSourceField.includeSummaryFunction.

The Server Summaries feature is available with Power or better licenses only. See smartclient.com/product for details.

Summarization can be statically configured directly in a .ds.xml file, or can be dynamically configured when sending a DSRequest, either client-side or server-side. The following examples all assume a DataSource with fields like this:

  <DataSource ID="dsOrders" ...>
       <fields>
           <field name="customerName" type="text" />
           <field name="orderDate" type="date" />
           <field name="deliveryStatus" type="string" />
           ...
       </fields>
  </DataSource>
  

Summaries in DataSource .ds.xml files

You can declare summarization directly on an operationBinding in a .ds.xml file, using OperationBinding.summaryFunctions and OperationBinding.groupBy. For example:

   <DataSource ID="dsOrders" ...>
       ...
       <operationBindings>
           <operationBinding operationType="fetch" operationId="lastOrderDateByCustomer">
               <summaryFunctions>
                   <orderDate>max</orderDate>
               </summaryFunctions>
               <groupBy>customerName</groupBy>
           </operationBinding>
       </operationBindings>
   </DataSource>
  

This would return summary records representing the most recent order per customer. Represented in JSON, the returned records would look like:

    { customerName: "JBar Struts", orderDate:"2012/02/05" },
    { customerName: "KFoo Widgets", orderDate:"2012/03/01" },
    ...
  

This is analogous to the result of a SQL query like:

  SELECT
   max(order.orderDate)
   order.customerName
  FROM
   order
  GROUP BY
   order.customerName
  

Note that, as with SQL, the returned records will only include the fields where summary functions were applied or which were used for grouping - "deliveryDate" and other fields are not included because in general, summary records may represent data from more than one record (there may be more than one record with the "max" value, and consider also "sum" or "avg" functions), so it's ambiguous which record's values should be returned for non-grouped, non-summarized fields.

Dynamically Requested Summaries

DSRequest.summaryFunctions and DSRequest.groupBy allow you to dynamically request a server summary from client-side code. For example:

   DSRequest requestProperties = new DSRequest();
   requestProperties.setGroupBy("customerName");
   requestProperties.setSummaryFunctions(new HashMap() {{
      put("orderDate", SummaryFunctionType.MAX);
   }});
   dsOrders.fetchData(null, callback, request);
  

By default such requests are allowed, but such requests can be disallowed on a per-DataSource or system-wide level if you have concerns - see DataSource.allowClientRequestedSummaries.

You can also dynamically request summaries from server-side code (for example, in a DMI method):

    DSRequest dsRequest = new DSRequest("dsOrders", "fetch");
    dsRequest.setSummaryFunctions(new HashMap() {{
      put("orderDate", SummaryFunctionType.MAX);
    }});
    dsRequest.setGroupBy("customerName");
    DSResponse dsResponse = dsRequest.execute();
  

Criteria, Sort & Data Paging

Criteria and sort directions are supported for queries that involve server summarization.

Criteria apply to record before summaries are applied. For example, if the "avg" function is being applied to a "price" field, criteria like "price < 5" will eliminate records where price is less than 5 before the average price is calculated. This means that client-side filtering may not work as expected with summarized results: client-side filter criteria are necessarily applied after summary functions have been applied, so may not match the server's behavior. You can set ResultSet.useClientFiltering to disable client-side filtering on a grid via ListGrid.dataProperties. Or individual fields can be marked canFilter:false.

Sort directions may only target fields that are returned by the query (only those fields included in groupBy or where a summaryFunction was applied).

Data paging is also supported, however, consider that for aggregated queries, when asked for a second page of data, the database is likely to have to repeat all the work of calculating aggregated values. Turning paging off or setting a generous ListGrid.dataPageSize is advised.

SQL Templating

SQL Templating is also supported with server summaries. Clause-by-clause substitution works normally.

Fields with customSelectExpression

Fields with customSelectExpression can be used with server summaries as both groupBy fields or fields with summaryFunction. In case of summaryFunction requested on field with customSelectExpression we will wrap SQL function around the expression, which may or may not be correct.

Summarizing without Grouping

Declaring just <summaryFunctions> without declaring <groupBy> is allowed. This will always give you exactly one summary record in the result, which will represent the summary functions as applied to all records that match the criteria in the DSRequest.

Grouping without Summarizing

Declaring just <groupBy> without <summaryFunctions> is also allowed. This gives results similar to a SQL "select distinct": one record per distinct set of values for the grouped fields. This kind of result can be used in various ways; one common use case is populating a ComboBoxItem with a list of existing values for a field that already appear in DataSource records.

Check out this example of grouping without summarizing being used to determine all unique values of a field.

See Also:

com.smartgwt.client.types.SummaryFunction, DSRequest.getSummaryFunctions(), DSRequest.getGroupBy(), OperationBinding.summaryFunctions, OperationBinding.groupBy, DataSourceField.includeSummaryFunction, DataSourceField.getJoinPrefix(), DataSourceField.getJoinString(), DataSourceField.getJoinSuffix(), DataSource.allowClientRequestedSummaries, DataSourceField.allowClientRequestedSummaries