Merge branch 'master' of https://github.com/javalite/activejdbc

Author: ericbn

activejdbc/src/main/java/org/javalite/activejdbc/Base.java

@@ -226,34 +226,8 @@ public void onNext(Map row) {
      * @param params list of parameters if query is parametrized.
      * @return instance of <code>RowProcessor</code> which has with() method for convenience.
      */
-    public static RowProcessor find(String query, Object... params) {
-      return new DB(DB.DEFAULT_NAME).find(query, params);
-    }
-
-    /**
-     * Executes a raw query and calls the listener to handle the results. The listener should extend
-     * {@link RowListener} to process individual rows, or implement {@link ResultSetListener} to process the whole
-     * ResultSet. For very large result sets, call this method with <tt>streaming</tt> as <tt>true</tt>, as it will
-     * create a streaming PreparedStatement (currently only available for MySQL). Example:
-     *
-     * <blockquote><pre>
-     * Base.findWith(new RowListenerAdapter() {
-     *     @Override public void onNext(Map row) {
-     *         // write your code here
-     *         Object o1 = row.get("first_name");
-     *         Object o2 = row.get("last_name");
-     *     }
-     * }, true, "select first_name, last_name from really_large_table");
-     * </pre></blockquote>
-     *
-     * @param listener a subclass of {@link RowListener} to process individual rows, or an implementation of
-     * {@link ResultSetListener} to process the whole ResultSet
-     * @param streaming true to create a streaming PreparedStatement, false otherwise
-     * @param query raw SQL query
-     * @param params parameters of parametrized query
-     */
-    public static void findWith(ResultSetListener listener, boolean streaming, String query, Object... params) {
-      new DB(DB.DEFAULT_NAME).findWith(listener, streaming, query, params);
+    public static RowProcessor find(String query, Object ... params) {
+      return new DB(DB.DEFAULT_NAME).find(query, params);       
     }
 
     /**
@@ -264,31 +238,17 @@ public static void findWith(ResultSetListener listener, boolean streaming, Strin
      * @param listener client listener implementation for processing individual rows.
      */
     public static void find(String sql, RowListener listener) {
-        new DB(DB.DEFAULT_NAME).find(sql, listener);
+        new DB(DB.DEFAULT_NAME).find(sql, listener);        
     }
 
-    /**
-     * Executes a raw query and calls the listener to handle the results. The listener should extend
-     * {@link RowListener} to process individual rows, or implement {@link ResultSetListener} to process the whole
-     * ResultSet. For very large result sets, call this method with <tt>streaming</tt> as <tt>true</tt>, as it will
-     * create a streaming Statement (currently only available for MySQL).
-     *
-     * @param listener a subclass of {@link RowListener} to process individual rows, or an implementation of
-     * {@link ResultSetListener} to handle the whole ResultSet
-     * @param streaming true to create a streaming Statement, false otherwise
-     * @param query raw SQL query
-     */
-    public static void findWith(ResultSetListener listener, boolean streaming, String query) {
-        new DB(DB.DEFAULT_NAME).findWith(listener, streaming, query);
-    }
 
     /**
      * Executes DML. Use it for inserts and updates.
      *
      * @param query raw DML.
      * @return number of rows afected by query.
      */
-    public static int exec(String query) {
+    public static int exec(String query){
         return new DB(DB.DEFAULT_NAME).exec(query);
     }
 
@@ -300,13 +260,14 @@ public static int exec(String query) {
      * @param params  query parameters.
      * @return number of records affected.
      */
-    public static int exec(String query, Object... params) {
+    public static int exec(String query, Object ... params){
         return new DB(DB.DEFAULT_NAME).exec(query, params);
     }
+    
 
     /**
      * This method is specific for inserts.
-     *
+     * 
      * @param query SQL for inserts.
      * @param autoIncrementColumnName name of a column that is auto-incremented.
      * @param params list of parameter values.

activejdbc/src/main/java/org/javalite/activejdbc/DB.java

@@ -350,23 +350,25 @@ public List<Map> all(String query, Object ... params) {
      * This method returns entire resultset as one list. Do not use it for large result sets.
      * Example:
      * <pre>
-     * List&lt;Map&gt; people = db.findAll(&quot;select * from people where first_name = ?&quot;, &quot;John&quot;);
-     * for (Map person : people)
-     *     System.out.println(person.get("first_name"));
+     * <code>List&lt;Map&lt;String, Object&gt;&gt; people = Base.findAll(&quot;select * from people where first_name = ?&quot;, &quot;John&quot;);
+     *  for(Map person: people)
+     *      System.out.println(person.get(&quot;first_name&quot;));
+     * </code>
      * </pre>
      *
      * @param query raw SQL query. This query is parametrized.
      * @param params list of parameters for a parametrized query.
      * @return entire result set corresponding to the query.
      */
-    public List<Map> findAll(String query, Object... params) {
+    public List<Map> findAll(String query, Object ... params) {
+
         final List<Map> results = new ArrayList<Map>();
         long start = System.currentTimeMillis();
-        findWith(new RowListenerAdapter() {
+        find(query, params).with(new RowListenerAdapter() {
             @Override public void onNext(Map<String, Object> row) {
                 results.add(row);
             }
-        }, false, query, params);
+        });
         LogFilter.logQuery(logger, query, params, start);
         return results;
     }
@@ -423,13 +425,14 @@ public List<Map> all(String query) {
      * @return entire result set corresponding to the query.
      */
     public List<Map> findAll(String query) {
-        final List<Map> results = new ArrayList<Map>();
+
+        final ArrayList<Map> results = new ArrayList<Map>();
         long start = System.currentTimeMillis();
-        findWith(new RowListenerAdapter() {
+        find(query).with(new RowListenerAdapter() {
             @Override public void onNext(Map<String, Object> row) {
                 results.add(row);
             }
-        }, false, query);
+        });
 
         LogFilter.logQuery(logger, query, null, start);
         return results;
@@ -451,60 +454,27 @@ public void onNext(Map row) {
      * @param params list of parameters if query is parametrized.
      * @return instance of <code>RowProcessor</code> which has with() method for convenience.
      */
-    public RowProcessor find(String query, Object... params) {
+    public RowProcessor find(String query, Object ... params) {
+
+        //TODO: count ? signs and number of params, throw exception if do not match
+
         if(query.indexOf('?') == -1 && params.length != 0) throw new IllegalArgumentException("you passed arguments, but the query does not have placeholders: (?)");
 
         if(!SELECT_PATTERN.matcher(query).find()) { throw new IllegalArgumentException("query must be 'select' query"); }
 
-        try {
-            PreparedStatement ps = prepareStreamingStatement(query);
-            setParameters(ps, params);
-            ResultSet rs = ps.executeQuery();
-            return new RowProcessor(rs, ps);
-            // ps and rs will be closed by RowProcessor
-        } catch (SQLException e) { throw new DBException(query, params, e); }
-    }
-
-    /**
-     * Executes a raw query and calls the listener to handle the results. The listener should extend
-     * {@link RowListener} to process individual rows, or implement {@link ResultSetListener} to process the whole
-     * ResultSet. For very large result sets, call this method with <tt>streaming</tt> as <tt>true</tt>, as it will
-     * create a streaming PreparedStatement (currently only available for MySQL). Example:
-     *
-     * <blockquote><pre>
-     * db.findWith(new RowListenerAdapter() {
-     *     @Override public void onNext(Map row) {
-     *         // write your code here
-     *         Object o1 = row.get("first_name");
-     *         Object o2 = row.get("last_name");
-     *     }
-     * }, true, "select first_name, last_name from really_large_table");
-     * </pre></blockquote>
-     *
-     * @param listener a subclass of {@link RowListener} to process individual rows, or an implementation of
-     * {@link ResultSetListener} to process the whole ResultSet
-     * @param streaming true to create a streaming PreparedStatement, false otherwise
-     * @param query raw SQL query
-     * @param params parameters of parametrized query
-     */
-    public void findWith(ResultSetListener listener, boolean streaming, String query, Object... params) {
         //TODO: cache prepared statements here too
-        PreparedStatement ps = null;
-        ResultSet rs = null;
+        PreparedStatement ps;
+        ResultSet rs;
         try {
-            ps = streaming ? prepareStreamingStatement(query) : connection().prepareStatement(query);
+            ps = createStreamingPreparedStatement(query);
             setParameters(ps, params);
             rs = ps.executeQuery();
-            listener.onResultSet(rs);
-        } catch (SQLException e) {
-            throw new DBException(query, params, e);
-        } finally {
-            closeQuietly(rs);
-            closeQuietly(ps);
-        }
+            return new RowProcessor(rs, ps);
+
+        } catch (SQLException e) { throw new DBException(query, params, e); }
     }
 
-    private PreparedStatement prepareStreamingStatement(String query) throws SQLException {
+    private PreparedStatement createStreamingPreparedStatement(String query) throws SQLException {
         Connection conn = connection();
         PreparedStatement res;
         if ("mysql".equalsIgnoreCase(conn.getMetaData().getDatabaseProductName())) {
@@ -524,29 +494,16 @@ private PreparedStatement prepareStreamingStatement(String query) throws SQLExce
      * @param listener client listener implementation for processing individual rows.
      */
     public void find(String sql, RowListener listener) {
-        findWith(listener, true, sql);
-    }
 
-    /**
-     * Executes a raw query and calls the listener to handle the results. The listener should extend
-     * {@link RowListener} to process individual rows, or implement {@link ResultSetListener} to process the whole
-     * ResultSet. For very large result sets, call this method with <tt>streaming</tt> as <tt>true</tt>, as it will
-     * create a streaming Statement (currently only available for MySQL).
-     *
-     * @param listener a subclass of {@link RowListener} to process individual rows, or an implementation of
-     * {@link ResultSetListener} to handle the whole ResultSet
-     * @param streaming true to create a streaming Statement, false otherwise
-     * @param query raw SQL query
-     */
-    public void findWith(ResultSetListener listener, boolean streaming, String query) {
         Statement s = null;
         ResultSet rs = null;
         try {
-            s = streaming ? createStreamingStatement() : connection().createStatement();
-            rs = s.executeQuery(query);
-            listener.onResultSet(rs);
+            s = createStreamingStatement();
+            rs = s.executeQuery(sql);
+            RowProcessor p = new RowProcessor(rs, s);
+            p.with(listener);
         } catch (SQLException e) {
-            throw new DBException(query, null, e);
+            throw new DBException(sql, null, e);
         } finally {
             closeQuietly(rs);
             closeQuietly(s);
@@ -687,7 +644,8 @@ Object execInsert(String query, String autoIncrementColumnName, Object... params
         } catch (SQLException e) {
             throw new DBException(query, params, e);
         } finally {
-            // don't close ps as it is cached!
+            // don't close ps as it could have come from the cache!
+            //TODO: close ps if not cached?
         }
     }
 

activejdbc/src/main/java/org/javalite/activejdbc/LazyList.java

@@ -326,11 +326,11 @@ protected void hydrate() {
         }
         delegate = new ArrayList<T>();
         long start = System.currentTimeMillis();
-        new DB(metaModel.getDbName()).findWith(new RowListenerAdapter() {
+        new DB(metaModel.getDbName()).find(sql, params).with(new RowListenerAdapter() {
             @Override public void onNext(Map<String, Object> map) {
                 delegate.add(ModelDelegate.<T>instance(map, metaModel));
             }
-        }, false, sql, params);
+        });
         LogFilter.logQuery(logger, sql, params, start);
         if(metaModel.cached()){
             delegate = Collections.unmodifiableList(delegate);

activejdbc/src/main/java/org/javalite/activejdbc/ModelDelegate.java

@@ -211,11 +211,12 @@ public static <T extends Model, M extends T> void findWith(final Class<M> clazz,
         long start = System.currentTimeMillis();
         final MetaModel metaModel = metaModelOf(clazz);
         String sql = metaModel.getDialect().selectStar(metaModel.getTableName(), query);
-        new DB(metaModel.getDbName()).findWith(new RowListenerAdapter() {
-            @Override public void onNext(Map<String, Object> row) {
+        new DB(metaModel.getDbName()).find(sql, params).with(new RowListenerAdapter() {
+            @Override
+            public void onNext(Map<String, Object> row) {
                 listener.onModel(instance(row, metaModel, clazz));
             }
-        }, true, sql, params);
+        });
         LogFilter.logQuery(logger, sql, null, start);
     }
 

activejdbc/src/main/java/org/javalite/activejdbc/ResultSetListener.java

@@ -1,39 +1,26 @@
 /*
-Copyright 2009-2015 Igor Polevoy
+Copyright 2009-2014 Igor Polevoy
 
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
+Licensed under the Apache License, Version 2.0 (the "License"); 
+you may not use this file except in compliance with the License. 
+You may obtain a copy of the License at 
 
-http://www.apache.org/licenses/LICENSE-2.0
+http://www.apache.org/licenses/LICENSE-2.0 
 
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
+Unless required by applicable law or agreed to in writing, software 
+distributed under the License is distributed on an "AS IS" BASIS, 
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+See the License for the specific language governing permissions and 
+limitations under the License. 
 */
+
+
 package org.javalite.activejdbc;
 
-import java.sql.ResultSet;
-import java.sql.ResultSetMetaData;
-import java.sql.SQLException;
 import java.util.Map;
 
-public abstract class RowListener implements ResultSetListener {
-    @Override
-    public final void onResultSet(ResultSet rs) throws SQLException {
-        ResultSetMetaData metaData = rs.getMetaData();
-        while (rs.next()) {
-            Map<String, Object> row = new CaseInsensitiveMap<Object>();
-            int i = 1;
-            while (i <= metaData.getColumnCount()) {
-                row.put(metaData.getColumnLabel(i), rs.getObject(i));
-                i++;
-            }
-            if (!next(row)) { break; }
-        }
-    }
+
+public interface RowListener {
 
     /**
      * Implementations of this interface can return "false" from the next() method in order to stop fetching more results from DB.
@@ -43,5 +30,5 @@ public final void onResultSet(ResultSet rs) throws SQLException {
      * @param row Map instance containing values for a row. Keys are names of columns and values are .. values.
      * @return false if this listener needs to stop processing (no more calls to this method)
      */
-    public abstract boolean next(Map<String, Object> row);
+    boolean next(Map<String, Object> row);
 }