Compare version numbers in a SQL query - sql

Question

I have a table which is used for storing the compatibility for a specific version of a software. For example whether a version of the client is compatible with the backend. There is a lower and an upper bound, both have major, minor and revision version numbers. Upper bound numbers can be null (there is a check constraint which ensures that either all or none of them is null).
I'd like to create a query which returns the rows for various majorVersion, minorVersion and revisionVersion numbers.
Example (clientId left out to make it more simple):
minMajorVersion | minMinorVersion | minRevisionVersion | maxMajorVersion | maxMinorVersion | maxRevisionVersion
1 0 0 NULL NULL NULL
1 2 5 NULL NULL NULL
1 3 0 NULL NULL NULL
2 0 1 5 1 0
Let's say I want to know which client version is compatible with a backend version 1.2.6. For this, the query should return the first two rows, because the min versions are smaller, and the max versions are NULL.
For another backend version 2.0.1 the query should return the last row, and for backend version 5.2.0 the query should return nothing.
What I was able to create is this:
SELECT c.* FROM COMPATIBILITYQUALIFIER q
join client c on (c.id = q.clientid)
WHERE (q.MINBACKENDMAJORVERSION < 2
OR (q.MINBACKENDMAJORVERSION = 2 AND q.MINBACKENDMINORVERSION < 3)
OR (q.MINBACKENDMAJORVERSION = 2 AND q.MINBACKENDMINORVERSION = 3 AND q.MINBACKENDREVISIONVERSION <=6))
AND ((q.MAXBACKENDMAJORVERSION IS NULL)
OR ((q.MAXBACKENDMAJORVERSION > 2)
OR (q.MAXBACKENDMAJORVERSION = 2 AND q.MAXBACKENDMINORVERSION > 3)
OR (q.MAXBACKENDMAJORVERSION = 2 AND q.MAXBACKENDMINORVERSION = 3 AND q.MAXBACKENDREVISIONVERSION >= 6)))
order by c.MAJORVERSION DESC, c.MINORVERSION DESC, c.REVISIONVERSION DESC;
I don't think it would be performant.
An easy way to do this would be to create a stored procedure, but I don't want to put code in the DB right now.
Is there a way to do it with sub-queries? Anything else which is fast?
UPDATED.

Answer 1

Sure, the query is not the prettiest. But just because you have multiple conditional clauses like that doesn't mean that your query will be any slower.
Only as a matter of readability and to avoid repeating hardcoded values, I would rewrite the query to something like this:
select c.*
from compatibilityqualifier q
join (select 2 as major,
3 as minor,
6 as revision
from dual) ver
on 1=1
join client c
on c.id = q.clientid
where ver.major >= q.minBackendMajorVersion
and (ver.major > q.minBackendMajorVersion or ver.minor >= q.minBackendMinorVersion)
and (ver.major > q.minBackendMajorVersion or ver.minor > q.minBackendMinorVersion or ver.revision >= q.minBackendRevisionVersion)
and (q.maxBackendMajorVersion is null
or (ver.major <= q.maxBackendMajorVersion
and (ver.major < q.maxBackendMajorVersion or ver.minor <= q.maxBackendMinorVersion)
and (ver.major < q.maxBackendMajorVersion or ver.minor < q.maxBackendMinorVersion or ver.revision <= q.maxBackendRevisionVersion)
)
)
order by c.majorversion desc,
c.minorversion desc,
c.revisionversion desc
But I expect the performance to be pretty much identical.

Answer 2

For any given version number expressed as a tuple of (Major, Minor, Revision) you can use the following query to retrieve rows from your CompatibilityQualifier table. For example Version 1,2,6 below:
select q.*
from (select 1 major
, 2 minor
, 6 revision from dual) v
join CompatibilityQualifier q
on ( q.minMajorVersion < v.major or
( q.minMajorVersion = v.major and
( q.minMinorVersion < v.minor or
( q.minMinorVersion = v.minor and
q.minRevisionVersion <= v.revision))))
and ( q.maxMajorVersion is null or
q.maxMajorVersion > v.major or
( q.maxMajorVersion = v.major and
( q.MaxMinorVersion is null or
q.MaxMinorVersion > v.minor or
( q.MaxMinorVersion = v.minor and
( maxRevisionVersion is null or
q.maxRevisionVersion >= v.revision)))));
Which yields the following results:
| MINMAJORVERSION | MINMINORVERSION | MINREVISIONVERSION | MAXMAJORVERSION | MAXMINORVERSION | MAXREVISIONVERSION |
|-----------------|-----------------|--------------------|-----------------|-----------------|--------------------|
| 1 | 0 | 0 | (null) | (null) | (null) |
| 1 | 2 | 5 | (null) | (null) | (null) |
With revision 2,0,1 every row from CompatibilityQualifier would be returned since there are no upper bounds on any of the 1,x,x records.
If you really want records with NULL values of maxMajorVersion excluded from the result set when the queried major version number differs from the minMajorVersion then you can use this revised version:
select q.*
from (select 2 major
, 0 minor
, 1 revision from dual) v
join CompatibilityQualifier q
on ( q.minMajorVersion < v.major or
( q.minMajorVersion = v.major and
( q.minMinorVersion < v.minor or
( q.minMinorVersion = v.minor and
q.minRevisionVersion <= v.revision))))
and ( --q.maxMajorVersion is null or
q.maxMajorVersion > v.major or
( coalesce(q.maxMajorVersion -- When Null compare to minMajorVersion
,q.minMajorVersion) = v.major and
( q.MaxMinorVersion is null or
q.MaxMinorVersion > v.minor or
( q.MaxMinorVersion = v.minor and
( maxRevisionVersion is null or
q.maxRevisionVersion >= v.revision)))));
which just returns the one row:
| MINMAJORVERSION | MINMINORVERSION | MINREVISIONVERSION | MAXMAJORVERSION | MAXMINORVERSION | MAXREVISIONVERSION |
|-----------------|-----------------|--------------------|-----------------|-----------------|--------------------|
| 2 | 0 | 1 | 5 | 1 | 0 |

Answer 3

I know I am bit late to the party, but I found a very easy solution to compare versions in Oracle. Just need to make compare versions as varchar and compare.
Check the following simple query and tested it for different versions and it worked!!!
select case when '1.0.30' < '1.1.22' then 'true' else 'false' end as isVersionHigher
from dual;
--Result => 'true'
You can even compare versions just having major and minor digits. Check below query.
select case when '1.0' < '1.1.22' then 'true' else 'false' end as isVersionHigher
from dual;
--Result => 'true'