public static PrimarSqlSetColumnExpressionNode VisitUpdatedElement(UpdatedElementContext context)
{
var column = IdentifierVisitor.VisitFullColumnName(context.fullColumnName());
var assignNode = new PrimarSqlSetColumnExpressionNode
{
Target = column.Name,
};
assignNode.Accessors.AddRange(column.Accessors);
QsiExpressionNode expression;
if (context.expression() != null)
{
expression = VisitExpression(context.expression());
}
else if (context.arrayExpression() != null)
{
expression = VisitArrayExpression(context.arrayExpression());
}
else if (context.arrayAddExpression() != null)
{
expression = VisitArrayAddExpression(context.arrayAddExpression());
}
else
{
expression = TreeHelper.CreateNullLiteral();
}
assignNode.Value.SetValue(expression);
PrimarSqlTree.PutContextSpan(assignNode, context);
return(assignNode);
}
public static QsiMultipleExpressionNode VisitExpressions(ExpressionsContext context)
{
var node = CreateMultipleExpression(context.expression());
PrimarSqlTree.PutContextSpan(node, context);
return(node);
}
public static QsiWhereExpressionNode VisitWhereExpression(FromClauseContext context)
{
return(TreeHelper.Create <QsiWhereExpressionNode>(n =>
{
n.Expression.SetValue(ExpressionVisitor.VisitExpression(context.whereExpr));
PrimarSqlTree.PutContextSpan(n, context.whereKeyword, context.whereExpr.Stop);
}));
}
public static QsiExpressionNode VisitBetweenPredicate(BetweenPredicateContext context)
{
return(TreeHelper.Create <QsiParametersExpressionNode>(n =>
{
n.Expressions.AddRange(context.predicate().Select(VisitPredicate));
PrimarSqlTree.PutContextSpan(n, context);
}));
}
public static QsiTableReferenceNode VisitTableName(TableNameContext context)
{
return(TreeHelper.Create <QsiTableReferenceNode>(n =>
{
n.Identifier = IdentifierVisitor.VisitFullId(context.fullId());
PrimarSqlTree.PutContextSpan(n, context);
}));
}
public static PrimarSqlAppendArrayExpressionNode VisitArrayAddExpression(ArrayAddExpressionContext context)
{
return(TreeHelper.Create <PrimarSqlAppendArrayExpressionNode>(n =>
{
n.Elements.AddRange(context.constant().Select(VisitConstant));
PrimarSqlTree.PutContextSpan(n, context);
}));
}
public static QsiLiteralExpressionNode VisitConstant(ConstantContext context)
{
switch (context)
{
case StringLiteralConstantContext literalContext:
{
return(VisitLiteral(literalContext.stringLiteral()));
}
case NegativeDecimalLiteralConstantContext literalContext:
{
var literal = VisitLiteral(literalContext.decimalLiteral());
literal.Value = -(decimal)literal.Value;
return(literal);
}
case PositiveDecimalLiteralConstantContext literalContext:
{
return(VisitLiteral(literalContext.decimalLiteral()));
}
case BooleanLiteralConstantContext literalContext:
{
return(VisitLiteral(literalContext.booleanLiteral()));
}
case RealLiteralConstantContext literalContext:
{
var node = new QsiLiteralExpressionNode
{
Value = decimal.Parse(literalContext.GetText()),
Type = QsiDataType.Decimal
};
PrimarSqlTree.PutContextSpan(node, literalContext);
return(node);
}
case BitStringConstantContext _:
{
throw TreeHelper.NotSupportedFeature("Bit string");
}
case NullConstantContext _:
{
return(new QsiLiteralExpressionNode
{
Value = null,
Type = QsiDataType.Null
});
}
default:
throw TreeHelper.NotSupportedTree(context);
}
}
private static QsiColumnExpressionNode VisitFullColumnName(FullColumnNameContext context)
{
return(TreeHelper.Create <QsiColumnExpressionNode>(n =>
{
n.Column.SetValue(IdentifierVisitor.VisitFullColumnName(context));
PrimarSqlTree.PutContextSpan(n.Column.Value, context);
PrimarSqlTree.PutContextSpan(n, context);
}));
}
public static QsiBinaryExpressionNode VisitIsNullPredicate(IsNullPredicateContext context)
{
return(TreeHelper.Create <QsiBinaryExpressionNode>(n =>
{
n.Left.SetValue(VisitPredicate(context.predicate()));
n.Operator = "IS";
n.Right.SetValue(VisitNullNotNull(context.nullNotnull()));
PrimarSqlTree.PutContextSpan(n, context);
}));
}
public static QsiBinaryExpressionNode VisitBinaryComparisonPredicate(BinaryComparisonPredicateContext context)
{
return(TreeHelper.Create <QsiBinaryExpressionNode>(n =>
{
n.Left.SetValue(VisitPredicate(context.left));
n.Operator = context.comparisonOperator().GetText();
n.Right.SetValue(VisitPredicate(context.right));
PrimarSqlTree.PutContextSpan(n, context);
}));
}
public static QsiBinaryExpressionNode VisitLogicalExpression(LogicalExpressionContext context)
{
return(TreeHelper.Create <QsiBinaryExpressionNode>(n =>
{
n.Left.SetValue(VisitExpression(context.left));
n.Operator = context.logicalOperator().GetText();
n.Right.SetValue(VisitExpression(context.right));
PrimarSqlTree.PutContextSpan(n, context);
}));
}
public static QsiAliasNode CreateAliasNode(UidContext context)
{
var node = new QsiAliasNode
{
Name = IdentifierVisitor.VisitUid(context)
};
PrimarSqlTree.PutContextSpan(node, context);
return(node);
}
public static QsiBinaryExpressionNode VisitInPredicate(InPredicateContext context)
{
return(TreeHelper.Create <QsiBinaryExpressionNode>(n =>
{
n.Operator = JoinTokens(context.NOT(), context.IN());
n.Left.SetValue(VisitPredicate(context.predicate()));
n.Right.SetValue(VisitExpressions(context.expressions()));
PrimarSqlTree.PutContextSpan(n, context);
}));
}
public static QsiExpressionNode VisitExpressionOrDefault(ExpressionOrDefaultContext context)
{
if (context.DEFAULT() != null)
{
var defaultLiteral = TreeHelper.CreateDefaultLiteral();
PrimarSqlTree.PutContextSpan(defaultLiteral, context);
return(defaultLiteral);
}
return(VisitExpression(context.expression()));
}
public static QsiRowValueExpressionNode VisitExpressionsWithDefaults(ExpressionsWithDefaultsContext context)
{
IEnumerable <QsiExpressionNode> expressions = context.expressionOrDefault()
.Select(VisitExpressionOrDefault);
var node = new QsiRowValueExpressionNode();
node.ColumnValues.AddRange(expressions);
PrimarSqlTree.PutContextSpan(node, context);
return(node);
}
public static PrimarSqlSetColumnExpressionNode VisitRemovedElement(RemovedElementContext context)
{
var column = IdentifierVisitor.VisitFullColumnName(context.fullColumnName());
var assignNode = new PrimarSqlSetColumnExpressionNode
{
Target = column.Name,
};
assignNode.Accessors.AddRange(column.Accessors);
PrimarSqlTree.PutContextSpan(assignNode, context);
return(assignNode);
}
public static QsiLimitExpressionNode VisitLimitClause(LimitClauseContext context)
{
return(TreeHelper.Create <QsiLimitExpressionNode>(n =>
{
n.Limit.SetValue(VisitLiteral(context.limit.decimalLiteral()));
if (context.offset != null)
{
n.Offset.SetValue(VisitLiteral(context.offset.decimalLiteral()));
}
PrimarSqlTree.PutContextSpan(n, context);
}));
}
public static PrimarSqlStartKeyExpressionNode VisitStartKeyClause(StartKeyClauseContext context)
{
return(TreeHelper.Create <PrimarSqlStartKeyExpressionNode>(n =>
{
n.HashKey.SetValue(VisitConstant(context.hashKey));
if (context.sortKey != null)
{
n.SortKey.SetValue(VisitConstant(context.sortKey));
}
PrimarSqlTree.PutContextSpan(n, context);
}));
}
public static QsiTableNode VisitSubqueryTableItem(SubqueryTableItemContext context)
{
if (context.alias == null)
{
throw new QsiException(QsiError.NoAlias);
}
return(TreeHelper.Create <QsiDerivedTableNode>(n =>
{
n.Columns.SetValue(TreeHelper.CreateAllColumnsDeclaration());
n.Source.SetValue(VisitSelectStatement(context.selectStatement()));
n.Alias.SetValue(CreateAliasNode(context.alias));
PrimarSqlTree.PutContextSpan(n, context);
}));
}
public static QsiColumnNode VisitSelectElement(SelectElementContext context)
{
QsiColumnNode node;
switch (context)
{
case SelectColumnElementContext columnElementContext:
{
node = VisitSelectColumnElement(columnElementContext);
break;
}
case SelectFunctionElementContext selectFunctionElementContext:
{
if (selectFunctionElementContext.builtInFunctionCall() is CountFunctionCallContext countFunctionCallContext)
{
return(TreeHelper.Create <QsiDerivedColumnNode>(n =>
{
n.Expression.SetValue(TreeHelper.Create <QsiInvokeExpressionNode>(en =>
{
en.Member.SetValue(TreeHelper.CreateFunction("count"));
}));
if (selectFunctionElementContext.alias != null)
{
n.Alias.SetValue(CreateAliasNode(selectFunctionElementContext.alias));
}
PrimarSqlTree.PutContextSpan(n, countFunctionCallContext);
}));
}
throw TreeHelper.NotSupportedFeature("Select Element Function");
}
case SelectExpressionElementContext _:
throw TreeHelper.NotSupportedFeature("Select Element Expression");
default:
{
node = null;
break;
}
}
return(node);
}
public static QsiLiteralExpressionNode VisitLiteral(ParserRuleContext context)
{
QsiDataType literalType;
object value;
switch (context)
{
case NullLiteralContext _:
literalType = QsiDataType.Null;
value = null;
break;
case StringLiteralContext stringLiteral:
{
value = string.Join("",
stringLiteral.STRING_LITERAL()
.Select(l => IdentifierUtility.Unescape(l.GetText())));
literalType = QsiDataType.String;
break;
}
case DecimalLiteralContext _:
literalType = QsiDataType.Decimal;
value = decimal.Parse(context.GetText());
break;
case BooleanLiteralContext _:
literalType = QsiDataType.Boolean;
value = bool.Parse(context.GetText());
break;
default:
throw TreeHelper.NotSupportedTree(context);
}
var node = new QsiLiteralExpressionNode
{
Value = value,
Type = literalType
};
PrimarSqlTree.PutContextSpan(node, context);
return(node);
}
public static QsiExpressionNode VisitNullNotNull(NullNotnullContext context)
{
var nullLiteral = VisitLiteral(context.nullLiteral());
if (context.NOT() != null)
{
return(TreeHelper.Create <QsiUnaryExpressionNode>(n =>
{
n.Operator = context.NOT().GetText();
n.Expression.SetValue(nullLiteral);
PrimarSqlTree.PutContextSpan(n, context);
}));
}
return(nullLiteral);
}
public static QsiTableNode VisitAtomTableItem(AtomTableItemContext context)
{
QsiTableNode node = VisitTableName(context.tableName());
if (context.alias == null)
{
return(node);
}
return(TreeHelper.Create <QsiDerivedTableNode>(n =>
{
n.Columns.SetValue(TreeHelper.CreateAllColumnsDeclaration());
n.Source.SetValue(node);
n.Alias.SetValue(CreateAliasNode(context.alias));
PrimarSqlTree.PutContextSpan(n, context);
}));
}
public static QsiTableNode VisitQuerySpecification(QuerySpecificationContext context)
{
var node = new PrimarSqlDerivedTableNode
{
SelectSpec = VisitSelectSpec(context.selectSpec())
};
node.Columns.SetValue(VisitSelectElements(context.selectElements()));
if (context.fromClause() != null)
{
node.Source.SetValue(VisitFromCluase(context.fromClause()));
if (context.fromClause().whereExpr != null)
{
node.Where.SetValue(VisitWhereExpression(context.fromClause()));
}
}
if (context.orderClause() != null)
{
node.Order.SetValue(TreeHelper.Create <QsiMultipleOrderExpressionNode>(n =>
{
n.Orders.Add(ExpressionVisitor.VisitOrderCluase(context.orderClause()));
PrimarSqlTree.PutContextSpan(n, context.orderClause());
}));
}
if (context.limitClause() != null)
{
node.Limit.SetValue(ExpressionVisitor.VisitLimitClause(context.limitClause()));
}
if (context.startKeyClause() != null)
{
node.StartKey.SetValue(ExpressionVisitor.VisitStartKeyClause(context.startKeyClause()));
}
PrimarSqlTree.PutContextSpan(node, context);
return(node);
}
public static QsiExpressionNode VisitExpressionAtom(ExpressionAtomContext context)
{
switch (context)
{
case ConstantExpressionAtomContext constantExpressionAtomContext:
return(VisitConstant(constantExpressionAtomContext.constant()));
case JsonExpressionAtomContext jsonExpressionAtomContext:
return(TreeHelper.Create <QsiLiteralExpressionNode>(n =>
{
n.Type = QsiDataType.Json;
n.Value = jsonExpressionAtomContext.jsonObject().GetText();
}));
// TODO: Check
case BinaryExpressionAtomContext binaryExpressionAtomContext:
return(TreeHelper.Create <QsiLiteralExpressionNode>(n =>
{
n.Type = QsiDataType.Binary;
n.Value = Convert.FromBase64String(binaryExpressionAtomContext.stringLiteral().GetText());
}));
case FullColumnNameExpressionAtomContext fullColumnNameContext:
return(VisitFullColumnName(fullColumnNameContext.fullColumnName()));
case FunctionCallExpressionAtomContext functionCallExpressionAtomContext:
return(VisitFunctionCall(functionCallExpressionAtomContext.functionCall()));
case NestedExpressionAtomContext nestedExpressionAtomContext:
{
var node = CreateMultipleExpression(nestedExpressionAtomContext.expression());
PrimarSqlTree.PutContextSpan(node, context);
return(node);
}
case BitExpressionAtomContext bitExpressionAtomContext:
{
return(TreeHelper.Create <QsiBinaryExpressionNode>(n =>
{
n.Left.SetValue(VisitExpressionAtom(bitExpressionAtomContext.left));
n.Operator = bitExpressionAtomContext.bitOperator().GetText();
n.Right.SetValue(VisitExpressionAtom(bitExpressionAtomContext.right));
PrimarSqlTree.PutContextSpan(n, context);
}));
}
case MathExpressionAtomContext mathExpressionAtomContext:
{
return(TreeHelper.Create <QsiBinaryExpressionNode>(n =>
{
n.Left.SetValue(VisitExpressionAtom(mathExpressionAtomContext.left));
n.Operator = mathExpressionAtomContext.mathOperator().GetText();
n.Right.SetValue(VisitExpressionAtom(mathExpressionAtomContext.right));
PrimarSqlTree.PutContextSpan(n, context);
}));
}
}
throw TreeHelper.NotSupportedTree(context);
}
