Introduced new Version-class to parse version-string information

Samuel Nitsche · Samuel Nitsche · commit 9e7fdd2af214 · 2017-11-05T14:37:11.000+01:00
diff --git a/src/main/java/org/utplsql/api/DBHelper.java b/src/main/java/org/utplsql/api/DBHelper.java
@@ -2,10 +2,7 @@
 
 import oracle.jdbc.OracleTypes;
 
-import java.sql.CallableStatement;
-import java.sql.Connection;
-import java.sql.SQLException;
-import java.sql.Types;
+import java.sql.*;
 
 /**
  * Database utility functions.
@@ -114,6 +111,28 @@ public static void failOnVersionCompatibilityCheckFailed( Connection conn )
         }
     }
 
+    /** Returns the Frameworks version string of the given connection
+     *
+     * @param conn Active db connection
+     * @return
+     * @throws SQLException
+     */
+    public static Version getDatabaseFrameworkVersion( Connection conn )
+            throws SQLException {
+        Version result = new Version("");
+        try (Statement stmt = conn.prepareStatement("select ut_runner.version() from dual"))
+        {
+            ResultSet rs = stmt.getResultSet();
+
+            if ( rs.next() )
+                result = new Version(rs.getString(1));
+
+            rs.close();
+        }
+
+        return result;
+    }
+
     /**
      * Enable the dbms_output buffer with unlimited size.
      * @param conn the connection
diff --git a/src/main/java/org/utplsql/api/Version.java b/src/main/java/org/utplsql/api/Version.java
@@ -0,0 +1,96 @@
+package org.utplsql.api;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/** Simple class to parse utPLSQL Version-information and provide the separate version-numbers
+ *
+ * @author pesse
+ */
+public class Version {
+    private String origString;
+    private Integer major;
+    private Integer minor;
+    private Integer bugfix;
+    private Integer build;
+    private boolean valid = false;
+
+    public Version( String versionString ) {
+        assert versionString != null;
+        this.origString = versionString;
+        parseVersionString();
+    }
+
+    private void parseVersionString()
+    {
+        Pattern p = Pattern.compile("([0-9]+)\\.?([0-9]+)?\\.?([0-9]+)?\\.?([0-9]+)?");
+
+        Matcher m = p.matcher(origString);
+
+        try {
+            if (m.find()) {
+                if ( m.group(1) != null )
+                    major = Integer.valueOf(m.group(1));
+                if ( m.group(2) != null )
+                    minor = Integer.valueOf(m.group(2));
+                if ( m.group(3) != null )
+                    bugfix = Integer.valueOf(m.group(3));
+                if ( m.group(4) != null )
+                    build = Integer.valueOf(m.group(4));
+
+                if ( major != null ) // We need a valid major version as minimum requirement for a Version object to be valid
+                    valid = true;
+            }
+        }
+        catch ( NumberFormatException e )
+        {
+            valid = false;
+        }
+    }
+
+    public String getOrigString() {
+        return origString;
+    }
+
+    public Integer getMajor() {
+        return major;
+    }
+
+    public Integer getMinor() {
+        return minor;
+    }
+
+    public Integer getBugfix() {
+        return bugfix;
+    }
+
+    public Integer getBuild() {
+        return build;
+    }
+
+    public boolean isValid() {
+        return valid;
+    }
+
+    /** Returns a normalized form of the parsed version information
+     *
+     * @return
+     */
+    public String getVersionString()
+    {
+        if ( isValid() ) {
+            StringBuilder sb = new StringBuilder();
+            sb.append(String.valueOf(major));
+            if ( minor != null )
+                sb.append("." + String.valueOf(minor));
+            if ( bugfix != null )
+                sb.append("." + String.valueOf(bugfix));
+            if ( build != null )
+                sb.append("." + String.valueOf(build));
+
+            return sb.toString();
+        }
+        else
+            return "invalid";
+    }
+}
diff --git a/src/test/java/org/utplsql/api/VersionObjectTest.java b/src/test/java/org/utplsql/api/VersionObjectTest.java
@@ -0,0 +1,43 @@
+package org.utplsql.api;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class VersionObjectTest {
+
+    @Test
+    public void versionPatternRecognitionFull() {
+        Version v = new Version("v3.1.3.1234");
+
+        Assert.assertEquals(3, (long)v.getMajor());
+        Assert.assertEquals(1, (long)v.getMinor());
+        Assert.assertEquals(3, (long)v.getBugfix());
+        Assert.assertEquals(1234, (long)v.getBuild());
+        Assert.assertEquals(true, v.isValid());
+        Assert.assertEquals("3.1.3.1234", v.getVersionString());
+    }
+
+    @Test
+    public void versionPatternRecognitionPartial() {
+        Version v = new Version("3.1.etc");
+
+        Assert.assertEquals(3, (long)v.getMajor());
+        Assert.assertEquals(1, (long)v.getMinor());
+        Assert.assertNull(v.getBugfix());
+        Assert.assertNull(v.getBuild());
+        Assert.assertEquals(true, v.isValid());
+        Assert.assertEquals("3.1", v.getVersionString());
+    }
+
+    @Test
+    public void versionPatternRecognitionInvalid() {
+        Version v = new Version("adseef");
+
+        Assert.assertNull(v.getMajor());
+        Assert.assertNull(v.getMinor());
+        Assert.assertNull(v.getBugfix());
+        Assert.assertNull(v.getBuild());
+        Assert.assertEquals(false, v.isValid());
+        Assert.assertEquals("invalid", v.getVersionString());
+    }
+}
