From e83d88304f0788b3dddb5bf2fb8860c7dc125856 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Sun, 19 Apr 2026 11:12:15 +0100 Subject: [PATCH 01/19] feat: introduce DatabaseCapability interface to define database feature support profiles --- .../utilities/DatabaseCapability.java | 101 ++++++++++++++++++ 1 file changed, 101 insertions(+) create mode 100644 tck/src/main/java/ee/jakarta/tck/data/framework/utilities/DatabaseCapability.java diff --git a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/DatabaseCapability.java b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/DatabaseCapability.java new file mode 100644 index 000000000..a6c31ae2f --- /dev/null +++ b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/DatabaseCapability.java @@ -0,0 +1,101 @@ +/* + * Copyright (c) 2026 Contributors to the Eclipse Foundation + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v. 2.0, which is available at + * http://www.eclipse.org/legal/epl-2.0. + * + * This Source Code may also be made available under the following Secondary + * Licenses when the conditions for such availability set forth in the + * Eclipse Public License v. 2.0 are satisfied: GNU General Public License, + * version 2 with the GNU Classpath Exception, which is available at + * https://www.gnu.org/software/classpath/license.html. + * + * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 + */ +/** + * Defines the capability profile of a database family or provider. + * + *

This interface represents what operations and expressions are expected + * to be supported by a given database type. Implementations should document + * nuances such as partial support, vendor-specific behavior, or limitations.

+ * + *

Important: A {@code true} value indicates expected support, + * but does not guarantee uniform behavior across all vendors of the same family.

+ */ +public interface DatabaseCapability { + + boolean capableOfAddition(); + + boolean capableOfAnd(); + + boolean capableOfAssignmentToExpression(); + + boolean capableOfBetween(); + + boolean capableOfAttributeVsAttributeComparison(); + + boolean capableOfConcat(); + + boolean capableOfConditionalDelete(); + + boolean capableOfConditionalUpdate(); + + boolean capableOfConstraintsOnNonIdAttributes(); + + boolean capableOfCount(); + + boolean capableOfCountingDeletes(); + + boolean capableOfCountingUpdates(); + + boolean capableOfDivision(); + + boolean capableOfGreaterThan(); + + boolean capableOfGreaterThanEqual(); + + boolean capableOfIn(); + + boolean capableOfLeft(); + + boolean capableOfLength(); + + boolean capableOfLessThan(); + + boolean capableOfLessThanEqual(); + + boolean capableOfLike(); + + boolean capableOfLower(); + + boolean capableOfMultipleSort(); + + boolean capableOfMultiplication(); + + boolean capableOfNotBetween(); + + boolean capableOfNotEqual(); + + boolean capableOfNotIn(); + + boolean capableOfNotLike(); + + boolean capableOfNotNull(); + + boolean capableOfNull(); + + boolean capableOfOr(); + + boolean capableOfParentheses(); + + boolean capableOfQueryWithoutWhere(); + + boolean capableOfRight(); + + boolean capableOfSingleSort(); + + boolean capableOfSubtraction(); + + boolean capableOfUpper(); +} \ No newline at end of file From 958f9bb0351f5426060ad4d5eced4cda357d6342 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Sun, 19 Apr 2026 11:13:47 +0100 Subject: [PATCH 02/19] chore: add package declaration to DatabaseCapability.java --- .../jakarta/tck/data/framework/utilities/DatabaseCapability.java | 1 + 1 file changed, 1 insertion(+) diff --git a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/DatabaseCapability.java b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/DatabaseCapability.java index a6c31ae2f..d18700089 100644 --- a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/DatabaseCapability.java +++ b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/DatabaseCapability.java @@ -13,6 +13,7 @@ * * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 */ +package ee.jakarta.tck.data.framework.utilities; /** * Defines the capability profile of a database family or provider. * From 7a2bafc062526e4b8e78d925066189b58edc695b Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Sun, 19 Apr 2026 11:14:27 +0100 Subject: [PATCH 03/19] feat: add AbstractDatabaseCapability base class with default conservative capability profile --- .../utilities/AbstractDatabaseCapability.java | 108 ++++++++++++++++++ 1 file changed, 108 insertions(+) create mode 100644 tck/src/main/java/ee/jakarta/tck/data/framework/utilities/AbstractDatabaseCapability.java diff --git a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/AbstractDatabaseCapability.java b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/AbstractDatabaseCapability.java new file mode 100644 index 000000000..b05297a5a --- /dev/null +++ b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/AbstractDatabaseCapability.java @@ -0,0 +1,108 @@ +/* + * Copyright (c) 2026 Contributors to the Eclipse Foundation + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v. 2.0, which is available at + * http://www.eclipse.org/legal/epl-2.0. + * + * This Source Code may also be made available under the following Secondary + * Licenses when the conditions for such availability set forth in the + * Eclipse Public License v. 2.0 are satisfied: GNU General Public License, + * version 2 with the GNU Classpath Exception, which is available at + * https://www.gnu.org/software/classpath/license.html. + * + * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 + */ +package ee.jakarta.tck.data.framework.utilities; +/** + * Base implementation for {@link DatabaseCapability}. + * + *

This class represents a conservative capability profile where no + * database features are assumed to be supported by default.

+ * + *

Concrete implementations should explicitly override only the + * capabilities they are expected to support. This avoids implicit + * assumptions and ensures that support is always intentional and + * documented.

+ * + *

Design note: Capability support may vary not only + * by database family but also by specific provider and configuration. + * Therefore, this base class does not assume any capability, even if it + * is commonly available in certain database categories.

+ */ +public abstract class AbstractDatabaseCapability implements DatabaseCapability { + + @Override public boolean capableOfAddition() { return false; } + + @Override public boolean capableOfAnd() { return false; } + + @Override public boolean capableOfAssignmentToExpression() { return false; } + + @Override public boolean capableOfBetween() { return false; } + + @Override public boolean capableOfAttributeVsAttributeComparison() { return false; } + + @Override public boolean capableOfConcat() { return false; } + + @Override public boolean capableOfConditionalDelete() { return false; } + + @Override public boolean capableOfConditionalUpdate() { return false; } + + @Override public boolean capableOfConstraintsOnNonIdAttributes() { return false; } + + @Override public boolean capableOfCount() { return false; } + + @Override public boolean capableOfCountingDeletes() { return false; } + + @Override public boolean capableOfCountingUpdates() { return false; } + + @Override public boolean capableOfDivision() { return false; } + + @Override public boolean capableOfGreaterThan() { return false; } + + @Override public boolean capableOfGreaterThanEqual() { return false; } + + @Override public boolean capableOfIn() { return false; } + + @Override public boolean capableOfLeft() { return false; } + + @Override public boolean capableOfLength() { return false; } + + @Override public boolean capableOfLessThan() { return false; } + + @Override public boolean capableOfLessThanEqual() { return false; } + + @Override public boolean capableOfLike() { return false; } + + @Override public boolean capableOfLower() { return false; } + + @Override public boolean capableOfMultipleSort() { return false; } + + @Override public boolean capableOfMultiplication() { return false; } + + @Override public boolean capableOfNotBetween() { return false; } + + @Override public boolean capableOfNotEqual() { return false; } + + @Override public boolean capableOfNotIn() { return false; } + + @Override public boolean capableOfNotLike() { return false; } + + @Override public boolean capableOfNotNull() { return false; } + + @Override public boolean capableOfNull() { return false; } + + @Override public boolean capableOfOr() { return false; } + + @Override public boolean capableOfParentheses() { return false; } + + @Override public boolean capableOfQueryWithoutWhere() { return false; } + + @Override public boolean capableOfRight() { return false; } + + @Override public boolean capableOfSingleSort() { return false; } + + @Override public boolean capableOfSubtraction() { return false; } + + @Override public boolean capableOfUpper() { return false; } +} \ No newline at end of file From dd3b7e16d7cdf7a5a17f15f68056d71e0b2564b4 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Sun, 19 Apr 2026 11:15:06 +0100 Subject: [PATCH 04/19] feat: add KeyValueCapability class with conservative profile for key-value databases --- .../utilities/KeyValueCapability.java | 32 +++++++++++++++++++ 1 file changed, 32 insertions(+) create mode 100644 tck/src/main/java/ee/jakarta/tck/data/framework/utilities/KeyValueCapability.java diff --git a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/KeyValueCapability.java b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/KeyValueCapability.java new file mode 100644 index 000000000..9efed8c65 --- /dev/null +++ b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/KeyValueCapability.java @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2026 Contributors to the Eclipse Foundation + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v. 2.0, which is available at + * http://www.eclipse.org/legal/epl-2.0. + * + * This Source Code may also be made available under the following Secondary + * Licenses when the conditions for such availability set forth in the + * Eclipse Public License v. 2.0 are satisfied: GNU General Public License, + * version 2 with the GNU Classpath Exception, which is available at + * https://www.gnu.org/software/classpath/license.html. + * + * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 + */ +package ee.jakarta.tck.data.framework.utilities; + +/** + * Capability profile for Key-Value databases based on the current behavior model. + * + *

In the existing model, key-value databases are considered the least flexible + * category. As a result, no query-related capabilities are assumed to be supported.

+ * + *

This implementation reflects that behavior by not enabling any capabilities. + * All operations beyond basic key-based access (put/get/delete) are treated as + * unsupported at the database level.

+ * + *

Note: While some key-value databases may offer extended features, + * this profile intentionally remains conservative to match the current TCK behavior.

+ */ +public final class KeyValueCapability extends AbstractDatabaseCapability { +} \ No newline at end of file From cbe148c0dc5a5d10907c109ae3616e33713d8637 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Sun, 19 Apr 2026 11:16:11 +0100 Subject: [PATCH 05/19] feat: add ColumnCapability class with conservative profile for column-oriented databases --- .../framework/utilities/ColumnCapability.java | 87 +++++++++++++++++++ 1 file changed, 87 insertions(+) create mode 100644 tck/src/main/java/ee/jakarta/tck/data/framework/utilities/ColumnCapability.java diff --git a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/ColumnCapability.java b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/ColumnCapability.java new file mode 100644 index 000000000..6d94a9ab4 --- /dev/null +++ b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/ColumnCapability.java @@ -0,0 +1,87 @@ +/* + * Copyright (c) 2026 Contributors to the Eclipse Foundation + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v. 2.0, which is available at + * http://www.eclipse.org/legal/epl-2.0. + * + * This Source Code may also be made available under the following Secondary + * Licenses when the conditions for such availability set forth in the + * Eclipse Public License v. 2.0 are satisfied: GNU General Public License, + * version 2 with the GNU Classpath Exception, which is available at + * https://www.gnu.org/software/classpath/license.html. + * + * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 + */ +package ee.jakarta.tck.data.framework.utilities; +/** + * Capability profile for Column-oriented databases based on the current behavior model. + * + *

In the existing model, column databases introduce basic comparison and + * filtering capabilities beyond simple key-based access. This includes support + * for range queries, null checks, and inclusion-based filtering.

+ * + *

More advanced features such as arithmetic operations, string manipulation, + * sorting, and conditional updates are not assumed to be supported at this level.

+ * + *

Note: Actual support may vary depending on the specific + * implementation (e.g., wide-column vs analytical column stores), but this + * profile reflects the conservative baseline defined in the current TCK behavior.

+ */ +public final class ColumnCapability extends AbstractDatabaseCapability { + + @Override + public boolean capableOfBetween() { + return true; + } + + @Override + public boolean capableOfGreaterThan() { + return true; + } + + @Override + public boolean capableOfGreaterThanEqual() { + return true; + } + + @Override + public boolean capableOfIn() { + return true; + } + + @Override + public boolean capableOfLessThan() { + return true; + } + + @Override + public boolean capableOfLessThanEqual() { + return true; + } + + @Override + public boolean capableOfNotBetween() { + return true; + } + + @Override + public boolean capableOfNotEqual() { + return true; + } + + @Override + public boolean capableOfNotIn() { + return true; + } + + @Override + public boolean capableOfNotNull() { + return true; + } + + @Override + public boolean capableOfNull() { + return true; + } +} \ No newline at end of file From 54335f3bde058e19be0f43428437d6afcd317f26 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Sun, 19 Apr 2026 11:17:21 +0100 Subject: [PATCH 06/19] feat: add DocumentCapability class with conservative profile for document-oriented databases --- .../utilities/DocumentCapability.java | 122 ++++++++++++++++++ 1 file changed, 122 insertions(+) create mode 100644 tck/src/main/java/ee/jakarta/tck/data/framework/utilities/DocumentCapability.java diff --git a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/DocumentCapability.java b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/DocumentCapability.java new file mode 100644 index 000000000..0e8285c5e --- /dev/null +++ b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/DocumentCapability.java @@ -0,0 +1,122 @@ +/* + * Copyright (c) 2026 Contributors to the Eclipse Foundation + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v. 2.0, which is available at + * http://www.eclipse.org/legal/epl-2.0. + * + * This Source Code may also be made available under the following Secondary + * Licenses when the conditions for such availability set forth in the + * Eclipse Public License v. 2.0 are satisfied: GNU General Public License, + * version 2 with the GNU Classpath Exception, which is available at + * https://www.gnu.org/software/classpath/license.html. + * + * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 + */ +package ee.jakarta.tck.data.framework.utilities; + +/** + * Capability profile for Document databases based on the current behavior model. + * + *

In the existing model, document databases introduce logical composition, + * basic aggregation, and query flexibility beyond simple comparisons. This + * includes support for logical operators, counting, sorting (single field), + * and filtering without requiring a strict schema.

+ * + *

While document databases often provide rich querying capabilities, + * support may vary significantly across vendors, especially for advanced + * expressions, arithmetic operations, and string manipulation functions.

+ * + *

This profile reflects a conservative baseline consistent with the current + * TCK behavior, enabling capabilities expected at the document level while + * leaving more advanced features to higher categories.

+ */ +public final class DocumentCapability extends AbstractDatabaseCapability { + + @Override + public boolean capableOfAnd() { + return true; + } + + @Override + public boolean capableOfConstraintsOnNonIdAttributes() { + return true; + } + + @Override + public boolean capableOfCount() { + return true; + } + + @Override + public boolean capableOfOr() { + return true; + } + + @Override + public boolean capableOfQueryWithoutWhere() { + return true; + } + + @Override + public boolean capableOfSingleSort() { + return true; + } + + // Inherited from COLUMN level + + @Override + public boolean capableOfBetween() { + return true; + } + + @Override + public boolean capableOfGreaterThan() { + return true; + } + + @Override + public boolean capableOfGreaterThanEqual() { + return true; + } + + @Override + public boolean capableOfIn() { + return true; + } + + @Override + public boolean capableOfLessThan() { + return true; + } + + @Override + public boolean capableOfLessThanEqual() { + return true; + } + + @Override + public boolean capableOfNotBetween() { + return true; + } + + @Override + public boolean capableOfNotEqual() { + return true; + } + + @Override + public boolean capableOfNotIn() { + return true; + } + + @Override + public boolean capableOfNotNull() { + return true; + } + + @Override + public boolean capableOfNull() { + return true; + } +} \ No newline at end of file From f8907f58d40ee56cb031d5ee7480e765d97ea354 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Sun, 19 Apr 2026 11:18:14 +0100 Subject: [PATCH 07/19] feat: add GraphCapability class with conservative profile for graph databases --- .../framework/utilities/GraphCapability.java | 159 ++++++++++++++++++ 1 file changed, 159 insertions(+) create mode 100644 tck/src/main/java/ee/jakarta/tck/data/framework/utilities/GraphCapability.java diff --git a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/GraphCapability.java b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/GraphCapability.java new file mode 100644 index 000000000..006de4b00 --- /dev/null +++ b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/GraphCapability.java @@ -0,0 +1,159 @@ +/* + * Copyright (c) 2026 Contributors to the Eclipse Foundation + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v. 2.0, which is available at + * http://www.eclipse.org/legal/epl-2.0. + * + * This Source Code may also be made available under the following Secondary + * Licenses when the conditions for such availability set forth in the + * Eclipse Public License v. 2.0 are satisfied: GNU General Public License, + * version 2 with the GNU Classpath Exception, which is available at + * https://www.gnu.org/software/classpath/license.html. + * + * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 + */ +package ee.jakarta.tck.data.framework.utilities; + +/** + * Capability profile for Graph databases based on the current behavior model. + * + *

In the existing model, graph databases extend document-level capabilities + * by introducing support for string manipulation and function-based expressions, + * such as substring operations and case transformations.

+ * + *

This includes operations like LEFT, RIGHT, LENGTH, LOWER, and UPPER, which + * are typically associated with query languages capable of traversing and + * transforming data within relationships.

+ * + *

While graph databases are often highly expressive in traversal and pattern + * matching, this profile focuses only on the capabilities defined in the current + * TCK behavior model.

+ * + *

Note: Actual support may vary by vendor and query language. + * This implementation reflects a conservative baseline consistent with the + * existing capability thresholds.

+ */ +public final class GraphCapability extends AbstractDatabaseCapability { + + // Graph-specific capabilities + + @Override + public boolean capableOfConcat() { + return true; + } + + @Override + public boolean capableOfLeft() { + return true; + } + + @Override + public boolean capableOfLength() { + return true; + } + + @Override + public boolean capableOfLower() { + return true; + } + + @Override + public boolean capableOfRight() { + return true; + } + + @Override + public boolean capableOfUpper() { + return true; + } + + // Inherited from DOCUMENT level + + @Override + public boolean capableOfAnd() { + return true; + } + + @Override + public boolean capableOfConstraintsOnNonIdAttributes() { + return true; + } + + @Override + public boolean capableOfCount() { + return true; + } + + @Override + public boolean capableOfOr() { + return true; + } + + @Override + public boolean capableOfQueryWithoutWhere() { + return true; + } + + @Override + public boolean capableOfSingleSort() { + return true; + } + + // Inherited from COLUMN level + + @Override + public boolean capableOfBetween() { + return true; + } + + @Override + public boolean capableOfGreaterThan() { + return true; + } + + @Override + public boolean capableOfGreaterThanEqual() { + return true; + } + + @Override + public boolean capableOfIn() { + return true; + } + + @Override + public boolean capableOfLessThan() { + return true; + } + + @Override + public boolean capableOfLessThanEqual() { + return true; + } + + @Override + public boolean capableOfNotBetween() { + return true; + } + + @Override + public boolean capableOfNotEqual() { + return true; + } + + @Override + public boolean capableOfNotIn() { + return true; + } + + @Override + public boolean capableOfNotNull() { + return true; + } + + @Override + public boolean capableOfNull() { + return true; + } +} \ No newline at end of file From b18156e3c28d66403fd0012232d54ed7297315e5 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Sun, 19 Apr 2026 11:36:39 +0100 Subject: [PATCH 08/19] refactor: remove redundant comments from GraphCapability class --- .../tck/data/framework/utilities/GraphCapability.java | 6 ------ 1 file changed, 6 deletions(-) diff --git a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/GraphCapability.java b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/GraphCapability.java index 006de4b00..fef7d9ad9 100644 --- a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/GraphCapability.java +++ b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/GraphCapability.java @@ -36,8 +36,6 @@ */ public final class GraphCapability extends AbstractDatabaseCapability { - // Graph-specific capabilities - @Override public boolean capableOfConcat() { return true; @@ -68,8 +66,6 @@ public boolean capableOfUpper() { return true; } - // Inherited from DOCUMENT level - @Override public boolean capableOfAnd() { return true; @@ -100,8 +96,6 @@ public boolean capableOfSingleSort() { return true; } - // Inherited from COLUMN level - @Override public boolean capableOfBetween() { return true; From 786d2dc75f349e65a68ae337a8c6f437408f55bd Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Sun, 19 Apr 2026 11:39:00 +0100 Subject: [PATCH 09/19] feat: add RelationalCapability class with comprehensive profile for relational databases --- .../utilities/RelationalCapability.java | 72 +++++++++++++++++++ 1 file changed, 72 insertions(+) create mode 100644 tck/src/main/java/ee/jakarta/tck/data/framework/utilities/RelationalCapability.java diff --git a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/RelationalCapability.java b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/RelationalCapability.java new file mode 100644 index 000000000..c1478a4ba --- /dev/null +++ b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/RelationalCapability.java @@ -0,0 +1,72 @@ +/* + * Copyright (c) 2026 Contributors to the Eclipse Foundation + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v. 2.0, which is available at + * http://www.eclipse.org/legal/epl-2.0. + * + * This Source Code may also be made available under the following Secondary + * Licenses when the conditions for such availability set forth in the + * Eclipse Public License v. 2.0 are satisfied: GNU General Public License, + * version 2 with the GNU Classpath Exception, which is available at + * https://www.gnu.org/software/classpath/license.html. + * + * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 + */ +package ee.jakarta.tck.data.framework.utilities; + +/** + * Capability profile for Relational databases based on the current behavior model. + * + *

In the existing model, relational databases represent the highest level of + * capability, supporting the full range of query operations, expressions, and + * data manipulation features defined in the TCK.

+ * + *

This includes arithmetic operations, logical composition, string functions, + * sorting, aggregation, conditional updates and deletes, and complex expressions + * involving multiple attributes.

+ * + *

Note: While relational databases generally provide the most + * comprehensive feature set, specific behavior and edge cases may still vary + * depending on the SQL dialect and vendor implementation.

+ */ +public final class RelationalCapability extends AbstractDatabaseCapability { + + @Override public boolean capableOfAddition() { return true; } + @Override public boolean capableOfAnd() { return true; } + @Override public boolean capableOfAssignmentToExpression() { return true; } + @Override public boolean capableOfBetween() { return true; } + @Override public boolean capableOfAttributeVsAttributeComparison() { return true; } + @Override public boolean capableOfConcat() { return true; } + @Override public boolean capableOfConditionalDelete() { return true; } + @Override public boolean capableOfConditionalUpdate() { return true; } + @Override public boolean capableOfConstraintsOnNonIdAttributes() { return true; } + @Override public boolean capableOfCount() { return true; } + @Override public boolean capableOfCountingDeletes() { return true; } + @Override public boolean capableOfCountingUpdates() { return true; } + @Override public boolean capableOfDivision() { return true; } + @Override public boolean capableOfGreaterThan() { return true; } + @Override public boolean capableOfGreaterThanEqual() { return true; } + @Override public boolean capableOfIn() { return true; } + @Override public boolean capableOfLeft() { return true; } + @Override public boolean capableOfLength() { return true; } + @Override public boolean capableOfLessThan() { return true; } + @Override public boolean capableOfLessThanEqual() { return true; } + @Override public boolean capableOfLike() { return true; } + @Override public boolean capableOfLower() { return true; } + @Override public boolean capableOfMultipleSort() { return true; } + @Override public boolean capableOfMultiplication() { return true; } + @Override public boolean capableOfNotBetween() { return true; } + @Override public boolean capableOfNotEqual() { return true; } + @Override public boolean capableOfNotIn() { return true; } + @Override public boolean capableOfNotLike() { return true; } + @Override public boolean capableOfNotNull() { return true; } + @Override public boolean capableOfNull() { return true; } + @Override public boolean capableOfOr() { return true; } + @Override public boolean capableOfParentheses() { return true; } + @Override public boolean capableOfQueryWithoutWhere() { return true; } + @Override public boolean capableOfRight() { return true; } + @Override public boolean capableOfSingleSort() { return true; } + @Override public boolean capableOfSubtraction() { return true; } + @Override public boolean capableOfUpper() { return true; } +} \ No newline at end of file From b3429b16e07fcbcda1dacbfa60156b126d7db5a6 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Sun, 19 Apr 2026 11:41:06 +0100 Subject: [PATCH 10/19] refactor: remove redundant class-level comments from capability profiles and add OtherCapability class --- .../utilities/DocumentCapability.java | 16 ---------------- .../framework/utilities/GraphCapability.java | 19 ------------------- .../utilities/KeyValueCapability.java | 13 ------------- .../framework/utilities/OtherCapability.java | 19 +++++++++++++++++++ .../utilities/RelationalCapability.java | 15 --------------- 5 files changed, 19 insertions(+), 63 deletions(-) create mode 100644 tck/src/main/java/ee/jakarta/tck/data/framework/utilities/OtherCapability.java diff --git a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/DocumentCapability.java b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/DocumentCapability.java index 0e8285c5e..97d89a768 100644 --- a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/DocumentCapability.java +++ b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/DocumentCapability.java @@ -15,22 +15,6 @@ */ package ee.jakarta.tck.data.framework.utilities; -/** - * Capability profile for Document databases based on the current behavior model. - * - *

In the existing model, document databases introduce logical composition, - * basic aggregation, and query flexibility beyond simple comparisons. This - * includes support for logical operators, counting, sorting (single field), - * and filtering without requiring a strict schema.

- * - *

While document databases often provide rich querying capabilities, - * support may vary significantly across vendors, especially for advanced - * expressions, arithmetic operations, and string manipulation functions.

- * - *

This profile reflects a conservative baseline consistent with the current - * TCK behavior, enabling capabilities expected at the document level while - * leaving more advanced features to higher categories.

- */ public final class DocumentCapability extends AbstractDatabaseCapability { @Override diff --git a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/GraphCapability.java b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/GraphCapability.java index fef7d9ad9..d75ad2697 100644 --- a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/GraphCapability.java +++ b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/GraphCapability.java @@ -15,25 +15,6 @@ */ package ee.jakarta.tck.data.framework.utilities; -/** - * Capability profile for Graph databases based on the current behavior model. - * - *

In the existing model, graph databases extend document-level capabilities - * by introducing support for string manipulation and function-based expressions, - * such as substring operations and case transformations.

- * - *

This includes operations like LEFT, RIGHT, LENGTH, LOWER, and UPPER, which - * are typically associated with query languages capable of traversing and - * transforming data within relationships.

- * - *

While graph databases are often highly expressive in traversal and pattern - * matching, this profile focuses only on the capabilities defined in the current - * TCK behavior model.

- * - *

Note: Actual support may vary by vendor and query language. - * This implementation reflects a conservative baseline consistent with the - * existing capability thresholds.

- */ public final class GraphCapability extends AbstractDatabaseCapability { @Override diff --git a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/KeyValueCapability.java b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/KeyValueCapability.java index 9efed8c65..c1f6ecd4e 100644 --- a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/KeyValueCapability.java +++ b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/KeyValueCapability.java @@ -15,18 +15,5 @@ */ package ee.jakarta.tck.data.framework.utilities; -/** - * Capability profile for Key-Value databases based on the current behavior model. - * - *

In the existing model, key-value databases are considered the least flexible - * category. As a result, no query-related capabilities are assumed to be supported.

- * - *

This implementation reflects that behavior by not enabling any capabilities. - * All operations beyond basic key-based access (put/get/delete) are treated as - * unsupported at the database level.

- * - *

Note: While some key-value databases may offer extended features, - * this profile intentionally remains conservative to match the current TCK behavior.

- */ public final class KeyValueCapability extends AbstractDatabaseCapability { } \ No newline at end of file diff --git a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/OtherCapability.java b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/OtherCapability.java new file mode 100644 index 000000000..2d22cc908 --- /dev/null +++ b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/OtherCapability.java @@ -0,0 +1,19 @@ +/* + * Copyright (c) 2026 Contributors to the Eclipse Foundation + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v. 2.0, which is available at + * http://www.eclipse.org/legal/epl-2.0. + * + * This Source Code may also be made available under the following Secondary + * Licenses when the conditions for such availability set forth in the + * Eclipse Public License v. 2.0 are satisfied: GNU General Public License, + * version 2 with the GNU Classpath Exception, which is available at + * https://www.gnu.org/software/classpath/license.html. + * + * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 + */ +package ee.jakarta.tck.data.framework.utilities; + +public final class OtherCapability extends RelationalCapability { +} \ No newline at end of file diff --git a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/RelationalCapability.java b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/RelationalCapability.java index c1478a4ba..27323759e 100644 --- a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/RelationalCapability.java +++ b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/RelationalCapability.java @@ -15,21 +15,6 @@ */ package ee.jakarta.tck.data.framework.utilities; -/** - * Capability profile for Relational databases based on the current behavior model. - * - *

In the existing model, relational databases represent the highest level of - * capability, supporting the full range of query operations, expressions, and - * data manipulation features defined in the TCK.

- * - *

This includes arithmetic operations, logical composition, string functions, - * sorting, aggregation, conditional updates and deletes, and complex expressions - * involving multiple attributes.

- * - *

Note: While relational databases generally provide the most - * comprehensive feature set, specific behavior and edge cases may still vary - * depending on the SQL dialect and vendor implementation.

- */ public final class RelationalCapability extends AbstractDatabaseCapability { @Override public boolean capableOfAddition() { return true; } From bfa133dfd7ba8de4a3197e27e11af5f649f8b774 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Sun, 19 Apr 2026 11:42:02 +0100 Subject: [PATCH 11/19] refactor: rename AbstractDatabaseCapability to MinimalDatabaseCapability --- ...ctDatabaseCapability.java => MinimalDatabaseCapability.java} | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) rename tck/src/main/java/ee/jakarta/tck/data/framework/utilities/{AbstractDatabaseCapability.java => MinimalDatabaseCapability.java} (98%) diff --git a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/AbstractDatabaseCapability.java b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/MinimalDatabaseCapability.java similarity index 98% rename from tck/src/main/java/ee/jakarta/tck/data/framework/utilities/AbstractDatabaseCapability.java rename to tck/src/main/java/ee/jakarta/tck/data/framework/utilities/MinimalDatabaseCapability.java index b05297a5a..a63b196e6 100644 --- a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/AbstractDatabaseCapability.java +++ b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/MinimalDatabaseCapability.java @@ -30,7 +30,7 @@ * Therefore, this base class does not assume any capability, even if it * is commonly available in certain database categories.

*/ -public abstract class AbstractDatabaseCapability implements DatabaseCapability { +public abstract class MinimalDatabaseCapability implements DatabaseCapability { @Override public boolean capableOfAddition() { return false; } From 47f66e25fd73ec2a14c6e17f34b2e1ad4b909775 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Sun, 19 Apr 2026 11:42:10 +0100 Subject: [PATCH 12/19] refactor: remove redundant class-level comments from MinimalDatabaseCapability --- .../utilities/MinimalDatabaseCapability.java | 17 +---------------- 1 file changed, 1 insertion(+), 16 deletions(-) diff --git a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/MinimalDatabaseCapability.java b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/MinimalDatabaseCapability.java index a63b196e6..ad91a0734 100644 --- a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/MinimalDatabaseCapability.java +++ b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/MinimalDatabaseCapability.java @@ -14,22 +14,7 @@ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 */ package ee.jakarta.tck.data.framework.utilities; -/** - * Base implementation for {@link DatabaseCapability}. - * - *

This class represents a conservative capability profile where no - * database features are assumed to be supported by default.

- * - *

Concrete implementations should explicitly override only the - * capabilities they are expected to support. This avoids implicit - * assumptions and ensures that support is always intentional and - * documented.

- * - *

Design note: Capability support may vary not only - * by database family but also by specific provider and configuration. - * Therefore, this base class does not assume any capability, even if it - * is commonly available in certain database categories.

- */ + public abstract class MinimalDatabaseCapability implements DatabaseCapability { @Override public boolean capableOfAddition() { return false; } From 4cdea610d426cf7758660a7aaa79af7591212f6f Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Sun, 19 Apr 2026 11:43:03 +0100 Subject: [PATCH 13/19] refactor: update capability classes to extend MinimalDatabaseCapability instead of AbstractDatabaseCapability --- .../jakarta/tck/data/framework/utilities/ColumnCapability.java | 2 +- .../tck/data/framework/utilities/DocumentCapability.java | 2 +- .../jakarta/tck/data/framework/utilities/GraphCapability.java | 2 +- .../tck/data/framework/utilities/KeyValueCapability.java | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/ColumnCapability.java b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/ColumnCapability.java index 6d94a9ab4..c2ad95be0 100644 --- a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/ColumnCapability.java +++ b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/ColumnCapability.java @@ -28,7 +28,7 @@ * implementation (e.g., wide-column vs analytical column stores), but this * profile reflects the conservative baseline defined in the current TCK behavior.

*/ -public final class ColumnCapability extends AbstractDatabaseCapability { +public final class ColumnCapability extends MinimalDatabaseCapability { @Override public boolean capableOfBetween() { diff --git a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/DocumentCapability.java b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/DocumentCapability.java index 97d89a768..88502019f 100644 --- a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/DocumentCapability.java +++ b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/DocumentCapability.java @@ -15,7 +15,7 @@ */ package ee.jakarta.tck.data.framework.utilities; -public final class DocumentCapability extends AbstractDatabaseCapability { +public final class DocumentCapability extends MinimalDatabaseCapability { @Override public boolean capableOfAnd() { diff --git a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/GraphCapability.java b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/GraphCapability.java index d75ad2697..e2de6c901 100644 --- a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/GraphCapability.java +++ b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/GraphCapability.java @@ -15,7 +15,7 @@ */ package ee.jakarta.tck.data.framework.utilities; -public final class GraphCapability extends AbstractDatabaseCapability { +public final class GraphCapability extends MinimalDatabaseCapability { @Override public boolean capableOfConcat() { diff --git a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/KeyValueCapability.java b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/KeyValueCapability.java index c1f6ecd4e..6a4fa2da5 100644 --- a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/KeyValueCapability.java +++ b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/KeyValueCapability.java @@ -15,5 +15,5 @@ */ package ee.jakarta.tck.data.framework.utilities; -public final class KeyValueCapability extends AbstractDatabaseCapability { +public final class KeyValueCapability extends MinimalDatabaseCapability { } \ No newline at end of file From 73b4cfa2498fbae4af54c9ec481ad46a25cadcf5 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Sun, 19 Apr 2026 11:46:53 +0100 Subject: [PATCH 14/19] refactor: delegate DatabaseType capability checks to DatabaseCapability instances --- .../framework/utilities/DatabaseType.java | 110 ++++++++++-------- 1 file changed, 62 insertions(+), 48 deletions(-) diff --git a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/DatabaseType.java b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/DatabaseType.java index b3f493fef..8245b26e3 100644 --- a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/DatabaseType.java +++ b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/DatabaseType.java @@ -22,173 +22,187 @@ * {@link TestProperty} databaseType */ public enum DatabaseType { - OTHER(Integer.MAX_VALUE), //No database type was configured - RELATIONAL(100), - GRAPH(50), - DOCUMENT(40), - TIME_SERIES(30), - COLUMN(20), - KEY_VALUE(10); + OTHER(Integer.MAX_VALUE, new OtherCapability()),// No database type was configured + RELATIONAL(100, new RelationalCapability()), + GRAPH(50, new GraphCapability()), + DOCUMENT(40, new DocumentCapability()), + TIME_SERIES(30, new TimeSeriesCapability()), + COLUMN(20, new ColumnCapability()), + KEY_VALUE(10, new KeyValueCapability()); - private int flexibility; + private final int level; + private final DatabaseCapability capability; - private DatabaseType(int flexibility) { - this.flexibility = flexibility; + DatabaseType(int level, DatabaseCapability capability) { + this.level = level; + this.capability = capability; + } + + public int level() { + return level; + } + + public DatabaseCapability capability() { + return capability; } public boolean capableOfAddition() { - return flexibility >= RELATIONAL.flexibility; + return capability.capableOfAddition(); } public boolean capableOfAnd() { - return flexibility >= DOCUMENT.flexibility; + return capability.capableOfAnd(); } public boolean capableOfAssignmentToExpression() { - return flexibility >= RELATIONAL.flexibility; + return capability.capableOfAssignmentToExpression(); } public boolean capableOfBetween() { - return flexibility >= COLUMN.flexibility; + return capability.capableOfBetween(); } public boolean capableOfAttributeVsAttributeComparison() { - return flexibility >= RELATIONAL.flexibility; + return capability.capableOfAttributeVsAttributeComparison(); } public boolean capableOfConcat() { - return flexibility >= GRAPH.flexibility; + return capability.capableOfConcat(); } public boolean capableOfConditionalDelete() { - return flexibility >= RELATIONAL.flexibility; + return capability.capableOfConditionalDelete(); } public boolean capableOfConditionalUpdate() { - return flexibility >= RELATIONAL.flexibility; + return capability.capableOfConditionalUpdate(); } public boolean capableOfConstraintsOnNonIdAttributes() { - return flexibility >= DOCUMENT.flexibility; + return capability.capableOfConstraintsOnNonIdAttributes(); } public boolean capableOfCount() { - return flexibility >= DOCUMENT.flexibility; + return capability.capableOfCount(); } public boolean capableOfCountingDeletes() { - return flexibility >= RELATIONAL.flexibility; + return capability.capableOfCountingDeletes(); } public boolean capableOfCountingUpdates() { - return flexibility >= RELATIONAL.flexibility; + return capability.capableOfCountingUpdates(); } public boolean capableOfDivision() { - return flexibility >= RELATIONAL.flexibility; + return capability.capableOfDivision(); } public boolean capableOfGreaterThan() { - return flexibility >= COLUMN.flexibility; + return capability.capableOfGreaterThan(); } public boolean capableOfGreaterThanEqual() { - return flexibility >= COLUMN.flexibility; + return capability.capableOfGreaterThanEqual(); } public boolean capableOfIn() { - return flexibility >= COLUMN.flexibility; + return capability.capableOfIn(); } public boolean capableOfLeft() { - return flexibility >= GRAPH.flexibility; + return capability.capableOfLeft(); } public boolean capableOfLength() { - return flexibility >= GRAPH.flexibility; + return capability.capableOfLength(); } public boolean capableOfLessThan() { - return flexibility >= COLUMN.flexibility; + return capability.capableOfLessThan(); } public boolean capableOfLessThanEqual() { - return flexibility >= COLUMN.flexibility; + return capability.capableOfLessThanEqual(); } public boolean capableOfLike() { - return flexibility >= RELATIONAL.flexibility; + return capability.capableOfLike(); } public boolean capableOfLower() { - return flexibility >= GRAPH.flexibility; + return capability.capableOfLower(); } public boolean capableOfMultipleSort() { - return flexibility >= RELATIONAL.flexibility; + return capability.capableOfMultipleSort(); } public boolean capableOfMultiplication() { - return flexibility >= RELATIONAL.flexibility; + return capability.capableOfMultiplication(); } - public boolean capableOfNotBetween() { - return flexibility >= COLUMN.flexibility; + return capability.capableOfNotBetween(); } public boolean capableOfNotEqual() { - return flexibility >= COLUMN.flexibility; + return capability.capableOfNotEqual(); } public boolean capableOfNotIn() { - return flexibility >= COLUMN.flexibility; + return capability.capableOfNotIn(); } public boolean capableOfNotLike() { - return flexibility >= RELATIONAL.flexibility; + return capability.capableOfNotLike(); } public boolean capableOfNotNull() { - return flexibility >= COLUMN.flexibility; + return capability.capableOfNotNull(); } public boolean capableOfNull() { - return flexibility >= COLUMN.flexibility; + return capability.capableOfNull(); } public boolean capableOfOr() { - return flexibility >= DOCUMENT.flexibility; + return capability.capableOfOr(); } public boolean capableOfParentheses() { - return flexibility >= RELATIONAL.flexibility; + return capability.capableOfParentheses(); } public boolean capableOfQueryWithoutWhere() { - return flexibility >= DOCUMENT.flexibility; + return capability.capableOfQueryWithoutWhere(); } public boolean capableOfRight() { - return flexibility >= GRAPH.flexibility; + return capability.capableOfRight(); } public boolean capableOfSingleSort() { - return flexibility >= DOCUMENT.flexibility; + return capability.capableOfSingleSort(); } public boolean capableOfSubtraction() { - return flexibility >= RELATIONAL.flexibility; + return capability.capableOfSubtraction(); } public boolean capableOfUpper() { - return flexibility >= GRAPH.flexibility; + return capability.capableOfUpper(); } + public static DatabaseType valueOfIgnoreCase(String value) { return Arrays.stream(DatabaseType.values()).filter(type -> type.name().equalsIgnoreCase(value)).findAny().orElse(DatabaseType.OTHER); } + /** + * @deprecated Use explicit capability checks instead. + */ + @Deprecated public boolean isKeywordSupportAtOrBelow(DatabaseType benchmark) { return this.flexibility <= benchmark.flexibility; } From b374390b4507ff8ffc2699e76b45dbb4d6453a24 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Sun, 19 Apr 2026 11:47:41 +0100 Subject: [PATCH 15/19] refactor: update RelationalCapability to implement DatabaseCapability directly --- .../tck/data/framework/utilities/RelationalCapability.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/RelationalCapability.java b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/RelationalCapability.java index 27323759e..3c60f9893 100644 --- a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/RelationalCapability.java +++ b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/RelationalCapability.java @@ -15,7 +15,7 @@ */ package ee.jakarta.tck.data.framework.utilities; -public final class RelationalCapability extends AbstractDatabaseCapability { +public final class RelationalCapability implements DatabaseCapability { @Override public boolean capableOfAddition() { return true; } @Override public boolean capableOfAnd() { return true; } From dfe5ba7525524c673d9b4a6a11e15079059d22a1 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Sun, 19 Apr 2026 11:50:04 +0100 Subject: [PATCH 16/19] refactor: make RelationalCapability non-final to allow subclassing --- .../tck/data/framework/utilities/RelationalCapability.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/RelationalCapability.java b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/RelationalCapability.java index 3c60f9893..deff8f459 100644 --- a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/RelationalCapability.java +++ b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/RelationalCapability.java @@ -15,7 +15,7 @@ */ package ee.jakarta.tck.data.framework.utilities; -public final class RelationalCapability implements DatabaseCapability { +public class RelationalCapability implements DatabaseCapability { @Override public boolean capableOfAddition() { return true; } @Override public boolean capableOfAnd() { return true; } From a12b3fe4d630fa850759bac2cac6f3895aa7b425 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Sun, 19 Apr 2026 11:51:17 +0100 Subject: [PATCH 17/19] feat: add TimeSeriesCapability class with full predicate support --- .../utilities/TimeSeriesCapability.java | 72 +++++++++++++++++++ 1 file changed, 72 insertions(+) create mode 100644 tck/src/main/java/ee/jakarta/tck/data/framework/utilities/TimeSeriesCapability.java diff --git a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/TimeSeriesCapability.java b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/TimeSeriesCapability.java new file mode 100644 index 000000000..c52b02051 --- /dev/null +++ b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/TimeSeriesCapability.java @@ -0,0 +1,72 @@ +/* + * Copyright (c) 22025 Contributors to the Eclipse Foundation + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v. 2.0, which is available at + * http://www.eclipse.org/legal/epl-2.0. + * + * This Source Code may also be made available under the following Secondary + * Licenses when the conditions for such availability set forth in the + * Eclipse Public License v. 2.0 are satisfied: GNU General Public License, + * version 2 with the GNU Classpath Exception, which is available at + * https://www.gnu.org/software/classpath/license.html. + * + * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 + */ +public final class TimeSeriesCapability extends MinimalDatabaseCapability { + + @Override + public boolean capableOfBetween() { + return true; + } + + @Override + public boolean capableOfGreaterThan() { + return true; + } + + @Override + public boolean capableOfGreaterThanEqual() { + return true; + } + + @Override + public boolean capableOfIn() { + return true; + } + + @Override + public boolean capableOfLessThan() { + return true; + } + + @Override + public boolean capableOfLessThanEqual() { + return true; + } + + @Override + public boolean capableOfNotBetween() { + return true; + } + + @Override + public boolean capableOfNotEqual() { + return true; + } + + @Override + public boolean capableOfNotIn() { + return true; + } + + @Override + public boolean capableOfNotNull() { + return true; + } + + @Override + public boolean capableOfNull() { + return true; + } +} \ No newline at end of file From 8918d0dbb981bec63c533123e380c5779c1f2ec4 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Sun, 19 Apr 2026 11:52:58 +0100 Subject: [PATCH 18/19] chore: update copyright year and add package declaration to TimeSeriesCapability --- .../tck/data/framework/utilities/TimeSeriesCapability.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/TimeSeriesCapability.java b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/TimeSeriesCapability.java index c52b02051..9edbef545 100644 --- a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/TimeSeriesCapability.java +++ b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/TimeSeriesCapability.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 22025 Contributors to the Eclipse Foundation + * Copyright (c) 2026 Contributors to the Eclipse Foundation * * This program and the accompanying materials are made available under the * terms of the Eclipse Public License v. 2.0, which is available at @@ -13,6 +13,8 @@ * * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 */ +package ee.jakarta.tck.data.framework.utilities; + public final class TimeSeriesCapability extends MinimalDatabaseCapability { @Override From c9c4142eb896ee2352c2e4c2fbe5e38021485cb3 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Sun, 19 Apr 2026 20:30:31 +0100 Subject: [PATCH 19/19] refactor: reformat capability method overrides for clarity and consistency --- .../framework/utilities/ColumnCapability.java | 9 +- .../framework/utilities/DatabaseType.java | 10 +- .../utilities/MinimalDatabaseCapability.java | 257 +++++++++++++----- .../utilities/RelationalCapability.java | 221 ++++++++++++--- 4 files changed, 378 insertions(+), 119 deletions(-) diff --git a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/ColumnCapability.java b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/ColumnCapability.java index c2ad95be0..28f3df632 100644 --- a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/ColumnCapability.java +++ b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/ColumnCapability.java @@ -14,19 +14,20 @@ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 */ package ee.jakarta.tck.data.framework.utilities; + /** * Capability profile for Column-oriented databases based on the current behavior model. * *

In the existing model, column databases introduce basic comparison and - * filtering capabilities beyond simple key-based access. This includes support - * for range queries, null checks, and inclusion-based filtering.

+ * filtering capabilities beyond simple key-based access. This includes support for range queries, null checks, and + * inclusion-based filtering.

* *

More advanced features such as arithmetic operations, string manipulation, * sorting, and conditional updates are not assumed to be supported at this level.

* *

Note: Actual support may vary depending on the specific - * implementation (e.g., wide-column vs analytical column stores), but this - * profile reflects the conservative baseline defined in the current TCK behavior.

+ * implementation (e.g., wide-column vs analytical column stores), but this profile reflects the conservative baseline + * defined in the current TCK behavior.

*/ public final class ColumnCapability extends MinimalDatabaseCapability { diff --git a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/DatabaseType.java b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/DatabaseType.java index 8245b26e3..523d101b0 100644 --- a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/DatabaseType.java +++ b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/DatabaseType.java @@ -30,16 +30,16 @@ public enum DatabaseType { COLUMN(20, new ColumnCapability()), KEY_VALUE(10, new KeyValueCapability()); - private final int level; + private final int flexibility; private final DatabaseCapability capability; - DatabaseType(int level, DatabaseCapability capability) { - this.level = level; + DatabaseType(int flexibility, DatabaseCapability capability) { + this.flexibility = flexibility; this.capability = capability; } - public int level() { - return level; + public int flexibility() { + return flexibility; } public DatabaseCapability capability() { diff --git a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/MinimalDatabaseCapability.java b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/MinimalDatabaseCapability.java index ad91a0734..60e9431eb 100644 --- a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/MinimalDatabaseCapability.java +++ b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/MinimalDatabaseCapability.java @@ -17,77 +17,188 @@ public abstract class MinimalDatabaseCapability implements DatabaseCapability { - @Override public boolean capableOfAddition() { return false; } - - @Override public boolean capableOfAnd() { return false; } - - @Override public boolean capableOfAssignmentToExpression() { return false; } - - @Override public boolean capableOfBetween() { return false; } - - @Override public boolean capableOfAttributeVsAttributeComparison() { return false; } - - @Override public boolean capableOfConcat() { return false; } - - @Override public boolean capableOfConditionalDelete() { return false; } - - @Override public boolean capableOfConditionalUpdate() { return false; } - - @Override public boolean capableOfConstraintsOnNonIdAttributes() { return false; } - - @Override public boolean capableOfCount() { return false; } - - @Override public boolean capableOfCountingDeletes() { return false; } - - @Override public boolean capableOfCountingUpdates() { return false; } - - @Override public boolean capableOfDivision() { return false; } - - @Override public boolean capableOfGreaterThan() { return false; } - - @Override public boolean capableOfGreaterThanEqual() { return false; } - - @Override public boolean capableOfIn() { return false; } - - @Override public boolean capableOfLeft() { return false; } - - @Override public boolean capableOfLength() { return false; } - - @Override public boolean capableOfLessThan() { return false; } - - @Override public boolean capableOfLessThanEqual() { return false; } - - @Override public boolean capableOfLike() { return false; } - - @Override public boolean capableOfLower() { return false; } - - @Override public boolean capableOfMultipleSort() { return false; } - - @Override public boolean capableOfMultiplication() { return false; } - - @Override public boolean capableOfNotBetween() { return false; } - - @Override public boolean capableOfNotEqual() { return false; } - - @Override public boolean capableOfNotIn() { return false; } - - @Override public boolean capableOfNotLike() { return false; } - - @Override public boolean capableOfNotNull() { return false; } - - @Override public boolean capableOfNull() { return false; } - - @Override public boolean capableOfOr() { return false; } - - @Override public boolean capableOfParentheses() { return false; } - - @Override public boolean capableOfQueryWithoutWhere() { return false; } - - @Override public boolean capableOfRight() { return false; } - - @Override public boolean capableOfSingleSort() { return false; } - - @Override public boolean capableOfSubtraction() { return false; } - - @Override public boolean capableOfUpper() { return false; } + @Override + public boolean capableOfAddition() { + return false; + } + + @Override + public boolean capableOfAnd() { + return false; + } + + @Override + public boolean capableOfAssignmentToExpression() { + return false; + } + + @Override + public boolean capableOfBetween() { + return false; + } + + @Override + public boolean capableOfAttributeVsAttributeComparison() { + return false; + } + + @Override + public boolean capableOfConcat() { + return false; + } + + @Override + public boolean capableOfConditionalDelete() { + return false; + } + + @Override + public boolean capableOfConditionalUpdate() { + return false; + } + + @Override + public boolean capableOfConstraintsOnNonIdAttributes() { + return false; + } + + @Override + public boolean capableOfCount() { + return false; + } + + @Override + public boolean capableOfCountingDeletes() { + return false; + } + + @Override + public boolean capableOfCountingUpdates() { + return false; + } + + @Override + public boolean capableOfDivision() { + return false; + } + + @Override + public boolean capableOfGreaterThan() { + return false; + } + + @Override + public boolean capableOfGreaterThanEqual() { + return false; + } + + @Override + public boolean capableOfIn() { + return false; + } + + @Override + public boolean capableOfLeft() { + return false; + } + + @Override + public boolean capableOfLength() { + return false; + } + + @Override + public boolean capableOfLessThan() { + return false; + } + + @Override + public boolean capableOfLessThanEqual() { + return false; + } + + @Override + public boolean capableOfLike() { + return false; + } + + @Override + public boolean capableOfLower() { + return false; + } + + @Override + public boolean capableOfMultipleSort() { + return false; + } + + @Override + public boolean capableOfMultiplication() { + return false; + } + + @Override + public boolean capableOfNotBetween() { + return false; + } + + @Override + public boolean capableOfNotEqual() { + return false; + } + + @Override + public boolean capableOfNotIn() { + return false; + } + + @Override + public boolean capableOfNotLike() { + return false; + } + + @Override + public boolean capableOfNotNull() { + return false; + } + + @Override + public boolean capableOfNull() { + return false; + } + + @Override + public boolean capableOfOr() { + return false; + } + + @Override + public boolean capableOfParentheses() { + return false; + } + + @Override + public boolean capableOfQueryWithoutWhere() { + return false; + } + + @Override + public boolean capableOfRight() { + return false; + } + + @Override + public boolean capableOfSingleSort() { + return false; + } + + @Override + public boolean capableOfSubtraction() { + return false; + } + + @Override + public boolean capableOfUpper() { + return false; + } } \ No newline at end of file diff --git a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/RelationalCapability.java b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/RelationalCapability.java index deff8f459..e2376b70c 100644 --- a/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/RelationalCapability.java +++ b/tck/src/main/java/ee/jakarta/tck/data/framework/utilities/RelationalCapability.java @@ -17,41 +17,188 @@ public class RelationalCapability implements DatabaseCapability { - @Override public boolean capableOfAddition() { return true; } - @Override public boolean capableOfAnd() { return true; } - @Override public boolean capableOfAssignmentToExpression() { return true; } - @Override public boolean capableOfBetween() { return true; } - @Override public boolean capableOfAttributeVsAttributeComparison() { return true; } - @Override public boolean capableOfConcat() { return true; } - @Override public boolean capableOfConditionalDelete() { return true; } - @Override public boolean capableOfConditionalUpdate() { return true; } - @Override public boolean capableOfConstraintsOnNonIdAttributes() { return true; } - @Override public boolean capableOfCount() { return true; } - @Override public boolean capableOfCountingDeletes() { return true; } - @Override public boolean capableOfCountingUpdates() { return true; } - @Override public boolean capableOfDivision() { return true; } - @Override public boolean capableOfGreaterThan() { return true; } - @Override public boolean capableOfGreaterThanEqual() { return true; } - @Override public boolean capableOfIn() { return true; } - @Override public boolean capableOfLeft() { return true; } - @Override public boolean capableOfLength() { return true; } - @Override public boolean capableOfLessThan() { return true; } - @Override public boolean capableOfLessThanEqual() { return true; } - @Override public boolean capableOfLike() { return true; } - @Override public boolean capableOfLower() { return true; } - @Override public boolean capableOfMultipleSort() { return true; } - @Override public boolean capableOfMultiplication() { return true; } - @Override public boolean capableOfNotBetween() { return true; } - @Override public boolean capableOfNotEqual() { return true; } - @Override public boolean capableOfNotIn() { return true; } - @Override public boolean capableOfNotLike() { return true; } - @Override public boolean capableOfNotNull() { return true; } - @Override public boolean capableOfNull() { return true; } - @Override public boolean capableOfOr() { return true; } - @Override public boolean capableOfParentheses() { return true; } - @Override public boolean capableOfQueryWithoutWhere() { return true; } - @Override public boolean capableOfRight() { return true; } - @Override public boolean capableOfSingleSort() { return true; } - @Override public boolean capableOfSubtraction() { return true; } - @Override public boolean capableOfUpper() { return true; } + @Override + public boolean capableOfAddition() { + return true; + } + + @Override + public boolean capableOfAnd() { + return true; + } + + @Override + public boolean capableOfAssignmentToExpression() { + return true; + } + + @Override + public boolean capableOfBetween() { + return true; + } + + @Override + public boolean capableOfAttributeVsAttributeComparison() { + return true; + } + + @Override + public boolean capableOfConcat() { + return true; + } + + @Override + public boolean capableOfConditionalDelete() { + return true; + } + + @Override + public boolean capableOfConditionalUpdate() { + return true; + } + + @Override + public boolean capableOfConstraintsOnNonIdAttributes() { + return true; + } + + @Override + public boolean capableOfCount() { + return true; + } + + @Override + public boolean capableOfCountingDeletes() { + return true; + } + + @Override + public boolean capableOfCountingUpdates() { + return true; + } + + @Override + public boolean capableOfDivision() { + return true; + } + + @Override + public boolean capableOfGreaterThan() { + return true; + } + + @Override + public boolean capableOfGreaterThanEqual() { + return true; + } + + @Override + public boolean capableOfIn() { + return true; + } + + @Override + public boolean capableOfLeft() { + return true; + } + + @Override + public boolean capableOfLength() { + return true; + } + + @Override + public boolean capableOfLessThan() { + return true; + } + + @Override + public boolean capableOfLessThanEqual() { + return true; + } + + @Override + public boolean capableOfLike() { + return true; + } + + @Override + public boolean capableOfLower() { + return true; + } + + @Override + public boolean capableOfMultipleSort() { + return true; + } + + @Override + public boolean capableOfMultiplication() { + return true; + } + + @Override + public boolean capableOfNotBetween() { + return true; + } + + @Override + public boolean capableOfNotEqual() { + return true; + } + + @Override + public boolean capableOfNotIn() { + return true; + } + + @Override + public boolean capableOfNotLike() { + return true; + } + + @Override + public boolean capableOfNotNull() { + return true; + } + + @Override + public boolean capableOfNull() { + return true; + } + + @Override + public boolean capableOfOr() { + return true; + } + + @Override + public boolean capableOfParentheses() { + return true; + } + + @Override + public boolean capableOfQueryWithoutWhere() { + return true; + } + + @Override + public boolean capableOfRight() { + return true; + } + + @Override + public boolean capableOfSingleSort() { + return true; + } + + @Override + public boolean capableOfSubtraction() { + return true; + } + + @Override + public boolean capableOfUpper() { + return true; + } } \ No newline at end of file