private void DeparseLockingNode(ScriptWriter writer, MySqlLockingNode node)
        {
            if (node.TableLockType == MySqlTableLockType.ShareMode)
            {
                writer.Write("LOCK IN SHARE MODE");
            }
            else
            {
                writer.Write("FOR ");
                writer.Write(node.TableLockType == MySqlTableLockType.Update ? "UPDATE" : "SHARE");

                if (!ListUtility.IsNullOrEmpty(node.Tables))
                {
                    writer.WriteSpace();
                    writer.Write("OF ");
                    writer.WriteJoin(", ", node.Tables);
                }

                if (node.RowLockType.HasValue)
                {
                    writer.WriteSpace();
                    writer.Write(node.RowLockType == MySqlRowLockType.SkipLocked ? "SKIP LOCKED" : "NOWAIT");
                }
            }
        }
Exemple #2
0
        // tableRef
        private void DeparseHanaTableReferenceNode(ScriptWriter writer, HanaTableReferenceNode node, QsiScript script)
        {
            // tableName
            writer.Write(node.Identifier);

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

            // partitionRestriction?
            if (!node.Partition.IsEmpty)
            {
                writer.WriteSpace();
                writer.Write(node.Partition.Value.Text);
            }

            // tableSampleClause?
            if (!node.Sampling.IsEmpty)
            {
                writer.WriteSpace();
                writer.Write(node.Sampling.Value.Text);
            }
        }
        protected override void DeparseDerivedTableNode(ScriptWriter writer, IQsiDerivedTableNode node, QsiScript script)
        {
            base.DeparseDerivedTableNode(writer, node, script);

            if (node is not MySqlDerivedTableNode mysqlNode)
            {
                return;
            }

            if (!mysqlNode.ProcedureAnalyse.IsEmpty)
            {
                var procedureAnalyse = mysqlNode.ProcedureAnalyse.Value;

                writer.WriteSpace();
                writer.Write("PROCEDURE ANALYSE (");
                writer.Write(procedureAnalyse.MaxElements);

                if (procedureAnalyse.MaxMemory.HasValue)
                {
                    writer.Write(", ");
                    writer.Write(procedureAnalyse.MaxMemory.Value);
                }

                writer.Write(')');
            }

            if (mysqlNode.Lockings?.Count > 0)
            {
                writer.WriteSpace();
                writer.WriteJoin(" ", mysqlNode.Lockings, DeparseLockingNode);
            }
        }
Exemple #4
0
        protected override void DeparseOrderExpressionNode(ScriptWriter writer, IQsiOrderExpressionNode node, QsiScript script)
        {
            if (node is HanaOrderByExpressionNode hanaOrderBy)
            {
                DeparseTreeNode(writer, node.Expression, script);

                if (!hanaOrderBy.Collate.IsEmpty)
                {
                    writer.WriteSpace();
                    DeparseTreeNode(writer, hanaOrderBy.Collate.Value, script);
                }

                writer.WriteSpace();
                writer.Write(node.Order == QsiSortOrder.Ascending ? "ASC" : "DESC");

                if (hanaOrderBy.NullBehavior.HasValue)
                {
                    var first = hanaOrderBy.NullBehavior == HanaOrderByNullBehavior.NullsFirst;

                    writer.WriteSpace();
                    writer.Write(first ? "NULLS FIRST" : "NULLS LAST");
                }

                return;
            }

            base.DeparseOrderExpressionNode(writer, node, script);
        }
Exemple #5
0
        private void DeparseImpalaValuesTableNode(ScriptWriter writer, ImpalaValuesTableNode node, QsiScript script)
        {
            writer.Write("VALUES ");

            writer.WriteJoin(", ", node.Rows, (w, row) =>
            {
                DeparseTreeNode(w, row, script);
            });

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

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

            if (!node.Limit.IsEmpty)
            {
                writer.WriteSpace();
                DeparseTreeNode(writer, node.Limit.Value, script);
            }
        }
Exemple #6
0
        private void DeparseHanaDerivedTableNode(ScriptWriter writer, IHanaDerivedTableNode node, QsiScript script)
        {
            if (IsAliasedTableReferenceNode(node))
            {
                DeparseTreeNode(writer, node.Source, script);
                writer.WriteSpace();
                DeparseTreeNode(writer, node.Alias, script);

                if (node.Sampling != null)
                {
                    writer.WriteSpace();
                    writer.Write(node.Sampling.Text);
                }

                return;
            }

            if (node.Directives != null)
            {
                DeparseTreeNode(writer, node.Directives, script);
                writer.WriteSpace();
            }

            writer.Write("SELECT ");

            if (node.Top != null)
            {
                writer.Write("TOP ");
                DeparseTreeNode(writer, node.Top, script);
            }

            if (node.Operation.HasValue)
            {
                writer.Write(node.Operation == HanaResultSetOperation.All ? "ALL " : "DISTINCT ");
            }

            if (node.Columns != null)
            {
                DeparseTreeNode(writer, node.Columns, script);
            }

            if (node.Source != null)
            {
                writer.WriteSpace().Write("FROM ");

                if (node.Source is IQsiDerivedTableNode leftSource && !IsAliasedTableReferenceNode(leftSource) ||
                    node.Source is IQsiCompositeTableNode)
                {
                    DeparseTreeNodeWithParenthesis(writer, node.Source, script);
                }
                else
                {
                    DeparseTreeNode(writer, node.Source, script);
                }
            }
Exemple #7
0
        private void DeparseImpalaOrderExpressionNode(ScriptWriter writer, ImpalaOrderExpressionNode node, QsiScript script)
        {
            DeparseTreeNode(writer, node.Expression.Value, script);

            writer.WriteSpace();
            writer.Write(node.Order == QsiSortOrder.Ascending ? "ASC" : "DESC");

            if (node.NullsOrder.HasValue)
            {
                writer.WriteSpace();
                writer.Write("NULLS ");
                writer.Write(node.NullsOrder == ImpalaNullsOrder.First ? "FIRST" : "LAST");
            }
        }
Exemple #8
0
        private void DeparseHanaTableUpdateBehaviorNode(ScriptWriter writer, HanaTableUpdateBehaviorNode node, QsiScript script)
        {
            writer.Write("FOR UPDATE");

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

            if (node.WaitTime.IsEmpty)
            {
                writer.WriteSpace();

                if (node.WaitTime.IsEmpty)
                {
                    writer.Write("NOWAIT");
                }
                else
                {
                    writer.Write("WAIT ");
                    DeparseTreeNode(writer, node.WaitTime.Value, script);
                }
            }

            if (node.IgnoreLocked)
            {
                writer.Write(" IGNORE LOCKED");
            }
        }
Exemple #9
0
        private void DeparseImpalaTableReferenceNode(ScriptWriter writer, ImpalaTableReferenceNode node, QsiScript script)
        {
            DeparseTableReferenceNode(writer, node, script);

            if (!string.IsNullOrWhiteSpace(node.TableSample))
            {
                writer.WriteSpace();
                writer.Write(node.TableSample);
            }

            if (!string.IsNullOrWhiteSpace(node.PlanHints))
            {
                writer.WriteSpace();
                writer.Write(node.PlanHints);
            }
        }
Exemple #10
0
        private void DeparseImpalaWhereExpressionNode(ScriptWriter writer, ImpalaWhereExpressionNode node, QsiScript script)
        {
            writer.Write("WHERE ");

            if (!string.IsNullOrWhiteSpace(node.PlanHints))
            {
                writer.Write(node.PlanHints);
                writer.WriteSpace();
            }

            DeparseTreeNode(writer, node.Expression.Value, script);
        }
Exemple #11
0
        protected override void DeparseLimitExpressionNode(ScriptWriter writer, IQsiLimitExpressionNode node, QsiScript script)
        {
            if (node is HanaLimitExpressionNode hanaLimit)
            {
                writer.Write("LIMIT ");
                DeparseTreeNode(writer, node.Limit, script);

                if (node.Offset != null)
                {
                    writer.WriteSpace();
                    DeparseTreeNode(writer, node.Offset, script);
                }

                if (hanaLimit.TotalRowCount)
                {
                    writer.WriteSpace();
                    writer.Write("TOTAL ROWCOUNT");
                }

                return;
            }

            base.DeparseLimitExpressionNode(writer, node, script);
        }
Exemple #12
0
        private void DeparseHanaAssociationReferenceNode(ScriptWriter writer, HanaAssociationReferenceNode node, QsiScript script)
        {
            writer.Write(node.Identifier);

            if (node.Condition != null)
            {
                writer.Write("[");

                DeparseTreeNode(writer, node.Condition.Value, script);

                if (!string.IsNullOrEmpty(node.Cardinality))
                {
                    writer.WriteSpace();
                    writer.Write(node.Cardinality);
                }

                writer.Write("]");
            }
        }
Exemple #13
0
        protected override void DeparseLimitExpressionNode(ScriptWriter writer, IQsiLimitExpressionNode node, QsiScript script)
        {
            if (node.Limit is not null)
            {
                writer.Write("LIMIT ");
                DeparseTreeNode(writer, node.Limit, script);
            }

            if (node.Offset is not null)
            {
                if (node.Limit is not null)
                {
                    writer.WriteSpace();
                }

                writer.Write("OFFSET ");
                DeparseTreeNode(writer, node.Offset, script);
            }
        }
Exemple #14
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);
            }
        }
Exemple #15
0
        protected override void DeparseDerivedTableNode(ScriptWriter writer, IQsiDerivedTableNode node, QsiScript script)
        {
            if (node is CqlDerivedTableNode cqlNode)
            {
                writer.Write("SELECT ");

                if (cqlNode.IsJson)
                {
                    writer.Write("JSON ");
                }

                if (cqlNode.IsDistinct)
                {
                    writer.Write("DISTINCT ");
                }

                if (node.Columns != null)
                {
                    DeparseTreeNode(writer, node.Columns, script);
                }

                writer.WriteSpace();
                writer.Write("FROM ");

                DeparseTreeNode(writer, node.Source, script);

                if (node.Where != null)
                {
                    writer.WriteSpace();
                    DeparseTreeNode(writer, node.Where, script);
                }

                if (node.Grouping != null)
                {
                    writer.WriteSpace();
                    DeparseTreeNode(writer, node.Grouping, script);
                }

                if (node.Order != null)
                {
                    writer.WriteSpace();
                    DeparseTreeNode(writer, node.Order, script);
                }

                if (!cqlNode.PerPartitionLimit.IsEmpty)
                {
                    writer.WriteSpace();
                    writer.Write("PER PARTITION LIMIT ");
                    DeparseTreeNode(writer, cqlNode.PerPartitionLimit.Value, script);
                }

                if (node.Limit != null)
                {
                    writer.WriteSpace();
                    DeparseTreeNode(writer, node.Limit, script);
                }

                if (cqlNode.AllowFiltering)
                {
                    writer.WriteSpace();
                    writer.Write("ALLOW FILTERING");
                }

                return;
            }

            base.DeparseDerivedTableNode(writer, node, script);
        }
Exemple #16
0
        private void DeparseImpalaDerivedTableNode(ScriptWriter writer, ImpalaDerivedTableNode node, QsiScript script)
        {
            if (IsAliasedTableReferenceNode(node))
            {
                DeparseTreeNode(writer, node.Source.Value, script);
                writer.WriteSpace();
                DeparseTreeNode(writer, node.Alias.Value, script);

                if (!string.IsNullOrWhiteSpace(node.TableSample))
                {
                    writer.WriteSpace();
                    writer.Write(node.TableSample);
                }

                if (!string.IsNullOrWhiteSpace(node.PlanHints))
                {
                    writer.WriteSpace();
                    writer.Write(node.PlanHints);
                }

                return;
            }

            if (!node.Alias.IsEmpty)
            {
                DeparseTreeNodeWithParenthesis(writer, node.Source.Value, script);
                writer.WriteSpace();
                DeparseTreeNode(writer, node.Alias.Value, script);

                if (!string.IsNullOrWhiteSpace(node.TableSample))
                {
                    writer.WriteSpace();
                    writer.Write(node.TableSample);
                }

                return;
            }

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

            writer.Write("SELECT ");

            if (node.IsDistinct.HasValue)
            {
                writer.Write(node.IsDistinct.Value ? "DISTINCT" : "ALL");
                writer.WriteSpace();
            }

            if (!string.IsNullOrWhiteSpace(node.PlanHints))
            {
                writer.Write(node.PlanHints);
                writer.WriteSpace();
            }

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

            if (!node.Source.IsEmpty)
            {
                writer.WriteSpace();
                writer.Write("FROM ");

                DeparseTreeNode(writer, node.Source.Value, script);
            }

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

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

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

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

            if (!string.IsNullOrWhiteSpace(node.TableSample))
            {
                writer.WriteSpace();
                writer.Write(node.TableSample);
            }
        }