sqlancer · mrigger · Apr 21, 2025 · Jan 14, 2024 · Apr 9, 2025 · Apr 13, 2025
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
@@ -297,6 +297,42 @@ jobs:
       - name: Run Tests
         run: mvn -Dtest=TestH2 test
 
+  hive:
+    name: DBMS Tests (Hive)
+    runs-on: ubuntu-latest
+    services:
+      metastore:
+        image: apache/hive:4.0.1
+        env:
+          SERVICE_NAME: 'metastore'
+        ports:
+          - 9083:9083
+        volumes:
+          - warehouse:/opt/hive/data/warehouse
+      hiveserver2:
+        image: apache/hive:4.0.1
+        env:
+          SERVICE_NAME: 'hiveserver2'
+        ports:
+          - 10000:10000
+          - 10002:10002
+        volumes:
+          - warehouse:/opt/hive/data/warehouse
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+      - name: Set up JDK 11
+        uses: actions/setup-java@v3
+        with:
+          distribution: 'temurin'
+          java-version: '11'
+          cache: 'maven'
+      - name: Build SQLancer
+        run: mvn -B package -DskipTests=true
+      - name: Run Tests
+        run: HIVE_AVAILABLE=true mvn -Dtest=TestHiveTLP test
+
   hsqldb:
     name: DBMS Tests (HSQLB)
     runs-on: ubuntu-latest

diff --git a/.gitignore b/.gitignore
@@ -1,8 +1,6 @@
 target/
 .classpath
-.settings/org.eclipse.core.resources.prefs
-.settings/org.eclipse.m2e.core.prefs
-.settings/org.eclipse.jdt.core.prefs
+.settings/
 .vscode
 .project
 .checkstyle

diff --git a/pom.xml b/pom.xml
@@ -377,6 +377,21 @@
       <groupId>org.apache.arrow</groupId>
       <artifactId>flight-sql-jdbc-driver</artifactId>
       <version>16.1.0</version>
+    </dependency>
+        <dependency>
+      <groupId>org.apache.hive</groupId>
+      <artifactId>hive-jdbc</artifactId>
+      <version>4.0.1</version>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.hive</groupId>
+      <artifactId>hive-serde</artifactId>
+      <version>4.0.1</version>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.hive</groupId>
+      <artifactId>hive-cli</artifactId>
+      <version>4.0.1</version>
     </dependency>
   </dependencies>
   <reporting>

diff --git a/src/sqlancer/Main.java b/src/sqlancer/Main.java
@@ -34,6 +34,7 @@
 import sqlancer.doris.DorisProvider;
 import sqlancer.duckdb.DuckDBProvider;
 import sqlancer.h2.H2Provider;
+import sqlancer.hive.HiveProvider;
 import sqlancer.hsqldb.HSQLDBProvider;
 import sqlancer.mariadb.MariaDBProvider;
 import sqlancer.materialize.MaterializeProvider;
@@ -735,6 +736,7 @@ private static void checkForIssue799(List<DatabaseProvider<?, ?, ?>> providers)
             providers.add(new DorisProvider());
             providers.add(new DuckDBProvider());
             providers.add(new H2Provider());
+            providers.add(new HiveProvider());
             providers.add(new HSQLDBProvider());
             providers.add(new MariaDBProvider());
             providers.add(new MaterializeProvider());

diff --git a/src/sqlancer/hive/HiveErrors.java b/src/sqlancer/hive/HiveErrors.java
@@ -0,0 +1,40 @@
+package sqlancer.hive;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import sqlancer.common.query.ExpectedErrors;
+
+public class HiveErrors {
+
+    private HiveErrors() {
+    }
+
+    public static List<String> getExpressionErrors() {
+        ArrayList<String> errors = new ArrayList<>();
+
+        errors.add("cannot recognize input near");
+        errors.add("Argument type mismatch");
+        errors.add("Error while compiling statement");
+
+        return errors;
+    }
+
+    public static void addExpressionErrors(ExpectedErrors errors) {
+        errors.addAll(getExpressionErrors());
+    }
+
+    public static List<String> getInsertErrors() {
+        ArrayList<String> errors = new ArrayList<>();
+
+        errors.add("Either CHECK or NOT NULL constraint violated!");
+        errors.add("Error running query");
+        errors.add("is different from preceding arguments");
+
+        return errors;
+    }
+
+    public static void addInsertErrors(ExpectedErrors errors) {
+        errors.addAll(getInsertErrors());
+    }
+}
diff --git a/src/sqlancer/hive/HiveGlobalState.java b/src/sqlancer/hive/HiveGlobalState.java
@@ -0,0 +1,11 @@
+package sqlancer.hive;
+
+import sqlancer.SQLGlobalState;
+
+public class HiveGlobalState extends SQLGlobalState<HiveOptions, HiveSchema> {
+
+    @Override
+    protected HiveSchema readSchema() throws Exception {
+        return HiveSchema.fromConnection(getConnection(), getDatabaseName());
+    }
+}
diff --git a/src/sqlancer/hive/HiveOptions.java b/src/sqlancer/hive/HiveOptions.java
@@ -0,0 +1,43 @@
+package sqlancer.hive;
+
+import com.beust.jcommander.Parameter;
+import com.beust.jcommander.Parameters;
+
+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 + ")")
+public class HiveOptions implements DBMSSpecificOptions<HiveOptions.HiveOracleFactory> {
+    public static final String DEFAULT_HOST = "localhost";
+    public static final int DEFAULT_PORT = 10000;
+
+    @Parameter(names = "--oracle")
+    public List<HiveOracleFactory> oracle = Arrays.asList(HiveOracleFactory.TLPWhere);
+
+    public enum HiveOracleFactory implements OracleFactory<HiveGlobalState> {
+        TLPWhere {
+            @Override
+            public TestOracle<HiveGlobalState> create(HiveGlobalState globalState) throws SQLException {
+                HiveExpressionGenerator gen = new HiveExpressionGenerator(globalState);
+                ExpectedErrors expectedErrors = ExpectedErrors.newErrors()
+                        .with(HiveErrors.getExpressionErrors()).build();
+
+                return new TLPWhereOracle<>(globalState, gen, expectedErrors);
+            }
+        };
+    }
+
+    @Override
+    public List<HiveOracleFactory> getTestOracleFactory() {
+        return oracle;
+    }
+}
diff --git a/src/sqlancer/hive/HiveProvider.java b/src/sqlancer/hive/HiveProvider.java
@@ -0,0 +1,121 @@
+package sqlancer.hive;
+
+import sqlancer.AbstractAction;
+import sqlancer.DatabaseProvider;
+import sqlancer.IgnoreMeException;
+import sqlancer.MainOptions;
+import sqlancer.Randomly;
+import sqlancer.SQLConnection;
+import sqlancer.SQLProviderAdapter;
+import sqlancer.StatementExecutor;
+import sqlancer.common.query.SQLQueryAdapter;
+import sqlancer.common.query.SQLQueryProvider;
+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> {
+
+    public HiveProvider() {
+        super(HiveGlobalState.class, HiveOptions.class);
+    }
+
+    public enum Action implements AbstractAction<HiveGlobalState> {
+
+        INSERT(HiveInsertGenerator::getQuery);
+
+        private final SQLQueryProvider<HiveGlobalState> sqlQueryProvider;
+
+        Action(SQLQueryProvider<HiveGlobalState> sqlQueryProvider) {
+            this.sqlQueryProvider = sqlQueryProvider;
+        }
+
+        @Override
+        public SQLQueryAdapter getQuery(HiveGlobalState state) throws Exception {
+            return sqlQueryProvider.getQuery(state);
+        }
+    }
+
+    private static int mapActions(HiveGlobalState globalState, Action a) {
+        Randomly r = globalState.getRandomly();
+        switch (a) {
+        case INSERT:
+            return r.getInteger(0, globalState.getOptions().getMaxNumberInserts());
+        default:
+            throw new AssertionError(a);
+        }
+    }
+
+    @Override
+    public void generateDatabase(HiveGlobalState globalState) throws Exception {
+        for (int i = 0; i < Randomly.fromOptions(1, 2); i++) {
+            boolean success;
+            do {
+                String tableName = globalState.getSchema().getFreeTableName();
+                SQLQueryAdapter qt = HiveTableGenerator.generate(globalState, tableName);
+                success = globalState.executeStatement(qt);
+            } while(!success);
+        }
+        if (globalState.getSchema().getDatabaseTables().isEmpty()) {
+            throw new IgnoreMeException(); // TODO
+        }
+
+        StatementExecutor<HiveGlobalState, Action> se = new StatementExecutor<HiveGlobalState, Action>(
+                globalState, Action.values(), 
+                HiveProvider::mapActions, (q) -> {
+                    if (globalState.getSchema().getDatabaseTables().isEmpty()) {
+                        throw new IgnoreMeException();
+                    }
+                });
+        se.executeStatements();
+    }
+
+    @Override
+    public SQLConnection createDatabase(HiveGlobalState globalState) throws SQLException {
+        String username = globalState.getOptions().getUserName();
+        String password = globalState.getOptions().getPassword();
+        String host = globalState.getOptions().getHost();
+        int port = globalState.getOptions().getPort();
+        if (host == null) {
+            host = HiveOptions.DEFAULT_HOST;
+        }
+        if (port == MainOptions.NO_SET_PORT) {
+            port = HiveOptions.DEFAULT_PORT;
+        }
+
+        String databaseName = globalState.getDatabaseName();
+
+        String url = String.format("jdbc:hive2://%s:%d/%s", host, port, "default");
+        Connection con = DriverManager.getConnection(url, username, password);
+        globalState.getState().logStatement("DROP DATABASE IF EXISTS " + databaseName + " CASCADE");
+        globalState.getState().logStatement("CREATE DATABASE " + databaseName);
+        globalState.getState().logStatement("USE " + databaseName);
+        try (Statement s = con.createStatement()) {
+            s.execute("DROP DATABASE IF EXISTS " + databaseName + " CASCADE");
+        }
+        try (Statement s = con.createStatement()) {
+            s.execute("CREATE DATABASE " + databaseName);
+        }
+        try (Statement s = con.createStatement()) {
+            s.execute("USE " + databaseName);
+        }
+        con.close();
+        con = DriverManager.getConnection(
+            String.format("jdbc:hive2://%s:%d/%s", host, port, databaseName,
+            username, password));
+
+        return new SQLConnection(con);
+    }
+
+    @Override
+    public String getDBMSName() {
+        return "hive";
+    }
+}