Merge lp:~mmcm/akiban-sql-parser/more-node-to-string into lp:~akiban-technologies/akiban-sql-parser/trunk

[Mike McMahon]

Add unparser support for missing Value-like nodes.

See switch additions for which node types these are and new test for how those manifest in the parser.

[Nathan Williams (nwilliams)]

Looks good.

review: Approve

[Thomas Jones-Low (tjoneslo)]

There were 2 failures during build/test:

* job sql-parser-build failed at build number 296: http://sneezy.softstart.com:8080/job/sql-parser-build/296/

* view must-pass failed: sql-parser-build is red

review: Needs Fixing

=== modified file 'src/main/java/com/akiban/sql/parser/LeftRightFuncOperatorNode.java'
--- src/main/java/com/akiban/sql/parser/LeftRightFuncOperatorNode.java	2013-05-08 22:13:20 +0000
+++ src/main/java/com/akiban/sql/parser/LeftRightFuncOperatorNode.java	2013-07-30 22:21:25 +0000
@@ -36,11 +36,11 @@
         switch(nodeType)
         {
             case NodeTypes.LEFT_FN_NODE:
-                op = "getLeft";
+                op = "LEFT";
                 method = "getLeft";
                 break;
             case NodeTypes.RIGHT_FN_NODE:
-                op = "getRight";
+                op = "RIGHT";
                 method = "getRight";
                 break;
             default:

=== modified file 'src/main/java/com/akiban/sql/parser/TrimOperatorNode.java'
--- src/main/java/com/akiban/sql/parser/TrimOperatorNode.java	2013-05-08 22:13:20 +0000
+++ src/main/java/com/akiban/sql/parser/TrimOperatorNode.java	2013-07-30 22:21:25 +0000
@@ -31,7 +31,7 @@
             case TRIM:
             case RTRIM:  super.init(trimSource,
                                     trimChar,
-                                    "TRIM",
+                                    optype.name(),
                                     optype.name().toLowerCase(),
                                     ValueClassName.StringDataValue,
                                     ValueClassName.StringDataValue);

=== modified file 'src/main/java/com/akiban/sql/parser/UnaryArithmeticOperatorNode.java'
--- src/main/java/com/akiban/sql/parser/UnaryArithmeticOperatorNode.java	2013-05-08 22:13:20 +0000
+++ src/main/java/com/akiban/sql/parser/UnaryArithmeticOperatorNode.java	2013-07-30 22:21:25 +0000
@@ -52,7 +52,7 @@
         PLUS("+", "plus"), 
         MINUS("-", "minus"), 
         SQRT("SQRT", "sqrt"), 
-        ABSOLUTE("ABS/ABSVAL", "absolute");
+        ABSOLUTE("ABS", "absolute");
 
         String operator, methodName;
         OperatorType(String operator, String methodName) {

=== modified file 'src/main/java/com/akiban/sql/unparser/NodeToString.java'
--- src/main/java/com/akiban/sql/unparser/NodeToString.java	2013-05-08 22:13:20 +0000
+++ src/main/java/com/akiban/sql/unparser/NodeToString.java	2013-07-30 22:21:25 +0000
@@ -131,7 +131,10 @@
         case NodeTypes.BINARY_DIVIDE_OPERATOR_NODE:
         case NodeTypes.BINARY_DIV_OPERATOR_NODE:
         case NodeTypes.BINARY_MINUS_OPERATOR_NODE:
+        case NodeTypes.MOD_OPERATOR_NODE:
             return binaryArithmeticOperatorNode((BinaryArithmeticOperatorNode)node);
+        case NodeTypes.BINARY_BIT_OPERATOR_NODE:
+            return binaryBitOperatorNode((BinaryBitOperatorNode)node);
         case NodeTypes.CONCATENATION_OPERATOR_NODE:
             return concatenationOperatorNode((ConcatenationOperatorNode)node);
         case NodeTypes.NOT_NODE:
@@ -141,10 +144,39 @@
             return isNullNode((IsNullNode)node);
         case NodeTypes.IS_NODE:
             return isNode((IsNode)node);
+        case NodeTypes.ABSOLUTE_OPERATOR_NODE:
+        case NodeTypes.SQRT_OPERATOR_NODE:
+            return unaryArithmeticOperatorNode((UnaryArithmeticOperatorNode)node);
+        case NodeTypes.UNARY_PLUS_OPERATOR_NODE:
+        case NodeTypes.UNARY_MINUS_OPERATOR_NODE:
+            return unaryPrefixOperatorNode((UnaryArithmeticOperatorNode)node);
+        case NodeTypes.UNARY_BITNOT_OPERATOR_NODE:
+            return unaryBitOperatorNode((UnaryBitOperatorNode)node);
         case NodeTypes.UNARY_DATE_TIMESTAMP_OPERATOR_NODE:
           return unaryDateTimestampOperatorNode((UnaryDateTimestampOperatorNode)node);
+        case NodeTypes.TIMESTAMP_OPERATOR_NODE:
+          return timestampOperatorNode((TimestampOperatorNode)node);
+        case NodeTypes.EXTRACT_OPERATOR_NODE:
+          return extractOperatorNode((ExtractOperatorNode)node);
+        case NodeTypes.CHAR_LENGTH_OPERATOR_NODE:
+          return lengthOperatorNode((LengthOperatorNode)node);
+        case NodeTypes.OCTET_LENGTH_OPERATOR_NODE:
+          return octetLengthOperatorNode((OctetLengthOperatorNode)node);
+        case NodeTypes.RIGHT_FN_NODE:
+        case NodeTypes.LEFT_FN_NODE:
+            return leftRightFuncOperatorNode((LeftRightFuncOperatorNode)node);
+        case NodeTypes.SIMPLE_STRING_OPERATOR_NODE:
+            return simpleStringOperatorNode((SimpleStringOperatorNode)node);
         case NodeTypes.LIKE_OPERATOR_NODE:
             return likeEscapeOperatorNode((LikeEscapeOperatorNode)node);
+        case NodeTypes.LOCATE_FUNCTION_NODE:
+        case NodeTypes.SUBSTRING_OPERATOR_NODE:
+            return ternaryOperatorNode((TernaryOperatorNode)node);
+        case NodeTypes.TIMESTAMP_ADD_FN_NODE:
+        case NodeTypes.TIMESTAMP_DIFF_FN_NODE:
+            return timestampFunctionNode((TernaryOperatorNode)node);
+        case NodeTypes.TRIM_OPERATOR_NODE:
+            return trimOperatorNode((TrimOperatorNode)node);
         case NodeTypes.IN_LIST_OPERATOR_NODE:
             return inListOperatorNode((InListOperatorNode)node);
         case NodeTypes.ROW_CTOR_NODE:
@@ -180,6 +212,8 @@
             return constantNode((ConstantNode)node);
         case NodeTypes.PARAMETER_NODE:
             return parameterNode((ParameterNode)node);
+        case NodeTypes.DEFAULT_NODE:
+            return "DEFAULT";
         case NodeTypes.USER_NODE:
             return "USER";
         case NodeTypes.CURRENT_USER_NODE:
@@ -200,6 +234,12 @@
             return currentDatetimeOperatorNode((CurrentDatetimeOperatorNode)node);
         case NodeTypes.CAST_NODE:
             return castNode((CastNode)node);
+        case NodeTypes.EXPLICIT_COLLATE_NODE:
+            return explicitCollateNode((ExplicitCollateNode)node);
+        case NodeTypes.NEXT_SEQUENCE_NODE:
+            return nextSequenceNode((NextSequenceNode)node);
+        case NodeTypes.CURRENT_SEQUENCE_NODE:
+            return currentSequenceNode((CurrentSequenceNode)node);
         case NodeTypes.JAVA_TO_SQL_VALUE_NODE:
             return javaToSQLValueNode((JavaToSQLValueNode)node);
         case NodeTypes.SQL_TO_JAVA_VALUE_NODE:
@@ -747,11 +787,26 @@
         return infixBinary(node);
     }
 
+    protected String binaryBitOperatorNode(BinaryBitOperatorNode node) 
+            throws StandardException {
+        return infixBinary(node);
+    }
+
     protected String concatenationOperatorNode(ConcatenationOperatorNode node)
             throws StandardException {
         return infixBinary(node);
     }
 
+    protected String leftRightFuncOperatorNode(LeftRightFuncOperatorNode node)
+            throws StandardException {
+        return functionBinary(node);
+    }
+
+    protected String simpleStringOperatorNode(SimpleStringOperatorNode node)
+            throws StandardException {
+        return functionUnary(node);
+    }
+
     protected String notNode(NotNode node) throws StandardException {
         return prefixUnary(node);
     }
@@ -760,11 +815,47 @@
         return suffixUnary(node);
     }
 
+    protected String unaryArithmeticOperatorNode(UnaryArithmeticOperatorNode node) 
+            throws StandardException {
+        return functionUnary(node);
+    }
+
+    protected String unaryPrefixOperatorNode(UnaryArithmeticOperatorNode node) 
+            throws StandardException {
+        return prefixUnary(node);
+    }
+
+    protected String unaryBitOperatorNode(UnaryBitOperatorNode node) 
+            throws StandardException {
+        return prefixUnary(node);
+    }
+
+    protected String extractOperatorNode(ExtractOperatorNode node) 
+            throws StandardException {
+        return node.getOperator().substring("EXTRACT ".length()).toUpperCase() + "(" +
+            toString(node.getOperand()) + ")";
+    }
+
     protected String unaryDateTimestampOperatorNode(UnaryDateTimestampOperatorNode node) 
             throws StandardException {
         return functionUnary(node);
     }
 
+    protected String timestampOperatorNode(TimestampOperatorNode node) 
+            throws StandardException {
+        return functionBinary(node);
+    }
+
+    protected String lengthOperatorNode(LengthOperatorNode node) 
+            throws StandardException {
+        return functionUnary(node);
+    }
+
+    protected String octetLengthOperatorNode(OctetLengthOperatorNode node) 
+            throws StandardException {
+        return functionUnary(node);
+    }
+
     protected String isNode(IsNode node) throws StandardException {
         StringBuilder str = new StringBuilder(maybeParens(node.getLeftOperand()));
         str.append(" IS ");
@@ -800,6 +891,81 @@
         return like;
     }
 
+    protected String ternaryOperatorNode(TernaryOperatorNode node)
+            throws StandardException {
+        StringBuilder str = new StringBuilder(node.getOperator().toUpperCase());
+        str.append("(");
+        str.append(toString(node.getReceiver()));
+        str.append(", ");
+        str.append(toString(node.getLeftOperand()));
+        if (node.getRightOperand() != null) {
+            str.append(", ");
+            str.append(toString(node.getRightOperand()));
+        }
+        return str.toString();
+    }
+
+    protected String timestampFunctionNode(TernaryOperatorNode node)
+            throws StandardException {
+        String interval = toString(node.getReceiver());
+        switch ((Integer)((ConstantNode)node.getReceiver()).getValue()) {
+        case TernaryOperatorNode.YEAR_INTERVAL:
+            interval = "YEAR";
+            break;
+        case TernaryOperatorNode.QUARTER_INTERVAL:
+            interval = "QUARTER";
+            break;
+        case TernaryOperatorNode.MONTH_INTERVAL:
+            interval = "MONTH";
+            break;
+        case TernaryOperatorNode.WEEK_INTERVAL:
+            interval = "WEEK";
+            break;
+        case TernaryOperatorNode.DAY_INTERVAL:
+            interval = "DAY";
+            break;
+        case TernaryOperatorNode.HOUR_INTERVAL:
+            interval = "HOUR";
+            break;
+        case TernaryOperatorNode.MINUTE_INTERVAL:
+            interval = "MINUTE";
+            break;
+        case TernaryOperatorNode.SECOND_INTERVAL:
+            interval = "SECOND";
+            break;
+        case TernaryOperatorNode.FRAC_SECOND_INTERVAL:
+            interval = "MICROSECOND>";
+            break;
+        }
+        return node.getOperator().toUpperCase() + "(" +
+            interval + ", " +
+            toString(node.getLeftOperand()) + ", " +
+            toString(node.getRightOperand()) + ")";
+    }
+
+    protected String trimOperatorNode(TrimOperatorNode node)
+            throws StandardException {
+        if ((node.getRightOperand() instanceof ConstantNode) &&
+            " ".equals(((ConstantNode)node.getRightOperand()).getValue())) {
+            return node.getOperator().toUpperCase() + "(" +
+                toString(node.getLeftOperand()) + ")";
+        }
+        else {
+            StringBuilder str = new StringBuilder("TRIM(");
+            if ("LTRIM".equals(node.getOperator()))
+                str.append("LEADING");
+            else if ("RTRIM".equals(node.getOperator()))
+                str.append("TRAILING");
+            else
+                str.append("BOTH");
+            str.append(" ");
+            str.append(toString(node.getRightOperand()));
+            str.append(" FROM ");
+            str.append(toString(node.getLeftOperand()));
+            return str.toString();
+        }
+    }
+
     protected String inListOperatorNode(InListOperatorNode node) throws StandardException {
         return maybeParens(node.getLeftOperand()) +
             " " + (node.isNegated() ? "NOT IN" : "IN") + 
@@ -880,6 +1046,12 @@
             maybeParens(node.getRightOperand());
     }
     
+    protected String functionBinary(BinaryOperatorNode node) throws StandardException {
+        return node.getOperator().toUpperCase() + "(" +
+            toString(node.getLeftOperand()) + ", " +
+            toString(node.getRightOperand()) + ")";
+    }
+    
     protected String functionCall(String functionName, ValueNodeList args)
             throws StandardException {
         return functionName + "(" + nodeList(args, true) + ")";
@@ -946,6 +1118,22 @@
             " AS " + node.getType().toString() + ")";
     }
 
+    protected String explicitCollateNode(ExplicitCollateNode node) 
+            throws StandardException {
+        return maybeParens(node.getOperand()) + 
+            " COLLATE " + node.getCollation();
+    }
+
+    protected String nextSequenceNode(NextSequenceNode node)
+            throws StandardException {
+        return "NEXT VALUE FOR " + toString(node.getSequenceName ());
+    }
+
+    protected String currentSequenceNode(CurrentSequenceNode node)
+            throws StandardException {
+        return "CURRENT VALUE FOR " + toString(node.getSequenceName ());
+    }
+
     protected String javaToSQLValueNode(JavaToSQLValueNode node) 
             throws StandardException {
         return toString(node.getJavaValueNode());

=== modified file 'src/test/java/com/akiban/sql/unparser/NodeToStringTest.java'
--- src/test/java/com/akiban/sql/unparser/NodeToStringTest.java	2013-05-08 22:13:20 +0000
+++ src/test/java/com/akiban/sql/unparser/NodeToStringTest.java	2013-07-30 22:21:25 +0000
@@ -19,6 +19,7 @@
 import com.akiban.sql.TestBase;
 
 import com.akiban.sql.parser.SQLParser;
+import com.akiban.sql.parser.SQLParserFeature;
 import com.akiban.sql.parser.StatementNode;
 
 import org.junit.Before;
@@ -30,6 +31,7 @@
 
 import java.io.File;
 import java.util.Collection;
+import java.util.EnumSet;
 
 @RunWith(Parameterized.class)
 public class NodeToStringTest extends TestBase implements TestBase.GenerateAndCheckResult
@@ -45,6 +47,7 @@
     public void before() throws Exception {
         parser = new SQLParser();
         unparser = new NodeToString();
+        parser.getFeatures().addAll(EnumSet.of(SQLParserFeature.INFIX_BIT_OPERATORS));
     }
 
     @Parameters

=== added file 'src/test/resources/com/akiban/sql/unparser/select-15.expected'
--- src/test/resources/com/akiban/sql/unparser/select-15.expected	1970-01-01 00:00:00 +0000
+++ src/test/resources/com/akiban/sql/unparser/select-15.expected	2013-07-30 22:21:25 +0000
@@ -0,0 +1,1 @@
+SELECT (ABS(- n)), (~ n), (n MOD 3), SQRT(n), CHAR_LENGTH(s), LENGTH(s), (LEFT(s, 3)), (RIGHT(s, 4)), UPPER(s), LOWER(s), (LOCATE(s, 'abc', 1), (LOCATE(s, 'xyz', 10), (SUBSTRING(s, 10), (SUBSTRING(s, 10, 3), LTRIM(s), (TRIM(TRAILING '!' FROM s), ((s || s) COLLATE en_us_ci), MONTH(d), (TIMESTAMP(d, '13:01:01')), (TIMESTAMPDIFF(DAY, d, CURRENT_TIMESTAMP)), (NEXT VALUE FOR seq), (CURRENT VALUE FOR seq) FROM t
\ No newline at end of file

=== added file 'src/test/resources/com/akiban/sql/unparser/select-15.sql'
--- src/test/resources/com/akiban/sql/unparser/select-15.sql	1970-01-01 00:00:00 +0000
+++ src/test/resources/com/akiban/sql/unparser/select-15.sql	2013-07-30 22:21:25 +0000
@@ -0,0 +1,13 @@
+SELECT abs(- n), ~n,
+  mod(n, 3), sqrt(n),
+  char_length(s), octet_length(s),
+  left(s, 3), right(s, 4),
+  upper(s), lower(s),
+  locate(s, 'abc'), locate(s, 'xyz', 10),
+  substring(s, 10), substring(s, 10, 3),
+  ltrim(s), trim(trailing '!' from s),
+  s||s collate en_us_ci,
+  month(d), timestamp(d, '13:01:01'), timestampdiff(day, d, current_timestamp),
+  next value for seq, current value for seq
+FROM t
+  
\ No newline at end of file