Code cleaning

pponec · pponec · commit ce98d556dadd · 2024-03-12T22:44:59.000+01:00
diff --git a/utils/SqlExecutor.java b/utils/SqlExecutor.java
@@ -7,10 +7,7 @@
  */
 package utils;
 
-import org.jetbrains.annotations.NotNull;
-import org.junit.jupiter.api.Assertions;
 import java.io.Closeable;
-import java.io.IOException;
 import java.sql.*;
 import java.time.LocalDate;
 import java.util.*;
@@ -27,12 +24,13 @@ public final class SqlExecutor {
     private final LocalDate someDate = LocalDate.parse("2018-09-12");
 
     public static void main(final String[] args) throws Exception {
+        System.out.println("Arguments: " + List.of(args));
         try (Connection dbConnection = db.connection()) {
-            new SqlExecutor().mainStart(dbConnection, args);
+            new SqlExecutor().mainStart(dbConnection);
         }
     }
 
-    void mainStart(Connection dbConnection, String... args) throws Exception {
+    void mainStart(Connection dbConnection) throws Exception {
         try (SqlParamBuilder builder = new SqlParamBuilder(dbConnection)) {
             // CREATE TABLE:
             builder.sql("""
@@ -41,16 +39,15 @@ void mainStart(Connection dbConnection, String... args) throws Exception {
                             , name VARCHAR(256) DEFAULT 'test'
                             , code VARCHAR(1)
                             , created DATE NOT NULL
-                            )""".stripLeading())
+                            )""")
                     .execute();
 
             // SINGLE INSERT:
-            System.out.println("SINGLE INSERT");
             builder.sql("""
                             INSERT INTO employee
                             ( id, code, created ) VALUES
                             ( :id, :code, :created )
-                            """.stripLeading())
+                            """)
                     .bind("id", 1)
                     .bind("code", "T")
                     .bind("created", someDate)
@@ -62,7 +59,7 @@ void mainStart(Connection dbConnection, String... args) throws Exception {
                             (id,code,created) VALUES
                             (:id1,:code,:created),
                             (:id2,:code,:created)
-                            """.stripLeading())
+                            """)
                     .bind("id1", 2)
                     .bind("id2", 3)
                     .bind("code", "T")
@@ -80,28 +77,29 @@ void mainStart(Connection dbConnection, String... args) throws Exception {
                             WHERE t.id < :id
                               AND t.code IN (:code)
                             ORDER BY t.id
-                            """.stripLeading())
+                            """)
                     .bind("id", 10)
                     .bind("code", "T", "V")
                     .streamMap(rs -> new Employee(
                             rs.getInt(1),
                             rs.getString(2),
                             rs.getObject(3, LocalDate.class)))
                     .toList();
-            Assertions.assertEquals(3, employees.size());
-            Assertions.assertEquals(1, employees.get(0).id);
-            Assertions.assertEquals("test", employees.get(0).name);
-            Assertions.assertEquals(someDate, employees.get(0).created);
 
-            // REUSE SELECT:
+            assertEquals(3, employees.size());
+            assertEquals(1, employees.get(0).id);
+            assertEquals("test", employees.get(0).name);
+            assertEquals(someDate, employees.get(0).created);
+
+            // REUSE THE SELECT:
             List<Employee> employees2 = builder
                     .bind("id", 100)
                     .streamMap(rs -> new Employee(
                             rs.getInt(1),
                             rs.getString(2),
                             rs.getObject(3, LocalDate.class)))
                     .toList();
-            Assertions.assertEquals(5, employees2.size());
+            assertEquals(5, employees2.size());
         }
     }
 
@@ -125,53 +123,85 @@ public static ConnectionProvider forH2(String user, String passwd) {
         }
     }
 
-    /** A utility class from the Ujorm framework */
-    static class SqlParamBuilder implements Closeable {
+    private <T> void assertEquals(T expected, T result) {
+        if (!Objects.equals(expected, result)) {
+            throw new IllegalStateException("Objects are not equals: '%s' <> '%s'".formatted(expected, result));
+        }
+    }
 
+    /**
+     * 170 lines long class to simplify working with JDBC.
+     * Original source: <a href="https://github.com/pponec/DirectoryBookmarks/blob/development/utils/SqlExecutor.java">GitHub</a>
+     * @version 1.0.5
+     */
+    static class SqlParamBuilder implements Closeable {
         /** SQL parameter mark type of {@code :param} */
-        private static final Pattern SQL_MARK = Pattern.compile(":(\\w+)(?=[\\s,;\\])]|$)");
+        private static final Pattern SQL_MARK = Pattern.compile(":(\\w+)");
         private final Connection dbConnection;
         private final Map<String, Object> params = new HashMap<>();
         private String sqlTemplate = null;
         private PreparedStatement preparedStatement = null;
-        private ResultSetWrapper rsWrapper = null;
+        private ResultSet resultSet = null;
 
         public SqlParamBuilder(Connection dbConnection) {
             this.dbConnection = dbConnection;
         }
 
         /** Close statement (if any) and set a new SQL template */
-        public SqlParamBuilder sql(@NotNull String... sqlTemplates ) {
+        public SqlParamBuilder sql(String... sqlTemplates ) {
             close();
+            this.params.clear();
             this.sqlTemplate = sqlTemplates.length == 1
                     ? sqlTemplates[0] : String.join("\n", sqlTemplates);
             return this;
         }
 
         /** Assign a SQL value(s) */
-        public SqlParamBuilder bind(@NotNull String key, @NotNull Object... value) {
+        public SqlParamBuilder bind(String key, Object... value) {
             this.params.put(key, value.length == 1 ? value[0] : List.of(value));
             return this;
         }
 
-        public Iterable<ResultSet> executeSelect() throws IllegalStateException, SQLException {
-            try (Closeable rs = rsWrapper) {
-            } catch (IOException e) {
+        private ResultSet executeSelect() throws IllegalStateException {
+            try (AutoCloseable rs = resultSet) {
+            } catch (Exception e) {
                 throw new IllegalStateException("Closing fails", e);
             }
-            rsWrapper = new ResultSetWrapper(prepareStatement().executeQuery());
-            return rsWrapper;
+            try {
+                resultSet = prepareStatement().executeQuery();
+                return resultSet;
+            } catch (Exception ex) {
+                throw (ex instanceof RuntimeException re) ? re : new IllegalStateException(ex);
+            }
+        }
+
+        /** Use a {@link #streamMap(SqlFunction)} rather */
+        private Stream<ResultSet> stream() {
+            final var resultSet = executeSelect();
+            final var iterator = new Iterator<ResultSet>() {
+                @Override
+                public boolean hasNext() {
+                    try {
+                        return resultSet.next();
+                    } catch (SQLException e) {
+                        throw new IllegalStateException(e);
+                    }
+                }
+                @Override
+                public ResultSet next() {
+                    return resultSet;
+                }
+            };
+            return StreamSupport.stream(Spliterators.spliteratorUnknownSize(iterator, Spliterator.ORDERED), false);
         }
 
         /** Iterate executed select */
         public void forEach(SqlConsumer<ResultSet> consumer) throws IllegalStateException, SQLException  {
-            for (ResultSet rs : executeSelect()) {
-                consumer.accept(rs);
-            }
+            stream().forEach(consumer);
         }
 
-        public <R> Stream<R> streamMap(SqlFunction<ResultSet, ? extends R> mapper ) throws SQLException {
-            return StreamSupport.stream(executeSelect().spliterator(), false).map(mapper);
+        public <R> Stream<R> streamMap(SqlFunction<ResultSet, ? extends R> mapper ) {
+            return stream().map(mapper);
         }
 
         public int execute() throws IllegalStateException, SQLException {
@@ -185,11 +215,11 @@ public Connection getConnection() {
         /** The method closes a PreparedStatement object with related objects, not the database connection. */
         @Override
         public void close() {
-            try (Closeable c1 = rsWrapper; PreparedStatement c2 = preparedStatement) {
+            try (AutoCloseable c1 = resultSet; PreparedStatement c2 = preparedStatement) {
             } catch (Exception e) {
                 throw new IllegalStateException("Closing fails", e);
             } finally {
-                rsWrapper = null;
+                resultSet = null;
                 preparedStatement = null;
             }
         }
@@ -245,80 +275,29 @@ public String toString() {
             return buildSql(new ArrayList<>(), true);
         }
 
-        /** Based on the {@code RowIterator} class of Ujorm framework. */
-        static final class ResultSetWrapper implements Iterable<ResultSet>, Iterator<ResultSet>, Closeable {
-            private ResultSet resultSet;
-            /** It the cursor ready for reading? After a row reading the value will be set to false */
-            private boolean cursorReady = false;
-            /** Has a resultset a next row? */
-            private boolean hasNext = false;
-
-            public ResultSetWrapper( final ResultSet resultSet) {
-                this.resultSet = resultSet;
-            }
-
-            @Override
-            public Iterator<ResultSet> iterator() {
-                return this;
-            }
-
-            /** The last checking closes all resources. */
-            @Override
-            public boolean hasNext() throws IllegalStateException {
-                if (!cursorReady) try {
-                    hasNext = resultSet.next();
-                    if (!hasNext) {
-                        close();
-                    }
-                    cursorReady = true;
-                } catch (SQLException e) {
-                    throw new IllegalStateException(e);
-                }
-                return hasNext;
-            }
-
-            @Override
-            public ResultSet next() {
-                if (hasNext()) {
-                    cursorReady = false;
-                    return resultSet;
-                }
-                throw new NoSuchElementException();
-            }
-
-            @Override
-            public void close() {
-                try (ResultSet rs = resultSet) {
-                    cursorReady = true;
-                    hasNext = false;
-                } catch (SQLException e) {
-                    throw new IllegalStateException(e);
-                }
-            }
-        }
-
-
         @FunctionalInterface
         public interface SqlFunction<T, R> extends Function<T, R> {
             default R apply(T resultSet) {
-                try { return applyRs(resultSet); } catch (SQLException ex) {
-                    throw new IllegalStateException(ex);
+                try {
+                    return applyRs(resultSet);
+                } catch (Exception ex) {
+                    throw (ex instanceof RuntimeException re) ? re : new IllegalStateException(ex);
                 }
             }
-
             R applyRs(T resultSet) throws SQLException;
         }
 
         @FunctionalInterface
         public interface SqlConsumer<T> extends Consumer<T> {
             @Override
             default void accept(final T t) {
-                try { acceptResultSet(t); } catch (SQLException e) {
-                    throw new IllegalStateException(e);
+                try {
+                    acceptResultSet(t);
+                } catch (Exception ex) {
+                    throw (ex instanceof RuntimeException re) ? re : new IllegalStateException(ex);
                 }
             }
-
-            void acceptResultSet(T t) throws SQLException;
+            void acceptResultSet(T t) throws Exception;
         }
     }
 }
diff --git a/utils/SqlExecutor.sh b/utils/SqlExecutor.sh
@@ -1,4 +1,6 @@
 #!/bin/bash
 # Sample SQL scripting for the Bash and Java v17.
 
-java -cp ../lib/h2-2.2.224.jar SqlExecutor.java
+java -cp ../lib/h2-2.2.224.jar SqlExecutor.java "$@"
+
+
diff --git a/utils/SqlParamBuilderTest.java b/utils/SqlParamBuilderTest.java
@@ -123,8 +123,7 @@ public void loggingSql() {
             Assertions.assertEquals(builder.sqlTemplate(), builder.toString());
 
             IllegalArgumentException ex = Assertions.assertThrows(IllegalArgumentException.class, () -> {
-                for (ResultSet rs : builder.executeSelect()) {
-                }
+                var count = builder.streamMap(t -> t).count();
             });
             assertEquals("Missing value of the keys: [code, id]", ex.getMessage());
 
