Small addons

Author: ZorTik

core/src/main/java/me/zort/sqllib/SQLDatabaseConnection.java

@@ -34,7 +34,7 @@ public SQLDatabaseConnection(SQLConnectionFactory connectionFactory) {
     }
 
     @ApiStatus.Experimental
-    public abstract <T> T createMapping(Class<T> mappingInterface);
+    public abstract <T> T createGate(Class<T> mappingInterface);
 
     /**
      * Saves this mapping object into database using upsert query.

core/src/main/java/me/zort/sqllib/SQLDatabaseConnectionImpl.java

@@ -130,7 +130,7 @@ public void setObjectMapper(@NotNull ObjectMapper objectMapper) {
      */
     @SuppressWarnings("unchecked")
     @ApiStatus.Experimental
-    public <T> T createMapping(Class<T> mappingInterface) {
+    public <T> T createGate(Class<T> mappingInterface) {
         StatementMappingStrategy<T> statementMapping = mappingFactory.create(mappingInterface, this);
         return (T) Proxy.newProxyInstance(mappingInterface.getClassLoader(),
                 new Class[]{mappingInterface}, (proxy, method, args) -> {

core/src/main/java/me/zort/sqllib/internal/query/QueryNodeRequest.java

@@ -25,8 +25,20 @@ public Optional<Row> obtainOne() {
                 : Optional.ofNullable(resultList.get(0));
     }
 
+    public <T> Optional<T> obtainOne(Class<T> mapTo) {
+        QueryRowsResult<T> resultList = obtainAll(mapTo);
+
+        return resultList.isEmpty()
+                ? Optional.empty()
+                : Optional.ofNullable(resultList.get(0));
+    }
+
     public QueryRowsResult<Row> obtainAll() {
         return invokeToConnection(connection -> connection.query(getAncestor()));
     }
 
+    public <T> QueryRowsResult<T> obtainAll(Class<T> mapTo) {
+        return invokeToConnection(connection -> connection.query(getAncestor(), mapTo));
+    }
+
 }

core/src/main/java/me/zort/sqllib/mapping/QueryAnnotation.java

@@ -22,7 +22,7 @@
  * Represents a query annotation wrapper used in default statement
  * mapping proxy. Query that is wrapped appears on abstract methods
  * of the proxy instance created using:
- * {@link me.zort.sqllib.SQLDatabaseConnection#createMapping(Class)}
+ * {@link me.zort.sqllib.SQLDatabaseConnection#createGate(Class)}
  *
  * @author ZorTik
  */

examples/src/main/java/me/zort/sqllib/QuickStart.java

@@ -0,0 +1,116 @@
+package me.zort.sqllib;
+
+import me.zort.sqllib.api.data.QueryResult;
+import me.zort.sqllib.api.data.QueryRowsResult;
+import me.zort.sqllib.api.data.Row;
+import me.zort.sqllib.internal.annotation.PrimaryKey;
+import me.zort.sqllib.mapping.annotation.*;
+
+import java.util.List;
+import java.util.Optional;
+
+public class QuickStart {
+
+    private SQLDatabaseConnection connection;
+
+    public void quickStart() {
+
+        String address = "localhost";
+        int port = 3306;
+        String database = "database";
+        String username = "username";
+        String password = "password";
+
+        connection = new SQLConnectionBuilder(address, port, database, username, password).build();
+
+        if (!connection.connect()) {
+            System.out.println("Failed to connect to the database!");
+            System.exit(1);
+        }
+
+        QueryResult result = connection.exec(() ->
+                "CREATE TABLE IF NOT EXISTS users(" +
+                "firstname VARCHAR(32) PRIMARY KEY NOT NULL," +
+                "lastname VARCHAR(32) NOT NULL);");
+
+        if (!result.isSuccessful()) {
+            System.out.println("Failed to create the table!");
+            System.out.println(result.getRejectMessage());
+            System.exit(1);
+        }
+
+        QueryResult result2 = connection.insert()
+                .into("users", "firstname", "lastname")
+                .values("John", "Doe")
+                .execute();
+
+        Optional<Row> result3 = connection.select()
+                .from("users")
+                .where().isEqual("firstname", "John")
+                .obtainOne();
+
+        if (!result3.isPresent()) {
+            System.out.println("Where did John go?");
+            System.exit(1);
+        }
+
+        connection.select();
+        connection.update();
+        connection.delete();
+        connection.upsert();
+
+        connection.disconnect();
+    }
+
+    class User {
+        @PrimaryKey
+        private String firstname;
+        private String lastname;
+
+        public User(String firstname, String lastname) {
+            this.firstname = firstname;
+            this.lastname = lastname;
+        }
+    }
+
+    public void saveUser() {
+        User user = new User("John", "Doe");
+        QueryResult result = connection.save("users", user);
+    }
+
+    public void loadUser() {
+        User user = connection.select()
+                .from("users")
+                .where().isEqual("firstname", "John")
+                .obtainOne(User.class)
+                .orElse(null);
+    }
+
+
+    @Table("users")
+    interface UsersGate {
+
+        @Save
+        QueryResult saveUser(User user);
+
+        @Select
+        @Where(@Where.Condition(column = "firstname", value = "{First Name}"))
+        Optional<User> getUser(@Placeholder("First Name") String firstName);
+
+        @Select
+        @Limit(10)
+        List<User> selectFirstTen();
+
+        @Delete
+        void deleteAll();
+    }
+
+    public void gateExample() {
+        UsersGate gate = connection.createGate(UsersGate.class);
+
+        QueryResult result = gate.saveUser(new User("John", "Doe"));
+
+        User user = gate.getUser("John").orElse(null);
+    }
+
+}

src/test/java/me/zort/sqllib/test/TestCase2.java

@@ -50,7 +50,7 @@ public void prepare() {
     public void test1_Mapping() {
         assertNull(connection.save("users", new User("User1", 1000)).getRejectMessage());
 
-        DatabaseRepository repository = connection.createMapping(DatabaseRepository.class);
+        DatabaseRepository repository = connection.createGate(DatabaseRepository.class);
         assertTrue(repository.selectOne("User1").isPresent());
         assertFalse(repository.selectAll().isEmpty());
         assertNull(repository.deleteAll().getRejectMessage());