Feat: ARX004_6A - SELECT SQL Integration Tests

Add comprehensive integration tests for SELECT SQL features:
- ORDER BY ASC/DESC with single and multiple fields
- GROUP BY with aggregates (count, sum)
- SKIP and LIMIT pagination
- Aggregate functions (COUNT, SUM, AVG, MIN, MAX)
- Subqueries with LET variables
- DISTINCT queries with set() function
- Combined WHERE, ORDER BY, LIMIT queries

19 test scenarios all passing against real ArcadeDB server.

Author: mindreframer

test/integration/sql/select_test.exs

@@ -0,0 +1,312 @@
+defmodule Arcadex.Integration.SQL.SelectTest do
+  @moduledoc """
+  Integration tests for SELECT SQL features against ArcadeDB.
+
+  Tests ORDER BY, GROUP BY, SKIP/LIMIT, aggregates, subqueries, and DISTINCT.
+  """
+  use Arcadex.IntegrationCase, async: true
+
+  setup_all %{conn: conn} do
+    # Create Product type with properties
+    Arcadex.command!(conn, "CREATE DOCUMENT TYPE Product")
+    Arcadex.command!(conn, "CREATE PROPERTY Product.uid STRING")
+    Arcadex.command!(conn, "CREATE PROPERTY Product.name STRING")
+    Arcadex.command!(conn, "CREATE PROPERTY Product.price DECIMAL")
+    Arcadex.command!(conn, "CREATE PROPERTY Product.category STRING")
+    Arcadex.command!(conn, "CREATE PROPERTY Product.stock INTEGER")
+    Arcadex.command!(conn, "CREATE INDEX ON Product (uid) UNIQUE")
+
+    # Seed test data with 10 products
+    for i <- 1..10 do
+      Arcadex.command!(
+        conn,
+        """
+        INSERT INTO Product SET
+          uid = :uid,
+          name = :name,
+          price = :price,
+          category = :category,
+          stock = :stock
+        """,
+        %{
+          uid: "prod_#{i}",
+          name: "Product #{i}",
+          price: i * 10.0,
+          category: if(rem(i, 2) == 0, do: "even", else: "odd"),
+          stock: i * 5
+        }
+      )
+    end
+
+    :ok
+  end
+
+  describe "ORDER BY" do
+    test "SELECT with ORDER BY ASC", %{conn: conn} do
+      products =
+        Arcadex.query!(
+          conn,
+          "SELECT name, price FROM Product ORDER BY price ASC LIMIT 3"
+        )
+
+      prices = Enum.map(products, & &1["price"])
+      assert prices == [10.0, 20.0, 30.0]
+    end
+
+    test "SELECT with ORDER BY DESC", %{conn: conn} do
+      products =
+        Arcadex.query!(
+          conn,
+          "SELECT name, price FROM Product ORDER BY price DESC LIMIT 3"
+        )
+
+      prices = Enum.map(products, & &1["price"])
+      assert prices == [100.0, 90.0, 80.0]
+    end
+
+    test "SELECT with multiple ORDER BY fields", %{conn: conn} do
+      products =
+        Arcadex.query!(
+          conn,
+          "SELECT name, category, price FROM Product ORDER BY category ASC, price DESC"
+        )
+
+      # First should be 'even' category with highest price
+      first = hd(products)
+      assert first["category"] == "even"
+      assert first["price"] == 100.0
+    end
+  end
+
+  describe "GROUP BY" do
+    test "SELECT with GROUP BY", %{conn: conn} do
+      results =
+        Arcadex.query!(
+          conn,
+          "SELECT category, count(*) as cnt FROM Product GROUP BY category"
+        )
+
+      assert length(results) == 2
+
+      by_category = Enum.into(results, %{}, fn r -> {r["category"], r["cnt"]} end)
+      assert by_category["even"] == 5
+      assert by_category["odd"] == 5
+    end
+
+    test "SELECT with GROUP BY and aggregate", %{conn: conn} do
+      results =
+        Arcadex.query!(
+          conn,
+          "SELECT category, sum(price) as total FROM Product GROUP BY category ORDER BY category"
+        )
+
+      # even: 20 + 40 + 60 + 80 + 100 = 300
+      # odd: 10 + 30 + 50 + 70 + 90 = 250
+      even_result = Enum.find(results, &(&1["category"] == "even"))
+      odd_result = Enum.find(results, &(&1["category"] == "odd"))
+
+      assert even_result["total"] == 300.0
+      assert odd_result["total"] == 250.0
+    end
+  end
+
+  describe "SKIP and LIMIT" do
+    test "SELECT with SKIP and LIMIT", %{conn: conn} do
+      products =
+        Arcadex.query!(
+          conn,
+          "SELECT FROM Product ORDER BY price ASC SKIP 2 LIMIT 3"
+        )
+
+      assert length(products) == 3
+      prices = Enum.map(products, & &1["price"])
+      # Skipping first 2 (10, 20), getting next 3 (30, 40, 50)
+      assert prices == [30.0, 40.0, 50.0]
+    end
+
+    test "SELECT with only LIMIT", %{conn: conn} do
+      products =
+        Arcadex.query!(
+          conn,
+          "SELECT FROM Product ORDER BY price ASC LIMIT 5"
+        )
+
+      assert length(products) == 5
+    end
+
+    test "SELECT with SKIP beyond data", %{conn: conn} do
+      products =
+        Arcadex.query!(
+          conn,
+          "SELECT FROM Product SKIP 100"
+        )
+
+      assert products == []
+    end
+  end
+
+  describe "Aggregates" do
+    test "SELECT with COUNT", %{conn: conn} do
+      [result] =
+        Arcadex.query!(
+          conn,
+          "SELECT count(*) as total FROM Product"
+        )
+
+      assert result["total"] == 10
+    end
+
+    test "SELECT with SUM", %{conn: conn} do
+      [result] =
+        Arcadex.query!(
+          conn,
+          "SELECT sum(price) as total FROM Product"
+        )
+
+      # 10 + 20 + 30 + ... + 100 = 550
+      assert result["total"] == 550.0
+    end
+
+    test "SELECT with AVG", %{conn: conn} do
+      [result] =
+        Arcadex.query!(
+          conn,
+          "SELECT avg(price) as average FROM Product"
+        )
+
+      # Average of 10, 20, ..., 100 = 55
+      assert result["average"] == 55.0
+    end
+
+    test "SELECT with MIN and MAX", %{conn: conn} do
+      [result] =
+        Arcadex.query!(
+          conn,
+          "SELECT min(price) as min_price, max(price) as max_price FROM Product"
+        )
+
+      assert result["min_price"] == 10.0
+      assert result["max_price"] == 100.0
+    end
+
+    test "SELECT with multiple aggregates", %{conn: conn} do
+      [result] =
+        Arcadex.query!(
+          conn,
+          "SELECT count(*) as cnt, sum(stock) as total_stock, avg(price) as avg_price FROM Product"
+        )
+
+      assert result["cnt"] == 10
+      # stock: 5 + 10 + 15 + ... + 50 = 275
+      assert result["total_stock"] == 275
+      assert result["avg_price"] == 55.0
+    end
+  end
+
+  describe "Subqueries" do
+    test "SELECT with subquery in WHERE", %{conn: conn} do
+      # First get the average price
+      [avg_result] =
+        Arcadex.query!(
+          conn,
+          "SELECT avg(price) as avg_price FROM Product"
+        )
+
+      avg_price = avg_result["avg_price"]
+
+      # Then use it in a parameterized query
+      products =
+        Arcadex.query!(
+          conn,
+          """
+          SELECT FROM Product
+          WHERE price > :avg_price
+          ORDER BY price ASC
+          """,
+          %{avg_price: avg_price}
+        )
+
+      # Products with price > 55 (average): 60, 70, 80, 90, 100
+      assert length(products) == 5
+      prices = Enum.map(products, & &1["price"])
+      assert Enum.all?(prices, &(&1 > 55.0))
+    end
+
+    test "SELECT with LET variable for computed value", %{conn: conn} do
+      # ArcadeDB uses LET for computed subquery values
+      [result] =
+        Arcadex.script!(
+          conn,
+          """
+          LET cnt = SELECT count(*) as cnt FROM Product;
+          RETURN $cnt[0].cnt
+          """
+        )
+
+      assert result["value"] == 10
+    end
+  end
+
+  describe "DISTINCT" do
+    test "SELECT DISTINCT on single field", %{conn: conn} do
+      results =
+        Arcadex.query!(
+          conn,
+          "SELECT DISTINCT category FROM Product ORDER BY category"
+        )
+
+      categories = Enum.map(results, & &1["category"])
+      assert categories == ["even", "odd"]
+    end
+
+    test "SELECT DISTINCT count", %{conn: conn} do
+      # ArcadeDB requires set() to count distinct values
+      [result] =
+        Arcadex.query!(
+          conn,
+          "SELECT set(category).size() as distinct_categories FROM Product"
+        )
+
+      assert result["distinct_categories"] == 2
+    end
+  end
+
+  describe "Combined features" do
+    test "SELECT with WHERE, ORDER BY, and LIMIT", %{conn: conn} do
+      products =
+        Arcadex.query!(
+          conn,
+          """
+          SELECT name, price FROM Product
+          WHERE category = 'odd'
+          ORDER BY price DESC
+          LIMIT 2
+          """
+        )
+
+      assert length(products) == 2
+      prices = Enum.map(products, & &1["price"])
+      # Top 2 odd products by price: 90, 70
+      assert prices == [90.0, 70.0]
+    end
+
+    test "SELECT with GROUP BY, HAVING would require HAVING", %{conn: conn} do
+      # ArcadeDB supports GROUP BY with aggregate filtering via WHERE
+      results =
+        Arcadex.query!(
+          conn,
+          """
+          SELECT category, count(*) as cnt, sum(price) as total
+          FROM Product
+          GROUP BY category
+          ORDER BY total DESC
+          """
+        )
+
+      # even total = 300, odd total = 250
+      first = hd(results)
+      assert first["category"] == "even"
+      assert first["total"] == 300.0
+    end
+  end
+end