Add support for CHECK constraint in INSERT statement in engine and SPI #14964

ebyhr · 2022-11-09T04:39:22Z

Description

Add support for CHECK constraint in INSERT statement to engine and SPI.

Release notes

(x) Release notes are required, with the following suggested text:

# General
* Add support for `CHECK` constraints in `INSERT` statement. ({issue}`14964`)

ebyhr · 2022-11-09T12:16:29Z

CI hit #14441

core/trino-spi/src/main/java/io/trino/spi/connector/ConnectorTableSchema.java

core/trino-spi/src/main/java/io/trino/spi/connector/ConnectorTableMetadata.java

findepi · 2022-11-14T14:21:34Z

core/trino-spi/src/main/java/io/trino/spi/connector/ConnectorTableSchema.java

@@ -21,14 +21,17 @@
 {
    private final SchemaTableName table;
    private final List<ColumnSchema> columns;
+    private final List<String> checkConstraints;


Do we need this here? Why?

To use from StatementAnalyzer. I would add a new method in Metadata if it's better than here. Or are you suggesting moving to the under column?

Feels like not belonging here at all. I'd like to understand this more.

Feels like it needs to stay here (or we would have to remove almost all usages of getTableSchema and migrate them to getTableMetadata)

findepi · 2022-11-14T14:22:54Z

core/trino-main/src/test/java/io/trino/sql/query/TestCheckConstraint.java

+                .matches("SELECT BIGINT '1'");
+
+        assertThatThrownBy(() -> assertions.query("INSERT INTO mock.tiny.nation VALUES (26, 'POLAND', 0, 'No comment')"))
+                .hasMessage("Cannot insert row that does not match to a check constraint: (\"nationkey\" > CAST(100 AS bigint))");


Can we also have planner tests that assert actual plans?

@martint @kasiafi would it be a good idea here?

electrum · 2022-11-16T03:29:04Z

Do we want to enforce that the check expression does not contain subqueries?

ebyhr · 2022-11-17T08:48:41Z

I think so. Changed to deny an expression having subqueries.

core/trino-spi/src/main/java/io/trino/spi/connector/ConnectorTableMetadata.java

findepi · 2022-11-17T09:27:58Z

core/trino-spi/src/main/java/io/trino/spi/connector/ConnectorTableSchema.java

@@ -21,14 +21,17 @@
 {
    private final SchemaTableName table;
    private final List<ColumnSchema> columns;
+    private final List<String> checkConstraints;


Feels like it needs to stay here (or we would have to remove almost all usages of getTableSchema and migrate them to getTableMetadata)

findepi · 2022-11-17T09:31:57Z

core/trino-main/src/main/java/io/trino/sql/analyzer/StatementAnalyzer.java

+            }
+            for (String checkConstraint : checkConstraints) {
+                ViewExpression filter = new ViewExpression(session.getIdentity().getUser(), Optional.of(name.getCatalogName()), Optional.of(name.getSchemaName()), checkConstraint);
+                Expression expression = analyzeRowFilter(session.getIdentity().getUser(), table, name, accessControlScope, filter);


analyzeRowFilter technically does more or less what we want -- it takes a String expression and produces an Expression.
However, the method name and checks done in that method (e.g. analysis.hasRowFilter(name, currentIdentity) or analysis.registerTableForRowFiltering(name, currentIdentity)) are not applicable to check constraints.

Let's rollback changes to analyzeRowFilter.
Let's extract common code for converting connector-provided String into Expression (with due verifications).

core/trino-main/src/main/java/io/trino/sql/analyzer/StatementAnalyzer.java

core/trino-main/src/main/java/io/trino/sql/analyzer/Analysis.java

core/trino-main/src/main/java/io/trino/sql/planner/LogicalPlanner.java

findepi · 2022-11-17T09:39:20Z

core/trino-main/src/main/java/io/trino/sql/planner/LogicalPlanner.java

+                // Predicate evaluates to UNKNOWN (e.g. NULL > 100) should not violate check constraint
+                new CoalesceExpression(predicate, TRUE_LITERAL),
+                TRUE_LITERAL,
+                new Cast(failFunction(metadata, session, CONSTRAINT_VIOLATION, "Cannot insert row that does not match to a check constraint: " + predicate), toSqlType(BOOLEAN)));


"Check constraint violation: " + predicate ?

what does eg PostgreSQL print?
what does MySQL print?

Here's the error message.

PostgreSQL

tpch=# create table test (c1 int check (c1 > 0)); tpch=# insert into test values (-1); ERROR: new row for relation "test" violates check constraint "test_c1_check" DETAIL: Failing row contains (-1).

MySQL

mysql> create table test (c1 int, check (c1 > 0)); mysql> insert into test values (-1); ERROR 3819 (HY000): Check constraint 'test_chk_1' is violated.

I like ours better, since it mentions the check formula. (we don't have a check name, and maybe we don't need one for error reporting)
I don't think we could do this for row filters, but i think we can do this for check constraints.

findepi · 2022-11-17T09:40:56Z

core/trino-main/src/main/java/io/trino/sql/planner/RelationPlanner.java


+    public RelationPlan addRowFilters(List<Expression> filters, Table node, RelationPlan plan, Function<Expression, Expression> predicateTransformation, Function<Table, Scope> accessControlScope)


for inserts/update/merge, the name addRowConstraints would be better.
Row filters become "row constraints", that's fine.
(the opposite, calling "check constraints" a "row filter" doesn't sound right)

findepi · 2022-11-17T09:41:45Z

core/trino-spi/pom.xml

@@ -210,6 +210,11 @@
                                </item>
                                <!-- Backwards incompatible changes since the previous release -->
                                <!-- Any exclusions below can be deleted after each release -->
+                                <item>
+                                    <code>java.method.numberOfParametersChanged</code>


Can we simply keep the old constructor as deprecated?

core/trino-spi/src/main/java/io/trino/spi/connector/ConnectorTableMetadata.java

ebyhr · 2022-11-18T06:07:16Z

CI core/trino-main hit #12627. Going to push an empty commit.

core/trino-spi/src/main/java/io/trino/spi/connector/ConnectorTableMetadata.java

findepi · 2022-11-18T08:18:01Z

core/trino-main/src/main/java/io/trino/sql/planner/LogicalPlanner.java

+                // Predicate evaluates to UNKNOWN (e.g. NULL > 100) should not violate check constraint
+                new CoalesceExpression(predicate, TRUE_LITERAL),
+                TRUE_LITERAL,
+                new Cast(failFunction(metadata, session, CONSTRAINT_VIOLATION, "Cannot insert row that does not match to a check constraint: " + predicate), toSqlType(BOOLEAN)));


I like ours better, since it mentions the check formula. (we don't have a check name, and maybe we don't need one for error reporting)
I don't think we could do this for row filters, but i think we can do this for check constraints.

findepi · 2022-11-18T08:24:07Z

core/trino-spi/src/main/java/io/trino/spi/connector/ConnectorTableSchema.java

@@ -23,6 +23,12 @@
    private final List<ColumnSchema> columns;
    private final List<String> checkConstraints;

+    @Deprecated


Let's make the new one experimental and remove deprecation. For now. We will add deprecation when the new one is no longer experimental.

ebyhr · 2022-11-21T02:38:21Z

Addressed comments and added tests for other statements, UPDATE, MERGE and DELETE.

ebyhr · 2022-12-14T02:48:26Z

Rebased on upstream to resolve conflicts.

core/trino-spi/src/main/java/io/trino/spi/connector/ConnectorTableMetadata.java

plugin/trino-base-jdbc/src/main/java/io/trino/plugin/jdbc/DefaultJdbcMetadata.java

plugin/trino-phoenix5/src/main/java/io/trino/plugin/phoenix5/PhoenixMetadata.java

core/trino-main/src/test/java/io/trino/sql/query/TestCheckConstraint.java

core/trino-spi/src/main/java/io/trino/spi/connector/ConnectorTableMetadata.java

martint · 2022-12-14T18:16:09Z

core/trino-main/src/main/java/io/trino/sql/analyzer/StatementAnalyzer.java

        }

-        private void analyzeFiltersAndMasks(Table table, QualifiedObjectName name, Optional<TableHandle> tableHandle, RelationType relationType, String authorization)
+        private void analyzeFiltersAndMasks(Table table, QualifiedObjectName name, Optional<TableHandle> tableHandle, RelationType relationType, String authorization, List<String> checkConstraints)


Why was checkConstraints added to this method? They don't belong here. This method is specifically about masks and filters on a source table, and check constraints are none of that. They don't even apply to a source table, only to the target of an insert or update.

martint · 2022-12-14T18:20:31Z

core/trino-main/src/main/java/io/trino/sql/analyzer/StatementAnalyzer.java

-            catch (ParsingException e) {
-                throw new TrinoException(INVALID_ROW_FILTER, extractLocation(table), format("Invalid row filter for '%s': %s", name, e.getErrorMessage()), e);
-            }
+            Expression expression = parseRowConstraintExpression(table, name, filter, INVALID_ROW_FILTER, "Invalid row filter");


Revert this. This is spurious reuse of functionality. We don't need to add an abstraction for a "row constraint expression". It's a bit of a stretch to call row filters and check constraints "constraint expressions"

martint · 2022-12-14T18:24:07Z

core/trino-main/src/main/java/io/trino/sql/analyzer/StatementAnalyzer.java


-            analysis.recordSubqueries(expression, expressionAnalysis);
-
+        private void addCoercionForRowConstraint(Table table, QualifiedObjectName name, Expression expression, ExpressionAnalysis expressionAnalysis, String constraintType)


There's nothing special about a "row constraint" in this method. If anything, it should be called coerceToBoolean, but it also feels like spurious reuse of code.

martint · 2022-12-14T18:26:24Z

core/trino-main/src/main/java/io/trino/sql/planner/RelationPlanner.java

@@ -251,26 +251,30 @@ protected RelationPlan visitTable(Table node, Void context)
            }
        }

-        plan = addRowFilters(node, plan);
+        plan = addRowConstraints(node, plan);


As I mentioned above, row filters and check constraints are two difference concepts. Let's not mix them up.

core/trino-spi/src/main/java/io/trino/spi/connector/ConnectorTableMetadata.java

core/trino-main/src/main/java/io/trino/sql/analyzer/StatementAnalyzer.java

ebyhr · 2022-12-15T07:37:19Z

Fixing CI failures.

ebyhr · 2022-12-21T02:26:24Z

@martint Thanks for your review. Addressed comments.

ebyhr · 2023-01-04T00:14:03Z

Rebased on upstream to resolve conflicts.

ebyhr · 2023-01-04T00:14:17Z

@martint Gentle reminder.

ebyhr · 2023-01-09T23:25:46Z

@martint Gentle reminder.

ebyhr · 2023-01-12T03:40:04Z

Rebased on upstream to resolve conflicts.

findepi · 2023-01-18T11:13:18Z

core/trino-main/src/main/java/io/trino/sql/analyzer/Analysis.java

    public List<Expression> getRowFilters(Table node)
    {
        return rowFilters.getOrDefault(NodeRef.of(node), ImmutableList.of());
    }

+    public List<Expression> getCheckConstraints(Table node)
+    {
+        return checkConstraints.getOrDefault(NodeRef.of(node), ImmutableList.of());


wrap in unmodifiableList

findepi · 2023-01-18T11:13:51Z

core/trino-main/src/main/java/io/trino/sql/analyzer/StatementAnalyzer.java

+                // TODO https://github.com/trinodb/trino/issues/15411 Add support for CHECK constraint to UPDATE statement
+                throw semanticException(NOT_SUPPORTED, update, "Updating a table with a check constraint is not supported");


findepi · 2023-01-18T12:40:40Z

core/trino-spi/src/main/java/io/trino/spi/connector/ConnectorTableMetadata.java

+     * List of constraints data in a table is expected to satisfy.
+     * Engine ensures rows written to a table meet these constraints.
+     * A check constraint is satisfied when it evaluates to True or Unknown.
+     * @return List of string representation of a Trino SQL scalar expression that can refer to table columns by name and produces a result coercible to boolean


My intellij formatter would put an empty line before @return line. Would yours too?

follow up airlift/airbase#338

findepi · 2023-01-18T12:40:44Z

core/trino-spi/src/main/java/io/trino/spi/connector/ConnectorTableSchema.java

+     * List of constraints data in a table is expected to satisfy.
+     * Engine ensures rows written to a table meet these constraints.
+     * A check constraint is satisfied when it evaluates to True or Unknown.
+     * @return List of string representation of a Trino SQL scalar expression that can refer to table columns by name and produces a result coercible to boolean


My intellij formatter would put an empty line before @return line. Would yours too?

findepi · 2023-01-18T12:42:05Z

core/trino-main/src/main/java/io/trino/sql/analyzer/StatementAnalyzer.java

+                    throw new TrinoException(TYPE_MISMATCH, extractLocation(table), format("Expected check constraint for '%s' to be of type BOOLEAN, but was %s", name, actualType), null);
+                }
+
+                analysis.addCoercion(expression, BOOLEAN, coercion.isTypeOnlyCoercion(actualType, BOOLEAN));


Is this coercion getting applied?
(see #15744)

findepi · 2023-01-18T12:42:34Z

core/trino-main/src/main/java/io/trino/sql/analyzer/StatementAnalyzer.java

+                throw semanticException(EXPRESSION_NOT_IN_DISTINCT, expression, "Check constraint expression should be deterministic");
+            }
+            if (containsCurrentTimeFunctions(expression)) {
+                throw semanticException(EXPRESSION_NOT_IN_DISTINCT, expression, "Check constraint expression should not contain CURRENT_DATE, CURRENT_TIME, CURRENT_TIMESTAMP, LOCALTIME or LOCALTIMESTAMP");


"should not contain temporal expression"
or "should not be time-dependent"

findepi · 2023-01-18T12:43:09Z

core/trino-main/src/main/java/io/trino/sql/analyzer/StatementAnalyzer.java

+            }
+
+            // Ensure that the expression doesn't contain non-deterministic functions. This should be "retrospectively deterministic" per SQL standard.
+            if (!DeterminismEvaluator.isDeterministic(expression, this::getResolvedFunction)) {


nit: can import isDeterministic statically

ebyhr · 2023-01-19T06:45:11Z

trino-redis hit #13779

ebyhr · 2023-01-19T06:50:48Z

I will merge this PR tomorrow if there's no objection.

martint · 2022-12-21T20:04:51Z

core/trino-main/src/main/java/io/trino/sql/analyzer/StatementAnalyzer.java

@@ -2193,17 +2211,8 @@ private void checkStorageTableNotRedirected(QualifiedObjectName source)
            });
        }

-        private void analyzeFiltersAndMasks(Table table, QualifiedObjectName name, Optional<TableHandle> tableHandle, List<Field> fields, String authorization)
+        private void analyzeFiltersAndMasks(Table table, QualifiedObjectName name, RelationType relationType, Scope accessControlScope)


Ok, that makes sense. Please add that short explanation to the commit message so it doesn't get lost.

martint · 2023-01-19T17:23:39Z

core/trino-main/src/main/java/io/trino/sql/analyzer/StatementAnalyzer.java

+                expression = sqlParser.createExpression(filter.getExpression(), createParsingOptions(session));
+            }
+            catch (ParsingException e) {
+                throw new TrinoException(INVALID_ROW_FILTER, extractLocation(table), format("Invalid check constraint for '%s': %s", name, e.getErrorMessage()), e);


This is the wrong error code. Check constraints are not row filters.

martint · 2023-01-19T17:24:49Z

core/trino-main/src/main/java/io/trino/sql/analyzer/StatementAnalyzer.java

+            }
+
+            // Ensure that the expression doesn't contain non-deterministic functions. This should be "retrospectively deterministic" per SQL standard.
+            if (!isDeterministic(expression, this::getResolvedFunction)) {


EXPRESSION_NOT_IN_DISTINCT is the wrong error code for this.

martint · 2023-01-19T17:26:16Z

core/trino-main/src/main/java/io/trino/sql/analyzer/StatementAnalyzer.java

@@ -4646,6 +4676,62 @@ private void analyzeRowFilter(String currentIdentity, Table table, QualifiedObje
            analysis.addRowFilter(table, expression);
        }

+        private void analyzeCheckConstraint(Table table, QualifiedObjectName name, Scope scope, ViewExpression filter)


Using filter for the argument name is a little misleading. Rename it to constraint

martint · 2023-01-19T17:28:49Z

core/trino-main/src/main/java/io/trino/sql/planner/RelationPlanner.java

@@ -291,6 +291,29 @@ public RelationPlan addRowFilters(Table node, RelationPlan plan, Function<Expres
        return new RelationPlan(planBuilder.getRoot(), plan.getScope(), plan.getFieldMappings(), outerContext);
    }

+    public RelationPlan addCheckConstraints(List<Expression> filters, Table node, RelationPlan plan, Function<Expression, Expression> predicateTransformation, Function<Table, Scope> accessControlScope)


What's "predicate transformation"?

That's a function inserting an expression to fail when the constraint is violated. Do you have any suggestions for the new variable name?

private static Function<Expression, Expression> failIfCheckConstraintIsNotMet(Metadata metadata, Session session) { return predicate -> new IfExpression( // When predicate evaluates to UNKNOWN (e.g. NULL > 100), it should not violate the check constraint. new CoalesceExpression(predicate, TRUE_LITERAL), TRUE_LITERAL, new Cast(failFunction(metadata, session, CONSTRAINT_VIOLATION, "Check constraint violation: " + predicate), toSqlType(BOOLEAN))); }

I'm not sure that abstraction is even necessary. Why not inline that logic directly in addCheckConstraints?

I.e., just modify addCheckConstraints to do this:

public RelationPlan addCheckConstraints(List<Expression> constraints, Table node, RelationPlan plan, Function<Table, Scope> accessControlScope) { ... for (Expression constraint : constraints) { ... Expression predicate = new IfExpression( // When predicate evaluates to UNKNOWN (e.g. NULL > 100), it should not violate the check constraint. new CoalesceExpression(coerceIfNecessary(analysis, constraint, planBuilder.rewrite(constraint)), TRUE_LITERAL), TRUE_LITERAL, new Cast(failFunction(plannerContext.getMetadata(), session, CONSTRAINT_VIOLATION, "Check constraint violation: " + predicate), toSqlType(BOOLEAN))); planBuilder = planBuilder.withNewRoot(new FilterNode( idAllocator.getNextId(), planBuilder.getRoot(), predicate)); } ... }

@martint Agree with inline. Updated.

martint · 2023-01-19T17:29:28Z

core/trino-main/src/main/java/io/trino/sql/planner/RelationPlanner.java

@@ -291,6 +291,29 @@ public RelationPlan addRowFilters(Table node, RelationPlan plan, Function<Expres
        return new RelationPlan(planBuilder.getRoot(), plan.getScope(), plan.getFieldMappings(), outerContext);
    }

+    public RelationPlan addCheckConstraints(List<Expression> filters, Table node, RelationPlan plan, Function<Expression, Expression> predicateTransformation, Function<Table, Scope> accessControlScope)


Similarly as above, the name filters is misleading. Rename it to constraints.

martint · 2023-01-19T17:34:42Z

core/trino-main/src/test/java/io/trino/sql/query/TestCheckConstraint.java

+    @Test
+    public void testInsert()
+    {
+        assertions.query("INSERT INTO mock.tiny.nation VALUES (101, 'POLAND', 0, 'No comment')")


assertThat(assertions.query(...)) .matches(...)

martint · 2023-01-19T17:35:13Z

core/trino-main/src/test/java/io/trino/sql/query/TestCheckConstraint.java

+
+        assertThatThrownBy(() -> assertions.query("INSERT INTO mock.tiny.nation VALUES (26, 'POLAND', 11, 'No comment')"))
+                .hasMessage("Check constraint violation: (\"regionkey\" < CAST(10 AS bigint))");
+        assertThatThrownBy(() -> assertions.query("INSERT INTO mock.tiny.nation VALUES "


Use text blocks

martint · 2023-01-19T17:39:11Z

core/trino-main/src/test/java/io/trino/sql/query/TestCheckConstraint.java

+    public void testMergeInsert()
+    {
+        // Within allowed row filter
+        assertThatThrownBy(() -> assertions.query("""


Format as:

assertThatThrownBy(() -> assertions.query(""" MERGE INTO mock.tiny.nation USING (VALUES 42) t(dummy) ON false WHEN NOT MATCHED THEN INSERT VALUES (101, 'POLAND', 0, 'No comment') """)) .hasMessage("line 1:1: Cannot merge into a table with check constraints");

ebyhr · 2023-01-19T23:06:43Z

@martint Addressed comments.

martint · 2023-01-24T20:17:43Z

core/trino-main/src/test/java/io/trino/sql/query/TestCheckConstraint.java

+    {
+        // Predicate evaluates to UNKNOWN (e.g. NULL > 100) should not violate check constraint
+        assertions.query("INSERT INTO mock.tiny.nation(nationkey) VALUES (null)")
+                .assertThat()


assertThat(assertions.query(...), here and everywhere else in this file

The same Scope instance should be used between row filters and check constraints in StatementAnalyzer. Otherwise, PlanSanityChecker throws "Unexpected identifier in logical plan" error.

cla-bot bot added the cla-signed label Nov 9, 2022

ebyhr mentioned this pull request Nov 9, 2022

Allow inserting into tables with CHECK constraint in Delta Lake #14863

Closed

ebyhr self-assigned this Nov 9, 2022

ebyhr commented Nov 10, 2022

View reviewed changes

core/trino-spi/src/main/java/io/trino/spi/connector/ConnectorTableSchema.java Show resolved Hide resolved

ebyhr requested review from findepi and martint November 10, 2022 01:49

ebyhr changed the title ~~Add support for CHECK constraint in INSERT statement~~ Add support for CHECK constraint in INSERT statement in engine and SPI Nov 10, 2022

findepi reviewed Nov 14, 2022

View reviewed changes

ebyhr force-pushed the ebi/core-check-constraint branch from 61cc472 to 1666575 Compare November 17, 2022 08:48

findepi reviewed Nov 17, 2022

View reviewed changes

ebyhr force-pushed the ebi/core-check-constraint branch from 1666575 to f361888 Compare November 18, 2022 04:57

findepi reviewed Nov 18, 2022

View reviewed changes

ebyhr force-pushed the ebi/core-check-constraint branch 2 times, most recently from a43263c to d5193c1 Compare November 21, 2022 02:38

ebyhr force-pushed the ebi/core-check-constraint branch from d11a4d6 to 850f38c Compare December 6, 2022 07:28

ebyhr force-pushed the ebi/core-check-constraint branch from 850f38c to f68c4a9 Compare December 14, 2022 02:47

findinpath reviewed Dec 14, 2022

View reviewed changes

findinpath added the docs label Dec 14, 2022

ebyhr mentioned this pull request Dec 14, 2022

Support inserting into table having CHECK constraint in Delta Lake #15396

Merged

findepi approved these changes Dec 14, 2022

View reviewed changes

martint requested changes Dec 14, 2022

View reviewed changes

ebyhr mentioned this pull request Dec 15, 2022

Add support for CHECK constraint to UPDATE and MERGE statements #15411

Closed

2 tasks

ebyhr force-pushed the ebi/core-check-constraint branch from e6f2f22 to a390038 Compare December 21, 2022 02:25

ebyhr mentioned this pull request Dec 21, 2022

Add CHECK_CONSTRAINTS table to information_schema #15483

Open

ebyhr force-pushed the ebi/core-check-constraint branch from a390038 to 58e4c54 Compare January 4, 2023 00:13

ebyhr force-pushed the ebi/core-check-constraint branch from 58e4c54 to 7daee6c Compare January 12, 2023 03:39

ebyhr force-pushed the ebi/core-check-constraint branch from 7daee6c to 9e28882 Compare January 12, 2023 05:36

findepi approved these changes Jan 18, 2023

View reviewed changes

Static import isDeterministic in StatementAnalyzer

48c56ec

ebyhr force-pushed the ebi/core-check-constraint branch from 9e28882 to 8f35174 Compare January 18, 2023 23:48

martint reviewed Jan 19, 2023

View reviewed changes

ebyhr force-pushed the ebi/core-check-constraint branch from 8f35174 to 20319f5 Compare January 19, 2023 23:06

ebyhr force-pushed the ebi/core-check-constraint branch from 20319f5 to aa09214 Compare January 20, 2023 22:13

ebyhr requested a review from martint January 24, 2023 03:37

martint approved these changes Jan 24, 2023

View reviewed changes

martint reviewed Jan 24, 2023

View reviewed changes

Add support for CHECK constraint in INSERT statement

cf39155

The same Scope instance should be used between row filters and check constraints in StatementAnalyzer. Otherwise, PlanSanityChecker throws "Unexpected identifier in logical plan" error.

ebyhr force-pushed the ebi/core-check-constraint branch from aa09214 to cf39155 Compare January 24, 2023 23:15

ebyhr merged commit d2003fc into trinodb:master Jan 25, 2023

ebyhr deleted the ebi/core-check-constraint branch January 25, 2023 02:21

ebyhr mentioned this pull request Jan 25, 2023

Release notes for 406 #15563

Closed

github-actions bot added this to the 406 milestone Jan 25, 2023

colebow mentioned this pull request Jan 25, 2023

Add Trino 406 release notes #15625

Merged

alexjo2144 mentioned this pull request Feb 1, 2023

Support changing Delta table protocol versions #15932

Closed


		public RelationPlan addRowFilters(List<Expression> filters, Table node, RelationPlan plan, Function<Expression, Expression> predicateTransformation, Function<Table, Scope> accessControlScope)


		analysis.recordSubqueries(expression, expressionAnalysis);

		private void addCoercionForRowConstraint(Table table, QualifiedObjectName name, Expression expression, ExpressionAnalysis expressionAnalysis, String constraintType)

		// TODO https://github.com/trinodb/trino/issues/15411 Add support for CHECK constraint to UPDATE statement
		throw semanticException(NOT_SUPPORTED, update, "Updating a table with a check constraint is not supported");

Add support for CHECK constraint in INSERT statement in engine and SPI #14964

Add support for CHECK constraint in INSERT statement in engine and SPI #14964

Conversation

ebyhr commented Nov 9, 2022 • edited Loading

Description

Release notes

ebyhr commented Nov 9, 2022

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

electrum commented Nov 16, 2022

ebyhr commented Nov 17, 2022

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

ebyhr commented Nov 18, 2022

Choose a reason for hiding this comment

Choose a reason for hiding this comment

ebyhr commented Nov 21, 2022

ebyhr commented Dec 14, 2022

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

ebyhr commented Dec 15, 2022

ebyhr commented Dec 21, 2022

ebyhr commented Jan 4, 2023

ebyhr commented Jan 4, 2023

ebyhr commented Jan 9, 2023

ebyhr commented Jan 12, 2023

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

ebyhr commented Jan 19, 2023

ebyhr commented Jan 19, 2023

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

martint Jan 19, 2023 • edited Loading

Choose a reason for hiding this comment

ebyhr commented Jan 19, 2023

Choose a reason for hiding this comment

ebyhr commented Nov 9, 2022 •

edited

Loading

martint Jan 19, 2023 •

edited

Loading