X-Git-Url: http://jaekl.net/gitweb/?p=cfb.git;a=blobdiff_plain;f=prod%2Fnet%2Fjaekl%2Fcfb%2Fstore%2FDbStore.java;h=3860ca5637e5c2fd31f93bec95b1d59900dec6d5;hp=7a1e6102febaf6916ad34c705033d01757451893;hb=2769cf82ccae57ee3716aecc9bd694be1f115d92;hpb=3c10b6100c6035a65ce37dea846b027135289f67 diff --git a/prod/net/jaekl/cfb/store/DbStore.java b/prod/net/jaekl/cfb/store/DbStore.java index 7a1e610..3860ca5 100644 --- a/prod/net/jaekl/cfb/store/DbStore.java +++ b/prod/net/jaekl/cfb/store/DbStore.java @@ -1,23 +1,376 @@ package net.jaekl.cfb.store; import java.sql.Connection; +import java.sql.SQLException; +import java.util.List; import net.jaekl.cfb.analyze.Analysis; +import net.jaekl.cfb.db.CfbSchema; +import net.jaekl.cfb.db.Column; +import net.jaekl.cfb.db.Condition; +import net.jaekl.cfb.db.Operation; +import net.jaekl.cfb.db.Row; +import net.jaekl.cfb.db.Sort; +import net.jaekl.cfb.db.Table; +import net.jaekl.cfb.db.TypeMismatchException; +import net.jaekl.cfb.db.driver.DbDriver; +import net.jaekl.cfb.xml.BugCollection; +import net.jaekl.cfb.xml.BugInstance; +import net.jaekl.cfb.xml.LocalVariable; +import net.jaekl.cfb.xml.messages.MessageCollection; public class DbStore { - Connection m_conn; + Connection m_con; + DbDriver m_driver; + MessageCollection m_msgColl; - public DbStore(Connection conn) { - m_conn = conn; + public DbStore(Connection con, DbDriver driver, MessageCollection msgColl) { + m_con = con; + m_driver = driver; + m_msgColl = msgColl; + } + + public Analysis getPrior(Analysis analysis) throws SQLException, TypeMismatchException { + if (null == analysis) { + return null; + } + Long priorId = getPriorId(analysis); + if (null == priorId) { + return null; + } + + return getAnalysis(priorId); } - public boolean put(Analysis analysis) { + public boolean put(Analysis analysis) throws SQLException, TypeMismatchException { if (null == analysis) { return false; } + // ---------------------------------- + // Add a run record for this analysis + + long runId = m_driver.nextVal(m_con, CfbSchema.RUN_SEQ); + Object[][] values = { + { + Long.valueOf(runId), + analysis.getProjectName(), + analysis.getBuildNumber(), + analysis.getStart(), + analysis.getEnd() + } + }; + int count = m_driver.insert(m_con, CfbSchema.RUNS, values); + if (1 != count) { + return false; + } + + // ------------------------------------- + // Add a found record for each bug found + + List bugs = analysis.getBugCollection().getBugs(); + values = new Object[bugs.size()][CfbSchema.FOUND.getNumColumns()]; + + int row = 0; + for (BugInstance bug : bugs) + { + Long foundId = Long.valueOf(m_driver.nextVal(m_con, CfbSchema.FOUND_SEQ)); + Long bugId = Long.valueOf(m_msgColl.getPattern(bug.getType()).getId()); + Long categoryId = Long.valueOf(m_msgColl.getCategory(bug.getCategory()).getId()); + List locs = bug.getLocations(); + Location firstLoc = (locs.size() > 0) ? locs.get(0) : null; + Location secondLoc = (locs.size() > 1) ? locs.get(1) : null; + Location thirdLoc = (locs.size() > 2) ? locs.get(2) : null; + + values[row][0] = foundId; + values[row][1] = runId; + values[row][2] = bugId; + values[row][3] = categoryId; + values[row][4] = getLocId(firstLoc); + values[row][5] = getLocId(secondLoc); + values[row][6] = getLocId(thirdLoc); + values[row][7] = getVarId(bug); + row++; + } + + count = m_driver.insert(m_con, CfbSchema.FOUND, values); + return (bugs.size() == count); + } + + String getBugType(Long bugPatternId) throws SQLException, TypeMismatchException + { + Column[] columns = { CfbSchema.TYPE }; + Table[] tables = { CfbSchema.BUGS }; + Condition[] conditions = { new Condition(CfbSchema.BUGID, bugPatternId, Operation.EQUAL) }; + Row row = m_driver.selectExactlyOne(m_con, columns, tables, conditions); + String type = row.getString(0); + return type; + } + + String getCategoryName(Long categoryId) throws SQLException, TypeMismatchException + { + Column[] columns = { CfbSchema.CATEGORY }; + Table[] tables = { CfbSchema.CATEGORIES }; + Condition[] conditions = { new Condition(CfbSchema.CATEGORYID, categoryId, Operation.EQUAL) }; + Row row = m_driver.selectExactlyOne(m_con, columns, tables, conditions); + String name = row.getString(0); + return name; + } + + + Location getLoc(Long locId) throws SQLException, TypeMismatchException + { + if (null == locId) { + return null; + } + + Column[] columns = { CfbSchema.CLASSNAME, CfbSchema.METHODNAME, CfbSchema.METHODROLE, CfbSchema.STARTLINE, CfbSchema.ENDLINE }; + Table[] tables = { CfbSchema.LOCATIONS }; + Condition[] conditions = { new Condition(CfbSchema.LOCID, locId, Operation.EQUAL) }; + + Row row = m_driver.selectExactlyOne(m_con, columns, tables, conditions); + + String className = row.getString(0); + String methodName = row.getString(1); + String methodRole = row.getString(2); + Integer startLine = row.getInt(3); + Integer endLine = row.getInt(4); + + Location loc = new Location(locId, className, methodName, methodRole, startLine, endLine); + return loc; + } + + Long getLocId(Location loc) throws SQLException, TypeMismatchException + { + if (null == loc) { + return null; + } + Long locId = findLocId(loc); + if (null != locId) { + return locId; + } + + return storeLoc(loc); + } + + Long findLocId(Location loc) throws SQLException, TypeMismatchException + { + Column[] columns = { CfbSchema.LOCID }; + Table[] tables = { CfbSchema.LOCATIONS }; + + Condition[] conditions = { + new Condition( CfbSchema.CLASSNAME, loc.getClassName(), Operation.EQUAL ), + new Condition( CfbSchema.METHODNAME, loc.getMethodName(), Operation.EQUAL ), + new Condition( CfbSchema.METHODROLE, loc.getMethodRole(), Operation.EQUAL ), + new Condition( CfbSchema.STARTLINE, loc.getStart(), Operation.EQUAL ), + new Condition( CfbSchema.ENDLINE, loc.getEnd(), Operation.EQUAL ) + }; + List rows = m_driver.select(m_con, columns, tables, conditions); + if (rows.size() > 0) { + assert(1 == rows.size()); // should only have one match + + return rows.get(0).getLong(0); + } + + return null; // not found + } + + Long storeLoc(Location loc) throws SQLException + { + long locId = m_driver.nextVal(m_con, CfbSchema.LOC_SEQ); + + Object[][] values = { { + Long.valueOf(locId), + loc.getClassName(), + loc.getMethodName(), + loc.getMethodRole(), + Long.valueOf(loc.getStart()), + Long.valueOf(loc.getEnd()) + } }; + int count = m_driver.insert(m_con, CfbSchema.LOCATIONS, values); + if (1 != count) { + return null; + } + + return Long.valueOf(locId); + } + + Long getVarId(BugInstance bug) throws SQLException, TypeMismatchException + { + if (null == bug) { + return null; + } + + List vars = bug.getVariables(); + if ((null == vars) || (0 == vars.size())) { + return null; + } + + return getVarId(vars.get(0)); + } + + LocalVariable getVar(Long varId) throws SQLException, TypeMismatchException + { + if (null == varId) { + return null; + } + + Column[] columns = { CfbSchema.NAME, CfbSchema.VARROLE }; + Table[] tables = { CfbSchema.VARIABLES }; + Condition[] conditions = { new Condition(CfbSchema.VARID_PK, varId, Operation.EQUAL) }; + + List result = m_driver.select(m_con, columns, tables, conditions); + if (result.size() < 1) { + throw new SQLException("No variable found for ID " + varId); + } + if (result.size() > 1) { + throw new SQLException("Too many matches (" + result.size() + ") found for variable ID " + varId); + } + + String varName = result.get(0).getString(0); + String varRole = result.get(0).getString(1); + + return new LocalVariable(varId, varName, varRole); + } + + Long getVarId(LocalVariable var) throws SQLException, TypeMismatchException + { + if (null == var) { + return null; + } + + Long result = findVarId(var); + + if (null != result) { + return result; + } + + return storeVar(var); + } + + Long findVarId(LocalVariable var) throws SQLException, TypeMismatchException + { + Column[] columns = { CfbSchema.VARID_PK }; + Table[] tables = { CfbSchema.VARIABLES }; + + Condition[] conditions = { + new Condition( CfbSchema.NAME, var.getName(), Operation.EQUAL ), + new Condition( CfbSchema.VARROLE, var.getRole(), Operation.EQUAL ) + }; + List rows = m_driver.select(m_con, columns, tables, conditions); + if (rows.size() > 0) { + assert(1 == rows.size()); // should only have one match + + return rows.get(0).getLong(0); + } + + return null; // not found + } + + Long storeVar(LocalVariable var) throws SQLException + { + long varId = m_driver.nextVal(m_con, CfbSchema.VARIABLE_SEQ); + + Object[][] values = { { + Long.valueOf(varId), + var.getName(), + var.getRole() + } }; + int count = m_driver.insert(m_con, CfbSchema.VARIABLES, values); + if (1 != count) { + return null; + } + + return Long.valueOf(varId); + } + + Long getPriorId(Analysis analysis) throws SQLException, TypeMismatchException + { + Column[] columns = { CfbSchema.RUNID }; + Table[] tables = { CfbSchema.RUNS }; + Condition[] conditions = { + new Condition( CfbSchema.PROJNAME, analysis.getProjectName(), Operation.EQUAL ), + new Condition( CfbSchema.STARTTIME, analysis.getStart(), Operation.LESS_THAN ) + }; + Sort[] sorts = { new Sort( CfbSchema.STARTTIME, Sort.Direction.DESCENDING ) }; + int limit = 1; + + List rows = m_driver.select(m_con, columns, tables, conditions, sorts, limit); + if (rows.size() < 1) { + return null; + } + return rows.get(0).getLong(0); + } + + Analysis getAnalysis(Long analysisId) throws SQLException, TypeMismatchException + { + Column[] columns = { CfbSchema.PROJNAME, CfbSchema.VERSION, CfbSchema.STARTTIME, CfbSchema.ENDTIME }; + Table[] tables = { CfbSchema.RUNS }; + Condition[] conditions = { new Condition( CfbSchema.RUNID, analysisId, Operation.EQUAL ) }; + + List rows = m_driver.select(m_con, columns, tables, conditions); + if (rows.size() < 1) { + return null; + } + Row row = rows.get(0); + + String projName = row.getString(0); + String version = row.getString(1); + java.util.Date start= row.getDate(2); + java.util.Date end = row.getDate(3); + + Analysis prior = new Analysis(projName, version); + prior.setId(analysisId.longValue()); + prior.setStart(start); + prior.setEnd(end); + + prior.setBugCollection(getBugCollection(analysisId)); + + return prior; + } + + BugCollection getBugCollection(Long runId) throws SQLException, TypeMismatchException + { + Column[] columns = { + CfbSchema.FOUNDID, + CfbSchema.BUGID, + CfbSchema.CATEGORYID, + CfbSchema.FIRSTLOCID, + CfbSchema.SECONDLOCID, + CfbSchema.THIRDLOCID, + CfbSchema.VARID_FK + }; + Table[] tables = { + CfbSchema.FOUND + }; + Condition[] conditions = { + new Condition(CfbSchema.RUNID, runId, Operation.EQUAL) + }; + + BugCollection coll = new BugCollection(); + + List rows = m_driver.select(m_con, columns, tables, conditions); + + for (Row row : rows) { + // long foundId = row.getLong(0); + Long bugId = row.getLong(1); + Long categoryId = row.getLong(2); + Long firstLocId = row.getLong(3); + Long secondLocId = row.getLong(4); + Long thirdLocId = row.getLong(5); + Long varId = row.getLong(6); + + String bugType = getBugType(bugId); + String category = getCategoryName(categoryId); + Location[] locations = { getLoc(firstLocId), getLoc(secondLocId), getLoc(thirdLocId) }; + LocalVariable[] vars = { getVar(varId) }; + + + BugInstance bug = new BugInstance(bugId, category, bugType, locations, vars); + coll.add(bug); + } - return true; + return coll; } }