diff --git a/src/main/java/com/dbf/naps/data/loader/DataMapper.java b/src/main/java/com/dbf/naps/data/loader/DataMapper.java
index 94462487f7a..fe9f79ed79e 100644
--- a/src/main/java/com/dbf/naps/data/loader/DataMapper.java
+++ b/src/main/java/com/dbf/naps/data/loader/DataMapper.java
@@ -6,13 +6,26 @@
 
 public interface DataMapper {
 	
-	@Select("SELECT id from naps.pollutants where name = #{name} AND method = #{method}")
-	public Integer getPollutantID(String name, String method);
+	@Select("SELECT id from naps.pollutants where name = #{name}")
+	public Integer getPollutantID(String name);
 	
-	@Insert("INSERT into naps.pollutants (name, method)"
-			+ " values (#{name}, #{method})"
+	@Insert("INSERT into naps.pollutants (name)"
+			+ " values (#{name})"
 			+ " ON CONFLICT DO NOTHING;")
-	public int insertPollutant(String name, String method);
+	public int insertPollutant(String name);
+	
+	@Select("<script> "
+			+ "SELECT id from naps.methods where dataset = #{dataset} and report_type = #{reportType} and method "
+			+ "<if test=\"method != null\">= #{method}</if>"
+			+ "<if test=\"method == null\">IS NULL</if>"
+			+ " and units = #{units}"
+			+ "</script>")
+	public Integer getMethodID(String dataset, String reportType, String method, String units);
+	
+	@Insert("INSERT into naps.methods (dataset, report_type, method, units)"
+			+ " values (#{dataset}, #{reportType}, #{method}, #{units})"
+			+ " ON CONFLICT DO NOTHING;")
+	public int insertMethod(String dataset, String reportType, String method, String units);
 	
 	@Select("SELECT id from naps.sites where NAPS_id = #{NAPSId}")
 	public Integer getSiteID(Integer NAPSId);
diff --git a/src/main/java/com/dbf/naps/data/loader/DataRecord.java b/src/main/java/com/dbf/naps/data/loader/DataRecord.java
index 40e917d35a4..35f83ae2731 100644
--- a/src/main/java/com/dbf/naps/data/loader/DataRecord.java
+++ b/src/main/java/com/dbf/naps/data/loader/DataRecord.java
@@ -7,6 +7,7 @@ public class DataRecord {
 
 	private Integer siteId;
 	private Integer pollutantId;
+	private Integer methodId;
 	private Date datetime;
 	private Integer year;
 	private Integer month;
@@ -15,17 +16,6 @@ public class DataRecord {
 	private BigDecimal data;
 
 	public DataRecord() {}
-	
-	public DataRecord(DataRecord other) {
-		this.siteId = other.siteId;
-		this.pollutantId = other.pollutantId;
-		this.datetime = other.datetime;
-		this.year = other.year;
-		this.month = other.month;
-		this.day = other.day;
-		this.dayOfWeek = other.dayOfWeek;
-		this.data = other.data;
-	}
 
 	public Integer getSiteId() {
 		return siteId;
@@ -95,5 +85,13 @@ public BigDecimal getData() {
 	
 	public void setData(BigDecimal data) {
 		this.data = data;
+	}
+
+	public Integer getMethodId() {
+		return methodId;
+	}
+
+	public void setMethodId(Integer methodId) {
+		this.methodId = methodId;
 	}	
 }
diff --git a/src/main/java/com/dbf/naps/data/loader/FileLoadRunner.java b/src/main/java/com/dbf/naps/data/loader/FileLoadRunner.java
index 4eb7ab1c364..b0c704bb9f3 100644
--- a/src/main/java/com/dbf/naps/data/loader/FileLoadRunner.java
+++ b/src/main/java/com/dbf/naps/data/loader/FileLoadRunner.java
@@ -19,8 +19,11 @@ public abstract class FileLoadRunner implements Runnable {
 	//Holds a mapping of NAPSID to SiteID, shared across threads
 	private static final Map<Integer, Integer> siteIDLookup = new ConcurrentHashMap<Integer, Integer>(300);
 	
-	//Holds a mapping of lookup key (Compound_Method) to PollutantID, shared across threads
-	private static final Map<String, Integer> pollutantIDLookup = new ConcurrentHashMap<String, Integer>(20);
+	//Holds a mapping of PollutantName to PollutantID, shared across threads
+	private static final Map<String, Integer> pollutantIDLookup = new ConcurrentHashMap<String, Integer>(200);
+	
+	//Holds a mapping of lookupKey (dataset, report_type, method) to MethodID, shared across threads
+	private static final Map<String, Integer> methodIDLookup = new ConcurrentHashMap<String, Integer>(50);
 	
 	private final int threadId;
 	private final LoaderOptions config;
@@ -100,25 +103,44 @@ protected Integer getSiteID(String napsID, long recordNumber) {
 		}
 	}
 	
-	protected Integer getPollutantID(String rawPollutantName, String method) {
-		String lookupKey = rawPollutantName + "_" + method;
+	protected Integer getPollutantID(String rawPollutantName) {
 		
 		//If one thread stamps overrides the data of another it's no big deal
-		return pollutantIDLookup.computeIfAbsent(lookupKey, pollutantName -> {
+		return pollutantIDLookup.computeIfAbsent(rawPollutantName, pollutantName -> {
 			Integer pollutantID = null;
 			pollutantName = PollutantMapping.lookupPollutantName(pollutantName);
 			//May or may not insert, let the DB manage contention
 			try(SqlSession session = sqlSessionFactory.openSession(true)) {
 				DataMapper mapper = session.getMapper(DataMapper.class);
-				mapper.insertPollutant(pollutantName, method);
-				pollutantID = mapper.getPollutantID(pollutantName, method);
+				mapper.insertPollutant(pollutantName);
+				pollutantID = mapper.getPollutantID(pollutantName);
 			}
-			if(null == pollutantID) {
-				throw new IllegalArgumentException("Could not find matching Pollutant ID for compound " + rawPollutantName + ", and method " + method);
+			if(null == pollutantID) { //Sanity check, should be impossible
+				throw new IllegalArgumentException("Could not find a matching pollutant ID with name " + rawPollutantName);
 			}
 			return pollutantID;
 		});
 	}
+	
+	protected Integer getMethodID(String dataset, String reportType, String method, String units) {
+		String lookupKey = dataset + "_" + reportType + "_" + method + "_" + units;
+		
+		//If one thread stamps overrides the data of another it's no big deal
+		return methodIDLookup.computeIfAbsent(lookupKey, key -> {
+			Integer methodID = null;
+
+			//May or may not insert, let the DB manage contention
+			try(SqlSession session = sqlSessionFactory.openSession(true)) {
+				DataMapper mapper = session.getMapper(DataMapper.class);
+				mapper.insertMethod(dataset, reportType, method, units);
+				methodID = mapper.getMethodID(dataset, reportType, method, units);
+			}
+			if(null == methodID) { //Sanity check, should be impossible
+				throw new IllegalArgumentException("Could not find a matching method ID using lookup key: " + key);
+			}
+			return methodID;
+		});
+	}
 
 	public int getThreadId() {
 		return threadId;
diff --git a/src/main/java/com/dbf/naps/data/loader/continuous/ContinuousDataMapper.java b/src/main/java/com/dbf/naps/data/loader/continuous/ContinuousDataMapper.java
index 9f06c3cf488..9520f07a1d9 100644
--- a/src/main/java/com/dbf/naps/data/loader/continuous/ContinuousDataMapper.java
+++ b/src/main/java/com/dbf/naps/data/loader/continuous/ContinuousDataMapper.java
@@ -8,16 +8,16 @@
 
 public interface ContinuousDataMapper {
 
-	@Insert("INSERT into naps.continuous_data (site_id, pollutant_id, date_time, year, month, day, hour, day_of_week, data)"
-			+ " values (#{siteId}, #{pollutantId}, #{datetime}, #{year}, #{month}, #{day}, #{hour}, #{dayOfWeek}, #{data})"
+	@Insert("INSERT into naps.continuous_data (site_id, pollutant_id, method_id, date_time, year, month, day, hour, day_of_week, data)"
+			+ " values (#{siteId}, #{pollutantId}, #{methodId}, #{datetime}, #{year}, #{month}, #{day}, #{hour}, #{dayOfWeek}, #{data})"
 			+ " ON CONFLICT DO NOTHING;")
-	public int insertContinuousData(Integer siteId, String pollutantId, Date datetime, Integer year, Integer month, Integer day, Integer hour, String dayOfWeek, BigDecimal data);
+	public int insertContinuousData(Integer siteId, String pollutantId, String methodId, Date datetime, Integer year, Integer month, Integer day, Integer hour, String dayOfWeek, BigDecimal data);
 	
 	@Insert({"<script>", 
-        "INSERT into naps.continuous_data (site_id, pollutant_id, date_time, year, month, day, hour, day_of_week, data) "
+        "INSERT into naps.continuous_data (site_id, pollutant_id, method_id, date_time, year, month, day, hour, day_of_week, data) "
         + "values ",
         "<foreach collection='dataRecords' item='record' index='index' open='(' separator = '),(' close=')' >"
-        + "#{record.siteId}, #{record.pollutantId}, #{record.datetime}, #{record.year}, #{record.month}, #{record.day}, #{record.hour}, #{record.dayOfWeek}, #{record.data}"
+        + "#{record.siteId}, #{record.pollutantId}, #{record.methodId}, #{record.datetime}, #{record.year}, #{record.month}, #{record.day}, #{record.hour}, #{record.dayOfWeek}, #{record.data}"
         + "</foreach>"
         + " ON CONFLICT DO NOTHING;",
         "</script>"})
diff --git a/src/main/java/com/dbf/naps/data/loader/continuous/ContinuousFileLoadRunner.java b/src/main/java/com/dbf/naps/data/loader/continuous/ContinuousFileLoadRunner.java
index dc62904009e..f399d421dd7 100644
--- a/src/main/java/com/dbf/naps/data/loader/continuous/ContinuousFileLoadRunner.java
+++ b/src/main/java/com/dbf/naps/data/loader/continuous/ContinuousFileLoadRunner.java
@@ -27,7 +27,6 @@ public class ContinuousFileLoadRunner extends FileLoadRunner {
 	
 	private static final CSVFormat csvFormat;
 	
-
 	private static final Long ONE_HOUR_MS = 60*60*1000L;
 	
 	static {
@@ -46,12 +45,11 @@ public ContinuousFileLoadRunner(int threadId, LoaderOptions config, SqlSessionFa
 		super(threadId, config, sqlSessionFactory, rawFile);
 	}
 	
-	
 	@Override
 	public void processFile() throws Exception {
 		log.info(getThreadId() + ":: Starting CSV parsing for file " + getRawFile() + ".");
 		List<ContinuousDataRecord> records = new ArrayList<ContinuousDataRecord>(100);
-		
+
 		//Load all the rows into memory. Let's assume we don't run out of memory. :) 
 		try (Reader reader = new FileReader(getRawFile(), StandardCharsets.ISO_8859_1); CSVParser parser = csvFormat.parse(reader)) {
 			for(CSVRecord line : parser) {
@@ -62,25 +60,39 @@ public void processFile() throws Exception {
 				}
 			
 				//More sanity checks, the line needs to start with a known pollutant
-				String compoudString = line.get(0).replace(".", ""); //PM2.5 -> PM25
+				String compoudString = line.get(0).replace(".", "").toUpperCase(); //PM2.5 -> PM25
 				if(!Compound.contains(compoudString)) continue;
 				
-				boolean isPM25 = compoudString.equalsIgnoreCase(Compound.PM25.name());
+				boolean isPM25 = compoudString.equals(Compound.PM25.name());
 				if(!((isPM25 && line.size() == 32) || (!isPM25 &&  line.size() == 31))) {
 					throw new IllegalArgumentException("Wrong number of columns (" + line.size() + ") on row " + line.getRecordNumber() + ". Expected " + (isPM25? "32.":"31."));
 				}
 				
 				int columnOffset = isPM25 ? 1:0;
-				String method = "CONT";
+				String method = null;
 				if(isPM25) {
-					//Append the PM25-specific method to the overall method
-					method += "_" + line.get(1); 
+					//Only PM25 has a specific method
+					method = line.get(1); 
+				}
+				
+				//The units are expected to be consistent for each compound type
+				String units = null;
+				if (compoudString.equals(Compound.CO.name())) {
+					units = "ppm";
+				} else if (compoudString.equals(Compound.SO2.name()) || compoudString.equals(Compound.O3.name())) {
+					units = "ppb";
+				} else if(isPM25 || compoudString.equals(Compound.PM10.name()) 
+						         || compoudString.equals(Compound.NOX.name())
+						         || compoudString.equals(Compound.NO2.name())
+						         || compoudString.equals(Compound.NO.name())) {
+					units = "µg/m³";
 				}
 				
 				//We create 24 records per CSV line, 1 per hour
 				for(int hour = 0; hour < 24; hour++) {
 					ContinuousDataRecord record = new ContinuousDataRecord();
-					record.setPollutantId(getPollutantID(compoudString, method));
+					record.setPollutantId(getPollutantID(compoudString));
+					record.setMethodId(getMethodID("Continuous", compoudString, method, units));
 					record.setSiteId(getSiteID(
 							line.get(1 + columnOffset),
 							line.get(2 + columnOffset),
diff --git a/src/main/java/com/dbf/naps/data/loader/integrated/IntegratedDataMapper.java b/src/main/java/com/dbf/naps/data/loader/integrated/IntegratedDataMapper.java
index 934ca1460d7..4f92037a143 100644
--- a/src/main/java/com/dbf/naps/data/loader/integrated/IntegratedDataMapper.java
+++ b/src/main/java/com/dbf/naps/data/loader/integrated/IntegratedDataMapper.java
@@ -7,11 +7,11 @@
 public interface IntegratedDataMapper {
 	
 	@Insert({"<script>", 
-        "INSERT into naps.integrated_data (site_id, pollutant_id, date_time, year, month, day, fine, cartridge, media, day_of_week,"
+        "INSERT into naps.integrated_data (site_id, pollutant_id, method_id, date_time, year, month, day, fine, cartridge, media, day_of_week,"
         + "sample_mass, sample_vol, sample_duration, tsp, data) "
         + "values ",
         "<foreach collection='dataRecords' item='record' index='index' open='(' separator = '),(' close=')' >"
-        + "#{record.siteId}, #{record.pollutantId}, #{record.datetime}, #{record.year}, #{record.month}, #{record.day}, "
+        + "#{record.siteId}, #{record.pollutantId}, #{record.methodId}, #{record.datetime}, #{record.year}, #{record.month}, #{record.day}, "
         + "#{record.fine, typeHandler=org.apache.ibatis.type.BooleanTypeHandler}, #{record.cartridge}, #{record.media}, #{record.dayOfWeek}, "
         + "#{record.mass}, #{record.volume}, #{record.duration}, #{record.tsp}, #{record.data}"
         + "</foreach>"
diff --git a/src/main/java/com/dbf/naps/data/loader/integrated/NAPSIntegratedDataLoader.java b/src/main/java/com/dbf/naps/data/loader/integrated/NAPSIntegratedDataLoader.java
index 416e4464fa7..b0fa245d81d 100644
--- a/src/main/java/com/dbf/naps/data/loader/integrated/NAPSIntegratedDataLoader.java
+++ b/src/main/java/com/dbf/naps/data/loader/integrated/NAPSIntegratedDataLoader.java
@@ -28,24 +28,24 @@ public class NAPSIntegratedDataLoader extends NAPSDataLoader {
 		mappings.add(new IntegratedRunnerMapping(CFFileLoadRunner.class, "DICHOT", "_DICH.XLS"));
 		mappings.add(new IntegratedRunnerMapping(CFFileLoadRunner.class, "PM2.5", "_PART25.XLS"));
 		
-		mappings.add(new IntegratedRunnerMapping(SampleMetaDataFileLoadRunner.class, "PAH", "_PAH.XLS"));
-		mappings.add(new IntegratedRunnerMapping(SampleMetaDataFileLoadRunner.class, "HCB", "_HCB.XLS"));
+		mappings.add(new IntegratedRunnerMapping(SampleMetaDataFileLoadRunner.class, "PAH", "_PAH.XLS", "ng/m³"));
+		mappings.add(new IntegratedRunnerMapping(SampleMetaDataFileLoadRunner.class, "HCB", "_HCB.XLS", "ng/m³"));
 		mappings.add(new IntegratedRunnerMapping(SampleMetaDataFileLoadRunner.class, "VOC", "_VOC.XLS"));
 		mappings.add(new IntegratedRunnerMapping(SampleMetaDataFileLoadRunner.class, "VOC", "_VOCS.XLS")); //One file is mis-named :) 
-		mappings.add(new IntegratedRunnerMapping(SampleMetaDataFileLoadRunner.class, "PCDD", "_PCDD.XLSX"));
-		mappings.add(new IntegratedRunnerMapping(SampleMetaDataFileLoadRunner.class, "PCDD", "_PCDD.XLS"));
-		mappings.add(new IntegratedRunnerMapping(SampleMetaDataFileLoadRunner.class, "PCB", "_PCB.XLS"));
+		mappings.add(new IntegratedRunnerMapping(SampleMetaDataFileLoadRunner.class, "PCDD", "_PCDD.XLSX", "pg/m³"));
+		mappings.add(new IntegratedRunnerMapping(SampleMetaDataFileLoadRunner.class, "PCDD", "_PCDD.XLS", "pg/m³"));
+		mappings.add(new IntegratedRunnerMapping(SampleMetaDataFileLoadRunner.class, "PCB", "_PCB.XLS", "pg/m³"));
 		
 		mappings.add(new IntegratedRunnerMapping(SpeciationFileLoadRunner.class, "CARB", "_CARB.XLS"));
 		mappings.add(new IntegratedRunnerMapping(SpeciationFileLoadRunner.class, "IC", "_IC.XLS"));
-		mappings.add(new IntegratedRunnerMapping(SpeciationFileLoadRunner.class, "ICPMS", "_ICPMS.XLS"));
+		mappings.add(new IntegratedRunnerMapping(SpeciationFileLoadRunner.class, "ICPMS", "_ICPMS.XLS", "ng/m³"));
 		mappings.add(new IntegratedRunnerMapping(SpeciationFileLoadRunner.class, "NA", "_NA.XLS"));
 		mappings.add(new IntegratedRunnerMapping(SpeciationFileLoadRunner.class, "NH4", "_NH4.XLS"));
 		mappings.add(new IntegratedRunnerMapping(SpeciationFileLoadRunner.class, "SPEC", "_SPEC.XLS"));
-		mappings.add(new IntegratedRunnerMapping(SpeciationFileLoadRunner.class, "WICPMS", "_WICPMS.XLS"));
-		mappings.add(new IntegratedRunnerMapping(SpeciationFileLoadRunner.class, "LEV", "_LEV.XLS"));
+		mappings.add(new IntegratedRunnerMapping(SpeciationFileLoadRunner.class, "WICPMS", "_WICPMS.XLS", "ng/m³"));
+		mappings.add(new IntegratedRunnerMapping(SpeciationFileLoadRunner.class, "LEV", "_LEV.XLS", "ng/m³"));
 		
-		mappings.add(new IntegratedRunnerMapping(XLSXFileLoadRunner.class, "PAH", Pattern.compile("S[0-9]+_PAH_[0-9]{4}(_EN)?\\.XLSX"))); //Match S90121_PAH_2010.XLSX
+		mappings.add(new IntegratedRunnerMapping(XLSXFileLoadRunner.class, "PAH", Pattern.compile("S[0-9]+_PAH_[0-9]{4}(_EN)?\\.XLSX"), "ng/m³")); //Match S90121_PAH_2010.XLSX
 		mappings.add(new IntegratedRunnerMapping(XLSXFileLoadRunner.class, "PM2.5", Pattern.compile("S[0-9]+_PM25_[0-9]{4}(_EN)?\\.XLSX"))); //Match S40103_PM25_2010.XLSX
 		mappings.add(new IntegratedRunnerMapping(XLSXFileLoadRunner.class, "PM2.5-10", Pattern.compile("S[0-9]+_PM25\\-10_[0-9]{4}(_EN)?\\.XLSX"))); //Match S30113_PM25-10_2010.XLSX
 
@@ -101,8 +101,8 @@ protected Collection<Runnable> processFile(File dataFile) {
 			for(IntegratedRunnerMapping mapping : mappings) {
 				if((null != mapping.getFileNameMatch() && fileName.endsWith(mapping.getFileNameMatch()))
 					|| (null != mapping.getFileNamePattern() && mapping.getFileNamePattern().matcher(fileName).matches())) {
-					return Collections.singletonList((Runnable) mapping.getRunnerClass().getConstructor(int.class, LoaderOptions.class, SqlSessionFactory.class, File.class, String.class)
-							.newInstance(getThreadID(), getOptions(), getSqlSessionFactory(), dataFile, mapping.getFileType()));
+					return Collections.singletonList((Runnable) mapping.getRunnerClass().getConstructor(int.class, LoaderOptions.class, SqlSessionFactory.class, File.class, String.class, String.class)
+							.newInstance(getThreadID(), getOptions(), getSqlSessionFactory(), dataFile, mapping.getFileType(), mapping.getUnits()));
 				}
 			}
 		} catch (InstantiationException | IllegalAccessException | IllegalArgumentException
diff --git a/src/main/java/com/dbf/naps/data/loader/integrated/runner/CFFileLoadRunner.java b/src/main/java/com/dbf/naps/data/loader/integrated/runner/CFFileLoadRunner.java
index 7071d059932..b1673472f20 100644
--- a/src/main/java/com/dbf/naps/data/loader/integrated/runner/CFFileLoadRunner.java
+++ b/src/main/java/com/dbf/naps/data/loader/integrated/runner/CFFileLoadRunner.java
@@ -14,8 +14,8 @@
  */
 public class CFFileLoadRunner extends IntegratedFileLoadRunner {
 
-	public CFFileLoadRunner(int threadId, LoaderOptions config, SqlSessionFactory sqlSessionFactory, File rawFile, String method) {
-		super(threadId, config, sqlSessionFactory, rawFile, method);
+	public CFFileLoadRunner(int threadId, LoaderOptions config, SqlSessionFactory sqlSessionFactory, File rawFile, String method, String units) {
+		super(threadId, config, sqlSessionFactory, rawFile, method, units);
 	}
 
 	@Override
diff --git a/src/main/java/com/dbf/naps/data/loader/integrated/runner/CarbonylsFileLoadRunner.java b/src/main/java/com/dbf/naps/data/loader/integrated/runner/CarbonylsFileLoadRunner.java
index bdc8292f320..9e904f5053e 100644
--- a/src/main/java/com/dbf/naps/data/loader/integrated/runner/CarbonylsFileLoadRunner.java
+++ b/src/main/java/com/dbf/naps/data/loader/integrated/runner/CarbonylsFileLoadRunner.java
@@ -15,8 +15,8 @@
  */
 public class CarbonylsFileLoadRunner extends VOCFileLoadRunner {
 
-	public CarbonylsFileLoadRunner(int threadId, LoaderOptions config, SqlSessionFactory sqlSessionFactory, File rawFile, String method) {
-		super(threadId, config, sqlSessionFactory, rawFile, method);
+	public CarbonylsFileLoadRunner(int threadId, LoaderOptions config, SqlSessionFactory sqlSessionFactory, File rawFile, String method, String units) {
+		super(threadId, config, sqlSessionFactory, rawFile, method, units);
 	}
 
 	//Store these column indexes so we only have to look them up once for the entire sheet 
diff --git a/src/main/java/com/dbf/naps/data/loader/integrated/runner/IntegratedFileLoadRunner.java b/src/main/java/com/dbf/naps/data/loader/integrated/runner/IntegratedFileLoadRunner.java
index 5e03bc93e66..869d642b673 100644
--- a/src/main/java/com/dbf/naps/data/loader/integrated/runner/IntegratedFileLoadRunner.java
+++ b/src/main/java/com/dbf/naps/data/loader/integrated/runner/IntegratedFileLoadRunner.java
@@ -81,17 +81,19 @@ public class IntegratedFileLoadRunner extends FileLoadRunner {
 	//State held during processing
 	private ExcelSheet sheet;
 	private int row;
+	private int col;
 	protected String method;
+	protected String units;
 	
 	private Integer siteID; //Track the site id to read it only once
 	private Integer headerRowNumber; //Track when we have reached the real header row
 	private Integer siteIDColumn; //Track when we have reached the NAPS ID which represents the last column
 	private final String fileType;
 	
-	
-	public IntegratedFileLoadRunner(int threadId, LoaderOptions config, SqlSessionFactory sqlSessionFactory, File rawFile, String fileType) {
+	public IntegratedFileLoadRunner(int threadId, LoaderOptions config, SqlSessionFactory sqlSessionFactory, File rawFile, String fileType, String units) {
 		super(threadId, config, sqlSessionFactory, rawFile);
 		this.fileType = fileType;
+		this.units = units;
 	}
 	
 	/**
@@ -116,9 +118,7 @@ protected List<String> getExcludedSheetNames() {
 		return DEFAULT_IGNORED_SHEETS;
 	}
 	
-	protected void setMethod() {
-		this.method = "INT_" + fileType;
-	}
+	protected void setMethod() {} //By default the method is null, do nothing here.
 	
 	/**
 	 * Processing of a single sheet of the workbook.
@@ -250,7 +250,7 @@ protected List<IntegratedDataRecord> processRow(Date date) {
 		
 		//Data is expected to start on column 2
 		//Last column is NAPS ID and is ignored
-        for (int col = 1; col < getLastColumn(); col++) {
+        for (col = 1; col < getLastColumn(); col++) {
         	String columnHeader = getSheet().getCellContents(col, getHeaderRowNumber()).trim();
         	if(isColumnIgnored(columnHeader)) continue;
         	
@@ -266,6 +266,8 @@ protected List<IntegratedDataRecord> processRow(Date date) {
 	 * 
 	 */
 	private boolean isColumnIgnored(String columnHeader) {
+		if(columnHeader.equals("")) return true;
+		
 		columnHeader = columnHeader.toUpperCase();
 		//ID is a special case that uses an exact match otherwise we might match 
 		//a compound that either start or end with the letter "id"
@@ -306,7 +308,8 @@ protected IntegratedDataRecord processSingleRecord(String columnHeader, String c
     	IntegratedDataRecord record = new IntegratedDataRecord();
 		record.setDatetime(date);
 		record.setSiteId(siteID);
-    	record.setPollutantId(getPollutantID(columnHeader, method));
+    	record.setPollutantId(getPollutantID(columnHeader));
+    	record.setMethodId(getMethodID("Integrated", fileType, method, units));
 
     	//Ignore empty cells, but not zeros
     	if(!"N.M.".equals(cellValue)) {
@@ -379,4 +382,8 @@ protected Integer getLastColumn() {
 	protected int getRow() {
 		return row;
 	}
+	
+	protected int getColumn() {
+		return col;
+	}
 }
diff --git a/src/main/java/com/dbf/naps/data/loader/integrated/runner/IntegratedRunnerMapping.java b/src/main/java/com/dbf/naps/data/loader/integrated/runner/IntegratedRunnerMapping.java
index e603a97fee7..f4bbd57327c 100644
--- a/src/main/java/com/dbf/naps/data/loader/integrated/runner/IntegratedRunnerMapping.java
+++ b/src/main/java/com/dbf/naps/data/loader/integrated/runner/IntegratedRunnerMapping.java
@@ -6,6 +6,7 @@ public class IntegratedRunnerMapping {
 
 	private Class<? extends IntegratedFileLoadRunner> runnerClass;
 	private String fileType;
+	private String units = "ug/m³";
 	private String fileNameMatch;
 	private Pattern fileNamePattern;
 	
@@ -15,34 +16,59 @@ public IntegratedRunnerMapping(Class<? extends IntegratedFileLoadRunner> runnerC
 		this.fileNameMatch = fileNameMatch.toUpperCase();
 	}
 	
+	public IntegratedRunnerMapping(Class<? extends IntegratedFileLoadRunner> runnerClass, String fileType, String fileNameMatch, String units) {
+		this(runnerClass, fileType, fileNameMatch);
+		this.setUnits(units);
+	}
+	
 	public IntegratedRunnerMapping(Class<? extends IntegratedFileLoadRunner> runnerClass, String fileType, Pattern fileNamePattern) {
 		this.runnerClass = runnerClass;
 		this.fileType = fileType;
 		this.fileNamePattern = fileNamePattern;
 	}
 	
+	public IntegratedRunnerMapping(Class<? extends IntegratedFileLoadRunner> runnerClass, String fileType, Pattern fileNamePattern, String units) {
+		this(runnerClass, fileType, fileNamePattern);
+		this.setUnits(units);
+	}
+	
 	public Class<? extends IntegratedFileLoadRunner> getRunnerClass() {
 		return runnerClass;
 	}
+	
 	public void setRunnerClass(Class<IntegratedFileLoadRunner> runnerClass) {
 		this.runnerClass = runnerClass;
 	}
+	
 	public String getFileType() {
 		return fileType;
 	}
+	
 	public void setFileType(String fileType) {
 		this.fileType = fileType;
 	}
+	
 	public String getFileNameMatch() {
 		return fileNameMatch;
 	}
+	
 	public void setFileNameMatch(String fileNameMatch) {
 		this.fileNameMatch = fileNameMatch;
 	}
+	
 	public Pattern getFileNamePattern() {
 		return fileNamePattern;
 	}
+	
 	public void setFileNamePattern(Pattern fileNamePattern) {
 		this.fileNamePattern = fileNamePattern;
 	}
+
+	public String getUnits() {
+		return units;
+	}
+
+	public void setUnits(String units) {
+		this.units = units;
+	}
 }
diff --git a/src/main/java/com/dbf/naps/data/loader/integrated/runner/SampleMetaDataFileLoadRunner.java b/src/main/java/com/dbf/naps/data/loader/integrated/runner/SampleMetaDataFileLoadRunner.java
index 0359bbca79d..a4c7e170c9d 100644
--- a/src/main/java/com/dbf/naps/data/loader/integrated/runner/SampleMetaDataFileLoadRunner.java
+++ b/src/main/java/com/dbf/naps/data/loader/integrated/runner/SampleMetaDataFileLoadRunner.java
@@ -15,8 +15,8 @@
  */
 public class SampleMetaDataFileLoadRunner extends IntegratedFileLoadRunner {
 
-	public SampleMetaDataFileLoadRunner(int threadId, LoaderOptions config, SqlSessionFactory sqlSessionFactory, File rawFile, String method) {
-		super(threadId, config, sqlSessionFactory, rawFile, method);
+	public SampleMetaDataFileLoadRunner(int threadId, LoaderOptions config, SqlSessionFactory sqlSessionFactory, File rawFile, String method, String units) {
+		super(threadId, config, sqlSessionFactory, rawFile, method, units);
 	}
 
 	//Store these column indexes so we only have to look them up once for the entire sheet 
diff --git a/src/main/java/com/dbf/naps/data/loader/integrated/runner/SpeciationFileLoadRunner.java b/src/main/java/com/dbf/naps/data/loader/integrated/runner/SpeciationFileLoadRunner.java
index e97da0cca04..6cb08c663b4 100644
--- a/src/main/java/com/dbf/naps/data/loader/integrated/runner/SpeciationFileLoadRunner.java
+++ b/src/main/java/com/dbf/naps/data/loader/integrated/runner/SpeciationFileLoadRunner.java
@@ -15,8 +15,8 @@
  */
 public class SpeciationFileLoadRunner extends IntegratedFileLoadRunner {
 
-	public SpeciationFileLoadRunner(int threadId, LoaderOptions config, SqlSessionFactory sqlSessionFactory, File rawFile, String method) {
-		super(threadId, config, sqlSessionFactory, rawFile, method);
+	public SpeciationFileLoadRunner(int threadId, LoaderOptions config, SqlSessionFactory sqlSessionFactory, File rawFile, String method, String units) {
+		super(threadId, config, sqlSessionFactory, rawFile, method, units);
 	}
 	
 	//Store these column indexes so we only have to look them up once for the entire sheet 
diff --git a/src/main/java/com/dbf/naps/data/loader/integrated/runner/VOCFileLoadRunner.java b/src/main/java/com/dbf/naps/data/loader/integrated/runner/VOCFileLoadRunner.java
index 8bef03a3252..c6d9ac735c5 100644
--- a/src/main/java/com/dbf/naps/data/loader/integrated/runner/VOCFileLoadRunner.java
+++ b/src/main/java/com/dbf/naps/data/loader/integrated/runner/VOCFileLoadRunner.java
@@ -12,8 +12,8 @@
 
 public class VOCFileLoadRunner extends IntegratedFileLoadRunner {
 
-	public VOCFileLoadRunner(int threadId, LoaderOptions config, SqlSessionFactory sqlSessionFactory, File rawFile, String method) {
-		super(threadId, config, sqlSessionFactory, rawFile, method);
+	public VOCFileLoadRunner(int threadId, LoaderOptions config, SqlSessionFactory sqlSessionFactory, File rawFile, String method, String units) {
+		super(threadId, config, sqlSessionFactory, rawFile, method, units);
 	}
 	
 	@Override
diff --git a/src/main/java/com/dbf/naps/data/loader/integrated/runner/XLSXFileLoadRunner.java b/src/main/java/com/dbf/naps/data/loader/integrated/runner/XLSXFileLoadRunner.java
index f3f5f342433..94454c4c1c0 100644
--- a/src/main/java/com/dbf/naps/data/loader/integrated/runner/XLSXFileLoadRunner.java
+++ b/src/main/java/com/dbf/naps/data/loader/integrated/runner/XLSXFileLoadRunner.java
@@ -4,7 +4,10 @@
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Date;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
+
 import org.apache.ibatis.session.SqlSessionFactory;
 import com.dbf.naps.data.loader.LoaderOptions;
 import com.dbf.naps.data.loader.integrated.IntegratedDataRecord;
@@ -38,8 +41,11 @@ public class XLSXFileLoadRunner extends IntegratedFileLoadRunner {
 		VALID_METHODS.add("IC");
 	}
 	
-	public XLSXFileLoadRunner(int threadId, LoaderOptions config, SqlSessionFactory sqlSessionFactory, File rawFile, String method) {
-		super(threadId, config, sqlSessionFactory, rawFile, method);
+	//Contains the units (eg. "ng/m³") for each of the data columns. Cached for faster lookup
+	private final Map<String, String> columnUnits = new HashMap<String, String>(50);
+	
+	public XLSXFileLoadRunner(int threadId, LoaderOptions config, SqlSessionFactory sqlSessionFactory, File rawFile, String method, String units) {
+		super(threadId, config, sqlSessionFactory, rawFile, method, units);
 	}
 
 	//Store these column indexes so we only have to look them up once for the entire sheet 
@@ -65,19 +71,29 @@ protected List<IntegratedDataRecord> processRow(Date date) {
 	@Override
 	protected IntegratedDataRecord processSingleRecord(String columnHeader, String cellValue, Date date) {
 		//Strip the abbreviation out of the column header
-		columnHeader = DataCleaner.replaceColumnHeaderAbbreviation(columnHeader); 
+		columnHeader = DataCleaner.replaceColumnHeaderAbbreviation(columnHeader);
+		
+		//Override the default units using the value explicitly defined above the column header
+		this.units = columnUnits.computeIfAbsent(columnHeader, header-> {
+			String units = getSheet().getCellContents(getColumn(), this.getHeaderRowNumber()-1).trim();
+			if("".equals(units)) {
+				throw new IllegalArgumentException("Unable to locate the units for " + header + " on column " + getColumn());
+			}
+			units = units.replace("m3", "m³");
+			return units;
+		});
+						
 		return super.processSingleRecord(columnHeader, cellValue, date);
 	}
 	
 	@Override
 	protected void setMethod() {
-		super.setMethod();
 		String sheetNameUpper = getSheet().getName().toUpperCase();
 		
 		//Other sheets may have the same data but using a different method
 		for (String method : VALID_METHODS) {
 			if(sheetNameUpper.contains(method)) {
-				this.method = this.method + "_" + method;
+				this.method = method;
 				break;
 			}
 		}
diff --git a/src/main/resources/schema/schema.sql b/src/main/resources/schema/schema.sql
index 090d2a4e2c3..a266efad56a 100644
--- a/src/main/resources/schema/schema.sql
+++ b/src/main/resources/schema/schema.sql
@@ -2,35 +2,36 @@ CREATE SCHEMA IF NOT EXISTS naps;
 
 CREATE TABLE IF NOT EXISTS naps.pollutants
 (
-   id SERIAL NOT NULL,
-   name VARCHAR(255) NOT NULL,
-   method VARCHAR(255) NOT NULL,
-   PRIMARY KEY (id)
+   id SERIAL PRIMARY KEY,
+   name VARCHAR(255) NOT NULL UNIQUE
 );
 
-CREATE UNIQUE INDEX IF NOT EXISTS idx_pollutants_name ON naps.pollutants (name, method ASC);
-CREATE INDEX IF NOT EXISTS idx_pollutants_method ON naps.pollutants (method ASC);
+CREATE TABLE IF NOT EXISTS naps.methods
+(
+   id SERIAL PRIMARY KEY,
+   dataset VARCHAR(15) NOT NULL,
+   report_type VARCHAR(15) NOT NULL,
+   method VARCHAR(10) NULL,
+   units VARCHAR(10) NOT NULL,
+   UNIQUE NULLS NOT DISTINCT (dataset, report_type, method, units)
+);
 
 CREATE TABLE IF NOT EXISTS naps.sites
 (
-   id            SERIAL NOT NULL,
-   NAPS_id       int not null,
-   station_name  VARCHAR(255) null,
+   id            SERIAL PRIMARY KEY,
+   NAPS_id       int NOT NULL UNIQUE,
+   station_name  VARCHAR(255) NULL,
    city_name     VARCHAR(255) NOT NULL,
    prov_terr     VARCHAR(50) NOT NULL,
    latitude      NUMERIC(16,12) NOT NULL,
    longitude     NUMERIC(16,12) NOT NULL,
-   site_type     VARCHAR(2) null,
-   urbanization  VARCHAR(2) null,
-   neighbourhood VARCHAR(2) null,
-   land_use      VARCHAR(1) null,
-   scale         VARCHAR(2) null,
-   elevation     int null,
-   PRIMARY KEY (id)
+   site_type     VARCHAR(2) NULL,
+   urbanization  VARCHAR(2) NULL,
+   neighbourhood VARCHAR(2) NULL,
+   land_use      VARCHAR(1) NULL,
+   scale         VARCHAR(2) NULL,
+   elevation     int NULL
 );
-
-CREATE UNIQUE INDEX IF NOT EXISTS idx_site_NAPS_id ON naps.sites (NAPS_id ASC);
-
 CREATE INDEX IF NOT EXISTS idx_sites_prov_terr ON naps.sites (prov_terr ASC);
 CREATE INDEX IF NOT EXISTS idx_sites_latitude ON naps.sites (latitude ASC);
 CREATE INDEX IF NOT EXISTS idx_sites_longitude ON naps.sites (longitude ASC);
@@ -44,15 +45,16 @@ CREATE INDEX IF NOT EXISTS idx_sites_elevation ON naps.sites (elevation ASC);
 CREATE TABLE IF NOT EXISTS naps.continuous_data
 (
    site_id int NOT NULL,
-   pollutant_id int not null,
+   pollutant_id int NOT NULL,
+   method_id int NOT NULL,
    date_time timestamp NOT NULL,
-   year smallint not null,
-   month smallint not null,
-   day smallint not null,
-   hour smallint not null,
-   day_of_week smallint not null,
+   year smallint NOT NULL,
+   month smallint NOT NULL,
+   day smallint NOT NULL,
+   hour smallint NOT NULL,
+   day_of_week smallint NOT NULL,
    data NUMERIC(8,3) NOT NULL,
-   PRIMARY KEY (site_id, pollutant_id, date_time),
+   PRIMARY KEY (site_id, pollutant_id, method_id, date_time),
    CONSTRAINT fk_continuous_data_site_id
 			    FOREIGN KEY (site_id)
 			    REFERENCES naps.sites (id)
@@ -60,9 +62,13 @@ CREATE TABLE IF NOT EXISTS naps.continuous_data
    CONSTRAINT fk_continuous_data_pollutant_id
 			    FOREIGN KEY (pollutant_id)
 			    REFERENCES naps.pollutants (id)
+			    ON DELETE CASCADE,
+   CONSTRAINT fk_continuous_data_method_id
+			    FOREIGN KEY (method_id)
+			    REFERENCES naps.methods (id)
 			    ON DELETE CASCADE
 );
-
+CREATE INDEX IF NOT EXISTS idx_continuous_data_method_id ON naps.continuous_data (method_id ASC);
 CREATE INDEX IF NOT EXISTS idx_continuous_data_pollutant_id ON naps.continuous_data (pollutant_id ASC);
 CREATE INDEX IF NOT EXISTS idx_continuous_data_date_time ON naps.continuous_data (date_time ASC);
 CREATE INDEX IF NOT EXISTS idx_continuous_data_year ON naps.continuous_data (year ASC);
@@ -73,15 +79,16 @@ CREATE INDEX IF NOT EXISTS idx_continuous_data_day_of_week ON naps.continuous_da
 CREATE TABLE IF NOT EXISTS naps.integrated_data
 (
    site_id int NOT NULL,
-   pollutant_id int not null,
+   pollutant_id int NOT NULL,
+   method_id int NOT NULL,
    date_time timestamp NOT NULL,
-   year smallint not null,
-   month smallint not null,
-   day smallint not null,
-   day_of_week smallint not null,
-   fine boolean null,
-   cartridge VARCHAR(2) null,
-   media VARCHAR(2) null,
+   year smallint NOT NULL,
+   month smallint NOT NULL,
+   day smallint NOT NULL,
+   day_of_week smallint NOT NULL,
+   fine boolean NULL,
+   cartridge VARCHAR(2) NULL,
+   media VARCHAR(2) NULL,
    sample_mass NUMERIC(12,6) NULL,
    sample_vol NUMERIC(12,6) NULL,
    sample_duration double precision NULL,
@@ -94,10 +101,14 @@ CREATE TABLE IF NOT EXISTS naps.integrated_data
    CONSTRAINT fk_integrated_data_pollutant_id
 			    FOREIGN KEY (pollutant_id)
 			    REFERENCES naps.pollutants (id)
+			    ON DELETE CASCADE,
+   CONSTRAINT fk_integrated_data_method_id
+			    FOREIGN KEY (method_id)
+			    REFERENCES naps.methods (id)
 			    ON DELETE CASCADE
 );
-
-CREATE UNIQUE INDEX IF NOT EXISTS idx_integrated_data_pk ON naps.integrated_data (site_id, pollutant_id, date_time, fine, cartridge, media);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_integrated_data_pk ON naps.integrated_data (site_id, pollutant_id, method_id, date_time, fine, cartridge, media) NULLS NOT DISTINCT;
+CREATE INDEX IF NOT EXISTS idx_integrated_data_method_id ON naps.integrated_data (method_id ASC);
 CREATE INDEX IF NOT EXISTS idx_integrated_data_pollutant_id ON naps.integrated_data (pollutant_id ASC);
 CREATE INDEX IF NOT EXISTS idx_integrated_data_date_time ON naps.integrated_data (date_time ASC);
 CREATE INDEX IF NOT EXISTS idx_integrated_data_year ON naps.integrated_data (year ASC);