From ee7cff944593fe4f038d72cf38e72f993047c4e9 Mon Sep 17 00:00:00 2001 From: James Agnew Date: Thu, 18 Jul 2019 05:47:32 -0400 Subject: [PATCH] =?UTF-8?q?Rename=20a=20few=20columns=20to=20not=20conflic?= =?UTF-8?q?t=20with=20res=C2=B4rved=20words?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../binstore/NullBinaryStorageSvcImpl.java | 31 + .../fhir/jpa/entity/ResourceSearchView.java | 4 +- .../ca/uhn/fhir/jpa/entity/TermConcept.java | 4 +- .../ca/uhn/fhir/jpa/entity/TermValueSet.java | 2 +- .../fhir/jpa/entity/TermValueSetConcept.java | 6 +- .../java/ca/uhn/fhir/jpa/util/TestUtil.java | 39 +- .../NullBinaryStorageSvcImplTest.java | 31 + .../jpa/migrate/taskdef/RenameColumnTask.java | 12 + .../tasks/HapiFhirJpaMigrationTasks.java | 10 + .../migrate/tasks/api/BaseMigrationTasks.java | 5 + .../migrate/taskdef/RenameColumnTaskTest.java | 18 +- .../main/resources/mysql-reserved-words.txt | 818 ++++++++++++++++++ src/changes/changes.xml | 6 + 13 files changed, 972 insertions(+), 14 deletions(-) create mode 100644 hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/binstore/NullBinaryStorageSvcImpl.java create mode 100644 hapi-fhir-jpaserver-base/src/test/java/ca/uhn/fhir/jpa/binstore/NullBinaryStorageSvcImplTest.java create mode 100644 hapi-fhir-test-utilities/src/main/resources/mysql-reserved-words.txt diff --git a/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/binstore/NullBinaryStorageSvcImpl.java b/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/binstore/NullBinaryStorageSvcImpl.java new file mode 100644 index 00000000000..a048fdd2496 --- /dev/null +++ b/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/binstore/NullBinaryStorageSvcImpl.java @@ -0,0 +1,31 @@ +package ca.uhn.fhir.jpa.binstore; + +import org.hl7.fhir.instance.model.api.IIdType; + +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.io.UnsupportedEncodingException; + +public class NullBinaryStorageSvcImpl implements IBinaryStorageSvc { + + @Override + public boolean shouldStoreBlob(long theSize, IIdType theResourceId, String theContentType) { + return false; + } + + @Override + public StoredDetails storeBlob(IIdType theResourceId, String theContentType, InputStream theInputStream) { + throw new UnsupportedOperationException(); + } + + @Override + public StoredDetails fetchBlobDetails(IIdType theResourceId, String theBlobId) { + throw new UnsupportedOperationException(); + } + + @Override + public void writeBlob(IIdType theResourceId, String theBlobId, OutputStream theOutputStream) { + throw new UnsupportedOperationException(); + } +} diff --git a/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/entity/ResourceSearchView.java b/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/entity/ResourceSearchView.java index 12b671eef1d..60515aaa4bf 100644 --- a/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/entity/ResourceSearchView.java +++ b/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/entity/ResourceSearchView.java @@ -48,7 +48,7 @@ import java.util.Date; ", h.res_updated as res_updated " + ", h.res_text as res_text " + ", h.res_encoding as res_encoding " + - ", f.forced_id as forced_pid " + + ", f.forced_id as FORCED_PID " + "FROM HFJ_RES_VER h " + " LEFT OUTER JOIN HFJ_FORCED_ID f ON f.resource_pid = h.res_id " + " INNER JOIN HFJ_RESOURCE r ON r.res_id = h.res_id and r.res_ver = h.res_ver") @@ -97,7 +97,7 @@ public class ResourceSearchView implements IBaseResourceEntity, Serializable { @Enumerated(EnumType.STRING) private ResourceEncodingEnum myEncoding; - @Column(name = "forced_pid", length= ForcedId.MAX_FORCED_ID_LENGTH) + @Column(name = "FORCED_PID", length= ForcedId.MAX_FORCED_ID_LENGTH) private String myForcedPid; public ResourceSearchView() { diff --git a/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/entity/TermConcept.java b/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/entity/TermConcept.java index 60fc0d1a8e4..5249be71b4f 100644 --- a/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/entity/TermConcept.java +++ b/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/entity/TermConcept.java @@ -44,7 +44,7 @@ import static org.apache.commons.lang3.StringUtils.length; @Entity @Indexed(interceptor = DeferConceptIndexingInterceptor.class) @Table(name = "TRM_CONCEPT", uniqueConstraints = { - @UniqueConstraint(name = "IDX_CONCEPT_CS_CODE", columnNames = {"CODESYSTEM_PID", "CODE"}) + @UniqueConstraint(name = "IDX_CONCEPT_CS_CODE", columnNames = {"CODESYSTEM_PID", "CODEVAL"}) }, indexes = { @Index(name = "IDX_CONCEPT_INDEXSTATUS", columnList = "INDEX_STATUS"), @Index(name = "IDX_CONCEPT_UPDATED", columnList = "CONCEPT_UPDATED") @@ -60,7 +60,7 @@ public class TermConcept implements Serializable { @OneToMany(fetch = FetchType.LAZY, mappedBy = "myParent", cascade = {}) private Collection myChildren; - @Column(name = "CODE", nullable = false, length = MAX_CODE_LENGTH) + @Column(name = "CODEVAL", nullable = false, length = MAX_CODE_LENGTH) @Fields({@Field(name = "myCode", index = org.hibernate.search.annotations.Index.YES, store = Store.YES, analyze = Analyze.YES, analyzer = @Analyzer(definition = "exactAnalyzer")),}) private String myCode; @Temporal(TemporalType.TIMESTAMP) diff --git a/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/entity/TermValueSet.java b/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/entity/TermValueSet.java index f586a9df8db..723472895bc 100644 --- a/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/entity/TermValueSet.java +++ b/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/entity/TermValueSet.java @@ -62,7 +62,7 @@ public class TermValueSet implements Serializable { @Column(name = "RES_ID", insertable = false, updatable = false) private Long myResourcePid; - @Column(name = "NAME", nullable = true, length = MAX_NAME_LENGTH) + @Column(name = "VSNAME", nullable = true, length = MAX_NAME_LENGTH) private String myName; @OneToMany(mappedBy = "myValueSet") diff --git a/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/entity/TermValueSetConcept.java b/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/entity/TermValueSetConcept.java index 49de4907693..078bedb8bda 100644 --- a/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/entity/TermValueSetConcept.java +++ b/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/entity/TermValueSetConcept.java @@ -36,7 +36,7 @@ import static org.apache.commons.lang3.StringUtils.left; import static org.apache.commons.lang3.StringUtils.length; @Table(name = "TRM_VALUESET_CONCEPT", indexes = { - @Index(name = "IDX_VALUESET_CONCEPT_CS_CD", columnList = "SYSTEM, CODE") + @Index(name = "IDX_VALUESET_CONCEPT_CS_CD", columnList = "SYSTEM, CODEVAL") }) @Entity() public class TermValueSetConcept implements Serializable { @@ -58,10 +58,10 @@ public class TermValueSetConcept implements Serializable { @Transient private String myValueSetName; - @Column(name = "SYSTEM", nullable = false, length = TermCodeSystem.MAX_URL_LENGTH) + @Column(name = "SYSTEM_URL", nullable = false, length = TermCodeSystem.MAX_URL_LENGTH) private String mySystem; - @Column(name = "CODE", nullable = false, length = TermConcept.MAX_CODE_LENGTH) + @Column(name = "CODEVAL", nullable = false, length = TermConcept.MAX_CODE_LENGTH) private String myCode; @Column(name = "DISPLAY", nullable = true, length = TermConcept.MAX_DESC_LENGTH) diff --git a/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/util/TestUtil.java b/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/util/TestUtil.java index cb6bb51d2aa..4f5c27daea8 100644 --- a/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/util/TestUtil.java +++ b/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/util/TestUtil.java @@ -20,10 +20,12 @@ package ca.uhn.fhir.jpa.util; * #L% */ +import ca.uhn.fhir.rest.api.Constants; import ca.uhn.fhir.rest.server.exceptions.InternalErrorException; import com.google.common.collect.ImmutableSet; import com.google.common.reflect.ClassPath; import com.google.common.reflect.ClassPath.ClassInfo; +import org.apache.commons.io.IOUtils; import org.apache.commons.lang3.Validate; import org.hibernate.validator.constraints.Length; import org.hl7.fhir.instance.model.api.IBaseResource; @@ -32,20 +34,25 @@ import org.hl7.fhir.r4.model.InstantType; import javax.persistence.*; import javax.validation.constraints.Size; import java.io.IOException; +import java.io.InputStream; import java.lang.reflect.AnnotatedElement; import java.lang.reflect.Field; import java.lang.reflect.Modifier; +import java.util.Arrays; import java.util.Date; import java.util.HashSet; import java.util.Set; +import java.util.stream.Collectors; +import static com.google.common.base.Ascii.toUpperCase; import static org.apache.commons.lang3.StringUtils.isBlank; import static org.apache.commons.lang3.StringUtils.isNotBlank; public class TestUtil { + public static final int MAX_COL_LENGTH = 2000; private static final int MAX_LENGTH = 30; private static final org.slf4j.Logger ourLog = org.slf4j.LoggerFactory.getLogger(TestUtil.class); - public static final int MAX_COL_LENGTH = 2000; + private static Set ourReservedWords; /** * non instantiable @@ -59,6 +66,16 @@ public class TestUtil { */ @SuppressWarnings("UnstableApiUsage") public static void scanEntities(String packageName) throws IOException, ClassNotFoundException { + + try (InputStream is = TestUtil.class.getResourceAsStream("/mysql-reserved-words.txt")) { + String contents = IOUtils.toString(is, Constants.CHARSET_UTF8); + String[] words = contents.split("\\n"); + ourReservedWords = Arrays.stream(words) + .filter(t -> isNotBlank(t)) + .map(t -> toUpperCase(t)) + .collect(Collectors.toSet()); + } + ImmutableSet classes = ClassPath.from(TestUtil.class.getClassLoader()).getTopLevelClasses(packageName); Set names = new HashSet(); @@ -141,7 +158,10 @@ public class TestUtil { JoinColumn joinColumn = theAnnotatedElement.getAnnotation(JoinColumn.class); if (joinColumn != null) { - assertNotADuplicateName(joinColumn.name(), null); + String columnName = joinColumn.name(); + validateColumnName(columnName, theAnnotatedElement); + + assertNotADuplicateName(columnName, null); ForeignKey fk = joinColumn.foreignKey(); if (theIsSuperClass) { Validate.isTrue(isBlank(fk.name()), "Foreign key on " + theAnnotatedElement.toString() + " has a name() and should not as it is a superclass"); @@ -155,7 +175,10 @@ public class TestUtil { Column column = theAnnotatedElement.getAnnotation(Column.class); if (column != null) { - assertNotADuplicateName(column.name(), null); + String columnName = column.name(); + validateColumnName(columnName, theAnnotatedElement); + + assertNotADuplicateName(columnName, null); Validate.isTrue(column.unique() == false, "Should not use unique attribute on column (use named @UniqueConstraint instead) on " + theAnnotatedElement.toString()); boolean hasLob = theAnnotatedElement.getAnnotation(Lob.class) != null; @@ -208,6 +231,15 @@ public class TestUtil { } + private static void validateColumnName(String theColumnName, AnnotatedElement theElement) { + if (!theColumnName.equals(theColumnName.toUpperCase())) { + throw new IllegalArgumentException("Column name must be all upper case: " + theColumnName + " found on " + theElement); + } + if (ourReservedWords.contains(theColumnName)) { + throw new IllegalArgumentException("Column name is a reserved word: " + theColumnName + " found on " + theElement); + } + } + private static void assertEquals(String theGenerator, String theName) { Validate.isTrue(theGenerator.equals(theName)); } @@ -250,5 +282,4 @@ public class TestUtil { } - } diff --git a/hapi-fhir-jpaserver-base/src/test/java/ca/uhn/fhir/jpa/binstore/NullBinaryStorageSvcImplTest.java b/hapi-fhir-jpaserver-base/src/test/java/ca/uhn/fhir/jpa/binstore/NullBinaryStorageSvcImplTest.java new file mode 100644 index 00000000000..b8ca92aef9e --- /dev/null +++ b/hapi-fhir-jpaserver-base/src/test/java/ca/uhn/fhir/jpa/binstore/NullBinaryStorageSvcImplTest.java @@ -0,0 +1,31 @@ +package ca.uhn.fhir.jpa.binstore; + +import org.hl7.fhir.r4.model.IdType; +import org.junit.Test; + +import static org.junit.Assert.assertFalse; + +public class NullBinaryStorageSvcImplTest { + + private NullBinaryStorageSvcImpl mySvc = new NullBinaryStorageSvcImpl(); + + @Test + public void shouldStoreBlob() { + assertFalse(mySvc.shouldStoreBlob(1, new IdType("Patient/2"), "application/json")); + } + + @Test(expected = UnsupportedOperationException.class) + public void storeBlob() { + mySvc.storeBlob(null, null, null); + } + + @Test(expected = UnsupportedOperationException.class) + public void fetchBlobDetails() { + mySvc.fetchBlobDetails(null, null); + } + + @Test(expected = UnsupportedOperationException.class) + public void writeBlob() { + mySvc.writeBlob(null, null, null); + } +} diff --git a/hapi-fhir-jpaserver-migrate/src/main/java/ca/uhn/fhir/jpa/migrate/taskdef/RenameColumnTask.java b/hapi-fhir-jpaserver-migrate/src/main/java/ca/uhn/fhir/jpa/migrate/taskdef/RenameColumnTask.java index 8e384081532..088929a0098 100644 --- a/hapi-fhir-jpaserver-migrate/src/main/java/ca/uhn/fhir/jpa/migrate/taskdef/RenameColumnTask.java +++ b/hapi-fhir-jpaserver-migrate/src/main/java/ca/uhn/fhir/jpa/migrate/taskdef/RenameColumnTask.java @@ -33,6 +33,7 @@ public class RenameColumnTask extends BaseTableTask { private static final Logger ourLog = LoggerFactory.getLogger(RenameColumnTask.class); private String myOldName; private String myNewName; + private boolean myAllowNeitherColumnToExist; public void setOldName(String theOldName) { Validate.notBlank(theOldName); @@ -53,6 +54,9 @@ public class RenameColumnTask extends BaseTableTask { throw new SQLException("Can not rename " + getTableName() + "." + myOldName + " to " + myNewName + " because both columns exist!"); } if (!haveOldName && !haveNewName) { + if (isAllowNeitherColumnToExist()) { + return; + } throw new SQLException("Can not rename " + getTableName() + "." + myOldName + " to " + myNewName + " because neither column exists!"); } if (haveNewName) { @@ -89,4 +93,12 @@ public class RenameColumnTask extends BaseTableTask { executeSql(getTableName(), sql); } + + public void setAllowNeitherColumnToExist(boolean theAllowNeitherColumnToExist) { + myAllowNeitherColumnToExist = theAllowNeitherColumnToExist; + } + + public boolean isAllowNeitherColumnToExist() { + return myAllowNeitherColumnToExist; + } } diff --git a/hapi-fhir-jpaserver-migrate/src/main/java/ca/uhn/fhir/jpa/migrate/tasks/HapiFhirJpaMigrationTasks.java b/hapi-fhir-jpaserver-migrate/src/main/java/ca/uhn/fhir/jpa/migrate/tasks/HapiFhirJpaMigrationTasks.java index dd366cb8463..a086f6caa5b 100644 --- a/hapi-fhir-jpaserver-migrate/src/main/java/ca/uhn/fhir/jpa/migrate/tasks/HapiFhirJpaMigrationTasks.java +++ b/hapi-fhir-jpaserver-migrate/src/main/java/ca/uhn/fhir/jpa/migrate/tasks/HapiFhirJpaMigrationTasks.java @@ -80,6 +80,16 @@ public class HapiFhirJpaMigrationTasks extends BaseMigrationTasks { .renameColumn("mySystemVersion", "SYSTEM_VERSION") .renameColumn("myValueSet", "VALUESET_URL"); + version.onTable("TRM_VALUESET") + .renameColumn("NAME", "VSNAME", true); + + version.onTable("TRM_VALUESET_CONCEPT") + .renameColumn("CODE", "CODEVAL", true) + .renameColumn("SYSTEM", "SYSTEM_URL", true); + + version.onTable("TRM_CONCEPT") + .renameColumn("CODE", "CODEVAL"); + // TermValueSet version.startSectionWithMessage("Processing table: TRM_VALUESET"); version.addIdGenerator("SEQ_VALUESET_PID"); diff --git a/hapi-fhir-jpaserver-migrate/src/main/java/ca/uhn/fhir/jpa/migrate/tasks/api/BaseMigrationTasks.java b/hapi-fhir-jpaserver-migrate/src/main/java/ca/uhn/fhir/jpa/migrate/tasks/api/BaseMigrationTasks.java index 421a0590e88..f4d3a07cb13 100644 --- a/hapi-fhir-jpaserver-migrate/src/main/java/ca/uhn/fhir/jpa/migrate/tasks/api/BaseMigrationTasks.java +++ b/hapi-fhir-jpaserver-migrate/src/main/java/ca/uhn/fhir/jpa/migrate/tasks/api/BaseMigrationTasks.java @@ -168,10 +168,15 @@ public class BaseMigrationTasks { } public BuilderWithTableName renameColumn(String theOldName, String theNewName) { + return renameColumn(theOldName, theNewName, false); + } + + public BuilderWithTableName renameColumn(String theOldName, String theNewName, boolean theAllowNeitherColumnToExist) { RenameColumnTask task = new RenameColumnTask(); task.setTableName(myTableName); task.setOldName(theOldName); task.setNewName(theNewName); + task.setAllowNeitherColumnToExist(theAllowNeitherColumnToExist); addTask(task); return this; } diff --git a/hapi-fhir-jpaserver-migrate/src/test/java/ca/uhn/fhir/jpa/migrate/taskdef/RenameColumnTaskTest.java b/hapi-fhir-jpaserver-migrate/src/test/java/ca/uhn/fhir/jpa/migrate/taskdef/RenameColumnTaskTest.java index 9a3d1e79be8..fb2bc53cad4 100644 --- a/hapi-fhir-jpaserver-migrate/src/test/java/ca/uhn/fhir/jpa/migrate/taskdef/RenameColumnTaskTest.java +++ b/hapi-fhir-jpaserver-migrate/src/test/java/ca/uhn/fhir/jpa/migrate/taskdef/RenameColumnTaskTest.java @@ -45,7 +45,7 @@ public class RenameColumnTaskTest extends BaseTest { } @Test - public void testNeitherColumnExists() throws SQLException { + public void testNeitherColumnExists() { executeSql("create table SOMETABLE (PID bigint not null)"); RenameColumnTask task = new RenameColumnTask(); @@ -65,7 +65,21 @@ public class RenameColumnTaskTest extends BaseTest { } @Test - public void testBothColumnsExist() throws SQLException { + public void testNeitherColumnExistsButAllowed() { + executeSql("create table SOMETABLE (PID bigint not null)"); + + RenameColumnTask task = new RenameColumnTask(); + task.setTableName("SOMETABLE"); + task.setOldName("myTextCol"); + task.setNewName("TEXTCOL"); + task.setAllowNeitherColumnToExist(true); + getMigrator().addTask(task); + + getMigrator().migrate(); + } + + @Test + public void testBothColumnsExist() { executeSql("create table SOMETABLE (PID bigint not null, PID2 bigint)"); RenameColumnTask task = new RenameColumnTask(); diff --git a/hapi-fhir-test-utilities/src/main/resources/mysql-reserved-words.txt b/hapi-fhir-test-utilities/src/main/resources/mysql-reserved-words.txt new file mode 100644 index 00000000000..9a60b019a5c --- /dev/null +++ b/hapi-fhir-test-utilities/src/main/resources/mysql-reserved-words.txt @@ -0,0 +1,818 @@ +ACCESSIBLE +ACCOUNT +ACTION +ACTIVE +ADD +ADMIN +AFTER +AGAINST +AGGREGATE +ALGORITHM +ALL +ALTER +ALWAYS +ANALYSE +ANALYZE +AND +ANY +ARRAY +AS +ASC +ASCII +ASENSITIVE +AT +AUTOEXTEND_SIZE +AUTO_INCREMENT +AVG +AVG_ROW_LENGTH +B +BACKUP +BEFORE +BEGIN +BETWEEN +BIGINT +BINARY +BINLOG +BIT +BLOB +BLOCK +BOOL +BOOLEAN +BOTH +BTREE +BUCKETS +BY +BYTE +C +CACHE +CALL +CASCADE +CASCADED +CASE +CATALOG_NAME +CHAIN +CHANGE +CHANGED +CHANNEL +CHAR +CHARACTER +CHARSET +CHECK +CHECKSUM +CIPHER +CLASS_ORIGIN +CLIENT +CLONE +CLOSE +COALESCE +CODE +COLLATE +COLLATION +COLUMN +COLUMNS +COLUMN_FORMAT +COLUMN_NAME +COMMENT +COMMIT +COMMITTED +COMPACT +COMPLETION +COMPONENT +COMPRESSED +COMPRESSION +CONCURRENT +CONDITION +CONNECTION +CONSISTENT +CONSTRAINT +CONSTRAINT_CATALOG +CONSTRAINT_NAME +CONSTRAINT_SCHEMA +CONTAINS +CONTEXT +CONTINUE +CONVERT +CPU +CREATE +CROSS +CUBE +CUME_DIST +CURRENT +CURRENT_DATE +CURRENT_TIME +CURRENT_TIMESTAMP +CURRENT_USER +CURSOR +CURSOR_NAME +D +DATA +DATABASE +DATABASES +DATAFILE +DATE +DATETIME +DAY +DAY_HOUR +DAY_MICROSECOND +DAY_MINUTE +DAY_SECOND +DEALLOCATE +DEC +DECIMAL +DECLARE +DEFAULT +DEFAULT_AUTH +DEFINER +DEFINITION +DELAYED +DELAY_KEY_WRITE +DELETE +DENSE_RANK +DESC +DESCRIBE +DESCRIPTION +DES_KEY_FILE +DETERMINISTIC +DIAGNOSTICS +DIRECTORY +DISABLE +DISCARD +DISK +DISTINCT +DISTINCTROW +DIV +DO +DOUBLE +DROP +DUAL +DUMPFILE +DUPLICATE +DYNAMIC +E +EACH +ELSE +ELSEIF +EMPTY +ENABLE +ENCLOSED +ENCRYPTION +END +ENDS +ENFORCED +ENGINE +ENGINES +ENUM +ERROR +ERRORS +ESCAPE +ESCAPED +EVENT +EVENTS +EVERY +EXCEPT +EXCHANGE +EXCLUDE +EXECUTE +EXISTS +EXIT +EXPANSION +EXPIRE +EXPLAIN +EXPORT +EXTENDED +EXTENT_SIZE +F +FALSE +FAST +FAULTS +FETCH +FIELDS +FILE +FILE_BLOCK_SIZE +FILTER +FIRST +FIRST_VALUE +FIXED +FLOAT +FLUSH +FOLLOWING +FOLLOWS +FOR +FORCE +FOREIGN +FORMAT +FOUND +FROM +FULL +FULLTEXT +FUNCTION +G +GENERAL +GENERATED +GEOMCOLLECTION +GEOMETRY +GEOMETRYCOLLECTION +GET +GET_FORMAT +GET_MASTER_PUBLIC_KEY +GLOBAL +GRANT +GRANTS +GROUP +GROUPING +GROUPS +GROUP_REPLICATION +H +HANDLER +HASH +HAVING +HELP +HIGH_PRIORITY +HISTOGRAM +HISTORY +HOST +HOSTS +HOUR +HOUR_MICROSECOND +HOUR_MINUTE +HOUR_SECOND +I +IDENTIFIED +IF +IGNORE +IGNORE_SERVER_IDS +IMPORT +IN +INACTIVE +INDEX +INDEXES +INFILE +INITIAL_SIZE +INNER +INOUT +INSENSITIVE +INSERT +INSERT_METHOD +INSTALL +INSTANCE +INT +INTEGER +INTERVAL +INTO +INVISIBLE +INVOKER +IO +IO_AFTER_GTIDS +IO_BEFORE_GTIDS +IO_THREAD +IPC +IS +ISOLATION +ISSUER +ITERATE +J +JOIN +JSON +JSON_TABLE +K +KEY +KEYS +KEY_BLOCK_SIZE +KILL +L +LAG +LANGUAGE +LAST +LAST_VALUE +LATERAL +LEAD +LEADING +LEAVE +LEAVES +LEFT +LESS +LEVEL +LIKE +LIMIT +LINEAR +LINES +LINESTRING +LIST +LOAD +LOCAL +LOCALTIME +LOCALTIMESTAMP +LOCK +LOCKED +LOCKS +LOGFILE +LOGS +LONG +LONGBLOB +LONGTEXT +LOOP +LOW_PRIORITY +M +MASTER +MASTER_AUTO_POSITION +MASTER_BIND +MASTER_COMPRESSION_ALGORITHMS +MASTER_CONNECT_RETRY +MASTER_DELAY +MASTER_HEARTBEAT_PERIOD +MASTER_HOST +MASTER_LOG_FILE +MASTER_LOG_POS +MASTER_PASSWORD +MASTER_PORT +MASTER_PUBLIC_KEY_PATH +MASTER_RETRY_COUNT +MASTER_SERVER_ID +MASTER_SSL +MASTER_SSL_CA +MASTER_SSL_CAPATH +MASTER_SSL_CERT +MASTER_SSL_CIPHER +MASTER_SSL_CRL +MASTER_SSL_CRLPATH +MASTER_SSL_KEY +MASTER_SSL_VERIFY_SERVER_CERT +MASTER_TLS_VERSION +MASTER_USER +MASTER_ZSTD_COMPRESSION_LEVEL +MATCH +MAXVALUE +MAX_CONNECTIONS_PER_HOUR +MAX_QUERIES_PER_HOUR +MAX_ROWS +MAX_SIZE +MAX_UPDATES_PER_HOUR +MAX_USER_CONNECTIONS +MEDIUM +MEDIUMBLOB +MEDIUMINT +MEDIUMTEXT +MEMBER +MEMORY +MERGE +MESSAGE_TEXT +MICROSECOND +MIDDLEINT +MIGRATE +MINUTE +MINUTE_MICROSECOND +MINUTE_SECOND +MIN_ROWS +MOD +MODE +MODIFIES +MODIFY +MONTH +MULTILINESTRING +MULTIPOINT +MULTIPOLYGON +MUTEX +MYSQL_ERRNO +N +NAME +NAMES +NATIONAL +NATURAL +NCHAR +NDB +NDBCLUSTER +NESTED +NETWORK_NAMESPACE +NEVER +NEW +NEXT +NO +NODEGROUP +NONE +NOT +NOWAIT +NO_WAIT +NO_WRITE_TO_BINLOG +NTH_VALUE +NTILE +NULL +NULLS +NUMBER +NUMERIC +NVARCHAR +O +OF +OFFSET +OJ +OLD +ON +ONE +ONLY +OPEN +OPTIMIZE +OPTIMIZER_COSTS +OPTION +OPTIONAL +OPTIONALLY +OPTIONS +OR +ORDER +ORDINALITY +ORGANIZATION +OTHERS +OUT +OUTER +OUTFILE +OVER +OWNER +P +PACK_KEYS +PAGE +PARSER +PARTIAL +PARTITION +PARTITIONING +PARTITIONS +PASSWORD +PATH +PERCENT_RANK +PERSIST +PERSIST_ONLY +PHASE +PLUGIN +PLUGINS +PLUGIN_DIR +POINT +POLYGON +PORT +PRECEDES +PRECEDING +PRECISION +PREPARE +PRESERVE +PREV +PRIMARY +PRIVILEGES +PROCEDURE +PROCESS +PROCESSLIST +PROFILE +PROFILES +PROXY +PURGE +Q +QUARTER +QUERY +QUICK +R +RANDOM +RANGE +RANK +READ +READS +READ_ONLY +READ_WRITE +REAL +REBUILD +RECOVER +RECURSIVE +REDOFILE +REDO_BUFFER_SIZE +REDUNDANT +REFERENCE +REFERENCES +REGEXP +RELAY +RELAYLOG +RELAY_LOG_FILE +RELAY_LOG_POS +RELAY_THREAD +RELEASE +RELOAD +REMOTE +REMOVE +RENAME +REORGANIZE +REPAIR +REPEAT +REPEATABLE +REPLACE +REPLICATE_DO_DB +REPLICATE_DO_TABLE +REPLICATE_IGNORE_DB +REPLICATE_IGNORE_TABLE +REPLICATE_REWRITE_DB +REPLICATE_WILD_DO_TABLE +REPLICATE_WILD_IGNORE_TABLE +REPLICATION +REQUIRE +RESET +RESIGNAL +RESOURCE +RESPECT +RESTART +RESTORE +RESTRICT +RESUME +RETAIN +RETURN +RETURNED_SQLSTATE +RETURNS +REUSE +REVERSE +REVOKE +RIGHT +RLIKE +ROLE +ROLLBACK +ROLLUP +ROTATE +ROUTINE +ROW +ROWS +ROW_COUNT +ROW_FORMAT +ROW_NUMBER +RTREE +S +SAVEPOINT +SCHEDULE +SCHEMA +SCHEMAS +SCHEMA_NAME +SECOND +SECONDARY +SECONDARY_ENGINE +SECONDARY_LOAD +SECONDARY_UNLOAD +SECOND_MICROSECOND +SECURITY +SELECT +SENSITIVE +SEPARATOR +SERIAL +SERIALIZABLE +SERVER +SESSION +SET +SHARE +SHOW +SHUTDOWN +SIGNAL +SIGNED +SIMPLE +SKIP +SLAVE +SLOW +SMALLINT +SNAPSHOT +SOCKET +SOME +SONAME +SOUNDS +SOURCE +SPATIAL +SPECIFIC +SQL +SQLEXCEPTION +SQLSTATE +SQLWARNING +SQL_AFTER_GTIDS +SQL_AFTER_MTS_GAPS +SQL_BEFORE_GTIDS +SQL_BIG_RESULT +SQL_BUFFER_RESULT +SQL_CACHE +SQL_CALC_FOUND_ROWS +SQL_NO_CACHE +SQL_SMALL_RESULT +SQL_THREAD +SQL_TSI_DAY +SQL_TSI_HOUR +SQL_TSI_MINUTE +SQL_TSI_MONTH +SQL_TSI_QUARTER +SQL_TSI_SECOND +SQL_TSI_WEEK +SQL_TSI_YEAR +SRID +SSL +STACKED +START +STARTING +STARTS +STATS_AUTO_RECALC +STATS_PERSISTENT +STATS_SAMPLE_PAGES +STATUS +STOP +STORAGE +STORED +STRAIGHT_JOIN +STRING +SUBCLASS_ORIGIN +SUBJECT +SUBPARTITION +SUBPARTITIONS +SUPER +SUSPEND +SWAPS +SWITCHES +SYSTEM +T +TABLE +TABLES +TABLESPACE +TABLE_CHECKSUM +TABLE_NAME +TEMPORARY +TEMPTABLE +TERMINATED +TEXT +THAN +THEN +THREAD_PRIORITY +TIES +TIME +TIMESTAMP +TIMESTAMPADD +TIMESTAMPDIFF +TINYBLOB +TINYINT +TINYTEXT +TO +TRAILING +TRANSACTION +TRIGGER +TRIGGERS +TRUE +TRUNCATE +TYPE +TYPES +U +UNBOUNDED +UNCOMMITTED +UNDEFINED +UNDO +UNDOFILE +UNDO_BUFFER_SIZE +UNICODE +UNINSTALL +UNION +UNIQUE +UNKNOWN +UNLOCK +UNSIGNED +UNTIL +UPDATE +UPGRADE +USAGE +USE +USER +USER_RESOURCES +USE_FRM +USING +UTC_DATE +UTC_TIME +UTC_TIMESTAMP +V +VALIDATION +VALUE +VALUES +VARBINARY +VARCHAR +VARCHARACTER +VARIABLES +VARYING +VCPU +VIEW +VIRTUAL +VISIBLE +W +WAIT +WARNINGS +WEEK +WEIGHT_STRING +WHEN +WHERE +WHILE +WINDOW +WITH +WITHOUT +WORK +WRAPPER +WRITE +X +XA +XID +XML +XOR +Y +YEAR +YEAR_MONTH +Z +ZEROFILL +A +ACTIVE +ADMIN +ARRAY +B +BUCKETS +C +CLONE +COMPONENT +CUME_DIST +D +DEFINITION +DENSE_RANK +DESCRIPTION +E +EMPTY +ENFORCED +EXCEPT +EXCLUDE +F +FIRST_VALUE +FOLLOWING +G +GEOMCOLLECTION +GET_MASTER_PUBLIC_KEY +GROUPING +GROUPS +H +HISTOGRAM +HISTORY +I +INACTIVE +INVISIBLE +J +JSON_TABLE +L +LAG +LAST_VALUE +LATERAL +LEAD +LOCKED +M +MASTER_COMPRESSION_ALGORITHMS +MASTER_PUBLIC_KEY_PATH +MASTER_ZSTD_COMPRESSION_LEVEL +MEMBER +N +NESTED +NETWORK_NAMESPACE +NOWAIT +NTH_VALUE +NTILE +NULLS +O +OF +OJ +OLD +OPTIONAL +ORDINALITY +ORGANIZATION +OTHERS +OVER +P +PATH +PERCENT_RANK +PERSIST +PERSIST_ONLY +PRECEDING +PROCESS +R +RANDOM +RANK +RECURSIVE +REFERENCE +RESOURCE +RESPECT +RESTART +RETAIN +REUSE +ROLE +ROW_NUMBER +S +SECONDARY +SECONDARY_ENGINE +SECONDARY_LOAD +SECONDARY_UNLOAD +SKIP +SRID +SYSTEM +T +THREAD_PRIORITY +TIES +U +UNBOUNDED +V +VCPU +VISIBLE +W +WINDOW +ANALYSE +DES_KEY_FILE +PARSE_GCOL_EXPR +REDOFILE +SQL_CACHE diff --git a/src/changes/changes.xml b/src/changes/changes.xml index 6563126f057..4b8dd99f5ab 100644 --- a/src/changes/changes.xml +++ b/src/changes/changes.xml @@ -316,6 +316,12 @@ request binary data in Attachments as raw binary content instead of as base 64 encoded content. + + A few columns named 'CODE' in the JPA terminology services tables have been + renamed to 'CODEVAL' to avoid any possibility of conflicting with reserved + words in MySQL. The database migrator tool has been updated to handle this + change. +