public override SqlExpression VisitQuantifiedExpression(PlSqlParser.QuantifiedExpressionContext context) { SqlExpression arg; if (context.subquery() != null) { arg = Subquery.Form(context.subquery()); } else if (context.expression_list() != null) { var elements = context.expression_list().expression().Select(Visit).ToArray(); arg = SqlExpression.Constant(Field.Array(elements)); } else { throw new ParseCanceledException("Invalid argument in a quantified expression."); } if (context.ALL() != null) { return(SqlExpression.All(arg)); } if (context.ANY() != null || context.SOME() != null) { return(SqlExpression.Any(arg)); } return(base.VisitQuantifiedExpression(context)); }
public override SqlStatement VisitInsertStatement(PlSqlParser.InsertStatementContext context) { var singleTableInsert = context.singleTableInsert(); var insertInto = singleTableInsert.insertIntoClause(); if (insertInto != null) { var tableName = Name.Object(insertInto.objectName()); var columnNames = new string[0]; if (insertInto.columnName() != null) { columnNames = insertInto.columnName().Select(Name.Simple).ToArray(); } if (singleTableInsert.valuesClause() != null) { var values = new List <SqlExpression[]>(); foreach (var listContext in singleTableInsert.valuesClause().expression_list()) { var array = listContext.expression().Select(Expression.Build).ToArray(); values.Add(array); } return(new InsertStatement(tableName, columnNames, values)); } if (singleTableInsert.subquery() != null) { var query = Subquery.Form(singleTableInsert.subquery()); return(new InsertSelectStatement(tableName, columnNames, query)); } } else if (singleTableInsert.insertSetClause() != null) { var tableName = Name.Object(singleTableInsert.insertSetClause().objectName()); var columns = new List <string>(); var values = new List <SqlExpression>(); foreach (var assignmentContext in singleTableInsert.insertSetClause().insertAssignment()) { var columnName = Name.Simple(assignmentContext.columnName()); var value = Expression.Build(assignmentContext.expression()); columns.Add(columnName); values.Add(value); } return(new InsertStatement(tableName, columns.ToArray(), new[] { values.ToArray() })); } return(base.VisitInsertStatement(context)); }
public static UpdateStatement Build(PlSqlParser.UpdateStatementContext context) { var tableName = Name.Object(context.objectName()); var setClause = context.updateSetClause(); var limitClause = context.updateLimitClause(); if (setClause != null) { var assignments = new List <SqlColumnAssignment>(); var whereClause = context.whereClause(); int limit = -1; if (limitClause != null) { limit = Number.PositiveInteger(limitClause.numeric()) ?? -1; } SqlExpression whereExpression = null; if (whereClause != null) { whereExpression = Expression.Build(whereClause.conditionWrapper()); } if (setClause.VALUE() != null) { var columnName = Name.Simple(setClause.columnName()); var value = Expression.Build(setClause.expression()); assignments.Add(new SqlColumnAssignment(columnName, value)); } else { var pairs = setClause.columnBasedUpdateClause().Select(x => new { columnName = Name.Simple(x.columnName()), value = Expression.Build(x.expression()) }); assignments = pairs.Select(x => new SqlColumnAssignment(x.columnName, x.value)).ToList(); } return(new UpdateStatement(tableName, whereExpression, assignments) { Limit = limit }); } if (context.updateFromClause() != null) { var query = Subquery.Form(context.updateFromClause().subquery()); } throw new NotSupportedException(); }
public static SqlStatement Declare(PlSqlParser.CursorDeclarationContext context) { var cursorName = Name.Simple(context.cursor_name()); var query = Subquery.Form(context.subquery()); CursorParameter[] parameters = null; if (context.parameterSpec() != null) { parameters = context.parameterSpec().Select(Parameter.Form).ToArray(); } return(new DeclareCursorStatement(cursorName, parameters, query)); }
public static SqlStatement Build(PlSqlParser.SelectStatementContext context) { IntoClause into; var query = Subquery.Form(context.subquery(), out into); if (into != null) { SqlExpression reference; if (into.TableName != null) { reference = SqlExpression.Reference(into.TableName); } else { var vars = into.Variables; reference = SqlExpression.Tuple(vars.Select(SqlExpression.VariableReference).Cast <SqlExpression>().ToArray()); } return(new SelectIntoStatement(query, reference)); } var statement = new SelectStatement(query); var orderBy = context.orderByClause(); var forUpdate = context.forUpdateClause(); if (orderBy != null) { var sortColumns = orderBy.orderByElements().orderByElement().Select(x => { bool asc = x.DESC() == null; var exp = Expression.Build(x.expression()); return(new SortColumn(exp, asc)); }); statement.OrderBy = sortColumns; } statement.ForUpdate = forUpdate != null; var limit = context.queryLimitClause(); if (limit != null) { var n1 = Number.PositiveInteger(limit.n1); var n2 = Number.PositiveInteger(limit.n2); if (n1 == null) { throw new ParseCanceledException("Invalid LIMIT clause"); } if (n2 != null) { statement.Limit = new QueryLimit(n1.Value, n2.Value); } else { statement.Limit = new QueryLimit(n1.Value); } } return(statement); }
public override SqlExpression VisitSubquery(PlSqlParser.SubqueryContext context) { return(Subquery.Form(context)); }