---
Added: v2.0.0
Status: Active
---
# DataTableAdapter interface

Defines how table data is supplied to [DataTable](datatable.component.md)
and [Tasklist](task-list.component.md) components.

## Properties

| Name | Type | Description |
| --- | --- | --- |
| selectedRow | DataRow | The data for the currently selected row. |

## Methods

`getRows(): Array<DataRow>;`<br/>
`setRows(rows: Array<DataRow>): void;`<br/>
Get/set the values for display in the table using an array of rows.

`getColumns(): Array<DataColumn>;`<br/>
`setColumns(columns: Array<DataColumn>): void;`<br/>
Get/set an array of column specifications.

`getValue(row: DataRow, col: DataColumn): any;`<br/>
Get the data value from a specific table cell.

`getSorting(): DataSorting;`
`setSorting(sorting: DataSorting): void;`
Get/set the sorting key and direction (ascending or descending).

`sort(key?: string, direction?: string): void;`
Sort the table with a specified key and direction (ascending or descending).


## Details

You can implement DataTableAdapter in your own class to display your data with the [DataTable](datatable.component.md)
and [Tasklist](task-list.component.md) components.
This interface (along with other interfaces for column and row data) hides the details of your class from the caller, so you can store your data internally however you like. The DataTable library implements the interface in the [ObjectDataTableAdapter](#objectdatatableadapter) class which is the standard adapter for the Datatable component.

The basic idea of DataTableAdapter is that the caller can request your class to return an array of column
definition objects. Each of these objects specifies the unique key, name, type and other properties of a single column.

The caller can also request the data values for the table as an array of row objects. The caller accesses the data from a row using a `getValue` method that returns the data from a specified column. This column is identified by the unique key that was set during the column definition.

The data-hiding works the other way around when the caller needs to set data in the DataTableAdapter class - the internal
details of the caller's storage are hidden by the column and row interfaces. When the `setColumns` and `setRows` methods are
called on the adapter, it can simply query the column/row objects it receives and then store the data in its own format.

### Columns and rows

Columns are defined by the DataColumn interface:

```ts
interface DataColumn {
    key: string;
    type: string;
    format?: string;
    sortable?: boolean;
    title?: string;
    srTitle?: string;
    cssClass?: string;
    template?: TemplateRef<any>;
    formatTooltip?: Function;
}
```

An array of these objects is passed to your object when the `setColumns` method is called.  The `key` property is used to identify columns and so each column's key should be unique. The `type` string can have a value of 'text', 'image' or 'date'.

An array of DataRow objects is passed to your object when the `setRows` method is called:

```ts
interface DataRow {
    isSelected: boolean;
    isDropTarget?: boolean;
    cssClass?: string;
    hasValue(key: string): boolean;
    getValue(key: string): any;
}
```

Each row contains a set of values. An item in the set is retrieved by passing its key (specified in the column description) to the `getValue` method. As a result, the row does not need to store its data items in any particular order or format as long as it can retrieve the right item using its key.

### ObjectDataTableAdapter

The DataTable library provides a implementation of DataTableAdapter, called
[ObjectDataTableAdapter](https://github.com/Alfresco/alfresco-ng2-components/blob/master/ng2-components/ng2-alfresco-datatable/src/data/object-datatable-adapter.ts). This is a simple adapter that binds to object arrays and turns object fields into columns:

```ts
let data = new ObjectDataTableAdapter(
    // Row data
    [
        { id: 1, name: 'Name 1' },
        { id: 2, name: 'Name 2' }
    ],
    // Column schema
    [
        { 
            type: 'text', 
            key: 'id', 
            title: 'Id', 
            sortable: true 
        },
        {
            type: 'text', 
            key: 'name', 
            title: 'Name', 
            sortable: true
        }
    ]
);
```

![DataTable demo](docassets/images/datatable-demo.png)

If you don't specify the column array then the constructor will infer the layout of the columns from
the structure of the row objects. The field names ('id' and 'name' in the example below) will be used
for both the `key` and `title` properties of the columns:

```ts
let data =  [
    { id: 2, name: 'abs' },
    { id: 1, name: 'xyz' }
];

let schema = ObjectDataTableAdapter.generateSchema(data);

/*Auto generated column schema:
[
    { 
        type: 'text', 
        key: 'id', 
        title: 'Id', 
        sortable: false 
    },
    {
        type: 'text', 
        key: 'name', 
        title: 'Name', 
        sortable: false
    }
] 
*/

```

<!-- Don't edit the See also section. Edit seeAlsoGraph.json and run config/generateSeeAlso.js -->
<!-- seealso start -->
## See also

- [Datatable component](datatable.component.md)
- [Task list component](task-list.component.md)
<!-- seealso end -->