TSK-1491: Change schema version check to work with lower but compatible TASKANA versions
This commit is contained in:
parent
8830cfa629
commit
0f1b3505bc
|
@ -0,0 +1,8 @@
|
|||
|
||||
Maven Artifact
|
||||
Copyright 2001-2019 The Apache Software Foundation
|
||||
|
||||
This product includes software developed at
|
||||
The Apache Software Foundation (http://www.apache.org/).
|
||||
|
||||
|
|
@ -43,4 +43,4 @@
|
|||
</dependency>
|
||||
</dependencies>
|
||||
|
||||
</project>
|
||||
</project>
|
||||
|
|
|
@ -18,6 +18,8 @@ import org.apache.ibatis.jdbc.SqlRunner;
|
|||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
import pro.taskana.common.internal.util.ComparableVersion;
|
||||
|
||||
/** This class create the schema for taskana. */
|
||||
public class DbSchemaCreator {
|
||||
|
||||
|
@ -75,7 +77,7 @@ public class DbSchemaCreator {
|
|||
}
|
||||
}
|
||||
|
||||
public boolean isValidSchemaVersion(String expectedVersion) {
|
||||
public boolean isValidSchemaVersion(String expectedMinVersion) {
|
||||
try (Connection connection = dataSource.getConnection()) {
|
||||
connection.setSchema(this.schemaName);
|
||||
SqlRunner runner = new SqlRunner(connection);
|
||||
|
@ -83,15 +85,18 @@ public class DbSchemaCreator {
|
|||
|
||||
String query =
|
||||
"select VERSION from TASKANA_SCHEMA_VERSION where "
|
||||
+ "VERSION = (select max(VERSION) from TASKANA_SCHEMA_VERSION) "
|
||||
+ "AND VERSION = ?";
|
||||
+ "VERSION = (select max(VERSION) from TASKANA_SCHEMA_VERSION) ";
|
||||
|
||||
Map<String, Object> queryResult = runner.selectOne(query, expectedVersion);
|
||||
if (queryResult == null || queryResult.isEmpty()) {
|
||||
Map<String, Object> queryResult = runner.selectOne(query);
|
||||
|
||||
ComparableVersion actualVersion = new ComparableVersion((String) queryResult.get("VERSION"));
|
||||
ComparableVersion minVersion = new ComparableVersion(expectedMinVersion);
|
||||
|
||||
if (actualVersion.compareTo(minVersion) < 0) {
|
||||
LOGGER.error(
|
||||
"Schema version not valid. The VERSION property in table TASKANA_SCHEMA_VERSION "
|
||||
+ "has not the expected value {}",
|
||||
expectedVersion);
|
||||
+ "has not the expected min value {}",
|
||||
expectedMinVersion);
|
||||
return false;
|
||||
} else {
|
||||
LOGGER.debug("Schema version is valid.");
|
||||
|
@ -101,8 +106,8 @@ public class DbSchemaCreator {
|
|||
} catch (RuntimeSqlException | SQLException e) {
|
||||
LOGGER.error(
|
||||
"Schema version not valid. The VERSION property in table TASKANA_SCHEMA_VERSION "
|
||||
+ "has not the expected value {}",
|
||||
expectedVersion);
|
||||
+ "has not the expected min value {}",
|
||||
expectedMinVersion);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -0,0 +1,683 @@
|
|||
package pro.taskana.common.internal.util;
|
||||
|
||||
/*
|
||||
* Licensed to the Apache Software Foundation (ASF) under one
|
||||
* or more contributor license agreements. See the NOTICE file
|
||||
* distributed with this work for additional information
|
||||
* regarding copyright ownership. The ASF licenses this file
|
||||
* to you under the Apache License, Version 2.0 (the
|
||||
* "License"); you may not use this file except in compliance
|
||||
* with the License. You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing,
|
||||
* software distributed under the License is distributed on an
|
||||
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||
* KIND, either express or implied. See the License for the
|
||||
* specific language governing permissions and limitations
|
||||
* under the License.
|
||||
*
|
||||
* Original file:
|
||||
* https://github.com/apache/maven/blob/master/maven-artifact/src/main/java/org/apache
|
||||
* /maven/artifact/versioning/ComparableVersion.java
|
||||
*/
|
||||
|
||||
import java.math.BigInteger;
|
||||
import java.util.ArrayDeque;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Deque;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
import java.util.Locale;
|
||||
import java.util.Properties;
|
||||
|
||||
/**
|
||||
* Generic implementation of version comparison. Features:
|
||||
*
|
||||
* <ul>
|
||||
* <li>mixing of '<code>-</code>' (hyphen) and '<code>.</code>' (dot) separators,
|
||||
* <li>transition between characters and digits also constitutes a separator: <code>
|
||||
* 1.0alpha1 => [1, 0, alpha, 1]</code>
|
||||
* <li>unlimited number of version components,
|
||||
* <li>version components in the text can be digits or strings,
|
||||
* <li>strings are checked for well-known qualifiers and the qualifier ordering is used for
|
||||
* version ordering. Well-known qualifiers (case insensitive) are:
|
||||
* <ul>
|
||||
* <li><code>alpha</code> or <code>a</code>
|
||||
* <li><code>beta</code> or <code>b</code>
|
||||
* <li><code>milestone</code> or <code>m</code>
|
||||
* <li><code>rc</code> or <code>cr</code>
|
||||
* <li><code>snapshot</code>
|
||||
* <li><code>(the empty string)</code> or <code>ga</code> or <code>final</code>
|
||||
* <li><code>sp</code>
|
||||
* </ul>
|
||||
* Unknown qualifiers are considered after known qualifiers, with lexical order (always case
|
||||
* insensitive),
|
||||
* <li>a hyphen usually precedes a qualifier, and is always less important than something preceded
|
||||
* with a dot.
|
||||
* </ul>
|
||||
*
|
||||
* @see <a href="https://cwiki.apache.org/confluence/display/MAVENOLD/Versioning">"Versioning" on
|
||||
* Maven Wiki</a>
|
||||
* @author <a href="mailto:kenney@apache.org">Kenney Westerhof</a>
|
||||
* @author <a href="mailto:hboutemy@apache.org">Hervé Boutemy</a>
|
||||
*/
|
||||
public class ComparableVersion implements Comparable<ComparableVersion> {
|
||||
private static final int MAX_INTITEM_LENGTH = 9;
|
||||
|
||||
private static final int MAX_LONGITEM_LENGTH = 18;
|
||||
|
||||
private String value;
|
||||
|
||||
private String canonical;
|
||||
|
||||
private ListItem items;
|
||||
|
||||
public ComparableVersion(String version) {
|
||||
parseVersion(version);
|
||||
}
|
||||
|
||||
@SuppressWarnings("checkstyle:innerassignment")
|
||||
public final void parseVersion(String version) {
|
||||
this.value = version;
|
||||
|
||||
items = new ListItem();
|
||||
|
||||
version = version.toLowerCase(Locale.ENGLISH);
|
||||
|
||||
ListItem list = items;
|
||||
|
||||
Deque<Item> stack = new ArrayDeque<>();
|
||||
stack.push(list);
|
||||
|
||||
boolean isDigit = false;
|
||||
|
||||
int startIndex = 0;
|
||||
|
||||
for (int i = 0; i < version.length(); i++) {
|
||||
char c = version.charAt(i);
|
||||
|
||||
if (c == '.') {
|
||||
if (i == startIndex) {
|
||||
list.add(IntItem.ZERO);
|
||||
} else {
|
||||
list.add(parseItem(isDigit, version.substring(startIndex, i)));
|
||||
}
|
||||
startIndex = i + 1;
|
||||
} else if (c == '-') {
|
||||
if (i == startIndex) {
|
||||
list.add(IntItem.ZERO);
|
||||
} else {
|
||||
list.add(parseItem(isDigit, version.substring(startIndex, i)));
|
||||
}
|
||||
startIndex = i + 1;
|
||||
|
||||
list.add(list = new ListItem());
|
||||
stack.push(list);
|
||||
} else if (Character.isDigit(c)) {
|
||||
if (!isDigit && i > startIndex) {
|
||||
list.add(new StringItem(version.substring(startIndex, i), true));
|
||||
startIndex = i;
|
||||
|
||||
list.add(list = new ListItem());
|
||||
stack.push(list);
|
||||
}
|
||||
|
||||
isDigit = true;
|
||||
} else {
|
||||
if (isDigit && i > startIndex) {
|
||||
list.add(parseItem(true, version.substring(startIndex, i)));
|
||||
startIndex = i;
|
||||
|
||||
list.add(list = new ListItem());
|
||||
stack.push(list);
|
||||
}
|
||||
|
||||
isDigit = false;
|
||||
}
|
||||
}
|
||||
|
||||
if (version.length() > startIndex) {
|
||||
list.add(parseItem(isDigit, version.substring(startIndex)));
|
||||
}
|
||||
|
||||
while (!stack.isEmpty()) {
|
||||
list = (ListItem) stack.pop();
|
||||
list.normalize();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public int compareTo(ComparableVersion o) {
|
||||
return items.compareTo(o.items);
|
||||
}
|
||||
|
||||
public String getCanonical() {
|
||||
if (canonical == null) {
|
||||
canonical = items.toString();
|
||||
}
|
||||
return canonical;
|
||||
}
|
||||
|
||||
/**
|
||||
* Main to test version parsing and comparison.
|
||||
*
|
||||
* <p>To check how "1.2.7" compares to "1.2-SNAPSHOT", for example, you can issue
|
||||
*
|
||||
* <pre>
|
||||
* java -jar ${maven.repo.local}/org/apache/maven/maven-artifact/
|
||||
* ${maven.version}/maven-artifact-${maven.version}.jar "1.2.7" "1.2-SNAPSHOT"
|
||||
* </pre>
|
||||
* command to command line. Result of given command will be something like this:
|
||||
*
|
||||
* <pre>
|
||||
* Display parameters as parsed by Maven (in canonical form) and comparison result:
|
||||
* 1. 1.2.7 == 1.2.7
|
||||
* 1.2.7 > 1.2-SNAPSHOT
|
||||
* 2. 1.2-SNAPSHOT == 1.2-snapshot
|
||||
* </pre>
|
||||
*
|
||||
* @param args the version strings to parse and compare. You can pass arbitrary number of version
|
||||
* strings and always two adjacent will be compared
|
||||
*/
|
||||
// CHECKSTYLE_ON: LineLength
|
||||
public static void main(String... args) {
|
||||
/* System.out.println(
|
||||
"Display parameters as parsed by Maven (in canonical form) and comparison result:");*/
|
||||
if (args.length == 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
ComparableVersion prev = null;
|
||||
int i = 1;
|
||||
for (String version : args) {
|
||||
ComparableVersion c = new ComparableVersion(version);
|
||||
|
||||
if (prev != null) {
|
||||
int compare = prev.compareTo(c);
|
||||
/* System.out.println(
|
||||
" "
|
||||
+ prev.toString()
|
||||
+ ' '
|
||||
+ ((compare == 0) ? "==" : ((compare < 0) ? "<" : ">"))
|
||||
+ ' '
|
||||
+ version);
|
||||
}*/
|
||||
|
||||
// System.out.println(String.valueOf(i++) + ". " + version + " == " + c.getCanonical());
|
||||
|
||||
prev = c;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static Item parseItem(boolean isDigit, String buf) {
|
||||
if (isDigit) {
|
||||
buf = stripLeadingZeroes(buf);
|
||||
if (buf.length() <= MAX_INTITEM_LENGTH) {
|
||||
// lower than 2^31
|
||||
return new IntItem(buf);
|
||||
} else if (buf.length() <= MAX_LONGITEM_LENGTH) {
|
||||
// lower than 2^63
|
||||
return new LongItem(buf);
|
||||
}
|
||||
return new BigIntegerItem(buf);
|
||||
}
|
||||
return new StringItem(buf, false);
|
||||
}
|
||||
|
||||
private static String stripLeadingZeroes(String buf) {
|
||||
if (buf == null || buf.isEmpty()) {
|
||||
return "0";
|
||||
}
|
||||
for (int i = 0; i < buf.length(); ++i) {
|
||||
char c = buf.charAt(i);
|
||||
if (c != '0') {
|
||||
return buf.substring(i);
|
||||
}
|
||||
}
|
||||
return buf;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return items.hashCode();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object o) {
|
||||
return (o instanceof ComparableVersion) && items.equals(((ComparableVersion) o).items);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return value;
|
||||
}
|
||||
|
||||
private interface Item {
|
||||
int INT_ITEM = 3;
|
||||
int LONG_ITEM = 4;
|
||||
int BIGINTEGER_ITEM = 0;
|
||||
int STRING_ITEM = 1;
|
||||
int LIST_ITEM = 2;
|
||||
|
||||
int compareTo(Item item);
|
||||
|
||||
int getType();
|
||||
|
||||
boolean isNull();
|
||||
}
|
||||
|
||||
/** Represents a numeric item in the version item list that can be represented with an int. */
|
||||
private static class IntItem implements Item {
|
||||
public static final IntItem ZERO = new IntItem();
|
||||
private final int value;
|
||||
|
||||
private IntItem() {
|
||||
this.value = 0;
|
||||
}
|
||||
|
||||
IntItem(String str) {
|
||||
this.value = Integer.parseInt(str);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getType() {
|
||||
return INT_ITEM;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isNull() {
|
||||
return value == 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int compareTo(Item item) {
|
||||
if (item == null) {
|
||||
return (value == 0) ? 0 : 1; // 1.0 == 1, 1.1 > 1
|
||||
}
|
||||
|
||||
switch (item.getType()) {
|
||||
case INT_ITEM:
|
||||
int itemValue = ((IntItem) item).value;
|
||||
return (value < itemValue) ? -1 : ((value == itemValue) ? 0 : 1);
|
||||
case LONG_ITEM:
|
||||
case BIGINTEGER_ITEM:
|
||||
return -1;
|
||||
|
||||
case STRING_ITEM:
|
||||
return 1; // 1.1 > 1-sp
|
||||
|
||||
case LIST_ITEM:
|
||||
return 1; // 1.1 > 1-1
|
||||
|
||||
default:
|
||||
throw new IllegalStateException("invalid item: " + item.getClass());
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return value;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object o) {
|
||||
if (this == o) {
|
||||
return true;
|
||||
}
|
||||
if (o == null || getClass() != o.getClass()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
IntItem intItem = (IntItem) o;
|
||||
|
||||
return value == intItem.value;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return Integer.toString(value);
|
||||
}
|
||||
}
|
||||
|
||||
/** Represents a numeric item in the version item list that can be represented with a long. */
|
||||
private static class LongItem implements Item {
|
||||
private final long value;
|
||||
|
||||
LongItem(String str) {
|
||||
this.value = Long.parseLong(str);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getType() {
|
||||
return LONG_ITEM;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isNull() {
|
||||
return value == 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int compareTo(Item item) {
|
||||
if (item == null) {
|
||||
return (value == 0) ? 0 : 1; // 1.0 == 1, 1.1 > 1
|
||||
}
|
||||
|
||||
switch (item.getType()) {
|
||||
case INT_ITEM:
|
||||
return 1;
|
||||
case LONG_ITEM:
|
||||
long itemValue = ((LongItem) item).value;
|
||||
return (value < itemValue) ? -1 : ((value == itemValue) ? 0 : 1);
|
||||
case BIGINTEGER_ITEM:
|
||||
return -1;
|
||||
|
||||
case STRING_ITEM:
|
||||
return 1; // 1.1 > 1-sp
|
||||
|
||||
case LIST_ITEM:
|
||||
return 1; // 1.1 > 1-1
|
||||
|
||||
default:
|
||||
throw new IllegalStateException("invalid item: " + item.getClass());
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return (int) (value ^ (value >>> 32));
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object o) {
|
||||
if (this == o) {
|
||||
return true;
|
||||
}
|
||||
if (o == null || getClass() != o.getClass()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
LongItem longItem = (LongItem) o;
|
||||
|
||||
return value == longItem.value;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return Long.toString(value);
|
||||
}
|
||||
}
|
||||
|
||||
/** Represents a numeric item in the version item list. */
|
||||
private static class BigIntegerItem implements Item {
|
||||
private final BigInteger value;
|
||||
|
||||
BigIntegerItem(String str) {
|
||||
this.value = new BigInteger(str);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getType() {
|
||||
return BIGINTEGER_ITEM;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isNull() {
|
||||
return BigInteger.ZERO.equals(value);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int compareTo(Item item) {
|
||||
if (item == null) {
|
||||
return BigInteger.ZERO.equals(value) ? 0 : 1; // 1.0 == 1, 1.1 > 1
|
||||
}
|
||||
|
||||
switch (item.getType()) {
|
||||
case INT_ITEM:
|
||||
case LONG_ITEM:
|
||||
return 1;
|
||||
|
||||
case BIGINTEGER_ITEM:
|
||||
return value.compareTo(((BigIntegerItem) item).value);
|
||||
|
||||
case STRING_ITEM:
|
||||
return 1; // 1.1 > 1-sp
|
||||
|
||||
case LIST_ITEM:
|
||||
return 1; // 1.1 > 1-1
|
||||
|
||||
default:
|
||||
throw new IllegalStateException("invalid item: " + item.getClass());
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return value.hashCode();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object o) {
|
||||
if (this == o) {
|
||||
return true;
|
||||
}
|
||||
if (o == null || getClass() != o.getClass()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
BigIntegerItem that = (BigIntegerItem) o;
|
||||
|
||||
return value.equals(that.value);
|
||||
}
|
||||
|
||||
public String toString() {
|
||||
return value.toString();
|
||||
}
|
||||
}
|
||||
|
||||
/** Represents a string in the version item list, usually a qualifier. */
|
||||
private static class StringItem implements Item {
|
||||
private static final List<String> QUALIFIERS =
|
||||
Arrays.asList("alpha", "beta", "milestone", "rc", "snapshot", "", "sp");
|
||||
|
||||
private static final Properties ALIASES = new Properties();
|
||||
/**
|
||||
* A comparable value for the empty-string qualifier. This one is used to determine if a given
|
||||
* qualifier makes the version older than one without a qualifier, or more recent.
|
||||
*/
|
||||
private static final String RELEASE_VERSION_INDEX = String.valueOf(QUALIFIERS.indexOf(""));
|
||||
|
||||
static {
|
||||
ALIASES.put("ga", "");
|
||||
ALIASES.put("final", "");
|
||||
ALIASES.put("release", "");
|
||||
ALIASES.put("cr", "rc");
|
||||
}
|
||||
|
||||
private final String value;
|
||||
|
||||
StringItem(String value, boolean followedByDigit) {
|
||||
if (followedByDigit && value.length() == 1) {
|
||||
// a1 = alpha-1, b1 = beta-1, m1 = milestone-1
|
||||
switch (value.charAt(0)) {
|
||||
case 'a':
|
||||
value = "alpha";
|
||||
break;
|
||||
case 'b':
|
||||
value = "beta";
|
||||
break;
|
||||
case 'm':
|
||||
value = "milestone";
|
||||
break;
|
||||
default:
|
||||
}
|
||||
}
|
||||
this.value = ALIASES.getProperty(value, value);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getType() {
|
||||
return STRING_ITEM;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isNull() {
|
||||
return (comparableQualifier(value).compareTo(RELEASE_VERSION_INDEX) == 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a comparable value for a qualifier.
|
||||
*
|
||||
* <p>This method takes into account the ordering of known qualifiers then unknown qualifiers
|
||||
* with lexical ordering.
|
||||
*
|
||||
* <p>just returning an Integer with the index here is faster, but requires a lot of
|
||||
* if/then/else to check for -1 or QUALIFIERS.size and then resort to lexical ordering. Most
|
||||
* comparisons are decided by the first character, so this is still fast. If more characters are
|
||||
* needed then it requires a lexical sort anyway.
|
||||
*
|
||||
* @param qualifier the qualifier
|
||||
* @return an equivalent value that can be used with lexical comparison
|
||||
*/
|
||||
public static String comparableQualifier(String qualifier) {
|
||||
int i = QUALIFIERS.indexOf(qualifier);
|
||||
|
||||
return i == -1 ? (QUALIFIERS.size() + "-" + qualifier) : String.valueOf(i);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int compareTo(Item item) {
|
||||
if (item == null) {
|
||||
// 1-rc < 1, 1-ga > 1
|
||||
return comparableQualifier(value).compareTo(RELEASE_VERSION_INDEX);
|
||||
}
|
||||
switch (item.getType()) {
|
||||
case INT_ITEM:
|
||||
case LONG_ITEM:
|
||||
case BIGINTEGER_ITEM:
|
||||
return -1; // 1.any < 1.1 ?
|
||||
|
||||
case STRING_ITEM:
|
||||
return comparableQualifier(value)
|
||||
.compareTo(comparableQualifier(((StringItem) item).value));
|
||||
|
||||
case LIST_ITEM:
|
||||
return -1; // 1.any < 1-1
|
||||
|
||||
default:
|
||||
throw new IllegalStateException("invalid item: " + item.getClass());
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return value.hashCode();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object o) {
|
||||
if (this == o) {
|
||||
return true;
|
||||
}
|
||||
if (o == null || getClass() != o.getClass()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
StringItem that = (StringItem) o;
|
||||
|
||||
return value.equals(that.value);
|
||||
}
|
||||
|
||||
public String toString() {
|
||||
return value;
|
||||
}
|
||||
}
|
||||
|
||||
// CHECKSTYLE_OFF: LineLength
|
||||
|
||||
/**
|
||||
* Represents a version list item. This class is used both for the global item list and for
|
||||
* sub-lists (which start with '-(number)' in the version specification).
|
||||
*/
|
||||
private static class ListItem extends ArrayList<Item> implements Item {
|
||||
@Override
|
||||
public int getType() {
|
||||
return LIST_ITEM;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isNull() {
|
||||
return (size() == 0);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int compareTo(Item item) {
|
||||
if (item == null) {
|
||||
if (size() == 0) {
|
||||
return 0; // 1-0 = 1- (normalize) = 1
|
||||
}
|
||||
Item first = get(0);
|
||||
return first.compareTo(null);
|
||||
}
|
||||
switch (item.getType()) {
|
||||
case INT_ITEM:
|
||||
case LONG_ITEM:
|
||||
case BIGINTEGER_ITEM:
|
||||
return -1; // 1-1 < 1.0.x
|
||||
|
||||
case STRING_ITEM:
|
||||
return 1; // 1-1 > 1-sp
|
||||
|
||||
case LIST_ITEM:
|
||||
Iterator<Item> left = iterator();
|
||||
Iterator<Item> right = ((ListItem) item).iterator();
|
||||
|
||||
while (left.hasNext() || right.hasNext()) {
|
||||
Item l = left.hasNext() ? left.next() : null;
|
||||
Item r = right.hasNext() ? right.next() : null;
|
||||
|
||||
// if this is shorter, then invert the compare and mul with -1
|
||||
int result = l == null ? (r == null ? 0 : -1 * r.compareTo(l)) : l.compareTo(r);
|
||||
|
||||
if (result != 0) {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
default:
|
||||
throw new IllegalStateException("invalid item: " + item.getClass());
|
||||
}
|
||||
}
|
||||
|
||||
void normalize() {
|
||||
for (int i = size() - 1; i >= 0; i--) {
|
||||
Item lastItem = get(i);
|
||||
|
||||
if (lastItem.isNull()) {
|
||||
// remove null trailing items: 0, "", empty list
|
||||
remove(i);
|
||||
} else if (!(lastItem instanceof ListItem)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
StringBuilder buffer = new StringBuilder();
|
||||
for (Item item : this) {
|
||||
if (buffer.length() > 0) {
|
||||
buffer.append((item instanceof ListItem) ? '-' : '.');
|
||||
}
|
||||
buffer.append(item);
|
||||
}
|
||||
return buffer.toString();
|
||||
}
|
||||
}
|
||||
}
|
|
@ -161,7 +161,7 @@ public class TaskanaEngineConfiguration {
|
|||
|
||||
if (!dbSchemaCreator.isValidSchemaVersion(TASKANA_SCHEMA_VERSION)) {
|
||||
throw new SystemException(
|
||||
"The Database Schema Version doesn't match the expected version "
|
||||
"The Database Schema Version doesn't match the expected minimal version "
|
||||
+ TASKANA_SCHEMA_VERSION);
|
||||
}
|
||||
|
||||
|
|
|
@ -125,7 +125,12 @@ class PojoTest {
|
|||
javaClass ->
|
||||
!javaClass.getSimpleName().equals("TaskHistoryEvent")
|
||||
&& !javaClass.getSimpleName().equals("WorkbasketHistoryEvent")
|
||||
&& !javaClass.getSimpleName().equals("ClassificationHistoryEvent"))
|
||||
&& !javaClass.getSimpleName().equals("ClassificationHistoryEvent")
|
||||
&& !javaClass.getSimpleName().equals("ComparableVersion")
|
||||
&& !javaClass.getSimpleName().equals("StringItem")
|
||||
&& !javaClass.getSimpleName().equals("BigIntegerItem")
|
||||
&& !javaClass.getSimpleName().equals("IntItem")
|
||||
&& !javaClass.getSimpleName().equals("LongItem"))
|
||||
.map(JavaClass::reflect)
|
||||
.collect(Collectors.toList());
|
||||
}
|
||||
|
|
Loading…
Reference in New Issue