1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 package org.apache.shardingsphere.sql.parser.sqlserver.visitor.statement;
19
20 import lombok.AccessLevel;
21 import lombok.Getter;
22 import org.antlr.v4.runtime.ParserRuleContext;
23 import org.antlr.v4.runtime.Token;
24 import org.antlr.v4.runtime.misc.Interval;
25 import org.antlr.v4.runtime.tree.ParseTree;
26 import org.antlr.v4.runtime.tree.TerminalNode;
27 import org.apache.shardingsphere.sql.parser.api.ASTNode;
28 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementBaseVisitor;
29 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.AggregationClauseContext;
30 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.AggregationFunctionContext;
31 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.AliasContext;
32 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.ApproxFunctionContext;
33 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.AssignmentContext;
34 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.AssignmentValueContext;
35 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.AssignmentValuesContext;
36 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.BitExprContext;
37 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.BitValueLiteralsContext;
38 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.BooleanLiteralsContext;
39 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.BooleanPrimaryContext;
40 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.CastFunctionContext;
41 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.CharFunctionContext;
42 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.ColumnNameContext;
43 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.ColumnNameWithSortContext;
44 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.ColumnNamesContext;
45 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.ColumnNamesWithSortContext;
46 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.ConstraintNameContext;
47 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.ConversionFunctionContext;
48 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.ConvertFunctionContext;
49 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.CreateTableAsSelectClauseContext;
50 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.CteClauseContext;
51 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.CteClauseSetContext;
52 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.DataTypeContext;
53 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.DataTypeLengthContext;
54 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.DataTypeNameContext;
55 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.DatabaseNameContext;
56 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.DeleteContext;
57 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.DelimitedIdentifierContext;
58 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.DuplicateSpecificationContext;
59 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.ExecContext;
60 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.ExprContext;
61 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.FromClauseContext;
62 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.FunctionCallContext;
63 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.GroupByClauseContext;
64 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.HavingClauseContext;
65 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.HexadecimalLiteralsContext;
66 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.IdentifierContext;
67 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.IndexNameContext;
68 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.InsertContext;
69 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.InsertDefaultValueContext;
70 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.InsertExecClauseContext;
71 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.InsertSelectClauseContext;
72 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.InsertValuesClauseContext;
73 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.IntoClauseContext;
74 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.JoinSpecificationContext;
75 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.JoinedTableContext;
76 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.JsonArrayFunctionContext;
77 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.JsonFunctionContext;
78 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.JsonKeyValueContext;
79 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.JsonNullClauseContext;
80 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.JsonObjectFunctionContext;
81 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.LiteralsContext;
82 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.MergeContext;
83 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.MergeInsertClauseContext;
84 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.MergeUpdateClauseContext;
85 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.MergeWhenClauseContext;
86 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.MultipleTableNamesContext;
87 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.MultipleTablesClauseContext;
88 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.NullValueLiteralsContext;
89 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.NumberLiteralsContext;
90 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.OpenJsonFunctionContext;
91 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.OpenQueryFunctionContext;
92 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.OpenRowSetFunctionContext;
93 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.OptionHintContext;
94 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.OrderByClauseContext;
95 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.OrderByItemContext;
96 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.OutputClauseContext;
97 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.OutputWithColumnContext;
98 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.OutputWithColumnsContext;
99 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.OwnerContext;
100 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.ParameterMarkerContext;
101 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.PredicateContext;
102 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.ProcedureNameContext;
103 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.ProjectionContext;
104 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.ProjectionsContext;
105 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.QualifiedShorthandContext;
106 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.RegularFunctionContext;
107 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.RegularIdentifierContext;
108 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.RowSetFunctionContext;
109 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.SampleOptionContext;
110 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.ScalarExpressionContext;
111 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.SchemaNameContext;
112 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.ScriptVariableNameContext;
113 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.SelectClauseContext;
114 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.SelectContext;
115 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.SetAssignmentsClauseContext;
116 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.SimpleExprContext;
117 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.SingleTableClauseContext;
118 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.SpecialFunctionContext;
119 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.StatisticsOptionContext;
120 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.StatisticsOptionsContext;
121 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.StatisticsWithClauseContext;
122 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.StringLiteralsContext;
123 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.SubqueryContext;
124 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.TableFactorContext;
125 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.TableHintLimitedContext;
126 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.TableNameContext;
127 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.TableNamesContext;
128 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.TableReferenceContext;
129 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.TableReferencesContext;
130 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.TopContext;
131 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.TrimFunctionContext;
132 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.UnreservedWordContext;
133 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.UpdateContext;
134 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.UpdateStatisticsContext;
135 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.ViewNameContext;
136 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.WhereClauseContext;
137 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.WindowFunctionContext;
138 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.WithClauseContext;
139 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.WithTableHintContext;
140 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.GraphFunctionContext;
141 import org.apache.shardingsphere.sql.parser.autogen.SQLServerStatementParser.GraphAggFunctionContext;
142 import org.apache.shardingsphere.sql.parser.sql.common.enums.AggregationType;
143 import org.apache.shardingsphere.sql.parser.sql.common.enums.JoinType;
144 import org.apache.shardingsphere.sql.parser.sql.common.enums.OrderDirection;
145 import org.apache.shardingsphere.sql.parser.sql.common.enums.ParameterMarkerType;
146 import org.apache.shardingsphere.sql.parser.sql.common.segment.SQLSegment;
147 import org.apache.shardingsphere.sql.parser.sql.common.segment.ddl.constraint.ConstraintSegment;
148 import org.apache.shardingsphere.sql.parser.sql.common.segment.ddl.index.IndexNameSegment;
149 import org.apache.shardingsphere.sql.parser.sql.common.segment.ddl.index.IndexSegment;
150 import org.apache.shardingsphere.sql.parser.sql.common.segment.ddl.routine.FunctionNameSegment;
151 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.assignment.ColumnAssignmentSegment;
152 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.assignment.InsertValuesSegment;
153 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.assignment.SetAssignmentSegment;
154 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.column.ColumnSegment;
155 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.column.InsertColumnsSegment;
156 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.expr.BetweenExpression;
157 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.expr.BinaryOperationExpression;
158 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.expr.ExpressionSegment;
159 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.expr.ExpressionWithParamsSegment;
160 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.expr.FunctionSegment;
161 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.expr.InExpression;
162 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.expr.KeyValueSegment;
163 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.expr.ListExpression;
164 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.expr.NotExpression;
165 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.expr.complex.CommonExpressionSegment;
166 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.expr.complex.CommonTableExpressionSegment;
167 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.expr.simple.LiteralExpressionSegment;
168 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.expr.simple.ParameterMarkerExpressionSegment;
169 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.expr.subquery.SubqueryExpressionSegment;
170 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.expr.subquery.SubquerySegment;
171 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.item.AggregationDistinctProjectionSegment;
172 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.item.AggregationProjectionSegment;
173 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.item.ColumnProjectionSegment;
174 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.item.ExpressionProjectionSegment;
175 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.item.ProjectionSegment;
176 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.item.ProjectionsSegment;
177 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.item.ShorthandProjectionSegment;
178 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.item.SubqueryProjectionSegment;
179 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.order.GroupBySegment;
180 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.order.OrderBySegment;
181 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.order.item.ColumnOrderByItemSegment;
182 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.order.item.ExpressionOrderByItemSegment;
183 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.order.item.IndexOrderByItemSegment;
184 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.order.item.OrderByItemSegment;
185 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.pagination.PaginationValueSegment;
186 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.pagination.limit.LimitSegment;
187 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.pagination.limit.NumberLiteralLimitValueSegment;
188 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.pagination.limit.ParameterMarkerLimitValueSegment;
189 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.pagination.rownum.NumberLiteralRowNumberValueSegment;
190 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.pagination.rownum.ParameterMarkerRowNumberValueSegment;
191 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.pagination.rownum.RowNumberValueSegment;
192 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.pagination.top.TopProjectionSegment;
193 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.predicate.HavingSegment;
194 import org.apache.shardingsphere.sql.parser.sql.common.segment.dml.predicate.WhereSegment;
195 import org.apache.shardingsphere.sql.parser.sql.common.segment.generic.AliasSegment;
196 import org.apache.shardingsphere.sql.parser.sql.common.segment.generic.DataTypeLengthSegment;
197 import org.apache.shardingsphere.sql.parser.sql.common.segment.generic.DataTypeSegment;
198 import org.apache.shardingsphere.sql.parser.sql.common.segment.generic.OutputSegment;
199 import org.apache.shardingsphere.sql.parser.sql.common.segment.generic.OwnerSegment;
200 import org.apache.shardingsphere.sql.parser.sql.common.segment.generic.ParameterMarkerSegment;
201 import org.apache.shardingsphere.sql.parser.sql.common.segment.generic.WithSegment;
202 import org.apache.shardingsphere.sql.parser.sql.common.segment.generic.table.DeleteMultiTableSegment;
203 import org.apache.shardingsphere.sql.parser.sql.common.segment.generic.table.FunctionTableSegment;
204 import org.apache.shardingsphere.sql.parser.sql.common.segment.generic.table.JoinTableSegment;
205 import org.apache.shardingsphere.sql.parser.sql.common.segment.generic.table.SimpleTableSegment;
206 import org.apache.shardingsphere.sql.parser.sql.common.segment.generic.table.SubqueryTableSegment;
207 import org.apache.shardingsphere.sql.parser.sql.common.segment.generic.table.TableNameSegment;
208 import org.apache.shardingsphere.sql.parser.sql.common.segment.generic.table.TableSegment;
209 import org.apache.shardingsphere.sql.parser.sql.common.statement.dml.MergeStatement;
210 import org.apache.shardingsphere.sql.parser.sql.common.util.SQLUtils;
211 import org.apache.shardingsphere.sql.parser.sql.common.value.collection.CollectionValue;
212 import org.apache.shardingsphere.sql.parser.sql.common.value.identifier.IdentifierValue;
213 import org.apache.shardingsphere.sql.parser.sql.common.value.keyword.KeywordValue;
214 import org.apache.shardingsphere.sql.parser.sql.common.value.literal.impl.BooleanLiteralValue;
215 import org.apache.shardingsphere.sql.parser.sql.common.value.literal.impl.NullLiteralValue;
216 import org.apache.shardingsphere.sql.parser.sql.common.value.literal.impl.NumberLiteralValue;
217 import org.apache.shardingsphere.sql.parser.sql.common.value.literal.impl.OtherLiteralValue;
218 import org.apache.shardingsphere.sql.parser.sql.common.value.literal.impl.StringLiteralValue;
219 import org.apache.shardingsphere.sql.parser.sql.common.value.parametermarker.ParameterMarkerValue;
220 import org.apache.shardingsphere.sql.parser.sql.dialect.segment.sqlserver.exec.ExecSegment;
221 import org.apache.shardingsphere.sql.parser.sql.dialect.segment.sqlserver.hint.OptionHintSegment;
222 import org.apache.shardingsphere.sql.parser.sql.dialect.segment.sqlserver.hint.TableHintLimitedSegment;
223 import org.apache.shardingsphere.sql.parser.sql.dialect.segment.sqlserver.hint.WithTableHintSegment;
224 import org.apache.shardingsphere.sql.parser.sql.dialect.segment.sqlserver.json.JsonNullClauseSegment;
225 import org.apache.shardingsphere.sql.parser.sql.dialect.segment.sqlserver.merge.MergeWhenAndThenSegment;
226 import org.apache.shardingsphere.sql.parser.sql.dialect.statement.sqlserver.ddl.SQLServerCreateTableStatement;
227 import org.apache.shardingsphere.sql.parser.sql.dialect.statement.sqlserver.ddl.SQLServerUpdateStatisticsStatement;
228 import org.apache.shardingsphere.sql.parser.sql.dialect.statement.sqlserver.dml.SQLServerDeleteStatement;
229 import org.apache.shardingsphere.sql.parser.sql.dialect.statement.sqlserver.dml.SQLServerInsertStatement;
230 import org.apache.shardingsphere.sql.parser.sql.dialect.statement.sqlserver.dml.SQLServerMergeStatement;
231 import org.apache.shardingsphere.sql.parser.sql.dialect.statement.sqlserver.dml.SQLServerSelectStatement;
232 import org.apache.shardingsphere.sql.parser.sql.dialect.statement.sqlserver.dml.SQLServerUpdateStatement;
233 import org.apache.shardingsphere.sql.parser.sql.dialect.statement.sqlserver.segment.SampleOptionSegment;
234 import org.apache.shardingsphere.sql.parser.sql.dialect.statement.sqlserver.segment.SampleStrategy;
235 import org.apache.shardingsphere.sql.parser.sql.dialect.statement.sqlserver.segment.ScanUnit;
236 import org.apache.shardingsphere.sql.parser.sql.dialect.statement.sqlserver.segment.StatisticsDimension;
237 import org.apache.shardingsphere.sql.parser.sql.dialect.statement.sqlserver.segment.StatisticsOptionSegment;
238 import org.apache.shardingsphere.sql.parser.sql.dialect.statement.sqlserver.segment.StatisticsStrategySegment;
239
240 import java.util.Collection;
241 import java.util.Collections;
242 import java.util.LinkedList;
243 import java.util.List;
244 import java.util.stream.Collectors;
245
246
247
248
249 @Getter(AccessLevel.PROTECTED)
250 public abstract class SQLServerStatementVisitor extends SQLServerStatementBaseVisitor<ASTNode> {
251
252 private final Collection<ParameterMarkerSegment> parameterMarkerSegments = new LinkedList<>();
253
254 @Override
255 public final ASTNode visitParameterMarker(final ParameterMarkerContext ctx) {
256 return new ParameterMarkerValue(parameterMarkerSegments.size(), ParameterMarkerType.QUESTION);
257 }
258
259 @Override
260 public final ASTNode visitLiterals(final LiteralsContext ctx) {
261 if (null != ctx.stringLiterals()) {
262 return visit(ctx.stringLiterals());
263 }
264 if (null != ctx.numberLiterals()) {
265 return visit(ctx.numberLiterals());
266 }
267 if (null != ctx.hexadecimalLiterals()) {
268 return visit(ctx.hexadecimalLiterals());
269 }
270 if (null != ctx.bitValueLiterals()) {
271 return visit(ctx.bitValueLiterals());
272 }
273 if (null != ctx.booleanLiterals()) {
274 return visit(ctx.booleanLiterals());
275 }
276 if (null != ctx.nullValueLiterals()) {
277 return visit(ctx.nullValueLiterals());
278 }
279 throw new IllegalStateException("Literals must have string, number, dateTime, hex, bit, boolean or null.");
280 }
281
282 @Override
283 public final ASTNode visitStringLiterals(final StringLiteralsContext ctx) {
284 if (null != ctx.STRING_()) {
285 return new StringLiteralValue(ctx.getText());
286 } else {
287 return new StringLiteralValue(ctx.getText().substring(1));
288 }
289 }
290
291 @Override
292 public final ASTNode visitNumberLiterals(final NumberLiteralsContext ctx) {
293 return new NumberLiteralValue(ctx.getText());
294 }
295
296 @Override
297 public final ASTNode visitHexadecimalLiterals(final HexadecimalLiteralsContext ctx) {
298
299 return new OtherLiteralValue(ctx.getText());
300 }
301
302 @Override
303 public final ASTNode visitBitValueLiterals(final BitValueLiteralsContext ctx) {
304
305 return new OtherLiteralValue(ctx.getText());
306 }
307
308 @Override
309 public final ASTNode visitBooleanLiterals(final BooleanLiteralsContext ctx) {
310 return new BooleanLiteralValue(ctx.getText());
311 }
312
313 @Override
314 public final ASTNode visitNullValueLiterals(final NullValueLiteralsContext ctx) {
315 return new NullLiteralValue(ctx.getText());
316 }
317
318 @Override
319 public final ASTNode visitIdentifier(final IdentifierContext ctx) {
320 return null == ctx.regularIdentifier() ? visit(ctx.delimitedIdentifier()) : visit(ctx.regularIdentifier());
321 }
322
323 @Override
324 public final ASTNode visitRegularIdentifier(final RegularIdentifierContext ctx) {
325 UnreservedWordContext unreservedWord = ctx.unreservedWord();
326 return null == unreservedWord ? new IdentifierValue(ctx.getText()) : (IdentifierValue) visit(unreservedWord);
327 }
328
329 @Override
330 public final ASTNode visitDelimitedIdentifier(final DelimitedIdentifierContext ctx) {
331 return new IdentifierValue(ctx.getText());
332 }
333
334 @Override
335 public final ASTNode visitUnreservedWord(final UnreservedWordContext ctx) {
336 return new IdentifierValue(ctx.getText());
337 }
338
339 @Override
340 public final ASTNode visitSchemaName(final SchemaNameContext ctx) {
341 return visit(ctx.identifier());
342 }
343
344 @Override
345 public final ASTNode visitTableName(final TableNameContext ctx) {
346 SimpleTableSegment result = new SimpleTableSegment(new TableNameSegment(ctx.name().getStart().getStartIndex(), ctx.name().getStop().getStopIndex(), (IdentifierValue) visit(ctx.name())));
347 OwnerContext owner = ctx.owner();
348 if (null != owner) {
349 OwnerSegment ownerSegment = new OwnerSegment(owner.getStart().getStartIndex(), owner.getStop().getStopIndex(), (IdentifierValue) visit(owner.identifier()));
350 if (null != ctx.databaseName()) {
351 DatabaseNameContext databaseName = ctx.databaseName();
352 ownerSegment.setOwner(new OwnerSegment(databaseName.getStart().getStartIndex(), databaseName.getStop().getStopIndex(), (IdentifierValue) visit(databaseName.identifier())));
353 }
354 result.setOwner(ownerSegment);
355 } else if (null != ctx.databaseName()) {
356 DatabaseNameContext databaseName = ctx.databaseName();
357 result.setOwner(new OwnerSegment(databaseName.getStart().getStartIndex(), databaseName.getStop().getStopIndex(), (IdentifierValue) visit(databaseName.identifier())));
358 }
359 return result;
360 }
361
362 @Override
363 public final ASTNode visitColumnName(final ColumnNameContext ctx) {
364 ColumnSegment result;
365 if (null != ctx.name()) {
366 result = new ColumnSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), (IdentifierValue) visit(ctx.name()));
367 } else {
368 result = new ColumnSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), (IdentifierValue) visit(ctx.scriptVariableName()));
369 }
370 OwnerContext owner = ctx.owner();
371 if (null != owner) {
372 OwnerSegment ownerSegment = new OwnerSegment(owner.getStart().getStartIndex(), owner.getStop().getStopIndex(), (IdentifierValue) visit(owner.identifier()));
373 if (null != ctx.databaseName()) {
374 ownerSegment.setOwner(new OwnerSegment(ctx.databaseName().getStart().getStartIndex(), ctx.databaseName().getStop().getStopIndex(),
375 (IdentifierValue) visit(ctx.databaseName().identifier())));
376 }
377 result.setOwner(ownerSegment);
378 }
379 return result;
380 }
381
382 @Override
383 public ASTNode visitScriptVariableName(final ScriptVariableNameContext ctx) {
384 return new IdentifierValue(ctx.getText());
385 }
386
387 @Override
388 public final ASTNode visitIndexName(final IndexNameContext ctx) {
389 IndexNameSegment indexName = new IndexNameSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), (IdentifierValue) visit(ctx.identifier()));
390 return new IndexSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), indexName);
391 }
392
393 @Override
394 public final ASTNode visitConstraintName(final ConstraintNameContext ctx) {
395 return new ConstraintSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), (IdentifierValue) visit(ctx.identifier()));
396 }
397
398 @Override
399 public final ASTNode visitTableNames(final TableNamesContext ctx) {
400 CollectionValue<SimpleTableSegment> result = new CollectionValue<>();
401 for (TableNameContext each : ctx.tableName()) {
402 result.getValue().add((SimpleTableSegment) visit(each));
403 }
404 return result;
405 }
406
407 @Override
408 public final ASTNode visitColumnNames(final ColumnNamesContext ctx) {
409 CollectionValue<ColumnSegment> result = new CollectionValue<>();
410 for (ColumnNameContext each : ctx.columnName()) {
411 result.getValue().add((ColumnSegment) visit(each));
412 }
413 return result;
414 }
415
416 @Override
417 public ASTNode visitColumnNamesWithSort(final ColumnNamesWithSortContext ctx) {
418 CollectionValue<ColumnSegment> result = new CollectionValue<>();
419 for (ColumnNameWithSortContext each : ctx.columnNameWithSort()) {
420 result.getValue().add((ColumnSegment) visit(each));
421 }
422 return result;
423 }
424
425 @Override
426 public final ASTNode visitExpr(final ExprContext ctx) {
427 if (null != ctx.booleanPrimary()) {
428 return visit(ctx.booleanPrimary());
429 }
430 if (null != ctx.LP_()) {
431 return visit(ctx.expr(0));
432 }
433 if (null != ctx.andOperator()) {
434 return createBinaryOperationExpression(ctx, ctx.andOperator().getText());
435 }
436 if (null != ctx.orOperator()) {
437 return createBinaryOperationExpression(ctx, ctx.orOperator().getText());
438 }
439 if (null != ctx.distinctFrom()) {
440 return createBinaryOperationExpression(ctx, ctx.distinctFrom().getText());
441 }
442 return new NotExpression(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), (ExpressionSegment) visit(ctx.expr(0)), false);
443 }
444
445 private ASTNode createBinaryOperationExpression(final ExprContext ctx, final String operator) {
446 ExpressionSegment left = (ExpressionSegment) visit(ctx.expr(0));
447 ExpressionSegment right = (ExpressionSegment) visit(ctx.expr(1));
448 String text = ctx.start.getInputStream().getText(new Interval(ctx.start.getStartIndex(), ctx.stop.getStopIndex()));
449 return new BinaryOperationExpression(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), left, right, operator, text);
450 }
451
452 @Override
453 public final ASTNode visitBooleanPrimary(final BooleanPrimaryContext ctx) {
454 if (null != ctx.IS()) {
455 String rightText = "";
456 if (null != ctx.NOT()) {
457 rightText = rightText.concat(ctx.start.getInputStream().getText(new Interval(ctx.NOT().getSymbol().getStartIndex(),
458 ctx.NOT().getSymbol().getStopIndex()))).concat(" ");
459 }
460 Token operatorToken = null;
461 if (null != ctx.NULL()) {
462 operatorToken = ctx.NULL().getSymbol();
463 }
464 if (null != ctx.TRUE()) {
465 operatorToken = ctx.TRUE().getSymbol();
466 }
467 if (null != ctx.FALSE()) {
468 operatorToken = ctx.FALSE().getSymbol();
469 }
470 int startIndex = null == operatorToken ? ctx.IS().getSymbol().getStopIndex() + 2 : operatorToken.getStartIndex();
471 rightText = rightText.concat(ctx.start.getInputStream().getText(new Interval(startIndex, ctx.stop.getStopIndex())));
472 ExpressionSegment right = new LiteralExpressionSegment(ctx.IS().getSymbol().getStopIndex() + 2, ctx.stop.getStopIndex(), rightText);
473 String text = ctx.start.getInputStream().getText(new Interval(ctx.start.getStartIndex(), ctx.stop.getStopIndex()));
474 ExpressionSegment left = (ExpressionSegment) visit(ctx.booleanPrimary());
475 String operator = "IS";
476 return new BinaryOperationExpression(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), left, right, operator, text);
477 }
478 if (null != ctx.comparisonOperator() || null != ctx.SAFE_EQ_()) {
479 return createCompareSegment(ctx);
480 }
481 return visit(ctx.predicate());
482 }
483
484 private ASTNode createCompareSegment(final BooleanPrimaryContext ctx) {
485 ExpressionSegment left = (ExpressionSegment) visit(ctx.booleanPrimary());
486 ExpressionSegment right;
487 if (null != ctx.predicate()) {
488 right = (ExpressionSegment) visit(ctx.predicate());
489 } else {
490 right = (ExpressionSegment) visit(ctx.subquery());
491 }
492 String operator = null == ctx.SAFE_EQ_() ? ctx.comparisonOperator().getText() : ctx.SAFE_EQ_().getText();
493 String text = ctx.start.getInputStream().getText(new Interval(ctx.start.getStartIndex(), ctx.stop.getStopIndex()));
494 return new BinaryOperationExpression(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), left, right, operator, text);
495 }
496
497 @Override
498 public final ASTNode visitPredicate(final PredicateContext ctx) {
499 if (null != ctx.IN()) {
500 return createInSegment(ctx);
501 }
502 if (null != ctx.BETWEEN()) {
503 return createBetweenSegment(ctx);
504 }
505 if (null != ctx.LIKE()) {
506 return createBinaryOperationExpressionFromLike(ctx);
507 }
508 return visit(ctx.bitExpr(0));
509 }
510
511 private BinaryOperationExpression createBinaryOperationExpressionFromLike(final PredicateContext ctx) {
512 ExpressionSegment left = (ExpressionSegment) visit(ctx.bitExpr(0));
513 ListExpression right = new ListExpression(ctx.simpleExpr(0).start.getStartIndex(), ctx.simpleExpr().get(ctx.simpleExpr().size() - 1).stop.getStopIndex());
514 for (SimpleExprContext each : ctx.simpleExpr()) {
515 right.getItems().add((ExpressionSegment) visit(each));
516 }
517 String operator = null == ctx.NOT() ? "LIKE" : "NOT LIKE";
518 String text = ctx.start.getInputStream().getText(new Interval(ctx.start.getStartIndex(), ctx.stop.getStopIndex()));
519 return new BinaryOperationExpression(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), left, right, operator, text);
520 }
521
522 private InExpression createInSegment(final PredicateContext ctx) {
523 ExpressionSegment left = (ExpressionSegment) visit(ctx.bitExpr(0));
524 ExpressionSegment right;
525 if (null == ctx.subquery()) {
526 ListExpression listExpression = new ListExpression(ctx.LP_().getSymbol().getStartIndex(), ctx.RP_().getSymbol().getStopIndex());
527 for (ExprContext each : ctx.expr()) {
528 listExpression.getItems().add((ExpressionSegment) visit(each));
529 }
530 right = listExpression;
531 } else {
532 right = new SubqueryExpressionSegment(new SubquerySegment(ctx.subquery().start.getStartIndex(), ctx.subquery().stop.getStopIndex(), (SQLServerSelectStatement) visit(ctx.subquery()),
533 getOriginalText(ctx.subquery())));
534 }
535 boolean not = null != ctx.NOT();
536 return new InExpression(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), left, right, not);
537 }
538
539 private BetweenExpression createBetweenSegment(final PredicateContext ctx) {
540 ExpressionSegment left = (ExpressionSegment) visit(ctx.bitExpr(0));
541 ExpressionSegment between = (ExpressionSegment) visit(ctx.bitExpr(1));
542 ExpressionSegment and = (ExpressionSegment) visit(ctx.predicate());
543 boolean not = null != ctx.NOT();
544 return new BetweenExpression(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), left, between, and, not);
545 }
546
547 @Override
548 public final ASTNode visitBitExpr(final BitExprContext ctx) {
549 if (null != ctx.simpleExpr()) {
550 return createExpressionSegment(visit(ctx.simpleExpr()), ctx);
551 }
552 ExpressionSegment left = (ExpressionSegment) visit(ctx.getChild(0));
553 ExpressionSegment right = (ExpressionSegment) visit(ctx.getChild(2));
554 String operator = ctx.getChild(1).getText();
555 String text = ctx.start.getInputStream().getText(new Interval(ctx.start.getStartIndex(), ctx.stop.getStopIndex()));
556 return new BinaryOperationExpression(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), left, right, operator, text);
557 }
558
559 private ASTNode createExpressionSegment(final ASTNode astNode, final ParserRuleContext context) {
560 if (astNode instanceof StringLiteralValue) {
561 return new LiteralExpressionSegment(context.start.getStartIndex(), context.stop.getStopIndex(), ((StringLiteralValue) astNode).getValue());
562 }
563 if (astNode instanceof NumberLiteralValue) {
564 return new LiteralExpressionSegment(context.start.getStartIndex(), context.stop.getStopIndex(), ((NumberLiteralValue) astNode).getValue());
565 }
566 if (astNode instanceof BooleanLiteralValue) {
567 return new LiteralExpressionSegment(context.start.getStartIndex(), context.stop.getStopIndex(), ((BooleanLiteralValue) astNode).getValue());
568 }
569 if (astNode instanceof ParameterMarkerValue) {
570 ParameterMarkerValue parameterMarker = (ParameterMarkerValue) astNode;
571 ParameterMarkerExpressionSegment segment = new ParameterMarkerExpressionSegment(context.start.getStartIndex(), context.stop.getStopIndex(),
572 parameterMarker.getValue(), parameterMarker.getType());
573 parameterMarkerSegments.add(segment);
574 return segment;
575 }
576 if (astNode instanceof SubquerySegment) {
577 return new SubqueryExpressionSegment((SubquerySegment) astNode);
578 }
579 if (astNode instanceof OtherLiteralValue) {
580 return new CommonExpressionSegment(context.getStart().getStartIndex(), context.getStop().getStopIndex(), context.getText());
581 }
582 return astNode;
583 }
584
585 @Override
586 public final ASTNode visitSimpleExpr(final SimpleExprContext ctx) {
587 int startIndex = ctx.getStart().getStartIndex();
588 int stopIndex = ctx.getStop().getStopIndex();
589 if (null != ctx.subquery()) {
590 return new SubquerySegment(startIndex, stopIndex, (SQLServerSelectStatement) visit(ctx.subquery()), getOriginalText(ctx.subquery()));
591 }
592 if (null != ctx.parameterMarker()) {
593 ParameterMarkerValue parameterMarker = (ParameterMarkerValue) visit(ctx.parameterMarker());
594 ParameterMarkerExpressionSegment result = new ParameterMarkerExpressionSegment(startIndex, stopIndex, parameterMarker.getValue(), parameterMarker.getType());
595 parameterMarkerSegments.add(result);
596 return result;
597 }
598 if (null != ctx.literals()) {
599 return SQLUtils.createLiteralExpression(visit(ctx.literals()), startIndex, stopIndex, ctx.literals().start.getInputStream().getText(new Interval(startIndex, stopIndex)));
600 }
601 if (null != ctx.functionCall()) {
602 return visit(ctx.functionCall());
603 }
604 if (null != ctx.columnName()) {
605 return visit(ctx.columnName());
606 }
607 if (null != ctx.LP_() && 1 == ctx.expr().size()) {
608 return visit(ctx.expr(0));
609 }
610 return visitRemainSimpleExpr(ctx);
611 }
612
613 private ASTNode visitRemainSimpleExpr(final SimpleExprContext ctx) {
614 if (null != ctx.caseExpression()) {
615 visit(ctx.caseExpression());
616 String text = ctx.start.getInputStream().getText(new Interval(ctx.start.getStartIndex(), ctx.stop.getStopIndex()));
617 return new OtherLiteralValue(text);
618 }
619 for (ExprContext each : ctx.expr()) {
620 visit(each);
621 }
622 for (SimpleExprContext each : ctx.simpleExpr()) {
623 visit(each);
624 }
625 String text = ctx.start.getInputStream().getText(new Interval(ctx.start.getStartIndex(), ctx.stop.getStopIndex()));
626 return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), text);
627 }
628
629 @Override
630 public final ASTNode visitFunctionCall(final FunctionCallContext ctx) {
631 if (null != ctx.aggregationFunction()) {
632 return visit(ctx.aggregationFunction());
633 }
634 if (null != ctx.specialFunction()) {
635 return visit(ctx.specialFunction());
636 }
637 if (null != ctx.regularFunction()) {
638 return visit(ctx.regularFunction());
639 }
640 throw new IllegalStateException("FunctionCallContext must have aggregationFunction, regularFunction or specialFunction.");
641 }
642
643 @Override
644 public final ASTNode visitAggregationFunction(final AggregationFunctionContext ctx) {
645 String aggregationType = ctx.aggregationFunctionName().getText();
646 return AggregationType.isAggregationType(aggregationType)
647 ? createAggregationSegment(ctx, aggregationType)
648 : new ExpressionProjectionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), getOriginalText(ctx));
649 }
650
651 private ASTNode createAggregationSegment(final AggregationFunctionContext ctx, final String aggregationType) {
652 AggregationType type = AggregationType.valueOf(aggregationType.toUpperCase());
653 if (null != ctx.distinct()) {
654 AggregationDistinctProjectionSegment result =
655 new AggregationDistinctProjectionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), type, getOriginalText(ctx), getDistinctExpression(ctx));
656 result.getParameters().addAll(getExpressions(ctx));
657 return result;
658 }
659 AggregationProjectionSegment result = new AggregationProjectionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), type, getOriginalText(ctx));
660 result.getParameters().addAll(getExpressions(ctx));
661 return result;
662 }
663
664 private Collection<ExpressionSegment> getExpressions(final AggregationFunctionContext ctx) {
665 if (null == ctx.expr()) {
666 return Collections.emptyList();
667 }
668 Collection<ExpressionSegment> result = new LinkedList<>();
669 for (ExprContext each : ctx.expr()) {
670 result.add((ExpressionSegment) visit(each));
671 }
672 return result;
673 }
674
675 private String getDistinctExpression(final AggregationFunctionContext ctx) {
676 StringBuilder result = new StringBuilder();
677 for (int i = 3; i < ctx.getChildCount() - 1; i++) {
678 result.append(ctx.getChild(i).getText());
679 }
680 return result.toString();
681 }
682
683 @Override
684 public final ASTNode visitSpecialFunction(final SpecialFunctionContext ctx) {
685 if (null != ctx.conversionFunction()) {
686 return visit(ctx.conversionFunction());
687 }
688 if (null != ctx.charFunction()) {
689 return visit(ctx.charFunction());
690 }
691 if (null != ctx.openJsonFunction()) {
692 return visit(ctx.openJsonFunction());
693 }
694 if (null != ctx.openRowSetFunction()) {
695 return visit(ctx.openRowSetFunction());
696 }
697 if (null != ctx.jsonFunction()) {
698 return visit(ctx.jsonFunction());
699 }
700 if (null != ctx.windowFunction()) {
701 return visit(ctx.windowFunction());
702 }
703 if (null != ctx.approxFunction()) {
704 return visit(ctx.approxFunction());
705 }
706 if (null != ctx.graphFunction()) {
707 return visit(ctx.graphFunction());
708 }
709 if (null != ctx.trimFunction()) {
710 return visit(ctx.trimFunction());
711 }
712 return new FunctionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getChild(0).getChild(0).getText(), getOriginalText(ctx));
713 }
714
715 private ASTNode getFunctionSegment(final int startIndex, final int stopIndex, final String functionName, final String text, final List<ExprContext> exprList) {
716 FunctionSegment result = new FunctionSegment(startIndex, stopIndex, functionName, text);
717 if (null != exprList) {
718 for (ExprContext each : exprList) {
719 result.getParameters().add((ExpressionSegment) visit(each));
720 }
721 }
722 return result;
723 }
724
725 @Override
726 public ASTNode visitTrimFunction(final TrimFunctionContext ctx) {
727 FunctionSegment result = new FunctionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.TRIM().getText(), getOriginalText(ctx));
728 if (null != ctx.BOTH()) {
729 result.getParameters().add(new LiteralExpressionSegment(ctx.BOTH().getSymbol().getStartIndex(), ctx.BOTH().getSymbol().getStopIndex(),
730 new OtherLiteralValue(ctx.BOTH().getSymbol().getText()).getValue()));
731 }
732 if (null != ctx.TRAILING()) {
733 result.getParameters().add(new LiteralExpressionSegment(ctx.TRAILING().getSymbol().getStartIndex(), ctx.TRAILING().getSymbol().getStopIndex(),
734 new OtherLiteralValue(ctx.TRAILING().getSymbol().getText()).getValue()));
735 }
736 if (null != ctx.LEADING()) {
737 result.getParameters().add(new LiteralExpressionSegment(ctx.LEADING().getSymbol().getStartIndex(), ctx.LEADING().getSymbol().getStopIndex(),
738 new OtherLiteralValue(ctx.LEADING().getSymbol().getText()).getValue()));
739 }
740 for (ExprContext each : ctx.expr()) {
741 result.getParameters().add((ExpressionSegment) visit(each));
742 }
743 return result;
744 }
745
746 @Override
747 public ASTNode visitGraphFunction(final GraphFunctionContext ctx) {
748 if (null != ctx.graphAggFunction()) {
749 return visit(ctx.graphAggFunction());
750 }
751 return new FunctionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getChild(0).getChild(0).getText(), getOriginalText(ctx));
752 }
753
754 @Override
755 public ASTNode visitGraphAggFunction(final GraphAggFunctionContext ctx) {
756 return getFunctionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.graphAggFunctionName().getText(), getOriginalText(ctx), ctx.expr());
757 }
758
759 @Override
760 public final ASTNode visitApproxFunction(final ApproxFunctionContext ctx) {
761 return getFunctionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.funcName.getText(), getOriginalText(ctx), ctx.expr());
762 }
763
764 @Override
765 public final ASTNode visitConversionFunction(final ConversionFunctionContext ctx) {
766 if (null != ctx.castFunction()) {
767 return visit(ctx.castFunction());
768 }
769 if (null != ctx.convertFunction()) {
770 return visit(ctx.convertFunction());
771 }
772 return new FunctionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getChild(0).getChild(0).getText(), getOriginalText(ctx));
773 }
774
775 @Override
776 public final ASTNode visitWindowFunction(final WindowFunctionContext ctx) {
777 FunctionSegment result = new FunctionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.funcName.getText(), getOriginalText(ctx));
778 result.getParameters().add((ExpressionSegment) visit(ctx.expr()));
779 return result;
780 }
781
782 @Override
783 public final ASTNode visitJsonFunction(final JsonFunctionContext ctx) {
784 if (null != ctx.jsonArrayFunction()) {
785 return visit(ctx.jsonArrayFunction());
786 }
787 if (null != ctx.jsonObjectFunction()) {
788 return visit(ctx.jsonObjectFunction());
789 }
790 return new FunctionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText(), getOriginalText(ctx));
791 }
792
793 @Override
794 public final ASTNode visitJsonArrayFunction(final JsonArrayFunctionContext ctx) {
795 FunctionSegment result = (FunctionSegment) getFunctionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.JSON_ARRAY().getText(), getOriginalText(ctx), ctx.expr());
796 if (null != ctx.jsonNullClause()) {
797 result.getParameters().add(new LiteralExpressionSegment(ctx.jsonNullClause().start.getStartIndex(), ctx.jsonNullClause().stop.getStopIndex(), ctx.jsonNullClause().getText()));
798 }
799 return result;
800 }
801
802 @Override
803 public final ASTNode visitJsonObjectFunction(final JsonObjectFunctionContext ctx) {
804 FunctionSegment result = new FunctionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.JSON_OBJECT().getText(), getOriginalText(ctx));
805 if (null != ctx.jsonKeyValue()) {
806 for (JsonKeyValueContext each : ctx.jsonKeyValue()) {
807 result.getParameters().add((ExpressionSegment) visit(each));
808 }
809 }
810 if (null != ctx.jsonNullClause()) {
811 result.getParameters().add((ExpressionSegment) visit(ctx.jsonNullClause()));
812 }
813 return result;
814 }
815
816 @Override
817 public final ASTNode visitJsonNullClause(final JsonNullClauseContext ctx) {
818 return new JsonNullClauseSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), getOriginalText(ctx));
819 }
820
821 @Override
822 public final ASTNode visitJsonKeyValue(final JsonKeyValueContext ctx) {
823 KeyValueSegment result = new KeyValueSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), ctx.getText());
824 if (null != ctx.expr()) {
825 result.setKey((ExpressionSegment) visit(ctx.expr(0)));
826 result.setValue((ExpressionSegment) visit(ctx.expr(1)));
827 }
828 return result;
829 }
830
831 @Override
832 public final ASTNode visitCastFunction(final CastFunctionContext ctx) {
833 calculateParameterCount(Collections.singleton(ctx.expr()));
834 String functionName = null != ctx.CAST() ? ctx.CAST().getText() : ctx.TRY_CAST().getText();
835 FunctionSegment result = new FunctionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), functionName, getOriginalText(ctx));
836 ASTNode exprSegment = visit(ctx.expr());
837 if (exprSegment instanceof ColumnSegment) {
838 result.getParameters().add((ColumnSegment) exprSegment);
839 } else if (exprSegment instanceof LiteralExpressionSegment) {
840 result.getParameters().add((LiteralExpressionSegment) exprSegment);
841 } else if (exprSegment instanceof FunctionSegment) {
842 result.getParameters().add((FunctionSegment) exprSegment);
843 }
844 result.getParameters().add((DataTypeSegment) visit(ctx.dataType()));
845 return result;
846 }
847
848 @Override
849 public ASTNode visitConvertFunction(final ConvertFunctionContext ctx) {
850 String functionName = null != ctx.CONVERT() ? ctx.CONVERT().getText() : ctx.TRY_CONVERT().getText();
851 FunctionSegment result = new FunctionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), functionName, getOriginalText(ctx));
852 result.getParameters().add((DataTypeSegment) visit(ctx.dataType()));
853 result.getParameters().add((ExpressionSegment) visit(ctx.expr()));
854 if (null != ctx.NUMBER_()) {
855 result.getParameters().add(new LiteralExpressionSegment(ctx.NUMBER_().getSymbol().getStartIndex(), ctx.NUMBER_().getSymbol().getStopIndex(), ctx.NUMBER_().getText()));
856 }
857 return result;
858 }
859
860 @Override
861 public final ASTNode visitCharFunction(final CharFunctionContext ctx) {
862 calculateParameterCount(ctx.expr());
863 return new FunctionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.CHAR().getText(), getOriginalText(ctx));
864 }
865
866 @Override
867 public final ASTNode visitOpenJsonFunction(final OpenJsonFunctionContext ctx) {
868 return getFunctionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.OPENJSON().getText(), getOriginalText(ctx), ctx.expr());
869 }
870
871 @Override
872 public final ASTNode visitOpenRowSetFunction(final OpenRowSetFunctionContext ctx) {
873 FunctionSegment result = (FunctionSegment) getFunctionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.OPENROWSET().getText(), getOriginalText(ctx), ctx.expr());
874 if (null != ctx.tableName()) {
875 result.getParameters().add(new LiteralExpressionSegment(ctx.tableName().getStart().getStartIndex(), ctx.tableName().getStop().getStopIndex(), ctx.tableName().getText()));
876 }
877 return result;
878 }
879
880 @Override
881 public ASTNode visitOpenQueryFunction(final OpenQueryFunctionContext ctx) {
882 return getFunctionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.OPENQUERY().getText(), getOriginalText(ctx), ctx.expr());
883 }
884
885 @Override
886 public final ASTNode visitRegularFunction(final RegularFunctionContext ctx) {
887 return getFunctionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.regularFunctionName().getText(), getOriginalText(ctx), ctx.expr());
888 }
889
890 @Override
891 public final ASTNode visitDataTypeName(final DataTypeNameContext ctx) {
892 return new KeywordValue(ctx.getText());
893 }
894
895
896 private void calculateParameterCount(final Collection<ExprContext> exprContexts) {
897 for (ExprContext each : exprContexts) {
898 visit(each);
899 }
900 }
901
902 @Override
903 public final ASTNode visitOrderByItem(final OrderByItemContext ctx) {
904 OrderDirection orderDirection = null == ctx.DESC() ? OrderDirection.ASC : OrderDirection.DESC;
905 if (null != ctx.columnName()) {
906 ColumnSegment column = (ColumnSegment) visit(ctx.columnName());
907 return new ColumnOrderByItemSegment(column, orderDirection, null);
908 }
909 if (null != ctx.numberLiterals()) {
910 return new IndexOrderByItemSegment(ctx.numberLiterals().getStart().getStartIndex(), ctx.numberLiterals().getStop().getStopIndex(),
911 SQLUtils.getExactlyNumber(ctx.numberLiterals().getText(), 10).intValue(), orderDirection, null);
912 }
913 return new ExpressionOrderByItemSegment(ctx.expr().getStart().getStartIndex(), ctx.expr().getStop().getStopIndex(), getOriginalText(ctx.expr()), orderDirection, null,
914 (ExpressionSegment) visit(ctx.expr()));
915 }
916
917 @Override
918 public final ASTNode visitDataType(final DataTypeContext ctx) {
919 DataTypeSegment result = new DataTypeSegment();
920 result.setDataTypeName(((KeywordValue) visit(ctx.dataTypeName())).getValue());
921 result.setStartIndex(ctx.start.getStartIndex());
922 result.setStopIndex(ctx.stop.getStopIndex());
923 if (null != ctx.dataTypeLength()) {
924 DataTypeLengthSegment dataTypeLengthSegment = (DataTypeLengthSegment) visit(ctx.dataTypeLength());
925 result.setDataLength(dataTypeLengthSegment);
926 }
927 return result;
928 }
929
930 @Override
931 public final ASTNode visitDataTypeLength(final DataTypeLengthContext ctx) {
932 DataTypeLengthSegment result = new DataTypeLengthSegment();
933 result.setStartIndex(ctx.start.getStartIndex());
934 result.setStopIndex(ctx.stop.getStartIndex());
935 List<TerminalNode> numbers = ctx.NUMBER_();
936 if (numbers.size() == 1) {
937 result.setPrecision(Integer.parseInt(numbers.get(0).getText()));
938 }
939 if (numbers.size() == 2) {
940 result.setPrecision(Integer.parseInt(numbers.get(0).getText()));
941 result.setScale(Integer.parseInt(numbers.get(1).getText()));
942 }
943 return result;
944 }
945
946 @Override
947 public final ASTNode visitViewName(final ViewNameContext ctx) {
948 SimpleTableSegment result = new SimpleTableSegment(new TableNameSegment(ctx.name().getStart().getStartIndex(),
949 ctx.name().getStop().getStopIndex(), (IdentifierValue) visit(ctx.name())));
950 OwnerContext owner = ctx.owner();
951 if (null != owner) {
952 result.setOwner(new OwnerSegment(owner.getStart().getStartIndex(), owner.getStop().getStopIndex(), (IdentifierValue) visit(owner.identifier())));
953 }
954 return result;
955 }
956
957 @Override
958 public ASTNode visitSelect(final SelectContext ctx) {
959 SQLServerSelectStatement result = (SQLServerSelectStatement) visit(ctx.aggregationClause());
960 result.addParameterMarkerSegments(getParameterMarkerSegments());
961 return result;
962 }
963
964 @Override
965 public ASTNode visitAggregationClause(final AggregationClauseContext ctx) {
966
967 return visit(ctx.selectClause(0));
968 }
969
970 @Override
971 public ASTNode visitSelectClause(final SelectClauseContext ctx) {
972 SQLServerSelectStatement result = new SQLServerSelectStatement();
973 result.setProjections((ProjectionsSegment) visit(ctx.projections()));
974 if (null != ctx.selectWithClause() && null != ctx.selectWithClause().cteClauseSet()) {
975 Collection<CommonTableExpressionSegment> commonTableExpressionSegments = getCommonTableExpressionSegmentsUsingCteClauseSet(ctx.selectWithClause().cteClauseSet());
976 WithSegment withSegment = new WithSegment(ctx.selectWithClause().start.getStartIndex(), ctx.selectWithClause().stop.getStopIndex(), commonTableExpressionSegments);
977 result.setWithSegment(withSegment);
978 }
979 if (null != ctx.duplicateSpecification()) {
980 result.getProjections().setDistinctRow(isDistinct(ctx));
981 }
982 if (null != ctx.intoClause()) {
983 result.setIntoSegment((TableSegment) visit(ctx.intoClause()));
984 }
985 if (null != ctx.fromClause()) {
986 TableSegment tableSource = (TableSegment) visit(ctx.fromClause().tableReferences());
987 result.setFrom(tableSource);
988 }
989 if (null != ctx.withTableHint()) {
990 result.setWithTableHintSegment((WithTableHintSegment) visit(ctx.withTableHint()));
991 }
992 if (null != ctx.whereClause()) {
993 result.setWhere((WhereSegment) visit(ctx.whereClause()));
994 }
995 if (null != ctx.groupByClause()) {
996 result.setGroupBy((GroupBySegment) visit(ctx.groupByClause()));
997 }
998 if (null != ctx.havingClause()) {
999 result.setHaving((HavingSegment) visit(ctx.havingClause()));
1000 }
1001 if (null != ctx.orderByClause()) {
1002 result.setOrderBy(getOrderBySegment(ctx.orderByClause()));
1003 result.setLimit(getLimitSegment(ctx.orderByClause()));
1004 }
1005 return result;
1006 }
1007
1008 private Collection<CommonTableExpressionSegment> getCommonTableExpressionSegmentsUsingCteClauseSet(final CteClauseSetContext ctx) {
1009 Collection<CommonTableExpressionSegment> result = new LinkedList<>();
1010 for (CteClauseContext each : ctx.cteClause()) {
1011 SubquerySegment subquery = new SubquerySegment(each.subquery().aggregationClause().start.getStartIndex(),
1012 each.subquery().aggregationClause().stop.getStopIndex(), (SQLServerSelectStatement) visit(each.subquery()), getOriginalText(each.subquery()));
1013 IdentifierValue identifier = (IdentifierValue) visit(each.identifier());
1014 CommonTableExpressionSegment commonTableExpression = new CommonTableExpressionSegment(each.start.getStartIndex(), each.stop.getStopIndex(), identifier, subquery);
1015 if (null != each.columnNames()) {
1016 ColumnNamesContext columnNames = each.columnNames();
1017 CollectionValue<ColumnSegment> columns = (CollectionValue<ColumnSegment>) visit(columnNames);
1018 commonTableExpression.getColumns().addAll(columns.getValue());
1019 }
1020 result.add(commonTableExpression);
1021 }
1022 return result;
1023 }
1024
1025 @Override
1026 public ASTNode visitHavingClause(final HavingClauseContext ctx) {
1027 ExpressionSegment expr = (ExpressionSegment) visit(ctx.expr());
1028 return new HavingSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), expr);
1029 }
1030
1031 private LimitSegment getLimitSegment(final OrderByClauseContext ctx) {
1032 LimitSegment result = null;
1033 PaginationValueSegment offset = null;
1034 PaginationValueSegment rowcount = null;
1035 if (null != ctx.OFFSET()) {
1036 ASTNode astNode = visit(ctx.expr(0));
1037 if (astNode instanceof LiteralExpressionSegment && ((LiteralExpressionSegment) astNode).getLiterals() instanceof Number) {
1038 offset = new NumberLiteralLimitValueSegment(ctx.expr(0).start.getStartIndex(), ctx.expr(0).stop.getStopIndex(),
1039 ((Number) ((LiteralExpressionSegment) astNode).getLiterals()).longValue());
1040 } else if (astNode instanceof ParameterMarkerExpressionSegment) {
1041 offset = new ParameterMarkerLimitValueSegment(ctx.expr(0).start.getStartIndex(), ctx.expr(0).stop.getStopIndex(), parameterMarkerSegments.size() - 1);
1042 }
1043 }
1044 if (null != ctx.FETCH()) {
1045 ASTNode astNode = visit(ctx.expr(1));
1046 if (astNode instanceof LiteralExpressionSegment && ((LiteralExpressionSegment) astNode).getLiterals() instanceof Number) {
1047 rowcount = new NumberLiteralLimitValueSegment(ctx.expr(1).start.getStartIndex(), ctx.expr(1).stop.getStopIndex(),
1048 ((Number) ((LiteralExpressionSegment) astNode).getLiterals()).longValue());
1049 } else if (astNode instanceof ParameterMarkerExpressionSegment) {
1050 rowcount = new ParameterMarkerLimitValueSegment(ctx.expr(1).start.getStartIndex(), ctx.expr(1).stop.getStopIndex(), parameterMarkerSegments.size() - 1);
1051 }
1052 }
1053 if (null != offset) {
1054 result = new LimitSegment(ctx.OFFSET().getSymbol().getStartIndex(), ctx.stop.getStopIndex(), offset, rowcount);
1055 }
1056 return result;
1057 }
1058
1059 private OrderBySegment getOrderBySegment(final OrderByClauseContext ctx) {
1060 Collection<OrderByItemSegment> items = new LinkedList<>();
1061 int orderByStartIndex = ctx.start.getStartIndex();
1062 int orderByStopIndex = ctx.start.getStartIndex();
1063 for (OrderByItemContext each : ctx.orderByItem()) {
1064 items.add((OrderByItemSegment) visit(each));
1065 orderByStopIndex = each.stop.getStopIndex();
1066 }
1067 return new OrderBySegment(orderByStartIndex, orderByStopIndex, items);
1068 }
1069
1070 private boolean isDistinct(final SelectClauseContext ctx) {
1071 return ((BooleanLiteralValue) visit(ctx.duplicateSpecification())).getValue();
1072 }
1073
1074 @Override
1075 public ASTNode visitProjections(final ProjectionsContext ctx) {
1076 List<ProjectionSegment> projections = new LinkedList<>();
1077 if (null != ctx.top()) {
1078 projections.add((ProjectionSegment) visit(ctx.top()));
1079 }
1080 for (ProjectionContext each : ctx.projection()) {
1081 projections.add((ProjectionSegment) visit(each));
1082 }
1083 ProjectionsSegment result = new ProjectionsSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex());
1084 result.getProjections().addAll(projections);
1085 return result;
1086 }
1087
1088 @Override
1089 public ASTNode visitTableReferences(final TableReferencesContext ctx) {
1090 TableSegment result = (TableSegment) visit(ctx.tableReference(0));
1091 if (ctx.tableReference().size() > 1) {
1092 for (int i = 1; i < ctx.tableReference().size(); i++) {
1093 result = generateJoinTableSourceFromTableReference(ctx.tableReference(i), result);
1094 }
1095 }
1096 return result;
1097 }
1098
1099 private JoinTableSegment generateJoinTableSourceFromTableReference(final TableReferenceContext ctx, final TableSegment tableSegment) {
1100 JoinTableSegment result = new JoinTableSegment();
1101 result.setStartIndex(tableSegment.getStartIndex());
1102 result.setStopIndex(ctx.stop.getStopIndex());
1103 result.setLeft(tableSegment);
1104 result.setRight((TableSegment) visit(ctx));
1105 result.setJoinType(JoinType.COMMA.name());
1106 return result;
1107 }
1108
1109 @Override
1110 public ASTNode visitWhereClause(final WhereClauseContext ctx) {
1111 return new WhereSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), (ExpressionSegment) visit(ctx.expr()));
1112 }
1113
1114 @Override
1115 public ASTNode visitGroupByClause(final GroupByClauseContext ctx) {
1116 Collection<OrderByItemSegment> items = new LinkedList<>();
1117 for (OrderByItemContext each : ctx.orderByItem()) {
1118 items.add((OrderByItemSegment) visit(each));
1119 }
1120 return new GroupBySegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), items);
1121 }
1122
1123
1124
1125
1126
1127
1128
1129 protected String getOriginalText(final ParserRuleContext ctx) {
1130 return ctx.start.getInputStream().getText(new Interval(ctx.start.getStartIndex(), ctx.stop.getStopIndex()));
1131 }
1132
1133 @Override
1134 public ASTNode visitInsert(final InsertContext ctx) {
1135 SQLServerInsertStatement result;
1136 if (null != ctx.insertDefaultValue()) {
1137 result = (SQLServerInsertStatement) visit(ctx.insertDefaultValue());
1138 } else if (null != ctx.insertValuesClause()) {
1139 result = (SQLServerInsertStatement) visit(ctx.insertValuesClause());
1140 } else if (null != ctx.insertExecClause()) {
1141 result = (SQLServerInsertStatement) visit(ctx.insertExecClause());
1142 } else {
1143 result = (SQLServerInsertStatement) visit(ctx.insertSelectClause());
1144 }
1145 if (null != ctx.withClause()) {
1146 result.setWithSegment((WithSegment) visit(ctx.withClause()));
1147 }
1148 if (null != ctx.withTableHint()) {
1149 result.setWithTableHintSegment((WithTableHintSegment) visit(ctx.withTableHint()));
1150 }
1151 if (null != ctx.tableName()) {
1152 result.setTable((SimpleTableSegment) visit(ctx.tableName()));
1153 }
1154 if (null != ctx.rowSetFunction()) {
1155 result.setRowSetFunctionSegment((FunctionSegment) visit(ctx.rowSetFunction()));
1156 }
1157 result.addParameterMarkerSegments(getParameterMarkerSegments());
1158 return result;
1159 }
1160
1161 @Override
1162 public ASTNode visitRowSetFunction(final RowSetFunctionContext ctx) {
1163 if (null != ctx.openRowSetFunction()) {
1164 return visit(ctx.openRowSetFunction());
1165 } else {
1166 return visit(ctx.openQueryFunction());
1167 }
1168 }
1169
1170 @Override
1171 public ASTNode visitWithTableHint(final WithTableHintContext ctx) {
1172 WithTableHintSegment result = new WithTableHintSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex());
1173 if (null != ctx.tableHintLimited()) {
1174 Collection<TableHintLimitedSegment> tableHintLimitedSegments = new LinkedList<>();
1175 for (TableHintLimitedContext each : ctx.tableHintLimited()) {
1176 tableHintLimitedSegments.add((TableHintLimitedSegment) visit(each));
1177 }
1178 result.getTableHintLimitedSegments().addAll(tableHintLimitedSegments);
1179 }
1180 return result;
1181 }
1182
1183 @Override
1184 public ASTNode visitTableHintLimited(final TableHintLimitedContext ctx) {
1185 TableHintLimitedSegment result = new TableHintLimitedSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex());
1186 result.setValue(ctx.getText());
1187 return result;
1188 }
1189
1190 @Override
1191 public ASTNode visitInsertDefaultValue(final InsertDefaultValueContext ctx) {
1192 SQLServerInsertStatement result = new SQLServerInsertStatement();
1193 result.setInsertColumns(createInsertColumns(ctx.columnNames(), ctx.start.getStartIndex()));
1194 if (null != ctx.outputClause()) {
1195 result.setOutputSegment((OutputSegment) visit(ctx.outputClause()));
1196 }
1197 return result;
1198 }
1199
1200 @Override
1201 public ASTNode visitInsertExecClause(final InsertExecClauseContext ctx) {
1202 SQLServerInsertStatement result = new SQLServerInsertStatement();
1203 result.setInsertColumns(createInsertColumns(ctx.columnNames(), ctx.start.getStartIndex()));
1204 result.setExecSegment((ExecSegment) visit(ctx.exec()));
1205 return result;
1206 }
1207
1208 @Override
1209 public ASTNode visitExec(final ExecContext ctx) {
1210 ExecSegment result = new ExecSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex());
1211 if (null != ctx.procedureName()) {
1212 result.setProcedureName((FunctionNameSegment) visitProcedureName(ctx.procedureName()));
1213 }
1214 if (null != ctx.expr()) {
1215 Collection<ExpressionSegment> items = new LinkedList<>();
1216 for (ExprContext each : ctx.expr()) {
1217 items.add((ExpressionSegment) visit(each));
1218 }
1219 result.getExpressionSegments().addAll(items);
1220 }
1221 return result;
1222 }
1223
1224 @Override
1225 public ASTNode visitProcedureName(final ProcedureNameContext ctx) {
1226 FunctionNameSegment result = new FunctionNameSegment(ctx.name().start.getStartIndex(), ctx.name().stop.getStopIndex(), (IdentifierValue) visit(ctx.name()));
1227 if (null != ctx.owner()) {
1228 result.setOwner(new OwnerSegment(ctx.owner().start.getStartIndex(), ctx.owner().stop.getStopIndex(), (IdentifierValue) visit(ctx.owner())));
1229 }
1230 return result;
1231 }
1232
1233 @Override
1234 public ASTNode visitOutputClause(final OutputClauseContext ctx) {
1235 OutputSegment result = new OutputSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex());
1236 if (null != ctx.outputWithColumns()) {
1237 OutputWithColumnsContext outputWithColumnsContext = ctx.outputWithColumns();
1238 ProjectionsSegment outputColumns = new ProjectionsSegment(outputWithColumnsContext.start.getStartIndex(), outputWithColumnsContext.stop.getStopIndex());
1239 for (int i = 0; i < outputWithColumnsContext.getChildCount(); i += 2) {
1240 ParseTree each = outputWithColumnsContext.getChild(i);
1241 if (each instanceof OutputWithColumnContext) {
1242 outputColumns.getProjections().add(createColumnProjectionSegment((OutputWithColumnContext) each));
1243 }
1244 if (each instanceof ScalarExpressionContext) {
1245 outputColumns.getProjections().add(createScalarExpressionContext((ScalarExpressionContext) each));
1246 }
1247 }
1248 result.setOutputColumns(outputColumns);
1249 }
1250 if (null != ctx.outputTableName()) {
1251 if (null != ctx.outputTableName().tableName()) {
1252 result.setTable((SimpleTableSegment) visit(ctx.outputTableName().tableName()));
1253 }
1254 if (null != ctx.columnNames()) {
1255 ColumnNamesContext columnNames = ctx.columnNames();
1256 CollectionValue<ColumnSegment> columns = (CollectionValue<ColumnSegment>) visit(columnNames);
1257 result.getTableColumns().addAll(columns.getValue());
1258 }
1259 }
1260 return result;
1261 }
1262
1263 private ProjectionSegment createScalarExpressionContext(final ScalarExpressionContext context) {
1264 ExpressionProjectionSegment result = new ExpressionProjectionSegment(context.start.getStartIndex(), context.stop.getStopIndex(),
1265 getOriginalText(context), (ExpressionSegment) visit(context.expr()));
1266 if (null != context.alias()) {
1267 result.setAlias(new AliasSegment(context.alias().start.getStartIndex(), context.alias().stop.getStopIndex(), new IdentifierValue(context.alias().getText())));
1268 }
1269 return result;
1270 }
1271
1272 private ProjectionSegment createColumnProjectionSegment(final OutputWithColumnContext context) {
1273 ColumnSegment column = new ColumnSegment(context.start.getStartIndex(), context.stop.getStopIndex(), new IdentifierValue(context.name().getText()));
1274 ColumnProjectionSegment result = new ColumnProjectionSegment(column);
1275 if (null != context.alias()) {
1276 result.setAlias(new AliasSegment(context.alias().start.getStartIndex(), context.alias().stop.getStopIndex(), new IdentifierValue(context.alias().getText())));
1277 }
1278 return result;
1279 }
1280
1281 @Override
1282 public ASTNode visitInsertValuesClause(final InsertValuesClauseContext ctx) {
1283 SQLServerInsertStatement result = new SQLServerInsertStatement();
1284 result.setInsertColumns(createInsertColumns(ctx.columnNames(), ctx.start.getStartIndex()));
1285 result.getValues().addAll(createInsertValuesSegments(ctx.assignmentValues()));
1286 if (null != ctx.outputClause()) {
1287 result.setOutputSegment((OutputSegment) visit(ctx.outputClause()));
1288 }
1289 return result;
1290 }
1291
1292 private Collection<InsertValuesSegment> createInsertValuesSegments(final Collection<AssignmentValuesContext> assignmentValuesContexts) {
1293 Collection<InsertValuesSegment> result = new LinkedList<>();
1294 for (AssignmentValuesContext each : assignmentValuesContexts) {
1295 result.add((InsertValuesSegment) visit(each));
1296 }
1297 return result;
1298 }
1299
1300 @Override
1301 public ASTNode visitInsertSelectClause(final InsertSelectClauseContext ctx) {
1302 SQLServerInsertStatement result = new SQLServerInsertStatement();
1303 result.setInsertColumns(createInsertColumns(ctx.columnNames(), ctx.start.getStartIndex()));
1304 result.setInsertSelect(createInsertSelectSegment(ctx));
1305 if (null != ctx.outputClause()) {
1306 result.setOutputSegment((OutputSegment) visit(ctx.outputClause()));
1307 }
1308 return result;
1309 }
1310
1311 @SuppressWarnings("unchecked")
1312 private InsertColumnsSegment createInsertColumns(final ColumnNamesContext columnNames, final int startIndex) {
1313 if (null == columnNames) {
1314 return new InsertColumnsSegment(startIndex - 1, startIndex - 1, Collections.emptyList());
1315 } else {
1316 CollectionValue<ColumnSegment> columnSegments = (CollectionValue<ColumnSegment>) visit(columnNames);
1317 return new InsertColumnsSegment(columnNames.start.getStartIndex(), columnNames.stop.getStopIndex(), columnSegments.getValue());
1318 }
1319 }
1320
1321 private SubquerySegment createInsertSelectSegment(final InsertSelectClauseContext ctx) {
1322 SQLServerSelectStatement selectStatement = (SQLServerSelectStatement) visit(ctx.select());
1323 return new SubquerySegment(ctx.select().start.getStartIndex(), ctx.select().stop.getStopIndex(), selectStatement, getOriginalText(ctx.select()));
1324 }
1325
1326 @Override
1327 public ASTNode visitWithClause(final WithClauseContext ctx) {
1328 Collection<CommonTableExpressionSegment> commonTableExpressionSegments = getCommonTableExpressionSegmentsUsingCteClauseSet(ctx.cteClauseSet());
1329 return new WithSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), commonTableExpressionSegments);
1330 }
1331
1332 @Override
1333 public ASTNode visitUpdate(final UpdateContext ctx) {
1334 SQLServerUpdateStatement result = new SQLServerUpdateStatement();
1335 if (null != ctx.withClause()) {
1336 result.setWithSegment((WithSegment) visit(ctx.withClause()));
1337 }
1338 result.setTable((TableSegment) visit(ctx.tableReferences()));
1339 result.setSetAssignment((SetAssignmentSegment) visit(ctx.setAssignmentsClause()));
1340 if (null != ctx.withTableHint()) {
1341 result.setWithTableHintSegment((WithTableHintSegment) visit(ctx.withTableHint()));
1342 }
1343 if (null != ctx.whereClause()) {
1344 result.setWhere((WhereSegment) visit(ctx.whereClause()));
1345 }
1346 if (null != ctx.optionHint()) {
1347 result.setOptionHintSegment((OptionHintSegment) visit(ctx.optionHint()));
1348 }
1349 if (null != ctx.outputClause()) {
1350 result.setOutputSegment((OutputSegment) visit(ctx.outputClause()));
1351 }
1352 result.addParameterMarkerSegments(getParameterMarkerSegments());
1353 return result;
1354 }
1355
1356 @Override
1357 public ASTNode visitOptionHint(final OptionHintContext ctx) {
1358 return new OptionHintSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), getOriginalText(ctx));
1359 }
1360
1361 @Override
1362 public ASTNode visitSetAssignmentsClause(final SetAssignmentsClauseContext ctx) {
1363 Collection<ColumnAssignmentSegment> assignments = new LinkedList<>();
1364 for (AssignmentContext each : ctx.assignment()) {
1365 assignments.add((ColumnAssignmentSegment) visit(each));
1366 }
1367 SetAssignmentSegment result = new SetAssignmentSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), assignments);
1368 if (null != ctx.fromClause()) {
1369 result.setFrom((TableSegment) visit(ctx.fromClause()));
1370 }
1371 return result;
1372 }
1373
1374 @Override
1375 public ASTNode visitAssignmentValues(final AssignmentValuesContext ctx) {
1376 List<ExpressionSegment> segments = new LinkedList<>();
1377 for (AssignmentValueContext each : ctx.assignmentValue()) {
1378 segments.add((ExpressionSegment) visit(each));
1379 }
1380 return new InsertValuesSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), segments);
1381 }
1382
1383 @Override
1384 public ASTNode visitAssignment(final AssignmentContext ctx) {
1385 ColumnSegment column = (ColumnSegment) visitColumnName(ctx.columnName());
1386 List<ColumnSegment> columnSegments = new LinkedList<>();
1387 columnSegments.add(column);
1388 ExpressionSegment value = (ExpressionSegment) visit(ctx.assignmentValue());
1389 return new ColumnAssignmentSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), columnSegments, value);
1390 }
1391
1392 @Override
1393 public ASTNode visitAssignmentValue(final AssignmentValueContext ctx) {
1394 ExprContext expr = ctx.expr();
1395 if (null != expr) {
1396 return visit(expr);
1397 }
1398 return new CommonExpressionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), ctx.getText());
1399 }
1400
1401 @Override
1402 public ASTNode visitDelete(final DeleteContext ctx) {
1403 SQLServerDeleteStatement result = new SQLServerDeleteStatement();
1404 if (null != ctx.withClause()) {
1405 result.setWithSegment((WithSegment) visit(ctx.withClause()));
1406 }
1407 if (null != ctx.multipleTablesClause()) {
1408 result.setTable((TableSegment) visit(ctx.multipleTablesClause()));
1409 } else {
1410 result.setTable((TableSegment) visit(ctx.singleTableClause()));
1411 }
1412 if (null != ctx.outputClause()) {
1413 result.setOutputSegment((OutputSegment) visit(ctx.outputClause()));
1414 }
1415 if (null != ctx.whereClause()) {
1416 result.setWhere((WhereSegment) visit(ctx.whereClause()));
1417 }
1418 if (null != ctx.outputClause()) {
1419 result.setOutputSegment((OutputSegment) visit(ctx.outputClause()));
1420 }
1421 result.addParameterMarkerSegments(getParameterMarkerSegments());
1422 return result;
1423 }
1424
1425 @Override
1426 public ASTNode visitSingleTableClause(final SingleTableClauseContext ctx) {
1427 SimpleTableSegment result = (SimpleTableSegment) visit(ctx.tableName());
1428 if (null != ctx.alias()) {
1429 result.setAlias((AliasSegment) visit(ctx.alias()));
1430 }
1431 return result;
1432 }
1433
1434 @Override
1435 public ASTNode visitMultipleTablesClause(final MultipleTablesClauseContext ctx) {
1436 DeleteMultiTableSegment result = new DeleteMultiTableSegment();
1437 TableSegment relateTableSource = (TableSegment) visit(ctx.tableReferences());
1438 result.setRelationTable(relateTableSource);
1439 result.setActualDeleteTables(generateTablesFromTableMultipleTableNames(ctx.multipleTableNames()));
1440 return result;
1441 }
1442
1443 private List<SimpleTableSegment> generateTablesFromTableMultipleTableNames(final MultipleTableNamesContext ctx) {
1444 List<SimpleTableSegment> result = new LinkedList<>();
1445 for (TableNameContext each : ctx.tableName()) {
1446 result.add((SimpleTableSegment) visit(each));
1447 }
1448 return result;
1449 }
1450
1451 @Override
1452 public ASTNode visitDuplicateSpecification(final DuplicateSpecificationContext ctx) {
1453 return new BooleanLiteralValue(null != ctx.DISTINCT());
1454 }
1455
1456 @Override
1457 public ASTNode visitProjection(final ProjectionContext ctx) {
1458 if (null != ctx.qualifiedShorthand()) {
1459 QualifiedShorthandContext shorthand = ctx.qualifiedShorthand();
1460 ShorthandProjectionSegment result = new ShorthandProjectionSegment(shorthand.getStart().getStartIndex(), shorthand.getStop().getStopIndex());
1461 IdentifierValue identifier = new IdentifierValue(shorthand.identifier().getText());
1462 result.setOwner(new OwnerSegment(shorthand.identifier().getStart().getStartIndex(), shorthand.identifier().getStop().getStopIndex(), identifier));
1463 return result;
1464 }
1465 if (null != ctx.unqualifiedShorthand()) {
1466 return new ShorthandProjectionSegment(ctx.unqualifiedShorthand().getStart().getStartIndex(), ctx.unqualifiedShorthand().getStop().getStopIndex());
1467 }
1468 AliasSegment alias = null == ctx.alias() ? null : (AliasSegment) visit(ctx.alias());
1469 if (null != ctx.columnName()) {
1470 ColumnSegment column = (ColumnSegment) visit(ctx.columnName());
1471 ColumnProjectionSegment result = new ColumnProjectionSegment(column);
1472 result.setAlias(alias);
1473 return result;
1474 }
1475 return createProjection(ctx, alias);
1476 }
1477
1478 @Override
1479 public ASTNode visitTop(final TopContext ctx) {
1480 int startIndex = ctx.topNum().getStart().getStartIndex();
1481 int stopIndex = ctx.topNum().getStop().getStopIndex();
1482 ASTNode topNum = visit(ctx.topNum());
1483 if (topNum instanceof NumberLiteralValue) {
1484 NumberLiteralRowNumberValueSegment rowNumberSegment = new NumberLiteralRowNumberValueSegment(startIndex, stopIndex, ((NumberLiteralValue) topNum).getValue().longValue(), false);
1485 return new TopProjectionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), rowNumberSegment, null != ctx.alias() ? ctx.alias().getText() : null);
1486 }
1487 ParameterMarkerSegment parameterSegment = new ParameterMarkerRowNumberValueSegment(startIndex, stopIndex, ((ParameterMarkerValue) topNum).getValue(), false);
1488 parameterMarkerSegments.add(parameterSegment);
1489 return new TopProjectionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex(), (RowNumberValueSegment) parameterSegment, null != ctx.alias() ? ctx.alias().getText() : null);
1490 }
1491
1492 @Override
1493 public ASTNode visitAlias(final AliasContext ctx) {
1494 if (null != ctx.identifier()) {
1495 return new AliasSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), (IdentifierValue) visit(ctx.identifier()));
1496 }
1497 if (null != ctx.NCHAR_TEXT()) {
1498 return new AliasSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), new IdentifierValue(ctx.NCHAR_TEXT().getText().substring(1)));
1499 }
1500 return new AliasSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), new IdentifierValue(ctx.STRING_().getText()));
1501 }
1502
1503 private ASTNode createProjection(final ProjectionContext ctx, final AliasSegment alias) {
1504 ASTNode projection = visit(ctx.expr());
1505 if (projection instanceof AggregationProjectionSegment) {
1506 ((AggregationProjectionSegment) projection).setAlias(alias);
1507 return projection;
1508 }
1509 if (projection instanceof ExpressionProjectionSegment) {
1510 ((ExpressionProjectionSegment) projection).setAlias(alias);
1511 return projection;
1512 }
1513 if (projection instanceof FunctionSegment) {
1514 FunctionSegment segment = (FunctionSegment) projection;
1515 ExpressionProjectionSegment result = new ExpressionProjectionSegment(segment.getStartIndex(), segment.getStopIndex(), segment.getText(), segment);
1516 result.setAlias(alias);
1517 return result;
1518 }
1519 if (projection instanceof CommonExpressionSegment) {
1520 CommonExpressionSegment segment = (CommonExpressionSegment) projection;
1521 ExpressionProjectionSegment result = new ExpressionProjectionSegment(segment.getStartIndex(), segment.getStopIndex(), segment.getText(), segment);
1522 result.setAlias(alias);
1523 return result;
1524 }
1525
1526 if (projection instanceof ColumnSegment) {
1527 ColumnProjectionSegment result = new ColumnProjectionSegment((ColumnSegment) projection);
1528 result.setAlias(alias);
1529 return result;
1530 }
1531 if (projection instanceof SubqueryExpressionSegment) {
1532 SubqueryExpressionSegment subqueryExpressionSegment = (SubqueryExpressionSegment) projection;
1533 String text = ctx.start.getInputStream().getText(new Interval(subqueryExpressionSegment.getStartIndex(), subqueryExpressionSegment.getStopIndex()));
1534 SubqueryProjectionSegment result = new SubqueryProjectionSegment(((SubqueryExpressionSegment) projection).getSubquery(), text);
1535 result.setAlias(alias);
1536 return result;
1537 }
1538 if (projection instanceof BinaryOperationExpression) {
1539 BinaryOperationExpression binaryExpression = (BinaryOperationExpression) projection;
1540 int startIndex = getStartIndexWithAlias(binaryExpression, alias);
1541 int stopIndex = getStopIndexWithAlias(binaryExpression, alias);
1542 ExpressionProjectionSegment result = new ExpressionProjectionSegment(startIndex, stopIndex, binaryExpression.getText(), binaryExpression);
1543 result.setAlias(alias);
1544 return result;
1545 }
1546 if (projection instanceof ParameterMarkerExpressionSegment) {
1547 ParameterMarkerExpressionSegment result = (ParameterMarkerExpressionSegment) projection;
1548 result.setAlias(alias);
1549 return projection;
1550 }
1551 LiteralExpressionSegment column = (LiteralExpressionSegment) projection;
1552 ExpressionProjectionSegment result = new ExpressionProjectionSegment(getStartIndexWithAlias(column, alias), getStopIndexWithAlias(column, alias), String.valueOf(column.getLiterals()), column);
1553 result.setAlias(alias);
1554 return result;
1555 }
1556
1557 private int getStartIndexWithAlias(final SQLSegment sqlSegment, final AliasSegment alias) {
1558 return null != alias && alias.getStartIndex() < sqlSegment.getStartIndex() ? alias.getStartIndex() : sqlSegment.getStartIndex();
1559 }
1560
1561 private int getStopIndexWithAlias(final SQLSegment sqlSegment, final AliasSegment alias) {
1562 return null != alias && alias.getStopIndex() > sqlSegment.getStopIndex() ? alias.getStopIndex() : sqlSegment.getStopIndex();
1563 }
1564
1565 @Override
1566 public ASTNode visitIntoClause(final IntoClauseContext ctx) {
1567 return visit(ctx.tableName());
1568 }
1569
1570 @Override
1571 public ASTNode visitFromClause(final FromClauseContext ctx) {
1572 return visit(ctx.tableReferences());
1573 }
1574
1575 @Override
1576 public ASTNode visitTableReference(final TableReferenceContext ctx) {
1577 TableSegment result;
1578 TableSegment left;
1579 left = (TableSegment) visit(ctx.tableFactor());
1580 if (!ctx.joinedTable().isEmpty()) {
1581 for (JoinedTableContext each : ctx.joinedTable()) {
1582 left = visitJoinedTable(each, left);
1583 }
1584 }
1585 result = left;
1586 return result;
1587 }
1588
1589 @Override
1590 public ASTNode visitTableFactor(final TableFactorContext ctx) {
1591 if (null != ctx.subquery()) {
1592 SubquerySegment subquerySegment = new SubquerySegment(ctx.subquery().start.getStartIndex(), ctx.subquery().stop.getStopIndex(), getOriginalText(ctx.subquery()));
1593 if (null != ctx.subquery().merge()) {
1594 subquerySegment.setMerge((MergeStatement) visit(ctx.subquery()));
1595 } else {
1596 subquerySegment.setSelect((SQLServerSelectStatement) visit(ctx.subquery()));
1597 }
1598 SubqueryTableSegment result = new SubqueryTableSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), subquerySegment);
1599 if (null != ctx.alias()) {
1600 result.setAlias((AliasSegment) visit(ctx.alias()));
1601 }
1602 return result;
1603 }
1604 if (null != ctx.tableName()) {
1605 SimpleTableSegment result = (SimpleTableSegment) visit(ctx.tableName());
1606 if (null != ctx.alias()) {
1607 result.setAlias((AliasSegment) visit(ctx.alias()));
1608 }
1609 return result;
1610 }
1611 if (null != ctx.expr()) {
1612 ExpressionSegment exprSegment = (ExpressionSegment) visit(ctx.expr());
1613 FunctionTableSegment result = new FunctionTableSegment(exprSegment.getStartIndex(), exprSegment.getStopIndex(), exprSegment);
1614 if (null != ctx.alias()) {
1615 result.setAlias((AliasSegment) visit(ctx.alias()));
1616 }
1617 return result;
1618 }
1619 return visit(ctx.tableReferences());
1620 }
1621
1622 private JoinTableSegment visitJoinedTable(final JoinedTableContext ctx, final TableSegment tableSegment) {
1623 JoinTableSegment result = new JoinTableSegment();
1624 result.setLeft(tableSegment);
1625 result.setStartIndex(tableSegment.getStartIndex());
1626 result.setStopIndex(ctx.stop.getStopIndex());
1627 TableSegment right = (TableSegment) visit(ctx.tableFactor());
1628 result.setRight(right);
1629 result.setJoinType(getJoinType(ctx));
1630 if (null != ctx.joinSpecification()) {
1631 visitJoinSpecification(ctx.joinSpecification(), result);
1632 }
1633 return result;
1634 }
1635
1636 private String getJoinType(final JoinedTableContext ctx) {
1637 if (null != ctx.LEFT()) {
1638 return JoinType.LEFT.name();
1639 } else if (null != ctx.RIGHT()) {
1640 return JoinType.RIGHT.name();
1641 } else if (null != ctx.FULL()) {
1642 return JoinType.FULL.name();
1643 } else if (null != ctx.INNER()) {
1644 return JoinType.INNER.name();
1645 } else if (null != ctx.CROSS()) {
1646 return JoinType.CROSS.name();
1647 }
1648 return JoinType.INNER.name();
1649 }
1650
1651 private void visitJoinSpecification(final JoinSpecificationContext ctx, final JoinTableSegment joinTableSource) {
1652 if (null != ctx.expr()) {
1653 ExpressionSegment condition = (ExpressionSegment) visit(ctx.expr());
1654 joinTableSource.setCondition(condition);
1655 }
1656 if (null != ctx.USING()) {
1657 joinTableSource.setUsing(ctx.columnNames().columnName().stream().map(each -> (ColumnSegment) visit(each)).collect(Collectors.toList()));
1658 }
1659 }
1660
1661 @Override
1662 public ASTNode visitSubquery(final SubqueryContext ctx) {
1663 if (null != ctx.merge()) {
1664 return visit(ctx.merge());
1665 }
1666 return visit(ctx.aggregationClause());
1667 }
1668
1669 @Override
1670 public ASTNode visitCreateTableAsSelectClause(final CreateTableAsSelectClauseContext ctx) {
1671 SQLServerCreateTableStatement result = new SQLServerCreateTableStatement();
1672 if (null != ctx.createTableAsSelect()) {
1673 result.setTable((SimpleTableSegment) visit(ctx.createTableAsSelect().tableName()));
1674 result.setSelectStatement((SQLServerSelectStatement) visit(ctx.createTableAsSelect().select()));
1675 if (null != ctx.createTableAsSelect().columnNames()) {
1676 CollectionValue<ColumnSegment> columnSegments = (CollectionValue<ColumnSegment>) visit(ctx.createTableAsSelect().columnNames());
1677 for (ColumnSegment each : columnSegments.getValue()) {
1678 result.getColumns().add(each);
1679 }
1680 }
1681 } else {
1682 result.setTable((SimpleTableSegment) visit(ctx.createRemoteTableAsSelect().tableName()));
1683 result.setSelectStatement((SQLServerSelectStatement) visit(ctx.createRemoteTableAsSelect().select()));
1684 }
1685 return result;
1686 }
1687
1688 @Override
1689 public ASTNode visitUpdateStatistics(final UpdateStatisticsContext ctx) {
1690 SQLServerUpdateStatisticsStatement result = new SQLServerUpdateStatisticsStatement();
1691 if (null != ctx.tableName()) {
1692 result.setTable((SimpleTableSegment) visit(ctx.tableName()));
1693 }
1694 if (null != ctx.indexName() && !ctx.indexName().isEmpty()) {
1695 List<IndexSegment> indexSegments = new LinkedList<>();
1696 for (IndexNameContext indexNameContext : ctx.indexName()) {
1697 indexSegments.add((IndexSegment) visit(indexNameContext));
1698 }
1699 result.setIndexes(indexSegments);
1700 }
1701 if (null != ctx.statisticsWithClause()) {
1702 result.setStrategy((StatisticsStrategySegment) visit(ctx.statisticsWithClause()));
1703 }
1704 return result;
1705 }
1706
1707 @Override
1708 public ASTNode visitStatisticsWithClause(final StatisticsWithClauseContext ctx) {
1709 StatisticsStrategySegment result = new StatisticsStrategySegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex());
1710 if (null != ctx.sampleOption()) {
1711 result.setSampleOption((SampleOptionSegment) visit(ctx.sampleOption()));
1712 }
1713 if (null != ctx.statisticsOptions()) {
1714 result.setStatisticsOptions((StatisticsOptionSegment) visit(ctx.statisticsOptions()));
1715 }
1716 return result;
1717 }
1718
1719 @Override
1720 public ASTNode visitSampleOption(final SampleOptionContext ctx) {
1721 SampleOptionSegment result = new SampleOptionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex());
1722 if (null != ctx.FULLSCAN()) {
1723 result.setStrategy(SampleStrategy.FULLSCAN);
1724 } else if (null != ctx.SAMPLE()) {
1725 result.setStrategy(SampleStrategy.SAMPLE);
1726 if (null != ctx.NUMBER_()) {
1727 List<TerminalNode> number = ctx.NUMBER_();
1728 result.setSampleNumber(number.get(0).getText());
1729 }
1730 if (null != ctx.PERCENT()) {
1731 result.setScanUnit(ScanUnit.PERCENT);
1732 } else if (null != ctx.ROWS()) {
1733 result.setScanUnit(ScanUnit.ROWS);
1734 }
1735 } else if (null != ctx.RESAMPLE()) {
1736 result.setStrategy(SampleStrategy.RESAMPLE);
1737 if (null != ctx.NUMBER_()) {
1738 List<String> partitions = new LinkedList<>();
1739 for (TerminalNode terminalNode : ctx.NUMBER_()) {
1740 partitions.add(terminalNode.getText());
1741 }
1742 result.setPartitions(partitions);
1743 }
1744 }
1745 if (null != ctx.PERSIST_SAMPLE_PERCENT()) {
1746 result.setPersistSamplePercent(null != ctx.ON());
1747 }
1748 return result;
1749 }
1750
1751 @Override
1752 public ASTNode visitStatisticsOptions(final StatisticsOptionsContext ctx) {
1753 StatisticsOptionSegment result = new StatisticsOptionSegment(ctx.getStart().getStartIndex(), ctx.getStop().getStopIndex());
1754 for (StatisticsOptionContext option : ctx.statisticsOption()) {
1755 if (null != option.ALL()) {
1756 result.setStatisticsDimension(StatisticsDimension.ALL);
1757 } else if (null != option.COLUMNS()) {
1758 result.setStatisticsDimension(StatisticsDimension.COLUMNS);
1759 } else if (null != option.INDEX()) {
1760 result.setStatisticsDimension(StatisticsDimension.INDEX);
1761 }
1762 if (null != option.NORECOMPUTE()) {
1763 result.setNoRecompute(true);
1764 }
1765 if (null != option.INCREMENTAL()) {
1766 result.setIncremental(null != option.ON());
1767 }
1768 if (null != option.MAXDOP()) {
1769 result.setMaxDegreeOfParallelism(option.NUMBER_().getText());
1770 }
1771 if (null != option.AUTO_DROP()) {
1772 result.setAutoDrop(null != option.ON());
1773 }
1774 }
1775 return result;
1776 }
1777
1778 @Override
1779 public ASTNode visitMerge(final MergeContext ctx) {
1780 SQLServerMergeStatement result = new SQLServerMergeStatement();
1781 result.setTarget((TableSegment) visit(ctx.mergeIntoClause().tableReferences()));
1782 if (null != ctx.withClause()) {
1783 result.setWithSegment((WithSegment) visit(ctx.withClause()));
1784 }
1785 if (null != ctx.withMergeHint()) {
1786 result.setWithTableHintSegment((WithTableHintSegment) visit(ctx.withMergeHint().withTableHint()));
1787 if (null != ctx.withMergeHint().indexName()) {
1788 Collection<IndexSegment> indexSegments = new LinkedList<>();
1789 for (IndexNameContext each : ctx.withMergeHint().indexName()) {
1790 indexSegments.add((IndexSegment) visit(each));
1791 }
1792 result.setIndexes(indexSegments);
1793 }
1794 }
1795 if (null != ctx.mergeUsingClause()) {
1796 result.setSource((TableSegment) visit(ctx.mergeUsingClause().tableReferences()));
1797 ExpressionWithParamsSegment onExpression = new ExpressionWithParamsSegment(ctx.mergeUsingClause().expr().start.getStartIndex(), ctx.mergeUsingClause().expr().stop.getStopIndex(),
1798 (ExpressionSegment) visit(ctx.mergeUsingClause().expr()));
1799 result.setExpression(onExpression);
1800 }
1801 if (null != ctx.mergeWhenClause()) {
1802 for (MergeWhenClauseContext each : ctx.mergeWhenClause()) {
1803 result.getWhenAndThenSegments().add((MergeWhenAndThenSegment) visit(each));
1804 }
1805 }
1806 if (null != ctx.outputClause()) {
1807 result.setOutputSegment((OutputSegment) visit(ctx.outputClause()));
1808 }
1809 if (null != ctx.optionHint()) {
1810 result.setOptionHintSegment((OptionHintSegment) visit(ctx.optionHint()));
1811 }
1812 return result;
1813 }
1814
1815 @Override
1816 public ASTNode visitMergeWhenClause(final MergeWhenClauseContext ctx) {
1817 MergeWhenAndThenSegment result = new MergeWhenAndThenSegment(ctx.start.getStartIndex(), ctx.stop.getStopIndex(), getOriginalText(ctx));
1818 if (null != ctx.mergeDeleteClause() && null != ctx.mergeDeleteClause().expr()) {
1819 result.setAndExpr((ExpressionSegment) visit(ctx.mergeDeleteClause().expr()));
1820 }
1821 if (null != ctx.mergeUpdateClause()) {
1822 result.setUpdate((SQLServerUpdateStatement) visit(ctx.mergeUpdateClause()));
1823 if (null != ctx.mergeUpdateClause().expr()) {
1824 result.setAndExpr((ExpressionSegment) visit(ctx.mergeUpdateClause().expr()));
1825 }
1826 }
1827 if (null != ctx.mergeInsertClause()) {
1828 result.setInsert((SQLServerInsertStatement) visit(ctx.mergeInsertClause()));
1829 if (null != ctx.mergeInsertClause().expr()) {
1830 result.setAndExpr((ExpressionSegment) visit(ctx.mergeInsertClause().expr()));
1831 }
1832 }
1833 return result;
1834 }
1835
1836 @Override
1837 public ASTNode visitMergeInsertClause(final MergeInsertClauseContext ctx) {
1838 SQLServerInsertStatement result;
1839 if (null != ctx.insertDefaultValue()) {
1840 result = (SQLServerInsertStatement) visit(ctx.insertDefaultValue());
1841 } else {
1842 result = (SQLServerInsertStatement) visit(ctx.insertValuesClause());
1843 }
1844 return result;
1845 }
1846
1847 @Override
1848 public ASTNode visitMergeUpdateClause(final MergeUpdateClauseContext ctx) {
1849 SQLServerUpdateStatement result = new SQLServerUpdateStatement();
1850 result.setSetAssignment((SetAssignmentSegment) visit(ctx.setAssignmentsClause()));
1851 return result;
1852 }
1853 }