Sets fields on which initial aggregates should be calculated

// calculates total sum of unitPrice field's values.
[{ field: "unitPrice", aggregate: "sum" }]

Specifies the local JavaScript object to use for the data source.

// bind the datasource to a local JavaScript array
var orders = [ { orderId: 10248, customerName: "Paul Smith" }, { orderId: 10249, customerName: "Jane Jones" }];
var dataSource = new kendo.data.DataSource({
     data: orders
});

Sets initial filter

// returns only data where orderId is equal to 10248
filter: { field: "orderId", operator: "eq", value: 10248 }

// returns only data where orderId is equal to 10248 and customerName starts with Paul
filter: [ { field: "orderId", operator: "eq", value: 10248 },
          { field: "customerName", operator: "startswith", value: "Paul" } ]

Sets initial grouping

// groups data by orderId field
group: { field: "orderId" }

// groups data by orderId and customerName fields
group: [ { field: "orderId", dir: "desc" }, { field: "customerName", dir: "asc" } ]

Sets the index of the displayed page of data.

var dataSource = new kendo.data.DataSource({
    page: 2 // displays the second page of data in the bound widget
});

Sets the number of records which contains a given page of data.

var dataSource = new kendo.data.DataSource({
    pageSize: 5 // 5 records per page of data
});

Set the object responsible for describing the raw data format

var dataSource = new kendo.data.DataSource({
     transport: {
       read: "Catalog/Titles",
     },
     schema: {
         aggregates: function(data) {
              // returns aggregates
         },
         data: function(data) {
             return data.result;
         },
         total: function(data) {
             return data.totalCount;
         },
         parse: function(data) {
             return data;
         },
         type: "jsonp"
     }
 });

var dataSource = new kendo.data.DataSource({
       //..
        schema: {
            model: {
                id: "ProductID",
                fields: {
                     ProductID: {
                        //this field will not be editable (default value is true)
                        editable: false,
                        // a defaultValue will not be assigned (default value is false)
                        nullable: true
                     },
                     ProductName: {
                         validation: { //set validation rules
                             required: true
                         }
                     },
                     UnitPrice: {
                       //data type of the field {Number|String|Boolean|Date} default is String
                       type: "number",
                       // used when new model is created
                       defaultValue: 42,
                       validation: {
                           required: true,
                           min: 1
                       }
                   }
               }
           }
       }
   })

Determines if aggregates should be calculated on the server.

var dataSource = new kendo.data.DataSource({
    transport: {
        read: "orders.json"
    },
    serverAggregates: true,
    aggregate: { field: "orderId", operator: "eq", value: 10248 } // return only data where orderId equals 10248
});

Determines if filtering of the data should be handled on the server.

The serverFiltering must be used in conjunction with the filter configuration. By default, a filter object is sent to the server with the query string in the following form:

• filter[logic]: and
• filter[filters][0][field]: orderId
• filter[filters][0][operator]: desc
• filter[filters][0][value]: 10248

Possible values for operator include:

It is possible to modify these parameters by using the parameterMap function found on the transport object (see transport in Configuration).

var dataSource = new kendo.data.DataSource({
    transport: {
        read: "orders.json"
    },
    serverFiltering: true,
    filter: { field: "orderId", operator: "eq", value: 10248 } // return only data where orderId equals 10248
});

Determines if grouping of the data should be handled on the server.

The serverGrouping must be used in conjunction with the group configuration. By default, a group object is sent to the server with the query string in the following form:

• group[0][field]: orderId
• group[0][dir]: desc

It is possible to modify these parameters by using the parameterMap function found on the transport object (see transport in Configuration).

var dataSource = new kendo.data.DataSource({
    transport: {
        read: "orders.json"
    },
    serverGrouping: true,
    sort: { field: "orderId", dir: "asc" } // group by orderId descending
});

Determines if paging of the data should be handled on the server.

serverPaging must be used in conjunction with the pageSize configuration setting. The following options to the server as part of the query string by default:

It is possible to modify these parameters by using the parameterMap function found on the transport object (see transport in Configuration).

var dataSource = new kendo.data.DataSource({
    transport: {
        read: "orders.json"
    },
    serverPaging: true,
    pageSize: 5 // 5 records per page
});

Determines if sorting of the data should be handled on the server.

The serverSorting must be used in conjunction with the sort configuration. By default, a sort object is sent to the server with the query string in the following form:

• sort[0][field]: orderId
• sort[0][dir]: asc

It is possible to modify these parameters by using the parameterMap function found on the transport object (see transport in Configuration).

var dataSource = new kendo.data.DataSource({
    transport: {
        read: "orders.json"
    },
    serverSorting: true,
    sort: { field: "orderId", dir: "asc" }
});

Sets initial sort order

// sorts data ascending by orderId field
sort: { field: "orderId", dir: "asc" }

// sorts data ascending by orderId field and then descending by shipmentDate
sort: [ { field: "orderId", dir: "asc" }, { field: "shipmentDate", dir: "desc" } ]

Sets the object responsible for loading and saving of data. This can be a remote or local/in-memory data.

var dataSource = new kendo.data.DataSource({
    transport: {
        read: "orders.json",
        update: {
            url: "orders/update.json",
            data: {
                orderId: $("#input").val() // sends the value of the input as the orderId
            }
        }
    }
});

var dataSource = new kendo.data.DataSource({
     transport: {
       read: "Catalog/Titles",
       parameterMap: function(options) {
          return {
             pageIndex: options.page,
             size: options.pageSize,
             orderBy: convertSort(options.sort)
          }
       }
     }
 });

// settings various options for remote data transport
var dataSource = new kendo.data.DataSource({
    transport: {
        read: {
            // the remote service URL
            url: "http://search.twitter.com/search.json",

            // JSONP is required for cross-domain AJAX
            dataType: "jsonp",

            // additional parameters sent to the remote service
            data: {
                q: function() {
                    return $("#searchFor").val();
                }
            }
        }
    }
});

 // consuming odata feed without setting additional options
 var dataSource = new kendo.data.DataSource({
     type: "odata",
     transport: {
         read: "http://odata.netflix.com/Catalog/Titles"
     }
 });

var dataSource = new kendo.data.DataSource({
    transport: {
        read: "orders.json",
        destroy: {
            url: "orders/create.json",
        }
    }
});