Index: Ringtoets/HydraRing/src/Ringtoets.HydraRing.Calculation/Parsers/OvertoppingCalculationWaveHeightParser.cs
===================================================================
diff -u -r9b0f9d3bc29ce2e4ad51ed5de1e7cf320cd7b16c -raff302727cbdd19c159e29ffe359487e3479d982
--- Ringtoets/HydraRing/src/Ringtoets.HydraRing.Calculation/Parsers/OvertoppingCalculationWaveHeightParser.cs	(.../OvertoppingCalculationWaveHeightParser.cs)	(revision 9b0f9d3bc29ce2e4ad51ed5de1e7cf320cd7b16c)
+++ Ringtoets/HydraRing/src/Ringtoets.HydraRing.Calculation/Parsers/OvertoppingCalculationWaveHeightParser.cs	(.../OvertoppingCalculationWaveHeightParser.cs)	(revision aff302727cbdd19c159e29ffe359487e3479d982)
@@ -19,13 +19,11 @@
 // Stichting Deltares and remain full property of Stichting Deltares at all times.
 // All rights reserved.
 
+using System;
 using System.Collections.Generic;
-using System.Globalization;
-using System.IO;
-using System.Linq;
 using Ringtoets.HydraRing.Calculation.Data.Output;
 using Ringtoets.HydraRing.Calculation.Exceptions;
-using Ringtoets.HydraRing.IO;
+using Ringtoets.HydraRing.Calculation.Properties;
 
 namespace Ringtoets.HydraRing.Calculation.Parsers
 {
@@ -34,190 +32,66 @@
     /// </summary>
     public class OvertoppingCalculationWaveHeightParser : IHydraRingFileParser
     {
-        private const string overtoppingStart = "Submechanism = Overtopping RTO";
-        private const string overflowStart = "Submechanism = Overflow";
-        private const string combineWindDirectionStart = "Status = Combined over wind directions";
-        private const string governingWindDirectionStart = "Governing wind direction";
-        private const string overtoppingWaveHeight = "Wave height (Hs)";
-        private const string windDirection = "Wind direction";
-        private const string closingSituation = "Closing situation";
-        private const string beta = "Beta";
-        private const char equalsCharacter = '=';
+        private const string sectionIdParameterName = "@sectionId";
+        private const string waveHeighColumn = "WaveHeight";
+        private const string isOvertoppingDominantColumn = "IsOvertoppingDominant";
 
-        private readonly List<OvertoppingResult> overtoppingResults;
-        private readonly List<GeneralResult> overflowResults;
-        private int governingWindDirection = -1;
+        private readonly string query =
+            $"SELECT Value as {waveHeighColumn}," +
+            $"(case when SubMechanismId is 102 then 1 else 0 end) as {isOvertoppingDominantColumn} FROM " +
+            "(SELECT d.OuterIterationId, TidalPeriod, BetaValue, ClosingSituation, WindDirection, LevelType, SubMechanismId " +
+            "FROM GoverningWind g " +
+            "JOIN DesignBeta d ON d.WindDirection = g.GoverningWind AND d.OuterIterationId = g.OuterIterationId AND d.TidalPeriod = g.PeriodId " +
+            $"WHERE LevelType = 7 AND d.SubMechanismId = 102 AND SectionId = {sectionIdParameterName} " +
+            "ORDER BY d.OuterIterationId DESC, TidalPeriod, BetaValue " +
+            "LIMIT 1) as g " +
+            "JOIN " +
+            "(SELECT Value FROM GoverningWind g " +
+            "JOIN DesignPointResults d ON d.WindDirection = g.GoverningWind AND d.OuterIterationId = g.OuterIterationId AND d.TidalPeriod = g.PeriodId " +
+            "JOIN DesignBeta db ON db.WindDirection = d.WindDirection AND db.ClosingSituation = d.ClosingSituation AND db.OuterIterationId = d.OuterIterationId " +
+            "AND db.TidalPeriod = d.TidalPeriod " +
+            $"WHERE OutputVarId = 3 AND db.LevelType = 7 AND db.SectionId = {sectionIdParameterName} " +
+            "ORDER BY d.OuterIterationId DESC, d.TidalPeriod, db.BetaValue " +
+            "LIMIT 1) " +
+            "Order By g.BetaValue " +
+            "LIMIT 1;";
 
         /// <summary>
-        /// Creates a new instance of <see cref="OvertoppingCalculationWaveHeightParser"/>.
-        /// </summary>
-        public OvertoppingCalculationWaveHeightParser()
-        {
-            overtoppingResults = new List<OvertoppingResult>();
-            overflowResults = new List<GeneralResult>();
-        }
-
-        /// <summary>
         /// Gets the output that was parsed from the output file.
         /// </summary>
         public OvertoppingCalculationWaveHeightOutput Output { get; private set; }
 
         public void Parse(string workingDirectory, int sectionId)
         {
-            string fileName = string.Format("{0}{1}", sectionId, HydraRingFileConstants.OutputFileSuffix);
+            Dictionary<string, object> result = HydraRingDatabaseParseHelper.ReadSingleLine(
+                workingDirectory,
+                query,
+                sectionId,
+                Resources.OvertoppingCalculationWaveHeightParser_Parse_No_overtopping_found_in_output_file);
 
-            try
-            {
-                ReadFile(Path.Combine(workingDirectory, fileName));
-                SetOutputs();
-            }
-            catch
-            {
-                throw new HydraRingFileParserException();
-            }
+            ReadResult(result);
         }
 
-        private void SetOutputs()
+        /// <summary>
+        /// Reads the <paramref name="result"/>.
+        /// </summary>
+        /// <param name="result">The result from the database read.</param>
+        /// <exception cref="HydraRingFileParserException">Thrown when the result
+        /// cannot be converted to the output format.</exception>
+        private void ReadResult(IDictionary<string, object> result)
         {
-            OvertoppingResult relevantOvertoppingResult = null;
-            foreach (OvertoppingResult overtoppingResult in overtoppingResults.Where(o => o.WindDirection == governingWindDirection))
+            try
             {
-                if (relevantOvertoppingResult == null || overtoppingResult.Beta < relevantOvertoppingResult.Beta)
-                {
-                    relevantOvertoppingResult = overtoppingResult;
-                }
-            }
+                double waveHeight = Convert.ToDouble(result[waveHeighColumn]);
+                bool isOvertoppingDominant = Convert.ToBoolean(result[isOvertoppingDominantColumn]);
 
-            if (relevantOvertoppingResult != null && overflowResults.Any())
-            {
-                GeneralResult governingOverflowResult = overflowResults
-                    .First(o => o.WindDirection == governingWindDirection && o.ClosingSituation == relevantOvertoppingResult.ClosingSituation);
-
-                Output = new OvertoppingCalculationWaveHeightOutput(
-                    relevantOvertoppingResult.WaveHeight,
-                    relevantOvertoppingResult.Beta < governingOverflowResult.Beta);
+                Output = new OvertoppingCalculationWaveHeightOutput(waveHeight,
+                                                                    isOvertoppingDominant);
             }
-        }
-
-        private void ReadFile(string filePath)
-        {
-            using (var file = new StreamReader(File.OpenRead(filePath)))
+            catch (InvalidCastException e)
             {
-                while (!file.EndOfStream)
-                {
-                    string currentLine = file.ReadLine();
-                    TryParseOvertoppingSection(currentLine, file);
-                    TryParseOverflowSection(currentLine, file);
-                    TryParseCombinationWindDirectionSection(currentLine, file);
-                }
+                throw new HydraRingFileParserException(Resources.OvertoppingCalculationWaveHeightParser_Parse_No_overtopping_found_in_output_file, e);
             }
         }
-
-        private void TryParseOvertoppingSection(string startLine, StreamReader file)
-        {
-            if (startLine.Contains(overtoppingStart))
-            {
-                var overtoppingResult = new OvertoppingResult();
-                while (!file.EndOfStream && double.IsNaN(overtoppingResult.Beta))
-                {
-                    string readLine = file.ReadLine();
-                    TryParseWaveHeight(readLine, overtoppingResult);
-                    TryParseWindDirection(readLine, overtoppingResult);
-                    TryParseClosingSituation(readLine, overtoppingResult);
-                    TryParseBeta(readLine, overtoppingResult);
-                }
-                overtoppingResults.Add(overtoppingResult);
-            }
-        }
-
-        private void TryParseOverflowSection(string startLine, StreamReader file)
-        {
-            if (startLine.Contains(overflowStart))
-            {
-                var overflowResult = new GeneralResult();
-                while (!file.EndOfStream && double.IsNaN(overflowResult.Beta))
-                {
-                    string readLine = file.ReadLine();
-                    TryParseWindDirection(readLine, overflowResult);
-                    TryParseClosingSituation(readLine, overflowResult);
-                    TryParseBeta(readLine, overflowResult);
-                }
-                overflowResults.Add(overflowResult);
-            }
-        }
-
-        private void TryParseCombinationWindDirectionSection(string startLine, StreamReader file)
-        {
-            if (startLine.Contains(combineWindDirectionStart))
-            {
-                while (!file.EndOfStream && governingWindDirection == -1)
-                {
-                    string readLine = file.ReadLine();
-                    TryParseGoverningWindDirection(readLine);
-                }
-            }
-        }
-
-        private void TryParseGoverningWindDirection(string line)
-        {
-            if (line.Contains(governingWindDirectionStart))
-            {
-                string governingWindDirectionString = line.Split(equalsCharacter)[1].Trim();
-                governingWindDirection = int.Parse(governingWindDirectionString);
-            }
-        }
-
-        private void TryParseWaveHeight(string line, OvertoppingResult overtoppingResult)
-        {
-            if (line.Contains(overtoppingWaveHeight))
-            {
-                string resultAsString = line.Split(equalsCharacter)[1].Trim();
-                overtoppingResult.WaveHeight = double.Parse(resultAsString, CultureInfo.InvariantCulture);
-            }
-        }
-
-        private void TryParseWindDirection(string line, GeneralResult generalResult)
-        {
-            if (line.Contains(windDirection))
-            {
-                string resultAsString = line.Split(equalsCharacter)[1].Trim();
-                generalResult.WindDirection = int.Parse(resultAsString, CultureInfo.InvariantCulture);
-            }
-        }
-
-        private void TryParseClosingSituation(string line, GeneralResult generalResult)
-        {
-            if (line.Contains(closingSituation))
-            {
-                string resultAsString = line.Split(equalsCharacter)[1].Trim();
-                generalResult.ClosingSituation = int.Parse(resultAsString, CultureInfo.InvariantCulture);
-            }
-        }
-
-        private void TryParseBeta(string line, GeneralResult generalResult)
-        {
-            if (line.Contains(beta))
-            {
-                string resultAsString = line.Split(equalsCharacter)[1].Trim();
-                generalResult.Beta = double.Parse(resultAsString, CultureInfo.InvariantCulture);
-            }
-        }
-
-        private class GeneralResult
-        {
-            public GeneralResult()
-            {
-                Beta = double.NaN;
-            }
-
-            public int WindDirection { get; set; }
-            public int ClosingSituation { get; set; }
-            public double Beta { get; set; }
-        }
-
-        private class OvertoppingResult : GeneralResult
-        {
-            public double WaveHeight { get; set; }
-        }
     }
 }
\ No newline at end of file