IGNITE-22717 SQL Calcite: User defined SQL views

docs/_docs/monitoring-metrics/system-views.adoc

@@ -645,8 +645,9 @@ This view exposes information about SQL views.
 [{table_opts}]
 |===
 |NAME | TYPE |    DESCRIPTION
-|NAME | string |  Name
 |SCHEMA | string |  Schema
+|NAME | string |  Name
+|SQL | string | SQL query for view
 |DESCRIPTION | string |  Description
 |===
 

docs/_docs/sql-reference/ddl.adoc

@@ -472,6 +472,66 @@ DROP INDEX idx_person_name;
 ----
 
 
+== CREATE VIEW
+
+Creates an user definded SQL view.
+
+
+[source,sql]
+----
+CREATE [OR REPLACE] VIEW [schemaName.]viewName AS query
+----
+
+Parameters:
+
+* `schemaName` - the name of the schema, where to create view.
+* `viewName` - the name of the view to create.
+* `OR REPLACE` - replace view if a view with the specified name already exists.
+* `query` - valid SQL query.
+
+Schema changes applied by this command are persisted on disk if link:persistence/native-persistence[Ignite persistence] is enabled. Thus, the changes can survive full cluster restarts.
+
+[discrete]
+=== Examples
+Create a view:
+
+
+[source,sql]
+----
+CREATE VIEW adult AS SELECT * FROM person WHERE age >= 18;
+----
+
+
+== DROP VIEW
+
+Deletes an existing user defined SQL view.
+
+
+[source,sql]
+----
+DROP VIEW [IF EXISTS] [schemaName.]viewName
+----
+
+Parameters:
+
+* `schemaName` - the schema of the view to drop.
+* `viewName` - the name of the view to drop.
+* `IF EXISTS` - do not throw an error if a view with the specified name does not exist.
+
+Schema changes applied by this command are persisted on disk if link:persistence/native-persistence[Ignite persistence] is enabled. Thus, the changes can survive full cluster restarts.
+
+
+[discrete]
+=== Examples
+Drop a view:
+
+
+[source,sql]
+----
+DROP VIEW adult;
+----
+
+
 == CREATE USER
 
 The command creates a user with a given name and password.

modules/calcite/src/main/codegen/config.fmpp

@@ -444,7 +444,8 @@ data: {
     createStatementParserMethods: [
       "SqlCreateTable",
       "SqlCreateIndex",
-      "SqlCreateUser"
+      "SqlCreateUser",
+      "SqlCreateView"
     ]
 
     # List of methods for parsing extensions to "DROP" calls.
@@ -453,7 +454,8 @@ data: {
     dropStatementParserMethods: [
       "SqlDropTable",
       "SqlDropIndex",
-      "SqlDropUser"
+      "SqlDropUser",
+      "SqlDropView"
     ]
 
     # List of methods for parsing extensions to "ALTER <scope>" calls.

modules/calcite/src/main/codegen/includes/parserImpls.ftl

@@ -191,6 +191,11 @@ SqlCreate SqlCreateTable(Span s, boolean replace) :
     final SqlNode query;
 }
 {
+    {
+        if (replace)
+            throw SqlUtil.newContextException(getPos(), IgniteResource.INSTANCE.unsupportedClause("REPLACE"));
+    }
+
     <TABLE>
     ifNotExists = IfNotExistsOpt()
     id = CompoundIdentifier()
@@ -258,6 +263,11 @@ SqlCreate SqlCreateIndex(Span s, boolean replace) :
     SqlNumericLiteral inlineSize = null;
 }
 {
+    {
+        if (replace)
+            throw SqlUtil.newContextException(getPos(), IgniteResource.INSTANCE.unsupportedClause("REPLACE"));
+    }
+
     <INDEX>
     ifNotExists = IfNotExistsOpt()
     [ idxId = SimpleIdentifier() ]
@@ -412,6 +422,11 @@ SqlCreate SqlCreateUser(Span s, boolean replace) :
     final SqlNode password;
 }
 {
+    {
+        if (replace)
+            throw SqlUtil.newContextException(getPos(), IgniteResource.INSTANCE.unsupportedClause("REPLACE"));
+    }
+
     <USER> user = SimpleIdentifier()
     <WITH> <PASSWORD> password = StringLiteral() {
         return new IgniteSqlCreateUser(s.end(this), user, SqlLiteral.unchain(password));
@@ -752,3 +767,26 @@ SqlNode SqlStatisticsAnalyze():
         return new IgniteSqlStatisticsAnalyze(tablesList, optionsList, s.end(this));
     }
 }
+
+SqlCreate SqlCreateView(Span s, boolean replace) :
+{
+    final SqlIdentifier id;
+    final SqlNode query;
+}
+{
+    <VIEW> id = CompoundIdentifier()
+    <AS> query = OrderedQueryOrExpr(ExprContext.ACCEPT_QUERY) {
+        return SqlDdlNodes.createView(s.end(this), replace, id, null, query);
+    }
+}
+
+SqlDrop SqlDropView(Span s, boolean replace) :
+{
+    final boolean ifExists;
+    final SqlIdentifier id;
+}
+{
+    <VIEW> ifExists = IfExistsOpt() id = CompoundIdentifier() {
+        return SqlDdlNodes.dropView(s.end(this), ifExists, id);
+    }
+}

modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/prepare/ddl/SqlToNativeCommandConverter.java

@@ -27,6 +27,9 @@
 import org.apache.calcite.sql.SqlIdentifier;
 import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.SqlNode;
+import org.apache.calcite.sql.ddl.SqlCreateView;
+import org.apache.calcite.sql.ddl.SqlDropView;
+import org.apache.calcite.sql.dialect.CalciteSqlDialect;
 import org.apache.ignite.cache.QueryIndex;
 import org.apache.ignite.internal.processors.cache.query.IgniteQueryErrorCode;
 import org.apache.ignite.internal.processors.query.IgniteSQLException;
@@ -55,9 +58,11 @@
 import org.apache.ignite.internal.sql.command.SqlCommand;
 import org.apache.ignite.internal.sql.command.SqlCreateIndexCommand;
 import org.apache.ignite.internal.sql.command.SqlCreateUserCommand;
+import org.apache.ignite.internal.sql.command.SqlCreateViewCommand;
 import org.apache.ignite.internal.sql.command.SqlDropIndexCommand;
 import org.apache.ignite.internal.sql.command.SqlDropStatisticsCommand;
 import org.apache.ignite.internal.sql.command.SqlDropUserCommand;
+import org.apache.ignite.internal.sql.command.SqlDropViewCommand;
 import org.apache.ignite.internal.sql.command.SqlIndexColumn;
 import org.apache.ignite.internal.sql.command.SqlKillComputeTaskCommand;
 import org.apache.ignite.internal.sql.command.SqlKillContinuousQueryCommand;
@@ -87,7 +92,9 @@ public static boolean isSupported(SqlNode sqlCmd) {
             || sqlCmd instanceof IgniteSqlAlterUser
             || sqlCmd instanceof IgniteSqlDropUser
             || sqlCmd instanceof IgniteSqlKill
-            || sqlCmd instanceof IgniteSqlStatisticsCommand;
+            || sqlCmd instanceof IgniteSqlStatisticsCommand
+            || sqlCmd instanceof SqlCreateView
+            || sqlCmd instanceof SqlDropView;
     }
 
     /**
@@ -120,6 +127,10 @@ else if (cmd instanceof IgniteSqlKill)
             return convertKill((IgniteSqlKill)cmd, pctx);
         else if (cmd instanceof IgniteSqlStatisticsCommand)
             return convertStatistics((IgniteSqlStatisticsCommand)cmd, pctx);
+        else if (cmd instanceof SqlCreateView)
+            return convertCreateView((SqlCreateView)cmd, pctx);
+        else if (cmd instanceof SqlDropView)
+            return convertDropView((SqlDropView)cmd, pctx);
 
         throw new IgniteSQLException("Unsupported native operation [" +
             "cmdName=" + (cmd == null ? null : cmd.getClass().getSimpleName()) + "; " +
@@ -198,6 +209,27 @@ private static SqlDropUserCommand convertDropUser(IgniteSqlDropUser sqlCmd, Plan
         return new SqlDropUserCommand(sqlCmd.user().getSimple());
     }
 
+    /**
+     * Converts CREATE VIEW ... command.
+     */
+    private static SqlCreateViewCommand convertCreateView(SqlCreateView sqlCmd, PlanningContext ctx) {
+        String schemaName = deriveSchemaName(sqlCmd.name, ctx);
+        String viewName = deriveObjectName(sqlCmd.name, ctx, "View name");
+
+        return new SqlCreateViewCommand(schemaName, viewName,
+            sqlCmd.query.toSqlString(CalciteSqlDialect.DEFAULT).toString(), sqlCmd.getReplace());
+    }
+
+    /**
+     * Converts DROP VIEW ... command.
+     */
+    private static SqlDropViewCommand convertDropView(SqlDropView sqlCmd, PlanningContext ctx) {
+        String schemaName = deriveSchemaName(sqlCmd.name, ctx);
+        String viewName = deriveObjectName(sqlCmd.name, ctx, "View name");
+
+        return new SqlDropViewCommand(schemaName, viewName, sqlCmd.ifExists);
+    }
+
     /**
      * Converts KILL ... command.
      */

modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/schema/IgniteSchema.java

@@ -20,11 +20,11 @@
 import java.util.Collections;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
-
 import com.google.common.collect.HashMultimap;
 import com.google.common.collect.Multimap;
 import com.google.common.collect.Multimaps;
 import org.apache.calcite.schema.Function;
+import org.apache.calcite.schema.SchemaPlus;
 import org.apache.calcite.schema.Table;
 import org.apache.calcite.schema.impl.AbstractSchema;
 
@@ -41,6 +41,9 @@ public class IgniteSchema extends AbstractSchema {
     /** */
     private final Multimap<String, Function> funcMap = Multimaps.synchronizedMultimap(HashMultimap.create());
 
+    /** */
+    private final Map<String, String> viewMap = new ConcurrentHashMap<>();
+
     /**
      * Creates a Schema.
      *
@@ -88,4 +91,33 @@ public void removeTable(String tblName) {
     public void addFunction(String name, Function func) {
         funcMap.put(name, func);
     }
+
+    /**
+     * @param name View name.
+     * @param sql View sql.
+     */
+    public void addView(String name, String sql) {
+        viewMap.put(name, sql);
+    }
+
+    /**
+     * @param name View name.
+     */
+    public void removeView(String name) {
+        viewMap.remove(name);
+    }
+
+    /**
+     * Registers current {@code IgniteSchema} in parent {@code SchemaPlus}.
+     *
+     * @param parent Parent schema.
+     * @return Registered schema.
+     */
+    public SchemaPlus register(SchemaPlus parent) {
+        SchemaPlus newSchema = parent.add(schemaName, this);
+
+        viewMap.forEach((name, sql) -> newSchema.add(name, new ViewTableMacroImpl(sql, newSchema)));
+
+        return newSchema;
+    }
 }

modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/schema/SchemaHolderImpl.java

@@ -40,6 +40,7 @@
 import org.apache.ignite.internal.processors.cache.GridCacheContextInfo;
 import org.apache.ignite.internal.processors.query.GridQueryTypeDescriptor;
 import org.apache.ignite.internal.processors.query.QueryField;
+import org.apache.ignite.internal.processors.query.QueryUtils;
 import org.apache.ignite.internal.processors.query.calcite.exec.exp.IgniteScalarFunction;
 import org.apache.ignite.internal.processors.query.calcite.trait.TraitUtils;
 import org.apache.ignite.internal.processors.query.calcite.type.IgniteTypeFactory;
@@ -367,6 +368,26 @@ private static Object affinityIdentity(CacheConfiguration<?, ?> ccfg) {
         rebuild();
     }
 
+    /** {@inheritDoc} */
+    @Override public void onViewCreated(String schemaName, String viewName, String viewSql) {
+        IgniteSchema schema = igniteSchemas.computeIfAbsent(schemaName, IgniteSchema::new);
+
+        schema.addView(viewName, viewSql);
+
+        rebuild();
+    }
+
+    /** {@inheritDoc} */
+    @Override public void onViewDropped(String schemaName, String viewName) {
+        IgniteSchema schema = igniteSchemas.get(schemaName);
+
+        if (schema != null) {
+            schema.removeView(viewName);
+
+            rebuild();
+        }
+    }
+
     /** {@inheritDoc} */
     @Override public SchemaPlus schema(@Nullable String schema) {
         return schema != null ? calciteSchema.getSubSchema(schema) : calciteSchema;
@@ -385,10 +406,14 @@ private IgniteCacheTable table(String schemaName, String tableName) {
     /** */
     private void rebuild() {
         SchemaPlus newCalciteSchema = Frameworks.createRootSchema(false);
+
         newCalciteSchema.add("UUID", typeFactory -> ((IgniteTypeFactory)typeFactory).createCustomType(UUID.class));
         newCalciteSchema.add("OTHER", typeFactory -> ((IgniteTypeFactory)typeFactory).createCustomType(Object.class));
-        newCalciteSchema.add("PUBLIC", new IgniteSchema("PUBLIC"));
-        igniteSchemas.forEach(newCalciteSchema::add);
+        newCalciteSchema.add(QueryUtils.DFLT_SCHEMA, new IgniteSchema(QueryUtils.DFLT_SCHEMA));
+
+        for (IgniteSchema schema : igniteSchemas.values())
+            schema.register(newCalciteSchema);
+
         calciteSchema = newCalciteSchema;
     }
 }

modules/calcite/src/main/java/org/apache/ignite/internal/processors/query/calcite/schema/ViewTableImpl.java

@@ -0,0 +1,52 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.ignite.internal.processors.query.calcite.schema;
+
+import java.lang.reflect.Type;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import org.apache.calcite.rel.type.RelProtoDataType;
+import org.apache.calcite.schema.impl.ViewTable;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Ignite SQL view table implementation.
+ */
+public class ViewTableImpl extends ViewTable {
+    /** Fields origins. */
+    private final Map<String, List<String>> origins;
+
+    /** Ctor. */
+    public ViewTableImpl(
+        Type elementType,
+        RelProtoDataType rowType,
+        String viewSql,
+        List<String> schemaPath,
+        Map<String, List<String>> origins
+    ) {
+        super(elementType, rowType, viewSql, schemaPath, null);
+
+        this.origins = Collections.unmodifiableMap(origins);
+    }
+
+    /** Get field origin. */
+    public @Nullable List<String> fieldOrigin(String fieldName) {
+        return origins.get(fieldName);
+    }
+}