Merge pull request #33 from ZorTik/development

Schema synchronization improvements & tests

Author: ZorTik

api/src/main/java/me/zort/sqllib/api/data/QueryResult.java

@@ -13,4 +13,17 @@ public interface QueryResult {
     @Nullable
     String getRejectMessage();
 
+    static QueryResult successful() {
+        return new QueryResult() {
+            @Override
+            public boolean isSuccessful() {
+                return true;
+            }
+            @Override
+            public @Nullable String getRejectMessage() {
+                return null;
+            }
+        };
+    }
+
 }

api/src/main/java/me/zort/sqllib/api/mapping/MappingProxyInstance.java

@@ -8,7 +8,7 @@
 
 public interface MappingProxyInstance<T> extends InvocationHandler {
 
-    T getProxyInstance();
+    Class<T> getTypeClass();
     List<TableSchema> getTableSchemas(NamingStrategy namingStrategy, boolean sqLite);
 
 }

api/src/main/java/me/zort/sqllib/api/model/ColumnDefinition.java

@@ -0,0 +1,18 @@
+package me.zort.sqllib.api.model;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@AllArgsConstructor
+@Getter
+public class ColumnDefinition {
+
+    private final String name;
+    private final String type;
+
+    @Override
+    public String toString() {
+        return name + " " + type;
+    }
+
+}

api/src/main/java/me/zort/sqllib/api/model/SchemaSynchronizer.java

@@ -1,11 +1,14 @@
 package me.zort.sqllib.api.model;
 
+import me.zort.sqllib.api.SQLConnection;
+import me.zort.sqllib.api.data.QueryResult;
+
 /**
  * Synchronized (updates) table schema (column definitions) in provided source.
  *
  * @param <S> The target source
  */
-public interface SchemaSynchronizer<S> {
+public interface SchemaSynchronizer<S extends SQLConnection> {
 
     /**
      * Table synchronization logic in provided source.
@@ -16,6 +19,6 @@ public interface SchemaSynchronizer<S> {
      * @param from The template schema
      * @param to The schema to be <u>updated</u> to match 'from' schema
      */
-    void synchronize(S source, TableSchema from, TableSchema to);
+    QueryResult synchronize(S source, TableSchema from, TableSchema to);
 
 }

api/src/main/java/me/zort/sqllib/api/model/TableSchema.java

@@ -1,20 +1,39 @@
 package me.zort.sqllib.api.model;
 
+import me.zort.sqllib.util.Pair;
+
 public class TableSchema {
 
     private final String table;
-    private final String[] definitions;
+    private final ColumnDefinition[] definitions;
 
-    public TableSchema(String table, String[] definitions) {
+    public TableSchema(String table, ColumnDefinition[] definitions) {
         this.table = table;
         this.definitions = definitions;
     }
 
-    public String getDefinition(int index) {
+    public ColumnDefinition getDefinitionDetails(int index) {
         return definitions[index];
     }
 
+    public String getDefinitionName(int index) {
+        return getDefinitionDetails(index).getName();
+    }
+
+    public String getDefinitionType(int index) {
+        return getDefinitionDetails(index).getType();
+    }
+
+    public String getDefinition(int index) {
+        ColumnDefinition details = getDefinitionDetails(index);
+        return details.getName() + " " + details.getType();
+    }
+
     public String[] getDefinitions() {
+        String[] definitions = new String[this.definitions.length];
+        for (int i = 0; i < definitions.length; i++) {
+            definitions[i] = getDefinition(i);
+        }
         return definitions;
     }
 

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

@@ -56,8 +56,15 @@ public SQLDatabaseConnection(final @NotNull SQLConnectionFactory connectionFacto
      * @param mappingFactory Mapping factory to use.
      */
     public abstract void setProxyMapping(final @NotNull StatementMappingFactory mappingFactory);
+
+    /**
+     * Sets the schema synchronizer to use with synchronizeModel methods.
+     *
+     * @param synchronizer Schema synchronizer to use
+     */
     @ApiStatus.Experimental
     public abstract void setSchemaSynchronizer(SchemaSynchronizer<SQLDatabaseConnection> synchronizer);
+
     @ApiStatus.Experimental
     public abstract StatementMappingRegistry getMappingRegistry();
 
@@ -101,12 +108,40 @@ public SQLDatabaseConnection(final @NotNull SQLConnectionFactory connectionFacto
     public abstract <T> T createProxy(Class<T> mappingInterface);
     public abstract <T> T createProxy(Class<T> mappingInterface, @NotNull StatementMappingOptions options);
     public abstract boolean buildEntitySchema(String tableName, Class<?> entityClass);
+
+    /**
+     * Synchronizes proxy mapping models with database.<br>
+     * <i>Warning:</i> This tries to update all tables that are part of mapping
+     * proxies. Should be used carefully.
+     *
+     * @return True if synchronization was successful
+     */
     @ApiStatus.Experimental
-    public abstract void synchronizeModel();
+    public abstract boolean synchronizeModel();
+
+    /**
+     * Synchronizes provided entity schema with the database
+     * In other words, it tries to update database schema (table) to match
+     * the provided entity schema.
+     *
+     * @param entitySchema Entity schema
+     * @param table Table name
+     * @return True if synchronization was successful
+     */
     @ApiStatus.Experimental
-    public abstract void synchronizeModel(TableSchema entitySchema, String table);
+    public abstract boolean synchronizeModel(TableSchema entitySchema, String table);
+    /**
+     * Synchronizes provided entity class with the database
+     * In other words, it tries to update database schema (table) to match
+     * the provided entity schema. This method uses synchronizeModel method
+     * with schema generated from the provided entity class.
+     *
+     * @param entity The entity (model) class
+     * @param table Table name
+     * @return True if synchronization was successful
+     */
     @ApiStatus.Experimental
-    public abstract void synchronizeModel(Class<?> entity, String table);
+    public abstract boolean synchronizeModel(Class<?> entity, String table);
 
     /**
      * Performs new query and returns the result. This result is never null.

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

@@ -176,28 +176,59 @@ public void enableCaching(CacheManager cacheManager) {
         this.cacheManager = cacheManager;
     }
 
+    /**
+     * Synchronizes proxy mapping models with database.<br>
+     * <i>Warning:</i> This tries to update all tables that are part of mapping
+     * proxies. Should be used carefully.
+     *
+     * @return True if synchronization was successful
+     */
     @ApiStatus.Experimental
     @Override
-    public void synchronizeModel() {
-        mappingRegistry.getProxyInstances()
+    public boolean synchronizeModel() {
+        return mappingRegistry.getProxyInstances()
                 .stream().flatMap(i -> i.getTableSchemas(
                         getOptions().getNamingStrategy(),
                         this instanceof SQLiteDatabaseConnectionImpl).stream())
-                .forEach(schema -> synchronizeModel(schema, schema.getTable()));
+                .allMatch(schema -> synchronizeModel(schema, schema.getTable()));
     }
 
+    /**
+     * Synchronizes provided entity schema with the database
+     * In other words, it tries to update database schema (table) to match
+     * the provided entity schema.
+     *
+     * @param entitySchema Entity schema
+     * @param table Table name
+     * @return True if synchronization was successful
+     */
     @ApiStatus.Experimental
     @Override
-    public void synchronizeModel(TableSchema entitySchema, String table) {
-        getSchemaSynchronizer().synchronize(this, entitySchema, getSchemaBuilder(table).buildTableSchema());
+    public boolean synchronizeModel(TableSchema entitySchema, String table) {
+        return getSchemaSynchronizer().synchronize(this, entitySchema, getSchemaBuilder(table).buildTableSchema()).isSuccessful();
     }
 
+    /**
+     * Synchronizes provided entity class with the database
+     * In other words, it tries to update database schema (table) to match
+     * the provided entity schema. This method uses synchronizeModel method
+     * with schema generated from the provided entity class.
+     *
+     * @param entity The entity (model) class
+     * @param table Table name
+     * @return True if synchronization was successful
+     */
     @ApiStatus.Experimental
     @Override
-    public void synchronizeModel(Class<?> entity, String table) {
-        synchronizeModel(new EntitySchemaBuilder(table, entity, getOptions().getNamingStrategy(), this instanceof SQLiteDatabaseConnectionImpl).buildTableSchema(), table);
+    public boolean synchronizeModel(Class<?> entity, String table) {
+        return synchronizeModel(new EntitySchemaBuilder(table, entity, getOptions().getNamingStrategy(), this instanceof SQLiteDatabaseConnectionImpl).buildTableSchema(), table);
     }
 
+    /**
+     * Sets the schema synchronizer to use with synchronizeModel methods.
+     *
+     * @param synchronizer Schema synchronizer to use
+     */
     @ApiStatus.Experimental
     @Override
     public void setSchemaSynchronizer(SchemaSynchronizer<SQLDatabaseConnection> synchronizer) {
@@ -279,15 +310,16 @@ public final <T> T createProxy(final @NotNull Class<T> mappingInterface, final @
         Objects.requireNonNull(options, "Options cannot be null!");
 
         AtomicReference<MappingProxyInstance<T>> instanceReference = new AtomicReference<>();
-        instanceReference.set(new ProxyInstanceImpl<>((T) Proxy.newProxyInstance(mappingInterface.getClassLoader(),
-                new Class[]{mappingInterface}, (proxy, method, args) -> instanceReference.get().invoke(proxy, method, args)),
+        T rawInstance = (T) Proxy.newProxyInstance(mappingInterface.getClassLoader(),
+                new Class[]{mappingInterface}, (proxy, method, args) -> instanceReference.get().invoke(proxy, method, args));
+        instanceReference.set(new ProxyInstanceImpl<>(mappingInterface,
                 options,
                 mappingFactory.strategy(mappingInterface, this),
                 mappingFactory.resultAdapter()));
 
         MappingProxyInstance<T> proxyInstanceWrapper = instanceReference.get();
         mappingRegistry.registerProxy(proxyInstanceWrapper);
-        return proxyInstanceWrapper.getProxyInstance();
+        return rawInstance;
     }
 
     @ApiStatus.Experimental

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

@@ -29,7 +29,7 @@ public MappingRegistryImpl(SQLDatabaseConnectionImpl connection, SchemaSynchroni
 
     @Override
     public void registerProxy(MappingProxyInstance<?> proxyInstance) {
-        proxyWrappers.put(proxyInstance.getProxyInstance().getClass(), proxyInstance);
+        proxyWrappers.put(proxyInstance.getTypeClass(), proxyInstance);
     }
 
     @Override

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

@@ -21,18 +21,18 @@
 @Getter
 public class ProxyInstanceImpl<T> implements MappingProxyInstance<T> {
 
-    private final T proxyInstance;
+    private final Class<T> typeClass;
     private final StatementMappingOptions options;
     private final StatementMappingStrategy<T> statementMapping;
     private final StatementMappingResultAdapter mappingResultAdapter;
 
     private final List<Method> pendingMethods = new CopyOnWriteArrayList<>();
 
-    public ProxyInstanceImpl(T proxyInstance,
+    public ProxyInstanceImpl(Class<T> typeClass,
                              StatementMappingOptions options,
                              StatementMappingStrategy<T> statementMappingStrategy,
                              StatementMappingResultAdapter mappingResultAdapter) {
-        this.proxyInstance = proxyInstance;
+        this.typeClass = typeClass;
         this.options = options;
         this.statementMapping = statementMappingStrategy;
         this.mappingResultAdapter = mappingResultAdapter;
@@ -61,10 +61,13 @@ public Object invoke(Object proxy, Method method, Object[] args) throws Throwabl
     @Override
     public List<TableSchema> getTableSchemas(NamingStrategy namingStrategy, boolean sqLite) {
         List<TableSchema> schemaList = new ArrayList<>();
-        for (Method method : proxyInstance.getClass().getDeclaredMethods()) {
+        for (Method method : getTypeClass().getDeclaredMethods()) {
             Class<?> resultType = mappingResultAdapter.retrieveResultType(method);
-            String table = Table.Util.getFromContext(method, null);
-            schemaList.add(new EntitySchemaBuilder(table, resultType, namingStrategy, sqLite).buildTableSchema());
+
+            if (!QueryResult.class.isAssignableFrom(resultType) && statementMapping.isMappingMethod(method)) {
+                String table = options.getTable() != null ? options.getTable() : Table.Util.getFromContext(method, null);
+                schemaList.add(new EntitySchemaBuilder(table, resultType, namingStrategy, sqLite).buildTableSchema());
+            }
         }
         return schemaList;
     }

core/src/main/java/me/zort/sqllib/mapping/annotation/Table.java

@@ -26,7 +26,7 @@ public static String getFromContext(Method method, @Nullable ParameterPair[] par
             } else if(method.getDeclaringClass().isAnnotationPresent(Table.class)) {
                 return mapper.assignValues(method.getDeclaringClass().getAnnotation(Table.class).value());
             } else {
-                throw new SQLMappingException("Method " + method.getName() + " requires @Table annotation", method, null);
+                throw new SQLMappingException("Method " + method.getName() + " in class " + method.getDeclaringClass().getSimpleName() + " requires @Table annotation", method, null);
             }
         }
     }