prod/net/jaekl/cfb/db/CfbSchema.java

   1 package net.jaekl.cfb.db;
   2
   3 // Copyright (C) 2015 Christian Jaekl
   4
   5 import static net.jaekl.cfb.db.Column.Null.*;
   6 import static net.jaekl.cfb.db.Column.Type.*;
   7
   8 import java.sql.Connection;
   9 import java.sql.SQLException;
  10 import java.util.Collection;
  11
  12 import net.jaekl.cfb.analyze.MessageMap;
  13 import net.jaekl.cfb.db.driver.DbDriver;
  14 import net.jaekl.cfb.xml.messages.BugCategory;
  15 import net.jaekl.cfb.xml.messages.BugPattern;
  16
  17
  18 public class CfbSchema extends Schema {
  19         MessageMap m_msgMap;
  20
  21         public static final Sequence BUG_SEQ      = new Sequence("BUG_SEQ");
  22         public static final Sequence CATEGORY_SEQ = new Sequence("CATEGORY_SEQ");
  23         public static final Sequence FOUND_SEQ    = new Sequence("FOUND_SEQ");
  24         public static final Sequence LOC_SEQ      = new Sequence("LOC_SEQ");
  25         public static final Sequence RUN_SEQ      = new Sequence("RUN_SEQ");
  26
  27         public static final String BUGID = "BUGID";
  28         public static final String CATEGORYID = "CATEGORYID";
  29         public static final String FOUNDID = "FOUNDID";
  30         public static final String LOCID = "LOCID";
  31         public static final String RUNID = "RUNID";
  32
  33         // Define each table as follows:
  34         // {
  35         //   { table_name },
  36         //   { column_name, type, width (-1 for default), null/not_null }
  37         // }
  38         private static final Object[][] BUGS_DEFN =
  39                                 {
  40                                         // Description of each possible bug
  41                                         { "BUG" },
  42                                         { BUGID, INTEGER, -1, NOT_NULL },
  43                                         { "TYPE", VARCHAR, 80, NOT_NULL }
  44                                 };
  45         private static final Object[][] CATEGORIES_DEFN =
  46                                 {
  47                                         // Description of each possible bug category
  48                                         { "CATEGORY" },
  49                                         { CATEGORYID, INTEGER, -1, NOT_NULL },
  50                                         { "CATEGORY", VARCHAR, 80, NOT_NULL }
  51                                 };
  52         private static final Object[][] FOUND_DEFN =
  53                                 {
  54                                         // One BugInstance, found during an analysis
  55                                         { "FOUND" },
  56                                         { FOUNDID, INTEGER, -1, NOT_NULL },
  57                                         { "BUGID", INTEGER, -1, NOT_NULL },
  58                                         { "CATEGORYID", INTEGER, -1, NOT_NULL },
  59                                         { "FIRSTLOCID", INTEGER, -1, NOT_NULL },
  60                                         { "SECONDLOCID", INTEGER, -1, NULL },
  61                                         { "THIRDLOCID", INTEGER, -1, NULL }
  62                                 };
  63         private static final Object[][] LOCATIONS_DEFN =
  64                                 {
  65                                         // Location in the source code referenced by a BugInstance
  66                                         { "LOCATION" },
  67                                         { LOCID, INTEGER, -1, NOT_NULL },
  68                                         { "CLASSNAME", VARCHAR, 256, NOT_NULL },
  69                                         { "STARTLINE", INTEGER, -1, NULL },
  70                                         { "ENDLINE", INTEGER, -1, NULL }
  71                                 };
  72         private static final Object[][] RUNS_DEFN =
  73                                 {
  74                                         // Runs of FindBugs, normally one per build version
  75                                         { "RUN" },
  76                                         { RUNID, INTEGER, -1, NOT_NULL },
  77                                         { "VERSION", VARCHAR, 32, NULL },
  78                                         { "STARTTIME", TIMESTAMPTZ, -1, NOT_NULL },
  79                                         { "ENDTIME", TIMESTAMPTZ, -1, NOT_NULL }
  80                                 };
  81
  82         public static final Table BUGS       = Table.construct(BUGS_DEFN);
  83         public static final Table CATEGORIES = Table.construct(CATEGORIES_DEFN);
  84         public static final Table FOUND      = Table.construct(FOUND_DEFN);
  85         public static final Table LOCATIONS  = Table.construct(LOCATIONS_DEFN);
  86         public static final Table RUNS       = Table.construct(RUNS_DEFN);
  87
  88         private static final Sequence[] SEQUENCES = {
  89                                         BUG_SEQ,
  90                                         CATEGORY_SEQ,
  91                                         FOUND_SEQ,
  92                                         LOC_SEQ,
  93                                         RUN_SEQ
  94                                 };
  95
  96         private static final Table[] TABLES = {
  97                                         BUGS,
  98                                         CATEGORIES,
  99                                         FOUND,
 100                                         LOCATIONS,
 101                                         RUNS
 102                                 };
 103
 104         public CfbSchema(DbDriver driver) {
 105                 super("CFB", driver);
 106
 107                 m_msgMap = null;
 108
 109                 addTables(TABLES);
 110                 addSequences(SEQUENCES);
 111         }
 112
 113         public void setMessageMap(MessageMap msgMap) {
 114                 m_msgMap = msgMap;
 115         }
 116
 117         @Override
 118         boolean postCreationInit(Connection con) throws SQLException {
 119                 assert(null != m_msgMap);
 120
 121                 if (! insertCategories(con)) {
 122                         return false;
 123                 }
 124                 if (! insertPatterns(con)) {
 125                         return false;
 126                 }
 127
 128                 return true;
 129         }
 130
 131         boolean insertCategories(Connection con) throws SQLException {
 132                 Collection<BugCategory> categories = m_msgMap.getColl().getCategories();
 133
 134                 Object[][] values = new Object[categories.size()][CATEGORIES.getNumColumns()];
 135
 136                 int row = 0;
 137                 for (BugCategory cat : categories) {
 138                         long categoryId = m_driver.nextVal(con, CATEGORY_SEQ);
 139
 140                         values[row][0] = Long.valueOf(categoryId);
 141                         values[row][1] = cat.getCategory();
 142                         row++;
 143                 }
 144
 145                 int count = m_driver.insert(con, CATEGORIES, values);
 146
 147                 return (categories.size() == count);
 148         }
 149
 150         boolean insertPatterns(Connection con) throws SQLException {
 151                 Collection<BugPattern> patterns = m_msgMap.getColl().getPatterns();
 152
 153                 Object[][] values = new Object[patterns.size()][BUGS.getNumColumns()];
 154
 155                 int row = 0;
 156                 for (BugPattern bug : patterns) {
 157                         long bugId = m_driver.nextVal(con, BUG_SEQ);
 158
 159                         values[row][0] = Long.valueOf(bugId);
 160                         values[row][1] = bug.getType();
 161                         row++;
 162                 }
 163
 164                 int count = m_driver.insert(con, BUGS, values);
 165
 166                 return (patterns.size() == count);
 167         }
 168 }