From b129d9156f45005e28960fedc83cf0c8e3bb1984 Mon Sep 17 00:00:00 2001 From: Denis Buzdalov Date: Tue, 24 Jun 2014 12:57:44 +0400 Subject: [PATCH 1/7] The ORM config class' constructor was made protected. This makes the user able to create ORM config with the custom SqlWriterStrategy which seems to be useful. --- jirm-orm/src/main/java/co/jirm/orm/OrmConfig.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/jirm-orm/src/main/java/co/jirm/orm/OrmConfig.java b/jirm-orm/src/main/java/co/jirm/orm/OrmConfig.java index 436ad30..7328701 100644 --- a/jirm-orm/src/main/java/co/jirm/orm/OrmConfig.java +++ b/jirm-orm/src/main/java/co/jirm/orm/OrmConfig.java @@ -25,7 +25,7 @@ public class OrmConfig { private final SqlObjectConfig sqlObjectConfig; private final SqlWriterStrategy sqlWriterStrategy; - private OrmConfig(SqlExecutor sqlExecutor, SqlObjectConfig sqlObjectConfig, SqlWriterStrategy sqlWriterStrategy) { + protected OrmConfig(SqlExecutor sqlExecutor, SqlObjectConfig sqlObjectConfig, SqlWriterStrategy sqlWriterStrategy) { super(); this.sqlExecutor = sqlExecutor; this.sqlObjectConfig = sqlObjectConfig; From 9207122fe28c699f59b2d57d27dbf54af7e0cee4 Mon Sep 17 00:00:00 2001 From: Denis Buzdalov Date: Tue, 24 Jun 2014 13:07:52 +0400 Subject: [PATCH 2/7] Well, it seems it's better to have event 'public' ORM config constructor. --- jirm-orm/src/main/java/co/jirm/orm/OrmConfig.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/jirm-orm/src/main/java/co/jirm/orm/OrmConfig.java b/jirm-orm/src/main/java/co/jirm/orm/OrmConfig.java index 7328701..01147b1 100644 --- a/jirm-orm/src/main/java/co/jirm/orm/OrmConfig.java +++ b/jirm-orm/src/main/java/co/jirm/orm/OrmConfig.java @@ -25,7 +25,7 @@ public class OrmConfig { private final SqlObjectConfig sqlObjectConfig; private final SqlWriterStrategy sqlWriterStrategy; - protected OrmConfig(SqlExecutor sqlExecutor, SqlObjectConfig sqlObjectConfig, SqlWriterStrategy sqlWriterStrategy) { + public OrmConfig(SqlExecutor sqlExecutor, SqlObjectConfig sqlObjectConfig, SqlWriterStrategy sqlWriterStrategy) { super(); this.sqlExecutor = sqlExecutor; this.sqlObjectConfig = sqlObjectConfig; From a807fa97685af68d0d98a9995776b43beef327b3 Mon Sep 17 00:00:00 2001 From: Denis Buzdalov Date: Tue, 24 Jun 2014 13:21:29 +0400 Subject: [PATCH 3/7] A constructor with parameters of the factory method was added to the sql writer strategy class. --- .../src/main/java/co/jirm/orm/writer/SqlWriterStrategy.java | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/jirm-orm/src/main/java/co/jirm/orm/writer/SqlWriterStrategy.java b/jirm-orm/src/main/java/co/jirm/orm/writer/SqlWriterStrategy.java index 30b2c15..4cdb101 100644 --- a/jirm-orm/src/main/java/co/jirm/orm/writer/SqlWriterStrategy.java +++ b/jirm-orm/src/main/java/co/jirm/orm/writer/SqlWriterStrategy.java @@ -47,8 +47,12 @@ protected SqlWriterStrategy(Joiner commaJoiner, String clauseSpaceSeparator) { this.clauseSpaceSeparator = clauseSpaceSeparator; } + protected SqlWriterStrategy(String sep) { + this(Joiner.on("," + sep), sep); + } + public static SqlWriterStrategy newInstance(String sep) { - return new SqlWriterStrategy(Joiner.on("," + sep),sep); + return new SqlWriterStrategy(sep); } public StringBuilder insertStatement(StringBuilder qb, final SqlObjectDefinition definition, Map m) { From da27940e2e513b082abd8b2943710617a0cb0920 Mon Sep 17 00:00:00 2001 From: Denis Buzdalov Date: Tue, 24 Jun 2014 14:51:19 +0400 Subject: [PATCH 4/7] Dao hooks notion was invented. Jet only pre-insert action is supported. It is called each time before the insert action is performed. --- .../src/main/java/co/jirm/orm/OrmConfig.java | 18 +++++++++++++++--- .../main/java/co/jirm/orm/dao/DaoHooks.java | 11 +++++++++++ .../src/main/java/co/jirm/orm/dao/JirmDao.java | 12 ++++++++++-- 3 files changed, 36 insertions(+), 5 deletions(-) create mode 100644 jirm-orm/src/main/java/co/jirm/orm/dao/DaoHooks.java diff --git a/jirm-orm/src/main/java/co/jirm/orm/OrmConfig.java b/jirm-orm/src/main/java/co/jirm/orm/OrmConfig.java index 01147b1..5a8db33 100644 --- a/jirm-orm/src/main/java/co/jirm/orm/OrmConfig.java +++ b/jirm-orm/src/main/java/co/jirm/orm/OrmConfig.java @@ -17,21 +17,29 @@ import co.jirm.core.execute.SqlExecutor; import co.jirm.mapper.SqlObjectConfig; +import co.jirm.orm.dao.DaoHooks; import co.jirm.orm.writer.SqlWriterStrategy; +import com.google.common.base.Optional; public class OrmConfig { private final SqlExecutor sqlExecutor; private final SqlObjectConfig sqlObjectConfig; private final SqlWriterStrategy sqlWriterStrategy; - - public OrmConfig(SqlExecutor sqlExecutor, SqlObjectConfig sqlObjectConfig, SqlWriterStrategy sqlWriterStrategy) { + private final Optional daoHooks; + + public OrmConfig(SqlExecutor sqlExecutor, SqlObjectConfig sqlObjectConfig, SqlWriterStrategy sqlWriterStrategy, Optional daoHooks) { super(); this.sqlExecutor = sqlExecutor; this.sqlObjectConfig = sqlObjectConfig; this.sqlWriterStrategy = sqlWriterStrategy; + this.daoHooks = daoHooks; } - + + public OrmConfig(SqlExecutor sqlExecutor, SqlObjectConfig sqlObjectConfig, SqlWriterStrategy sqlWriterStrategy) { + this(sqlExecutor, sqlObjectConfig, sqlWriterStrategy, Optional.absent()); + } + public static OrmConfig newInstance(SqlExecutor sqlExecutor, SqlObjectConfig objectConfig) { return new OrmConfig(sqlExecutor, SqlObjectConfig.DEFAULT, SqlWriterStrategy.newInstance("\n")); } @@ -51,4 +59,8 @@ public SqlObjectConfig getSqlObjectConfig() { public SqlExecutor getSqlExecutor() { return sqlExecutor; } + + public Optional getDaoHooks() { + return daoHooks; + } } diff --git a/jirm-orm/src/main/java/co/jirm/orm/dao/DaoHooks.java b/jirm-orm/src/main/java/co/jirm/orm/dao/DaoHooks.java new file mode 100644 index 0000000..e6c4bbf --- /dev/null +++ b/jirm-orm/src/main/java/co/jirm/orm/dao/DaoHooks.java @@ -0,0 +1,11 @@ +package co.jirm.orm.dao; + +import co.jirm.mapper.definition.*; + +import java.util.*; + +public interface DaoHooks { + public void beforeInsert(SqlObjectDefinition definition, Map values); + + // TODO to add beforeInsertMaps() method and its usage to the JirmDao. +} diff --git a/jirm-orm/src/main/java/co/jirm/orm/dao/JirmDao.java b/jirm-orm/src/main/java/co/jirm/orm/dao/JirmDao.java index 5707f0f..ba17d2a 100644 --- a/jirm-orm/src/main/java/co/jirm/orm/dao/JirmDao.java +++ b/jirm-orm/src/main/java/co/jirm/orm/dao/JirmDao.java @@ -61,6 +61,7 @@ public final class JirmDao { private final UpdateBuilderFactory updateBuilderFactory; private final DeleteBuilderFactory deleteBuilderFactory; private final SqlWriterStrategy writerStrategy; + private final Optional daoHooks; private JirmDao( SqlExecutor sqlExecutor, @@ -69,7 +70,8 @@ private JirmDao( SqlWriterStrategy writerStrategy, SelectBuilderFactory selectBuilderFactory, UpdateBuilderFactory updateBuilderFactory, - DeleteBuilderFactory deleteBuilderFactory) { + DeleteBuilderFactory deleteBuilderFactory, + Optional daoHooks) { super(); this.sqlExecutor = sqlExecutor; this.config = config; @@ -78,6 +80,7 @@ private JirmDao( this.selectBuilderFactory = selectBuilderFactory; this.updateBuilderFactory = updateBuilderFactory; this.deleteBuilderFactory = deleteBuilderFactory; + this.daoHooks = daoHooks; } public static JirmDao newInstance(Class type, OrmConfig config) { @@ -90,7 +93,8 @@ public static JirmDao newInstance(Class type, OrmConfig config) { config.getSqlExecutor(), config.getSqlObjectConfig(), definition, config.getSqlWriterStrategy(), - selectBuilderFactory, updateBuilderFactory, deleteBuilderFactory); + selectBuilderFactory, updateBuilderFactory, deleteBuilderFactory, + config.getDaoHooks()); } private LinkedHashMap toLinkedHashMap(T t, boolean bulkInsert) { @@ -220,6 +224,10 @@ public T reload(T t) { } public void insert(Map values) { + if (daoHooks.isPresent()) { + daoHooks.get().beforeInsert(definition, values); + } + StringBuilder qb = new StringBuilder(); writerStrategy.insertStatement(qb, definition, values); sqlExecutor.update(qb.toString(), writerStrategy.fillValues(definition, values).toArray()); From 16c7b15d20d8a7ab033397fc65ae6676bcc68ba7 Mon Sep 17 00:00:00 2001 From: Denis Buzdalov Date: Wed, 25 Jun 2014 13:02:56 +0400 Subject: [PATCH 5/7] Nested optional jirm factory was added to the jirm dao. --- .../src/main/java/co/jirm/orm/dao/JirmDao.java | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/jirm-orm/src/main/java/co/jirm/orm/dao/JirmDao.java b/jirm-orm/src/main/java/co/jirm/orm/dao/JirmDao.java index ba17d2a..36469d3 100644 --- a/jirm-orm/src/main/java/co/jirm/orm/dao/JirmDao.java +++ b/jirm-orm/src/main/java/co/jirm/orm/dao/JirmDao.java @@ -34,6 +34,7 @@ import co.jirm.mapper.copy.CopyBuilder; import co.jirm.mapper.definition.SqlObjectDefinition; import co.jirm.mapper.definition.SqlParameterDefinition; +import co.jirm.orm.JirmFactory; import co.jirm.orm.OrmConfig; import co.jirm.orm.builder.delete.DeleteBuilderFactory; import co.jirm.orm.builder.delete.DeleteRootClauseBuilder; @@ -62,6 +63,7 @@ public final class JirmDao { private final DeleteBuilderFactory deleteBuilderFactory; private final SqlWriterStrategy writerStrategy; private final Optional daoHooks; + private final Optional jirmFactory; private JirmDao( SqlExecutor sqlExecutor, @@ -71,7 +73,8 @@ private JirmDao( SelectBuilderFactory selectBuilderFactory, UpdateBuilderFactory updateBuilderFactory, DeleteBuilderFactory deleteBuilderFactory, - Optional daoHooks) { + Optional daoHooks, + Optional jirmFactory) { super(); this.sqlExecutor = sqlExecutor; this.config = config; @@ -81,9 +84,14 @@ private JirmDao( this.updateBuilderFactory = updateBuilderFactory; this.deleteBuilderFactory = deleteBuilderFactory; this.daoHooks = daoHooks; + this.jirmFactory = jirmFactory; } - + public static JirmDao newInstance(Class type, OrmConfig config) { + return newInstance(type, config, Optional.absent()); + } + + public static JirmDao newInstance(Class type, OrmConfig config, Optional jirmFactory) { SqlObjectDefinition definition = config.getSqlObjectConfig().resolveObjectDefinition(type); SelectBuilderFactory selectBuilderFactory = SelectBuilderFactory.newInstance(definition, config); UpdateBuilderFactory updateBuilderFactory = UpdateBuilderFactory.newInstance(definition, config); @@ -94,7 +102,8 @@ public static JirmDao newInstance(Class type, OrmConfig config) { config.getSqlObjectConfig(), definition, config.getSqlWriterStrategy(), selectBuilderFactory, updateBuilderFactory, deleteBuilderFactory, - config.getDaoHooks()); + config.getDaoHooks(), + jirmFactory); } private LinkedHashMap toLinkedHashMap(T t, boolean bulkInsert) { From 17647c9a2ee542399523e8900e10bf849488950f Mon Sep 17 00:00:00 2001 From: Denis Buzdalov Date: Wed, 25 Jun 2014 13:20:04 +0400 Subject: [PATCH 6/7] Recusrive objects saving using newly added factory was added. --- .../main/java/co/jirm/orm/dao/JirmDao.java | 44 ++++++++++++++++--- 1 file changed, 38 insertions(+), 6 deletions(-) diff --git a/jirm-orm/src/main/java/co/jirm/orm/dao/JirmDao.java b/jirm-orm/src/main/java/co/jirm/orm/dao/JirmDao.java index 36469d3..be3485e 100644 --- a/jirm-orm/src/main/java/co/jirm/orm/dao/JirmDao.java +++ b/jirm-orm/src/main/java/co/jirm/orm/dao/JirmDao.java @@ -106,7 +106,7 @@ public static JirmDao newInstance(Class type, OrmConfig config, Option jirmFactory); } - private LinkedHashMap toLinkedHashMap(T t, boolean bulkInsert) { + private LinkedHashMap toLinkedHashMap(T t, boolean bulkInsert, ForeignAct foreignAct) { LinkedHashMap m = config.getObjectMapper().convertObjectToSqlMap(t); /* * Replace the complex objects with there ids. @@ -121,6 +121,8 @@ private LinkedHashMap toLinkedHashMap(T t, boolean bulkInsert) { /* * TODO: We only set it if the object is actually present. ie do you really want to set null? */ + actForeign(pd.getParameterType(), m.get(pd.getParameterName()), foreignAct); + m.put(pd.getParameterName(), idDef.convertToSql(nkv.object)); } else if (bulkInsert) { @@ -152,7 +154,35 @@ else if (bulkInsert) { return m; } - + + private void actForeign(final Class clazz, final Object object, ForeignAct foreignAct) { + if (object != null && jirmFactory.isPresent()) { + @SuppressWarnings("unchecked") + final JirmDao foreignDao = ((JirmDao) jirmFactory.get().daoFor(clazz)); + + foreignAct.act(foreignDao, object); + } + } + + private static interface ForeignAct { + public void act(final JirmDao dao, final T object); + + public static final ForeignAct NO_ACT = new ForeignAct() { + @Override + public void act(final JirmDao dao, final T object) { + } + }; + } + + private static class ForeignInsert implements ForeignAct { + public static final ForeignInsert INSERT = new ForeignInsert(); + + @Override + public void act(final JirmDao dao, final T object) { + dao.insert(object); + } + } + public CopyBuilder copyBuilder() { return CopyBuilder.newInstance(definition.getObjectType(), config.getObjectMapper()); } @@ -194,7 +224,7 @@ public T findById(Object id) { } public void insert(T t) { - LinkedHashMap m = toLinkedHashMap(t, false); + LinkedHashMap m = toLinkedHashMap(t, false, ForeignInsert.INSERT); Iterator> it = m.entrySet().iterator(); /* * Remove the null values that are to be generated. @@ -220,12 +250,14 @@ public int deleteById(Object id) { } public UpdateObjectBuilder update(T t) { - LinkedHashMap m = toLinkedHashMap(t, false); + // todo to probably change the foreign act (probably with the ForeignAct interface). + LinkedHashMap m = toLinkedHashMap(t, false, ForeignAct.NO_ACT); return updateBuilderFactory.update(m); } public T reload(T t) { - LinkedHashMap m = toLinkedHashMap(t, false); + // todo to probably change the foreign act (probably with the ForeignAct interface). + LinkedHashMap m = toLinkedHashMap(t, false, ForeignAct.NO_ACT); Optional id = definition.idParameter(); check.state(id.isPresent(), "No id definition"); Optional o = id.get().valueFrom(m); @@ -246,7 +278,7 @@ public void insert(Iterator values, int batchSize) { Iterator> t = Iterators.transform(values, new Function>() { @Override public Map apply(T input) { - return toLinkedHashMap(input, true); + return toLinkedHashMap(input, true, ForeignInsert.INSERT); } }); insertMaps(t, batchSize); From faabe0dadb03f780127caed9c4996f4fcfbc47c3 Mon Sep 17 00:00:00 2001 From: Denis Buzdalov Date: Wed, 25 Jun 2014 14:14:56 +0400 Subject: [PATCH 7/7] Spring jirm factory was made able to create recursive daos. --- .../main/java/co/jirm/spring/SpringJirmFactory.java | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/jirm-spring/src/main/java/co/jirm/spring/SpringJirmFactory.java b/jirm-spring/src/main/java/co/jirm/spring/SpringJirmFactory.java index 7e7fd03..6519228 100644 --- a/jirm-spring/src/main/java/co/jirm/spring/SpringJirmFactory.java +++ b/jirm-spring/src/main/java/co/jirm/spring/SpringJirmFactory.java @@ -20,6 +20,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.jdbc.core.JdbcTemplate; +import com.google.common.base.Optional; import com.google.common.base.Supplier; import com.google.common.base.Suppliers; @@ -35,9 +36,14 @@ public class SpringJirmFactory implements JirmFactory { private final JdbcTemplate jdbcTemplate; private final Supplier sqlExecutorSupplier; private final Supplier ormConfigSupplier; - + private final boolean recursive; + @Autowired public SpringJirmFactory(DataSource dataSource) { + this(dataSource, false); + } + + public SpringJirmFactory(DataSource dataSource, boolean recursive) { jdbcTemplate = new JdbcTemplate(dataSource); ormConfigSupplier = Suppliers.memoize(new Supplier() { @Override @@ -51,10 +57,11 @@ public SqlExecutor get() { return SpringJirmFactory.this.createSqlExecutor(); } }); + this.recursive = recursive; } public JirmDao daoFor(Class k) { - return JirmDao.newInstance(k, ormConfigSupplier.get()); + return JirmDao.newInstance(k, ormConfigSupplier.get(), recursive ? Optional.of(this) : Optional.absent()); } protected OrmConfig createOrmConfig() {