Implementing chunkSize in writesql

src/main/java/joinery/DataFrame.java

@@ -2281,9 +2281,9 @@ public static final DataFrame<Object> readSql(final ResultSet rs)
      * @param sql the SQL statement
      * @throws SQLException if an error occurs executing the statement
      */
-    public final void writeSql(final Connection c, final String sql)
+    public final void writeSql(final Connection c, final String sql, final int chunkSize)
     throws SQLException {
-        writeSql(c.prepareStatement(sql));
+        writeSql(c.prepareStatement(sql), chunkSize);
     }
 
     /**
@@ -2293,9 +2293,9 @@ public final void writeSql(final Connection c, final String sql)
      * @param stmt a prepared insert statement
      * @throws SQLException if an error occurs executing the statement
      */
-    public final void writeSql(final PreparedStatement stmt)
+    public final void writeSql(final PreparedStatement stmt, final int chunkSize)
     throws SQLException {
-        Serialization.writeSql(this, stmt);
+        Serialization.writeSql(this, stmt, chunkSize);
     }
 
     public final String toString(final int limit) {

src/main/java/joinery/impl/Serialization.java

@@ -447,7 +447,23 @@ public static DataFrame<Object> readSql(final ResultSet rs)
         }
     }
 
-    public static <V> void writeSql(final DataFrame<V> df, final PreparedStatement stmt)
+    /**
+     *
+     * Executes SQL statement to write local data to SQL database in splits.
+     * User can specific the number of splits to divide rows of data so the method operates efficiently and minimizes chances of failing
+     * while writing big query.
+     * It takes DataFrame object df, SQL statement stmt, and number of splits, chunkSize.
+     * This method writes directly to connected SQL database, so there is no return type.
+     *
+     * @param  df  DataFrame object of loaded data
+     * @param  stmt SQL statement
+     * @param  chunkSize number of splits for rows of data
+     * @return      none
+     * Link to the issue: https://github.com/cardillo/joinery/issues/94
+     */
+
+
+    public static <V> void writeSql(final DataFrame<V> df, final PreparedStatement stmt, int chunkSize)
     throws SQLException {
         try {
             ParameterMetaData md = stmt.getParameterMetaData();
@@ -456,13 +472,51 @@ public static <V> void writeSql(final DataFrame<V> df, final PreparedStatement s
                 columns.add(md.getParameterType(i));
             }
 
-            for (int r = 0; r < df.length(); r++) {
-                for (int c = 1; c <= df.size(); c++) {
-                    stmt.setObject(c, df.get(r, c - 1));
+            if (chunkSize <= 0 | chunkSize >= df.length())
+            {
+                chunkSize = 1;
+            }
+
+            int split = df.length() / chunkSize;
+
+
+
+            if (chunkSize == 1)
+            {
+                for (int r = 0; r < df.length(); r++) {
+                    for (int c = 1; c <= df.size(); c++) {
+                        stmt.setObject(c, df.get(r, c - 1));
+                    }
+                    stmt.addBatch();
                 }
-                stmt.addBatch();
             }
 
+            else
+            {
+                int index = 0;
+
+                for (int z = 0; z < chunkSize-1; z++) {
+                    for (int r = 0; r < split; r++) {
+                        for (int c = 1; c <= df.size(); c++) {
+                            stmt.setObject(c, df.get(index, c - 1));
+                        }
+                        ++index;
+                        stmt.addBatch();
+                    }
+                }
+
+                for (;index < df.length();index++)
+                {
+                    for (int c = 1; c <= df.size(); c++) {
+                        stmt.setObject(c, df.get(index, c - 1));
+                    }
+                    stmt.addBatch();
+
+                }
+            }
+
+
+
             stmt.executeBatch();
         } finally {
             stmt.close();

src/test/java/joinery/DataFrameSerializationTest.java

@@ -283,15 +283,16 @@ public void testToStringEmptyHeader()
         DataFrame<Object> dfEmptyHeader = DataFrame.readCsv(ClassLoader.getSystemResourceAsStream("serialization_empty_header.csv"));
         dfEmptyHeader.transpose().toString();
     }
-
+    //Link to the issue: https://github.com/cardillo/joinery/issues/94
     @Test
     public void testToFromSql()
     throws Exception {
         Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
         try (Connection dbc = DriverManager.getConnection("jdbc:derby:memory:testdb;create=true")) {
             dbc.createStatement().executeUpdate("create table test (category varchar(32), name varchar(32), value int)");
             PreparedStatement stmt = dbc.prepareStatement("insert into test values (?,?,?)");
-            df.writeSql(stmt);
+            int chunkSize = 5;
+            df.writeSql(stmt, chunkSize);
 
             Map<Object, Object> names = new HashMap<>();
             names.put("CATEGORY", "category");