sqlancer · mrigger · Apr 24, 2025 · Jan 3, 2025 · Jan 5, 2025 · Jan 14, 2025
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
@@ -569,6 +569,7 @@ jobs:
           mvn -Dtest=TestSQLitePQS test
           mvn -Dtest=TestSQLiteTLP test
           mvn -Dtest=TestSQLiteNoREC test
+          mvn -Dtest=TestSQLiteCODDTest test
 
   sqlite-qpg:
     name: QPG Tests (SQLite)

diff --git a/pom.xml b/pom.xml
@@ -378,7 +378,7 @@
       <artifactId>flight-sql-jdbc-driver</artifactId>
       <version>16.1.0</version>
     </dependency>
-        <dependency>
+    <dependency>
       <groupId>org.apache.hive</groupId>
       <artifactId>hive-jdbc</artifactId>
       <version>4.0.1</version>

diff --git a/src/sqlancer/common/oracle/CODDTestBase.java b/src/sqlancer/common/oracle/CODDTestBase.java
@@ -0,0 +1,25 @@
+package sqlancer.common.oracle;
+
+import sqlancer.Main.StateLogger;
+import sqlancer.MainOptions;
+import sqlancer.SQLConnection;
+import sqlancer.SQLGlobalState;
+import sqlancer.common.query.ExpectedErrors;
+
+public abstract class CODDTestBase<S extends SQLGlobalState<?, ?>> implements TestOracle<S> {
+    protected final S state;
+    protected final ExpectedErrors errors = new ExpectedErrors();
+    protected final StateLogger logger;
+    protected final MainOptions options;
+    protected final SQLConnection con;
+    protected String auxiliaryQueryString;
+    protected String foldedQueryString;
+    protected String originalQueryString;
+
+    public CODDTestBase(S state) {
+        this.state = state;
+        this.con = state.getConnection();
+        this.logger = state.getLogger();
+        this.options = state.getOptions();
+    }
+}
diff --git a/src/sqlancer/common/schema/AbstractTables.java b/src/sqlancer/common/schema/AbstractTables.java
@@ -34,4 +34,27 @@ public String columnNamesAsString(Function<C, String> function) {
         return getColumns().stream().map(function).collect(Collectors.joining(", "));
     }
 
+    public void addTable(T table) {
+        if (!this.tables.contains(table)) {
+            this.tables.add(table);
+            columns.addAll(table.getColumns());
+        }
+    }
+
+    public void removeTable(T table) {
+        if (this.tables.contains(table)) {
+            this.tables.remove(table);
+            for (C c : table.getColumns()) {
+                columns.remove(c);
+            }
+        }
+    }
+
+    public boolean isContained(T table) {
+        return this.tables.contains(table);
+    }
+
+    public int getSize() {
+        return this.tables.size();
+    }
 }
diff --git a/src/sqlancer/hive/HiveErrors.java b/src/sqlancer/hive/HiveErrors.java
@@ -5,7 +5,7 @@
 
 import sqlancer.common.query.ExpectedErrors;
 
-public class HiveErrors {
+public final class HiveErrors {
 
     private HiveErrors() {
     }

diff --git a/src/sqlancer/hive/HiveOptions.java b/src/sqlancer/hive/HiveOptions.java
@@ -1,18 +1,18 @@
 package sqlancer.hive;
 
+import java.sql.SQLException;
+import java.util.Arrays;
+import java.util.List;
+
 import com.beust.jcommander.Parameter;
 import com.beust.jcommander.Parameters;
 
+import sqlancer.DBMSSpecificOptions;
+import sqlancer.OracleFactory;
 import sqlancer.common.oracle.TLPWhereOracle;
 import sqlancer.common.oracle.TestOracle;
 import sqlancer.common.query.ExpectedErrors;
-import sqlancer.DBMSSpecificOptions;
 import sqlancer.hive.gen.HiveExpressionGenerator;
-import sqlancer.OracleFactory;
-
-import java.sql.SQLException;
-import java.util.Arrays;
-import java.util.List;
 
 @Parameters(separators = "=", commandDescription = "Hive (default port: " + HiveOptions.DEFAULT_PORT
         + ", default host: " + HiveOptions.DEFAULT_HOST + ")")
@@ -28,8 +28,8 @@ public enum HiveOracleFactory implements OracleFactory<HiveGlobalState> {
             @Override
             public TestOracle<HiveGlobalState> create(HiveGlobalState globalState) throws SQLException {
                 HiveExpressionGenerator gen = new HiveExpressionGenerator(globalState);
-                ExpectedErrors expectedErrors = ExpectedErrors.newErrors()
-                        .with(HiveErrors.getExpressionErrors()).build();
+                ExpectedErrors expectedErrors = ExpectedErrors.newErrors().with(HiveErrors.getExpressionErrors())
+                        .build();
 
                 return new TLPWhereOracle<>(globalState, gen, expectedErrors);
             }

diff --git a/src/sqlancer/hive/HiveProvider.java b/src/sqlancer/hive/HiveProvider.java
@@ -1,5 +1,12 @@
 package sqlancer.hive;
 
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+import com.google.auto.service.AutoService;
+
 import sqlancer.AbstractAction;
 import sqlancer.DatabaseProvider;
 import sqlancer.IgnoreMeException;
@@ -13,13 +20,6 @@
 import sqlancer.hive.gen.HiveInsertGenerator;
 import sqlancer.hive.gen.HiveTableGenerator;
 
-import java.sql.Connection;
-import java.sql.DriverManager;
-import java.sql.SQLException;
-import java.sql.Statement;
-
-import com.google.auto.service.AutoService;
-
 @AutoService(DatabaseProvider.class)
 public class HiveProvider extends SQLProviderAdapter<HiveGlobalState, HiveOptions> {
 
@@ -61,14 +61,13 @@ public void generateDatabase(HiveGlobalState globalState) throws Exception {
                 String tableName = globalState.getSchema().getFreeTableName();
                 SQLQueryAdapter qt = HiveTableGenerator.generate(globalState, tableName);
                 success = globalState.executeStatement(qt);
-            } while(!success);
+            } while (!success);
         }
         if (globalState.getSchema().getDatabaseTables().isEmpty()) {
             throw new IgnoreMeException(); // TODO
         }
 
-        StatementExecutor<HiveGlobalState, Action> se = new StatementExecutor<HiveGlobalState, Action>(
-                globalState, Action.values(), 
+        StatementExecutor<HiveGlobalState, Action> se = new StatementExecutor<>(globalState, Action.values(),
                 HiveProvider::mapActions, (q) -> {
                     if (globalState.getSchema().getDatabaseTables().isEmpty()) {
                         throw new IgnoreMeException();
@@ -107,9 +106,8 @@ public SQLConnection createDatabase(HiveGlobalState globalState) throws SQLExcep
             s.execute("USE " + databaseName);
         }
         con.close();
-        con = DriverManager.getConnection(
-            String.format("jdbc:hive2://%s:%d/%s", host, port, databaseName,
-            username, password));
+        con = DriverManager
+                .getConnection(String.format("jdbc:hive2://%s:%d/%s", host, port, databaseName, username, password));
 
         return new SQLConnection(con);
     }

diff --git a/src/sqlancer/hive/HiveSchema.java b/src/sqlancer/hive/HiveSchema.java
@@ -1,5 +1,13 @@
 package sqlancer.hive;
 
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
 import sqlancer.Randomly;
 import sqlancer.SQLConnection;
 import sqlancer.common.schema.AbstractRelationalTable;
@@ -9,14 +17,6 @@
 import sqlancer.common.schema.TableIndex;
 import sqlancer.hive.HiveSchema.HiveTable;
 
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.sql.Statement;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-
 public class HiveSchema extends AbstractSchema<HiveGlobalState, HiveTable> {
 
     public enum HiveDataType {

diff --git a/src/sqlancer/hive/HiveToStringVisitor.java b/src/sqlancer/hive/HiveToStringVisitor.java
@@ -2,11 +2,11 @@
 
 import sqlancer.common.ast.newast.NewToStringVisitor;
 import sqlancer.common.ast.newast.TableReferenceNode;
+import sqlancer.hive.ast.HiveCastOperation;
 import sqlancer.hive.ast.HiveConstant;
 import sqlancer.hive.ast.HiveExpression;
 import sqlancer.hive.ast.HiveJoin;
 import sqlancer.hive.ast.HiveSelect;
-import sqlancer.hive.ast.HiveCastOperation;
 
 public class HiveToStringVisitor extends NewToStringVisitor<HiveExpression> {
 
@@ -71,26 +71,26 @@ private void visit(HiveSelect select) {
 
     private void visit(HiveJoin join) {
         switch (join.getJoinType()) {
-            case INNER:
-                sb.append(" INNER JOIN ");
-                break;
-            case LEFT_OUTER:
-                sb.append(" LEFT JOIN ");
-                break;
-            case RIGHT_OUTER:
-                sb.append(" RIGHT JOIN ");
-                break;
-            case FULL_OUTER:
-                sb.append(" FULL JOIN ");
-                break;
-            case LEFT_SEMI:
-                sb.append(" LEFT SEMI JOIN ");
-                break;
-            case CROSS:
-                sb.append(" CROSS JOIN ");
-                break;
-            default:
-                throw new UnsupportedOperationException();
+        case INNER:
+            sb.append(" INNER JOIN ");
+            break;
+        case LEFT_OUTER:
+            sb.append(" LEFT JOIN ");
+            break;
+        case RIGHT_OUTER:
+            sb.append(" RIGHT JOIN ");
+            break;
+        case FULL_OUTER:
+            sb.append(" FULL JOIN ");
+            break;
+        case LEFT_SEMI:
+            sb.append(" LEFT SEMI JOIN ");
+            break;
+        case CROSS:
+            sb.append(" CROSS JOIN ");
+            break;
+        default:
+            throw new UnsupportedOperationException();
         }
         visit((TableReferenceNode<HiveExpression, HiveSchema.HiveTable>) join.getRightTable());
         if (join.getOnClause() != null) {

diff --git a/src/sqlancer/hive/ast/HiveBetweenOperation.java b/src/sqlancer/hive/ast/HiveBetweenOperation.java
@@ -2,11 +2,9 @@
 
 import sqlancer.common.ast.newast.NewBetweenOperatorNode;
 
-public class HiveBetweenOperation extends NewBetweenOperatorNode<HiveExpression>
-        implements HiveExpression {
-
-    public HiveBetweenOperation(HiveExpression left, HiveExpression middle, HiveExpression right,
-            boolean isTrue) {
+public class HiveBetweenOperation extends NewBetweenOperatorNode<HiveExpression> implements HiveExpression {
+
+    public HiveBetweenOperation(HiveExpression left, HiveExpression middle, HiveExpression right, boolean isTrue) {
         super(left, middle, right, isTrue);
     }
 }
diff --git a/src/sqlancer/hive/ast/HiveBinaryOperation.java b/src/sqlancer/hive/ast/HiveBinaryOperation.java
@@ -3,9 +3,8 @@
 import sqlancer.common.ast.BinaryOperatorNode.Operator;
 import sqlancer.common.ast.newast.NewBinaryOperatorNode;
 
-public class HiveBinaryOperation extends NewBinaryOperatorNode<HiveExpression> 
-        implements HiveExpression {
-
+public class HiveBinaryOperation extends NewBinaryOperatorNode<HiveExpression> implements HiveExpression {
+
     public HiveBinaryOperation(HiveExpression left, HiveExpression right, Operator op) {
         super(left, right, op);
     }

diff --git a/src/sqlancer/hive/ast/HiveCaseOperation.java b/src/sqlancer/hive/ast/HiveCaseOperation.java
@@ -5,7 +5,7 @@
 import sqlancer.common.ast.newast.NewCaseOperatorNode;
 
 public class HiveCaseOperation extends NewCaseOperatorNode<HiveExpression> implements HiveExpression {
-    
+
     public HiveCaseOperation(HiveExpression switchCondition, List<HiveExpression> conditions,
             List<HiveExpression> expressions, HiveExpression elseExpr) {
         super(switchCondition, conditions, expressions, elseExpr);

diff --git a/src/sqlancer/hive/ast/HiveCastOperation.java b/src/sqlancer/hive/ast/HiveCastOperation.java
@@ -3,22 +3,22 @@
 import sqlancer.hive.HiveSchema.HiveDataType;
 
 public class HiveCastOperation implements HiveExpression {
-    
+
     private final HiveExpression expression;
     private final HiveDataType type;
-    
+
     public HiveCastOperation(HiveExpression expression, HiveDataType type) {
         if (expression == null) {
             throw new AssertionError();
         }
         this.expression = expression;
         this.type = type;
     }
-    
+
     public HiveExpression getExpression() {
         return expression;
     }
-    
+
     public HiveDataType getType() {
         return type;
     }

diff --git a/src/sqlancer/hive/ast/HiveFunction.java b/src/sqlancer/hive/ast/HiveFunction.java
@@ -9,5 +9,5 @@ public class HiveFunction<F> extends NewFunctionNode<HiveExpression, F> implemen
     public HiveFunction(List<HiveExpression> args, F func) {
         super(args, func);
     }
-    
+
 }
diff --git a/src/sqlancer/hive/ast/HiveInOperation.java b/src/sqlancer/hive/ast/HiveInOperation.java
@@ -5,7 +5,7 @@
 import sqlancer.common.ast.newast.NewInOperatorNode;
 
 public class HiveInOperation extends NewInOperatorNode<HiveExpression> implements HiveExpression {
-    
+
     public HiveInOperation(HiveExpression left, List<HiveExpression> right, boolean isNegated) {
         super(left, right, isNegated);
     }

diff --git a/src/sqlancer/hive/ast/HiveJoin.java b/src/sqlancer/hive/ast/HiveJoin.java
@@ -17,7 +17,7 @@ public enum JoinType {
         INNER, LEFT_OUTER, RIGHT_OUTER, FULL_OUTER, LEFT_SEMI, CROSS;
     }
 
-    public HiveJoin(HiveTableReference leftTable, HiveTableReference rightTable, JoinType joinType, 
+    public HiveJoin(HiveTableReference leftTable, HiveTableReference rightTable, JoinType joinType,
             HiveExpression onClause) {
         this.leftTable = leftTable;
         this.rightTable = rightTable;

diff --git a/src/sqlancer/hive/ast/HiveSelect.java b/src/sqlancer/hive/ast/HiveSelect.java
@@ -4,11 +4,11 @@
 
 import sqlancer.common.ast.SelectBase;
 import sqlancer.common.ast.newast.Select;
-import sqlancer.hive.HiveToStringVisitor;
 import sqlancer.hive.HiveSchema.HiveColumn;
 import sqlancer.hive.HiveSchema.HiveTable;
+import sqlancer.hive.HiveToStringVisitor;
 
-public class HiveSelect extends SelectBase<HiveExpression> 
+public class HiveSelect extends SelectBase<HiveExpression>
         implements Select<HiveJoin, HiveExpression, HiveTable, HiveColumn>, HiveExpression {
 
     private boolean isDistinct;

diff --git a/src/sqlancer/hive/ast/HiveTableReference.java b/src/sqlancer/hive/ast/HiveTableReference.java
@@ -3,11 +3,11 @@
 import sqlancer.common.ast.newast.TableReferenceNode;
 import sqlancer.hive.HiveSchema;
 
-public class HiveTableReference extends TableReferenceNode<HiveExpression, HiveSchema.HiveTable> 
+public class HiveTableReference extends TableReferenceNode<HiveExpression, HiveSchema.HiveTable>
         implements HiveExpression {
 
     public HiveTableReference(HiveSchema.HiveTable table) {
         super(table);
     }
 
-}
+}
diff --git a/src/sqlancer/hive/ast/HiveUnaryPostfixOperation.java b/src/sqlancer/hive/ast/HiveUnaryPostfixOperation.java
@@ -3,8 +3,7 @@
 import sqlancer.common.ast.BinaryOperatorNode.Operator;
 import sqlancer.common.ast.newast.NewUnaryPostfixOperatorNode;
 
-public class HiveUnaryPostfixOperation extends NewUnaryPostfixOperatorNode<HiveExpression>
-        implements HiveExpression {
+public class HiveUnaryPostfixOperation extends NewUnaryPostfixOperatorNode<HiveExpression> implements HiveExpression {
 
     public HiveUnaryPostfixOperation(HiveExpression expr, Operator op) {
         super(expr, op);
-Original file line number
+Diff line change
@@ Expand Up @@
         public HiveFunction(List<HiveExpression> args, F func) {
             super(args, func);
         }
     }