X-mode social Interview

CSVWriter.java

import java.io.*;
import java.util.*;

public class CSVWriter {
    private final String fullPath;
    private HashMap<String, TreeSet<String>> fieldsMap;
    private boolean hasHeader = false;

    public CSVWriter(String filename, String path) {
        fullPath = path + File.separator + filename;
        fieldsMap = new HashMap<String, TreeSet<String>>();
    }

    public void addColumn(String name) {
        if (fieldsMap.containsKey(name)) {
            throw new IllegalArgumentException("Duplicate column name: " + name);
        }

        fieldsMap.put(name, new TreeSet<String>());
    }

    public void appendToColumn(String column, String value) {
        if (!fieldsMap.containsKey(column)) {
            addColumn(column);
        }
        TreeSet<String> values = fieldsMap.get(column);
        values.add(value);
        fieldsMap.put(column, values);
    }

    public void write() {
        performPreWriteChecks();

        try {
            FileWriter fileWriter = new FileWriter(fullPath, true);
            BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
            PrintWriter printWriter = new PrintWriter(bufferedWriter);

            if (!hasHeader) {
                printWriter.println(getHeaderRow());
                hasHeader = true;
            }

            List<Iterator<String>> iterators = new ArrayList<Iterator<String>>();
            for (TreeSet<String> s: fieldsMap.values()){
                iterators.add(s.iterator());
            }

            while (iterators.get(iterators.size()).hasNext()) {
                printWriter.println(getRow(iterators));
            }

            printWriter.close();
            bufferedWriter.close();
            fileWriter.close();

            refresh();
        } catch (IOException e) {
            throw new IllegalArgumentException("Could not find file or file was a directory.");
        }
    }

    private void refresh() {
        fieldsMap = new HashMap<String, TreeSet<String>>();
    }

    private void performPreWriteChecks() {
        if (fieldsMap.isEmpty()) {
            throw new IllegalStateException("Nothing to write.");
        }

        int count = -1;
        for (TreeSet<String> entry: fieldsMap.values()) {
            if (count == -1) {
                count = entry.size();
                continue;
            }

            if (entry.size() != count) {
                throw new IllegalStateException("All fields must have the same amount of values");
            }
        }

        if (count == 0) {
            throw new IllegalStateException("Must have more than 0 entries.");
        }
    }

    private String getHeaderRow() {
        StringBuilder builder = new StringBuilder();
        for(String key: fieldsMap.keySet()) {
            builder.append(key)
                    .append(",");
        }


        builder.deleteCharAt(builder.lastIndexOf(","));
        return builder.toString();
    }

    private String getRow(List<Iterator<String>> iterators) {
        StringBuilder builder = new StringBuilder();

        for (Iterator<String> iterator : iterators) {
            builder.append(iterator.next())
                    .append(",");
        }

        builder.deleteCharAt(builder.lastIndexOf(","));
        return builder.toString();
    }
}

DatabaseConnector.java

import java.sql.*;

public class DatabaseConnector {

    private final static String DB_URL = "jdbc:mysql://localhost/db";
    private final static String USER = "username";
    private final static String PASS = "password";

    private static DatabaseConnector instance;
    private Connection connection;

    public static DatabaseConnector getInstance() {
        if (instance == null) {
            instance = new DatabaseConnector();
        }

        return instance;
    }

    private DatabaseConnector() {
        try {
            connection = DriverManager.getConnection(DB_URL, USER, PASS);
        } catch (SQLException e) {
            throw new IllegalStateException("Could not connect to database.");
        }
    }

    public ResultSet execute(String sql) {
        try {
            Statement statement = connection.createStatement();
            ResultSet set = statement.executeQuery(sql);
            statement.close();

            return set;
        } catch (SQLException e) {
            throw new IllegalArgumentException("Invalid query: " + sql);
        }
    }
}

Main.java

import java.sql.Date;
import java.sql.ResultSet;
import java.sql.SQLException;

public class Main {
    public static void main(String[] args) {
        DatabaseConnector db = DatabaseConnector.getInstance();
        ResultSet resultSet = db.execute(
                "SELECT * FROM location \n" +
                "WHERE timestamp BETWEEN \n" +
                "\"2017-05-01 00:00:00.000\" \n" +
                "AND \"2017-05-01 23:59:59.999\";"
        );

        CSVWriter csvWriter = new CSVWriter("data.csv", "/tmp");
        try {
            int refreshCounter = 0;
            while (resultSet.next()) {
                String advertiserId = resultSet.getString("advertiser_id");
                double latitude = resultSet.getDouble("latitude");
                double longitude = resultSet.getDouble("longitude");
                double horizontalAccuracy = resultSet.getDouble("horizontal_accuracy");
                Date date = resultSet.getDate("timestamp");

                csvWriter.appendToColumn("advertiser_id", advertiserId);
                csvWriter.appendToColumn("latitude", String.valueOf(latitude));
                csvWriter.appendToColumn("longitude", String.valueOf(longitude));
                csvWriter.appendToColumn("horizontal_accuracy", String.valueOf(horizontalAccuracy));
                csvWriter.appendToColumn("timestamp", date.toString());

                refreshCounter++;
                if (resultSet.getFetchSize() <= refreshCounter) {
                    refreshCounter = 0;
                    csvWriter.write();
                }
            }
            resultSet.close();
        } catch (SQLException e) {
            System.out.println("Could not access the database.");
        }
    }
}