X-Git-Url: http://jaekl.net/gitweb/?p=cfb.git;a=blobdiff_plain;f=prod%2Fnet%2Fjaekl%2Fcfb%2Fstore%2FDbStore.java;h=ed22291387c14c8047593d7b1a11932633df6361;hp=315ade579272e91cb8d91b22bd8b5d1d58fca54c;hb=e8190c8189a5270ada70aaa478409db6dbf1efae;hpb=9635991f7480e1b82f897948cf8adf56537c1818 diff --git a/prod/net/jaekl/cfb/store/DbStore.java b/prod/net/jaekl/cfb/store/DbStore.java index 315ade5..ed22291 100644 --- a/prod/net/jaekl/cfb/store/DbStore.java +++ b/prod/net/jaekl/cfb/store/DbStore.java @@ -2,23 +2,25 @@ package net.jaekl.cfb.store; import java.sql.Connection; import java.sql.SQLException; -import java.util.ArrayList; import java.util.List; +import java.util.Locale; +import net.jaekl.cfb.CfbBundle; 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.BugClass; +import net.jaekl.cfb.xml.BugCollection; import net.jaekl.cfb.xml.BugInstance; -import net.jaekl.cfb.xml.BugMethod; import net.jaekl.cfb.xml.LocalVariable; -import net.jaekl.cfb.xml.SourceLine; +import net.jaekl.cfb.xml.messages.BugCategory; +import net.jaekl.cfb.xml.messages.BugPattern; import net.jaekl.cfb.xml.messages.MessageCollection; public class DbStore { @@ -31,8 +33,22 @@ public class DbStore { 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) throws SQLException, TypeMismatchException { + public boolean put(Analysis analysis) throws SQLException, TypeMismatchException, StoreException { + CfbBundle bundle = CfbBundle.getInst(Locale.getDefault()); + if (null == analysis) { return false; } @@ -44,6 +60,7 @@ public class DbStore { Object[][] values = { { Long.valueOf(runId), + analysis.getProjectName(), analysis.getBuildNumber(), analysis.getStart(), analysis.getEnd() @@ -66,18 +83,26 @@ public class DbStore { 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()); - Location[] locs = computeLocations(bug); - Location firstLoc = (locs.length > 0) ? locs[0] : null; - Location secondLoc = (locs.length > 1) ? locs[1] : null; - Location thirdLoc = (locs.length > 2) ? locs[2] : null; + 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; + + if (BugPattern.UNKNOWN.getId() == bugId) { + throw new StoreException(bundle.get(CfbBundle.BUG_TYPE_UNKNOWN, ""+bug.getType())); + } + if (BugCategory.UNKNOWN.getId() == categoryId) { + throw new StoreException(bundle.get(CfbBundle.BUG_CATEGORY_UNKNOWN, ""+bug.getCategory())); + } values[row][0] = foundId; - values[row][1] = bugId; - values[row][2] = categoryId; - values[row][3] = getLocId(firstLoc); - values[row][4] = getLocId(secondLoc); - values[row][5] = getLocId(thirdLoc); - values[row][6] = getVarId(bug); + 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++; } @@ -85,61 +110,47 @@ public class DbStore { return (bugs.size() == count); } - Location[] computeLocations(BugInstance bug) + String getBugType(Long bugPatternId) throws SQLException, TypeMismatchException { - ArrayList locs = new ArrayList(); - - /* - Somewhat unfortunate special case. - The primary "location" for a bug instance is split between tags. - Most bugs have a pattern like this: - - ... - - - - ... - - - - The primary location for a bug is given by the with no role attribute, - but the inside that method describes the whole range of lines - covered by that Method, not the spot where the bug is located--that is given - by the that is a direct child fo the . - */ - - BugMethod primaryMethod = null; - SourceLine primaryLine = null; - - for (BugMethod method : bug.getMethods()) { - if (null != method.getRole()) { - primaryMethod = method; - break; - } - } - if (bug.getLines().size() > 0) { - primaryLine = bug.getLines().get(0); + 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; } - if ((null != primaryMethod) && (null != primaryLine)) { - locs.add(new Location(primaryMethod, primaryLine)); - } + 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) }; - for (BugMethod method : bug.getMethods()) { - if (primaryMethod != method) { - locs.add(new Location(method)); - } - } - for (SourceLine line : bug.getLines()) { - if (primaryLine != line) { - locs.add(new Location(line)); - } - } - for (BugClass clazz : bug.getClasses()) { - locs.add(new Location(clazz)); - } + 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); - return locs.toArray(new Location[locs.size()]); + Location loc = new Location(locId, className, methodName, methodRole, startLine, endLine); + return loc; } Long getLocId(Location loc) throws SQLException, TypeMismatchException @@ -211,6 +222,30 @@ public class DbStore { 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) { @@ -261,4 +296,94 @@ public class DbStore { 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 coll; + } }