Example #1
0
        public static IQsiDefinitionNode VisitCreateViewStatement(CreateViewStatementContext context)
        {
            var node = new HanaViewDefinitionNode
            {
                Identifier = context.name,
                Comment    = context.comment,
                StructuredPrivilegeCheck = context.structuredPrivilegeCheck,
                Force       = context.force,
                CheckOption = context.checkOption,
                DdlOnly     = context.ddlOnly,
                ReadOnly    = context.readOnly
            };

            if (context.TryGetRuleContext <ColumnListClauseContext>(out var columnList))
            {
                node.Columns.SetValue(TableVisitor.VisitColumnListClause(columnList, null));
            }

            if (context.TryGetRuleContext <ParameterizedViewClauseContext>(out var parameterizedViewClause))
            {
                node.Parameters.SetValue(TreeHelper.Fragment(parameterizedViewClause.GetInputText()));
            }

            node.Source.SetValue(TableVisitor.VisitSelectStatement(context.selectStatement()));

            if (context.TryGetRuleContext <WithAssociationClauseContext>(out var withAssociationClause))
            {
                node.Associations.SetValue(TreeHelper.Fragment(withAssociationClause.GetInputText()));
            }

            if (context.TryGetRuleContext <WithMaskClauseContext>(out var withMaskClause))
            {
                node.Masks.SetValue(TreeHelper.Fragment(withMaskClause.GetInputText()));
            }

            if (context.TryGetRuleContext <WithExpressionMacroClauseContext>(out var withExpressionMacroClause))
            {
                node.ExpressionMacros.SetValue(TreeHelper.Fragment(withExpressionMacroClause.GetInputText()));
            }

            if (context.TryGetRuleContext <WithAnnotationClauseContext>(out var withAnnotationClause))
            {
                node.Annotation.SetValue(TreeHelper.Fragment(withAnnotationClause.GetInputText()));
            }

            if (context.TryGetRuleContext <WithCacheClauseContext>(out var withCacheClause))
            {
                node.Cache.SetValue(TreeHelper.Fragment(withCacheClause.GetInputText()));
            }

            if (context.TryGetRuleContext <WithAnonymizationClauseContext>(out var withAnonymizationClause))
            {
                node.Anonymization.SetValue(TreeHelper.Fragment(withAnonymizationClause.GetInputText()));
            }

            HanaTree.PutContextSpan(node, context);

            return(node);
        }
Example #2
0
        private void DeparseHanaViewDefinitionNode(ScriptWriter writer, HanaViewDefinitionNode node, QsiScript script)
        {
            writer.Write("CREATE VIEW ").Write(node.Identifier);

            if (!string.IsNullOrEmpty(node.Comment))
            {
                writer.Write(" COMMENT ");
                writer.Write(IdentifierUtility.Escape(node.Comment, EscapeQuotes.Single, EscapeBehavior.TwoTime));
            }

            if (!node.Columns.IsEmpty)
            {
                writer.WriteSpace();
                writer.Write('(');
                DeparseTreeNode(writer, node.Columns.Value, script);
                writer.Write(')');
            }

            if (!node.Parameters.IsEmpty)
            {
                writer.WriteSpace().Write(node.Parameters.Value.Text);
            }

            writer.Write(" AS ");
            DeparseTreeNode(writer, node.Source.Value, script);

            if (!node.Associations.IsEmpty)
            {
                writer.WriteSpace().Write(node.Associations.Value.Text);
            }

            if (!node.Masks.IsEmpty)
            {
                writer.WriteSpace().Write(node.Masks.Value.Text);
            }

            if (!node.ExpressionMacros.IsEmpty)
            {
                writer.WriteSpace().Write(node.ExpressionMacros.Value.Text);
            }

            if (!node.Annotation.IsEmpty)
            {
                writer.WriteSpace().Write(node.Annotation.Value.Text);
            }

            if (node.StructuredPrivilegeCheck)
            {
                writer.WriteSpace().Write("WITH STRUCTURED PRIVILEGE CHECK");
            }

            if (!node.Cache.IsEmpty)
            {
                writer.WriteSpace().Write(node.Cache.Value.Text);
            }

            if (!node.Force)
            {
                writer.WriteSpace().Write("FORCE");
            }

            if (!node.CheckOption)
            {
                writer.WriteSpace().Write("WITH CHECK OPTION");
            }

            if (!node.DdlOnly)
            {
                writer.WriteSpace().Write("WITH DDL ONLY");
            }

            if (!node.ReadOnly)
            {
                writer.WriteSpace().Write("WITH READ ONLY");
            }

            if (!node.Anonymization.IsEmpty)
            {
                writer.WriteSpace().Write(node.Anonymization.Value.Text);
            }
        }