Build a Table from a DataTable

Often your application will pull data from a database and store it in the form of a DataTable. You may wish to easily insert this data into your document as a new table and quickly apply formatting to the whole table.

Note that the preferred way of inserting data from a DataTable into a document table is by using Mail Merge with Regions. The technique presented in this article is only suggested if you are unable to create a suitable template beforehand to merge data with, in other words, if you require everything to happen programmatically.

Using Aspose.Words, you can easily retrieve data from a database and store it as a table:

1. Create a new DocumentBuilder object on your Document.
2. Start a new table using DocumentBuilder.
3. If we want to insert the names of each of the columns from our DataTable as a header row then iterate through each data column and write the column names into a row in the table.
4. Iterate through each DataRow in the DataTable:
   1. Iterate through each object in the DataRow.
   2. Insert the object into the document using DocumentBuilder. The method used depends on the type of the object being inserted e.g DocumentBuilder.writeln() for text and DocumentBuilder.insertImage() for a byte array which represents an image.
   3. At the end of processing of the data row also end the row being created by the DocumentBuilder by using DocumentBuilder.endRow().
5. Once all rows from the DataTable have been processed finish the table by calling DocumentBuilder.endTable().
6. Finally, we can set the desired table style using one of the appropriate table properties such as Table.getStyleIdentifier() to automatically apply formatting to the entire table. The following data in our DataTable is used in this example:

The following code example shows how to execute the above algorithm in Aspose.Words:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
/// <summary>
/// Imports the content from the specified DataTable into a new Aspose.Words Table object.
/// The table is inserted at the document builder's current position and using the current builder's formatting if any is defined.
/// </summary>
public Table importTableFromDataTable(DocumentBuilder builder, DataTable dataTable,
    boolean importColumnHeadings)
{
    Table table = builder.startTable();

    // Check if the columns' names from the data source are to be included in a header row.
    if (importColumnHeadings)
    {
        // Store the original values of these properties before changing them.
        boolean boldValue = builder.getFont().getBold();
        int paragraphAlignmentValue = builder.getParagraphFormat().getAlignment();

        // Format the heading row with the appropriate properties.
        builder.getFont().setBold(true);
        builder.getParagraphFormat().setAlignment(ParagraphAlignment.CENTER);

        // Create a new row and insert the name of each column into the first row of the table.
        for (DataColumn column : dataTable.getColumns())
        {
            builder.insertCell();
            builder.writeln(column.getColumnName());
        }

        builder.endRow();

        // Restore the original formatting.
        builder.getFont().setBold(boldValue);
        builder.getParagraphFormat().setAlignment(paragraphAlignmentValue);
    }

    for (DataRow dataRow : (Iterable<DataRow>) dataTable.getRows())
    {
        for (Object item : dataRow.getItemArray())
        {
            // Insert a new cell for each object.
            builder.insertCell();

            switch (item.getClass().getName())
            {
                case "DateTime":
                    // Define a custom format for dates and times.
                    Date dateTime = (Date) item;
                    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("MMMM d, yyyy");
                    builder.write(simpleDateFormat.format(dateTime));
                    break;
                default:
                    // By default any other item will be inserted as text.
                    builder.write(item.toString());
                    break;
            }
        }

        // After we insert all the data from the current record, we can end the table row.
        builder.endRow();
    }

    // We have finished inserting all the data from the DataTable, we can end the table.
    builder.endTable();

    return table;
}

The method can then be easily called using your DocumentBuilder and data.

The following code example shows how to import the data from a DataTable and insert it into a new table in the document:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Document doc = new Document();
// We can position where we want the table to be inserted and specify any extra formatting to the table.
DocumentBuilder builder = new DocumentBuilder(doc);

// We want to rotate the page landscape as we expect a wide table.
doc.getFirstSection().getPageSetup().setOrientation(Orientation.LANDSCAPE);

DataSet ds = new DataSet();
ds.readXml(getMyDir() + "List of people.xml");
// Retrieve the data from our data source, which is stored as a DataTable.
DataTable dataTable = ds.getTables().get(0);

// Build a table in the document from the data contained in the DataTable.
Table table = importTableFromDataTable(builder, dataTable, true);

// We can apply a table style as a very quick way to apply formatting to the entire table.
table.setStyleIdentifier(StyleIdentifier.MEDIUM_LIST_2_ACCENT_1);
table.setStyleOptions(TableStyleOptions.FIRST_ROW | TableStyleOptions.ROW_BANDS | TableStyleOptions.LAST_COLUMN);

// For our table, we want to remove the heading for the image column.
table.getFirstRow().getLastCell().removeAllChildren();

doc.save(getArtifactsDir() + "WorkingWithTables.BuildTableFromDataTable.docx");

The table shown in the picture below is produced by running the above code.