killbill-aplcache

util: speedup DefaultAuditDao Fetch record_id <-> id mappings

12/21/2013 3:52:33 PM

Details

diff --git a/server/src/main/java/com/ning/billing/server/modules/DBIProvider.java b/server/src/main/java/com/ning/billing/server/modules/DBIProvider.java
index 7891ebb..cb39d3d 100644
--- a/server/src/main/java/com/ning/billing/server/modules/DBIProvider.java
+++ b/server/src/main/java/com/ning/billing/server/modules/DBIProvider.java
@@ -32,6 +32,7 @@ import com.ning.billing.util.dao.DateTimeArgumentFactory;
 import com.ning.billing.util.dao.DateTimeZoneArgumentFactory;
 import com.ning.billing.util.dao.EnumArgumentFactory;
 import com.ning.billing.util.dao.LocalDateArgumentFactory;
+import com.ning.billing.util.dao.RecordIdIdMappingsMapper;
 import com.ning.billing.util.dao.UUIDArgumentFactory;
 import com.ning.billing.util.dao.UuidMapper;
 import com.ning.jetty.jdbi.config.DaoConfig;
@@ -73,6 +74,7 @@ public class DBIProvider implements Provider<DBI> {
         dbi.registerArgumentFactory(new EnumArgumentFactory());
         dbi.registerMapper(new UuidMapper());
         dbi.registerMapper(new AuditLogModelDaoMapper());
+        dbi.registerMapper(new RecordIdIdMappingsMapper());
 
         if (sqlLog != null) {
             dbi.setSQLLog(sqlLog);
diff --git a/util/src/main/java/com/ning/billing/util/audit/dao/DefaultAuditDao.java b/util/src/main/java/com/ning/billing/util/audit/dao/DefaultAuditDao.java
index b49a8b7..f9f032b 100644
--- a/util/src/main/java/com/ning/billing/util/audit/dao/DefaultAuditDao.java
+++ b/util/src/main/java/com/ning/billing/util/audit/dao/DefaultAuditDao.java
@@ -16,8 +16,10 @@
 
 package com.ning.billing.util.audit.dao;
 
+import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Map;
 import java.util.UUID;
 
 import javax.inject.Inject;
@@ -36,6 +38,7 @@ import com.ning.billing.util.audit.DefaultAuditLog;
 import com.ning.billing.util.cache.CacheControllerDispatcher;
 import com.ning.billing.util.dao.NonEntityDao;
 import com.ning.billing.util.dao.NonEntitySqlDao;
+import com.ning.billing.util.dao.RecordIdIdMappings;
 import com.ning.billing.util.dao.TableName;
 import com.ning.billing.util.entity.dao.EntitySqlDao;
 import com.ning.billing.util.entity.dao.EntitySqlDaoTransactionWrapper;
@@ -67,7 +70,7 @@ public class DefaultAuditDao implements AuditDao {
         // Since we want to stream the results out, we don't want to auto-commit when this method returns.
         final EntitySqlDao auditSqlDao = transactionalSqlDao.onDemand(EntitySqlDao.class);
         final Iterator<AuditLogModelDao> auditLogsForAccountRecordId = auditSqlDao.getAuditLogsForAccountRecordId(context);
-        final Iterator<AuditLog> allAuditLogs = buildAuditLogsFromModelDao(auditLogsForAccountRecordId);
+        final Iterator<AuditLog> allAuditLogs = buildAuditLogsFromModelDao(auditLogsForAccountRecordId, context);
 
         return new DefaultAccountAuditLogs(accountId, auditLevel, allAuditLogs);
     }
@@ -86,12 +89,14 @@ public class DefaultAuditDao implements AuditDao {
         // Since we want to stream the results out, we don't want to auto-commit when this method returns.
         final EntitySqlDao auditSqlDao = transactionalSqlDao.onDemand(EntitySqlDao.class);
         final Iterator<AuditLogModelDao> auditLogsForTableNameAndAccountRecordId = auditSqlDao.getAuditLogsForTableNameAndAccountRecordId(actualTableName, context);
-        final Iterator<AuditLog> allAuditLogs = buildAuditLogsFromModelDao(auditLogsForTableNameAndAccountRecordId);
+        final Iterator<AuditLog> allAuditLogs = buildAuditLogsFromModelDao(auditLogsForTableNameAndAccountRecordId, context);
 
         return new DefaultAccountAuditLogsForObjectType(auditLevel, allAuditLogs);
     }
 
-    private Iterator<AuditLog> buildAuditLogsFromModelDao(final Iterator<AuditLogModelDao> auditLogsForAccountRecordId) {
+    private Iterator<AuditLog> buildAuditLogsFromModelDao(final Iterator<AuditLogModelDao> auditLogsForAccountRecordId, final InternalTenantContext tenantContext) {
+        final Map<TableName, Map<Long, UUID>> recordIdIdsCache = new HashMap<TableName, Map<Long, UUID>>();
+        final Map<TableName, Map<Long, UUID>> historyRecordIdIdsCache = new HashMap<TableName, Map<Long, UUID>>();
         return Iterators.<AuditLogModelDao, AuditLog>transform(auditLogsForAccountRecordId,
                                                                new Function<AuditLogModelDao, AuditLog>() {
                                                                    @Override
@@ -105,12 +110,38 @@ public class DefaultAuditDao implements AuditDao {
                                                                        if (originalTableNameForHistoryTableName != null) {
                                                                            // input point to a history entry
                                                                            objectType = originalTableNameForHistoryTableName.getObjectType();
-                                                                           auditedEntityId = nonEntitySqlDao.getIdFromHistoryRecordId(input.getTargetRecordId(),
-                                                                                                                                      originalTableNameForHistoryTableName.getTableName(),
-                                                                                                                                      input.getTableName().getTableName());
+
+                                                                           if (historyRecordIdIdsCache.get(originalTableNameForHistoryTableName) == null) {
+                                                                               if (TableName.ACCOUNT.equals(originalTableNameForHistoryTableName)) {
+                                                                                   final Iterable<RecordIdIdMappings> mappings = nonEntitySqlDao.getHistoryRecordIdIdMappingsForAccountsTable(originalTableNameForHistoryTableName.getTableName(),
+                                                                                                                                                                                              input.getTableName().getTableName(),
+                                                                                                                                                                                              tenantContext);
+                                                                                   historyRecordIdIdsCache.put(originalTableNameForHistoryTableName, RecordIdIdMappings.toMap(mappings));
+                                                                               } else if (TableName.TAG_DEFINITIONS.equals(originalTableNameForHistoryTableName)) {
+                                                                                   final Iterable<RecordIdIdMappings> mappings = nonEntitySqlDao.getHistoryRecordIdIdMappingsForTablesWithoutAccountRecordId(originalTableNameForHistoryTableName.getTableName(),
+                                                                                                                                                                                                             input.getTableName().getTableName(),
+                                                                                                                                                                                                             tenantContext);
+                                                                                   historyRecordIdIdsCache.put(originalTableNameForHistoryTableName, RecordIdIdMappings.toMap(mappings));
+                                                                               } else {
+                                                                                   final Iterable<RecordIdIdMappings> mappings = nonEntitySqlDao.getHistoryRecordIdIdMappings(originalTableNameForHistoryTableName.getTableName(),
+                                                                                                                                                                              input.getTableName().getTableName(),
+                                                                                                                                                                              tenantContext);
+                                                                                   historyRecordIdIdsCache.put(originalTableNameForHistoryTableName, RecordIdIdMappings.toMap(mappings));
+
+                                                                               }
+                                                                           }
+
+                                                                           auditedEntityId = historyRecordIdIdsCache.get(originalTableNameForHistoryTableName).get(input.getTargetRecordId());
                                                                        } else {
                                                                            objectType = input.getTableName().getObjectType();
-                                                                           auditedEntityId = nonEntitySqlDao.getIdFromObject(input.getTargetRecordId(), input.getTableName().getTableName());
+
+                                                                           if (recordIdIdsCache.get(input.getTableName()) == null) {
+                                                                               final Iterable<RecordIdIdMappings> mappings = nonEntitySqlDao.getRecordIdIdMappings(input.getTableName().getTableName(),
+                                                                                                                                                                   tenantContext);
+                                                                               recordIdIdsCache.put(input.getTableName(), RecordIdIdMappings.toMap(mappings));
+                                                                           }
+
+                                                                           auditedEntityId = recordIdIdsCache.get(input.getTableName()).get(input.getTargetRecordId());
                                                                        }
 
                                                                        return new DefaultAuditLog(input, objectType, auditedEntityId);
diff --git a/util/src/main/java/com/ning/billing/util/dao/NonEntitySqlDao.java b/util/src/main/java/com/ning/billing/util/dao/NonEntitySqlDao.java
index 07e88c1..82c3a7f 100644
--- a/util/src/main/java/com/ning/billing/util/dao/NonEntitySqlDao.java
+++ b/util/src/main/java/com/ning/billing/util/dao/NonEntitySqlDao.java
@@ -19,12 +19,15 @@ package com.ning.billing.util.dao;
 import java.util.UUID;
 
 import org.skife.jdbi.v2.sqlobject.Bind;
+import org.skife.jdbi.v2.sqlobject.BindBean;
 import org.skife.jdbi.v2.sqlobject.SqlQuery;
 import org.skife.jdbi.v2.sqlobject.customizers.Define;
 import org.skife.jdbi.v2.sqlobject.mixins.CloseMe;
 import org.skife.jdbi.v2.sqlobject.mixins.Transactional;
 import org.skife.jdbi.v2.sqlobject.stringtemplate.UseStringTemplate3StatementLocator;
 
+import com.ning.billing.callcontext.InternalTenantContext;
+
 @UseStringTemplate3StatementLocator
 public interface NonEntitySqlDao extends Transactional<NonEntitySqlDao>, CloseMe {
 
@@ -56,7 +59,21 @@ public interface NonEntitySqlDao extends Transactional<NonEntitySqlDao>, CloseMe
     public Long getHistoryTargetRecordId(@Bind("recordId") Long recordId, @Define("tableName") final String tableName);
 
     @SqlQuery
-    public UUID getIdFromHistoryRecordId(@Bind("historyRecordId") Long historyRecordId,
-                                         @Define("tableName") String tableName,
-                                         @Define("historyTableName") String historyTableName);
+    public Iterable<RecordIdIdMappings> getHistoryRecordIdIdMappings(@Define("tableName") String tableName,
+                                                                     @Define("historyTableName") String historyTableName,
+                                                                     @BindBean final InternalTenantContext context);
+
+    @SqlQuery
+    public Iterable<RecordIdIdMappings> getHistoryRecordIdIdMappingsForAccountsTable(@Define("tableName") String tableName,
+                                                                                     @Define("historyTableName") String historyTableName,
+                                                                                     @BindBean final InternalTenantContext context);
+
+    @SqlQuery
+    public Iterable<RecordIdIdMappings> getHistoryRecordIdIdMappingsForTablesWithoutAccountRecordId(@Define("tableName") String tableName,
+                                                                                                    @Define("historyTableName") String historyTableName,
+                                                                                                    @BindBean final InternalTenantContext context);
+
+    @SqlQuery
+    public Iterable<RecordIdIdMappings> getRecordIdIdMappings(@Define("tableName") String tableName,
+                                                              @BindBean final InternalTenantContext context);
 }
diff --git a/util/src/main/java/com/ning/billing/util/dao/RecordIdIdMappings.java b/util/src/main/java/com/ning/billing/util/dao/RecordIdIdMappings.java
new file mode 100644
index 0000000..5f9fdc5
--- /dev/null
+++ b/util/src/main/java/com/ning/billing/util/dao/RecordIdIdMappings.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2010-2013 Ning, Inc.
+ *
+ * Ning licenses this file to you 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
+ *
+ * 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 com.ning.billing.util.dao;
+
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.UUID;
+
+public class RecordIdIdMappings {
+
+    private final Long recordId;
+    private final UUID id;
+
+    public RecordIdIdMappings(final long recordId, final UUID id) {
+        this.recordId = recordId;
+        this.id = id;
+    }
+
+    public Long getRecordId() {
+        return recordId;
+    }
+
+    public UUID getId() {
+        return id;
+    }
+
+    public static Map<Long, UUID> toMap(final Iterable<RecordIdIdMappings> mappings) {
+        final Map<Long, UUID> result = new LinkedHashMap<Long, UUID>();
+        for (final RecordIdIdMappings mapping : mappings) {
+            result.put(mapping.getRecordId(), mapping.getId());
+        }
+        return result;
+    }
+}
diff --git a/util/src/main/java/com/ning/billing/util/dao/RecordIdIdMappingsMapper.java b/util/src/main/java/com/ning/billing/util/dao/RecordIdIdMappingsMapper.java
new file mode 100644
index 0000000..729a13a
--- /dev/null
+++ b/util/src/main/java/com/ning/billing/util/dao/RecordIdIdMappingsMapper.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2010-2013 Ning, Inc.
+ *
+ * Ning licenses this file to you 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
+ *
+ * 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 com.ning.billing.util.dao;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.Map;
+import java.util.UUID;
+
+import org.joda.time.DateTime;
+import org.skife.jdbi.v2.StatementContext;
+import org.skife.jdbi.v2.tweak.ResultSetMapper;
+
+import com.ning.billing.callcontext.DefaultCallContext;
+import com.ning.billing.util.audit.ChangeType;
+import com.ning.billing.util.audit.dao.AuditLogModelDao;
+import com.ning.billing.util.callcontext.CallContext;
+
+public class RecordIdIdMappingsMapper extends MapperBase implements ResultSetMapper<RecordIdIdMappings> {
+
+    @Override
+    public RecordIdIdMappings map(final int index, final ResultSet r, final StatementContext ctx) throws SQLException {
+        final long recordId = r.getLong("record_id");
+        final UUID id = getUUID(r, "id");
+        return new RecordIdIdMappings(recordId, id);
+    }
+}
diff --git a/util/src/main/resources/com/ning/billing/util/dao/NonEntitySqlDao.sql.stg b/util/src/main/resources/com/ning/billing/util/dao/NonEntitySqlDao.sql.stg
index 6b2b6af..b7e4d4b 100644
--- a/util/src/main/resources/com/ning/billing/util/dao/NonEntitySqlDao.sql.stg
+++ b/util/src/main/resources/com/ning/billing/util/dao/NonEntitySqlDao.sql.stg
@@ -73,13 +73,45 @@ where record_id = :recordId
 ;
 >>
 
-getIdFromHistoryRecordId(tableName, historyTableName) ::= <<
+getHistoryRecordIdIdMappings(tableName, historyTableName) ::= <<
 select
-  t.id
+  ht.record_id
+, t.id
 from <tableName> t
 join <historyTableName> ht on ht.target_record_id = t.record_id
-where ht.record_id = :historyRecordId
-limit 1
+where t.account_record_id = :accountRecordId
+and t.tenant_record_id = :tenantRecordId
 ;
 >>
 
+getHistoryRecordIdIdMappingsForAccountsTable(tableName, historyTableName) ::= <<
+select
+  ht.record_id
+, t.id
+from <tableName> t
+join <historyTableName> ht on ht.target_record_id = t.record_id
+where t.record_id = :accountRecordId
+and t.tenant_record_id = :tenantRecordId
+;
+>>
+
+getHistoryRecordIdIdMappingsForTablesWithoutAccountRecordId(tableName, historyTableName) ::= <<
+select
+  ht.record_id
+, t.id
+from <tableName> t
+join <historyTableName> ht on ht.target_record_id = t.record_id
+where 1 = 1
+and t.tenant_record_id = :tenantRecordId
+;
+>>
+
+getRecordIdIdMappings(tableName) ::= <<
+select
+  t.record_id
+, t.id
+from <tableName> t
+where t.account_record_id = :accountRecordId
+and t.tenant_record_id = :tenantRecordId
+;
+>>
\ No newline at end of file
diff --git a/util/src/test/java/com/ning/billing/dbi/DBIProvider.java b/util/src/test/java/com/ning/billing/dbi/DBIProvider.java
index 2c30cba..46033f4 100644
--- a/util/src/test/java/com/ning/billing/dbi/DBIProvider.java
+++ b/util/src/test/java/com/ning/billing/dbi/DBIProvider.java
@@ -27,14 +27,12 @@ import com.ning.billing.util.dao.DateTimeArgumentFactory;
 import com.ning.billing.util.dao.DateTimeZoneArgumentFactory;
 import com.ning.billing.util.dao.EnumArgumentFactory;
 import com.ning.billing.util.dao.LocalDateArgumentFactory;
+import com.ning.billing.util.dao.RecordIdIdMappingsMapper;
 import com.ning.billing.util.dao.UUIDArgumentFactory;
 import com.ning.billing.util.dao.UuidMapper;
 
 import com.google.inject.Inject;
 import com.google.inject.Provider;
-import com.jolbox.bonecp.BoneCPConfig;
-import com.jolbox.bonecp.BoneCPDataSource;
-import com.mchange.v2.c3p0.ComboPooledDataSource;
 
 public class DBIProvider implements Provider<IDBI> {
 
@@ -55,6 +53,7 @@ public class DBIProvider implements Provider<IDBI> {
         dbi.registerArgumentFactory(new EnumArgumentFactory());
         dbi.registerMapper(new UuidMapper());
         dbi.registerMapper(new AuditLogModelDaoMapper());
+        dbi.registerMapper(new RecordIdIdMappingsMapper());
 
         // Restart transactions in case of deadlocks
         dbi.setTransactionHandler(new SerializableTransactionRunner());