Writing Data in Batches with Kotlin

Welcome to the unit on Writing Data in Batches. In this lesson, we'll explore how to efficiently handle large datasets by writing data in batches using Kotlin. This technique is invaluable when managing substantial amounts of data where processing the entire dataset at once is impractical. By the end of this lesson, you will be able to write data in batches to manage and handle large datasets effectively.

Batching is the process of dividing a large amount of data into smaller, manageable chunks or batches. This practice is crucial in data handling as it offers several advantages:

• Memory Efficiency: Smaller chunks can be processed more efficiently than large datasets, reducing memory usage.
• Performance Improvement: Writing and reading smaller sets of data can enhance performance, especially in I/O operations.

Batching is particularly useful when dealing with data that cannot fit into memory all at once or when working with streaming data.

In this lesson, we're tackling the challenge of handling large datasets by writing data to a file in batches using Kotlin. This method enhances efficiency, especially for large volumes that aren't feasible to process in one go. Here's our breakdown:

• Generate Sample Data: We'll start by creating a dataset of random numbers.
• Structure Data into Batches: This dataset will be divided into smaller, more manageable portions referred to as batches.
• Sequential Batch Writing: Each of these batches will then be written to a file one after the other, optimizing both memory usage and performance.

This approach reflects real-world requirements, where handling vast datasets efficiently is crucial for ensuring smooth data processing and storage.

To begin, we need to set up our data generation and define the configuration for batch processing to write data to a CSV file. We'll specify the file path for the output, the number of batches, the batch size indicating the number of rows per batch, and the number of columns for each row. Here's how the setup looks in code:

import java.nio.file.Paths
import kotlin.random.Random

// The file path for the CSV file to be written
val filePath = Paths.get("large_data.csv")

// Configuration for the batches
val numBatches = 5       // Number of batches to write
val batchSize = 200      // Number of rows per batch
val numColumns = 10      // Number of columns in each row

val random = Random.Default  // Random generator for sample data

In this code:

• filePath: Path of the file where data will be written.
• numBatches: Specifies the total number of batches to be written.
• batchSize: Determines how many rows each batch contains.
• numColumns: Establishes how many columns each row will have.
• random: Generates the random numerical values for our data.

To efficiently manage the writing of data in batches, we'll utilize the BufferedWriter. Here's how we set up the writer:

import java.io.BufferedWriter
import java.io.FileWriter

// Create a BufferedWriter for the target file
val writer = BufferedWriter(FileWriter(filePath.toFile()))

In this snippet:

• We create a BufferedWriter object for the writer to use, which will handle writing data to the file efficiently.

With the writer set up, the next step is to generate data in batches and write each batch to the CSV file sequentially:

// Start writing batches
for (batch in 0 until numBatches) {
    // StringBuilder to store rows for the current batch
    val batchData = StringBuilder()

    // Create rows for the current batch
    for (i in 0 until batchSize) {
        // Create a row of random double values
        val row = List(numColumns) { random.nextDouble() }
        // Convert the row to a CSV formatted string and append to batchData
        batchData.append(row.joinToString(separator = ",")).append("\n")
    }

    // Write batch data to the file
    writer.write(batchData.toString())
    println("Written batch ${batch + 1} to ${filePath.toString()}")
}

// Close the writer after all batches are written
writer.close()

In this code:

• We loop over the number of batches defined by numBatches.
• For each batch, we generate a StringBuilder to accumulate the CSV formatted strings for each row.
• We populate each row with random numbers, convert it to a CSV formatted string, and append it to the StringBuilder.
• We use the BufferedWriter's write() method to write all rows of the current batch to the file.
• Finally, we close the writer to ensure all data is flushed and resources are released.

After writing the data, it's crucial to ensure that our file contains the expected number of rows. We can verify this by counting the lines in the generated CSV file:

import java.nio.file.Files

// Count the lines in the file to verify successful data writing
val lineCount = Files.lines(filePath).count()

// Print the number of lines in the file to confirm data integrity
println("The file ${filePath} has $lineCount lines.")

We use Files.lines() to read the lines from the file and count() to get the total number of lines. This step confirms that all data has been written as expected.

Example output:

The file large_data.csv has 1000 lines.

This indicates that 1000 rows (5 batches * 200 rows per batch) have been successfully written to the CSV file.

In this lesson, we've covered the essentials of writing data in batches to efficiently manage large datasets using Kotlin. You've learned how to generate data, set up a BufferedWriter to write data in batches, and verify the integrity of the written files. Utilizing the BufferedWriter allows us to append data to a file efficiently, which is crucial for handling large datasets effectively, ensuring memory efficiency and improved performance.