fix sql parsing, add tests

Author: tpellissier

README.md

@@ -14,7 +14,7 @@ A minimal Python SDK to use Microsoft Dataverse as a database for Azure AI Found
 ## Features
 
 - Simple `DataverseClient` facade for CRUD, SQL (read-only), and table metadata.
-- SQL-over-API: Constrained T-SQL (single SELECT with limited WHERE/TOP/ORDER BY) via native Web API `?sql=` parameter.
+- SQL-over-API: Constrained SQL (single SELECT with limited WHERE/TOP/ORDER BY) via native Web API `?sql=` parameter.
 - Table metadata ops: create simple custom tables with primitive columns (string/int/decimal/float/datetime/bool) and delete them.
 - Bulk create via `CreateMultiple` (collection-bound) by passing `list[dict]` to `create(entity_set, payloads)`; returns list of created IDs.
 - Bulk update via `UpdateMultiple` by calling `update_multiple(entity_set, records)` with primary key attribute present in each record; returns nothing.

pyproject.toml

@@ -3,9 +3,9 @@ requires = ["setuptools>=61.0"]
 build-backend = "setuptools.build_meta"
 
 [project]
-name = "dataverse-sdk-poc"
+name = "dataverse-python-client"
 version = "0.1.0"
-description = "POC: Dataverse Python SDK with TDS reads and OData CRUD via SQL router"
+description = "Dataverse Python client"
 authors = [{ name = "POC" }]
 readme = "README.md"
 requires-python = ">=3.10"

src/dataverse_sdk/client.py

@@ -14,7 +14,7 @@ class DataverseClient:
 
     This client exposes a simple, stable surface for:
     - OData CRUD: create, get, update, delete records
-    - SQL (read-only): execute T-SQL via Dataverse Custom API (no ODBC/TDS driver)
+    - SQL (read-only): query SQL via ?sql parameter in Web API
     - Table metadata: create, inspect, and delete simple custom tables
 
     The client owns authentication (Azure Identity) and configuration, and delegates
@@ -183,7 +183,7 @@ def get_multiple(
         )
 
     # SQL via Web API sql parameter
-    def query_sql(self, tsql: str):
+    def query_sql(self, sql: str):
         """Execute a read-only SQL query using the Dataverse Web API `?sql=` capability.
 
         The query must follow the currently supported subset: single SELECT with optional WHERE,
@@ -192,15 +192,15 @@ def query_sql(self, tsql: str):
 
         Parameters
         ----------
-        tsql : str
+        sql : str
             Supported single SELECT statement.
 
         Returns
         -------
         list[dict]
             Result rows (empty list if none).
         """
-        return self._get_odata().query_sql(tsql)
+        return self._get_odata().query_sql(sql)
 
     # Table metadata helpers
     def get_table_info(self, tablename: str) -> Optional[Dict[str, Any]]:

src/dataverse_sdk/odata.py

@@ -376,7 +376,7 @@ def _do_request(url: str, *, params: Optional[Dict[str, Any]] = None) -> Dict[st
             next_link = data.get("@odata.nextLink") or data.get("odata.nextLink") if isinstance(data, dict) else None
 
     # --------------------------- SQL Custom API -------------------------
-    def query_sql(self, tsql: str) -> list[dict[str, Any]]:
+    def query_sql(self, sql: str) -> list[dict[str, Any]]:
         """Execute a read-only SQL query using the Dataverse Web API `?sql=` capability.
 
         The platform supports a constrained subset of SQL SELECT statements directly on entity set endpoints:
@@ -387,7 +387,7 @@ def query_sql(self, tsql: str) -> list[dict[str, Any]]:
 
         Parameters
         ----------
-        tsql : str
+        sql : str
             Single SELECT statement within supported subset.
 
         Returns
@@ -402,17 +402,12 @@ def query_sql(self, tsql: str) -> list[dict[str, Any]]:
         RuntimeError
             If metadata lookup for the logical name fails.
         """
-        if not isinstance(tsql, str) or not tsql.strip():
-            raise ValueError("tsql must be a non-empty string")
-        sql = tsql.strip()
+        if not isinstance(sql, str) or not sql.strip():
+            raise ValueError("sql must be a non-empty string")
+        sql = sql.strip()
 
-        # Naive parse: find token after FROM (ignore brackets); stop at whitespace/newline
-        # Example: SELECT name FROM account AS a WHERE a.name LIKE 'Acme%'
-        m = re.search(r"from\s+([a-zA-Z0-9_]+)\b", sql, flags=re.IGNORECASE)
-        if not m:
-            raise ValueError("Unable to determine table logical name from SQL (expected 'FROM <logical>').")
-        logical_candidate = m.group(1)
-        logical = logical_candidate.lower()
+        # Extract logical table name via helper (robust to identifiers ending with 'from')
+        logical = self._extract_logical_table(sql)
 
         entity_set = self._entity_set_from_logical(logical)
         # Issue GET /{entity_set}?sql=<query>
@@ -445,6 +440,25 @@ def query_sql(self, tsql: str) -> list[dict[str, Any]]:
             return [row for row in body if isinstance(row, dict)]
         return []
 
+    @staticmethod
+    def _extract_logical_table(sql: str) -> str:
+        """Extract the logical table name after the first standalone FROM.
+
+        Examples:
+            SELECT * FROM account
+            SELECT col1, startfrom FROM new_sampleitem WHERE col1 = 1
+
+        """
+        if not isinstance(sql, str):
+            raise ValueError("sql must be a string")
+        # Mask out single-quoted string literals to avoid matching FROM inside them.
+        masked = re.sub(r"'([^']|'')*'", "'x'", sql)
+        pattern = r"\bfrom\b\s+([A-Za-z0-9_]+)"  # minimal, single-line regex
+        m = re.search(pattern, masked, flags=re.IGNORECASE)
+        if not m:
+            raise ValueError("Unable to determine table logical name from SQL (expected 'FROM <name>').")
+        return m.group(1).lower()
+
     # ---------------------- Entity set resolution -----------------------
     def _entity_set_from_logical(self, logical: str) -> str:
         """Resolve entity set name (plural) from a logical (singular) name using metadata.

src/dataverse_sdk/odata_pandas_wrappers.py

@@ -139,13 +139,13 @@ def get_ids(self, entity_set: str, ids: Sequence[str] | pd.Series | pd.Index, se
         return pd.DataFrame(rows)
 
     # --------------------------- Query SQL -------------------------------
-    def query_sql_df(self, tsql: str) -> pd.DataFrame:
+    def query_sql_df(self, sql: str) -> pd.DataFrame:
         """Execute a SQL query via the Dataverse Web API `?sql=` parameter and return a DataFrame.
 
         The statement must adhere to the supported subset (single SELECT, optional WHERE/TOP/ORDER BY, no joins).
         Empty result -> empty DataFrame (columns inferred only if rows present).
         """
-        rows: Any = self._c.query_sql(tsql)
+        rows: Any = self._c.query_sql(sql)
 
         # If API returned a JSON string, parse it
         if isinstance(rows, str):

tests/test_sql_parse.py

@@ -0,0 +1,38 @@
+import pytest
+from dataverse_sdk.odata import ODataClient
+
+class DummyAuth:
+    def acquire_token(self, scope):
+        class T: access_token = "x"  # no real token needed for parsing tests
+        return T()
+
+def _client():
+    return ODataClient(DummyAuth(), "https://org.example", None)
+
+def test_basic_from():
+    c = _client()
+    assert c._extract_logical_table("SELECT a FROM account") == "account"
+
+def test_underscore_name():
+    c = _client()
+    assert c._extract_logical_table("select x FROM new_sampleitem where x=1") == "new_sampleitem"
+
+def test_startfrom_identifier():
+    c = _client()
+    # Ensure we pick the real table 'case', not 'from' portion inside 'startfrom'
+    assert c._extract_logical_table("SELECT col, startfrom FROM case") == "case"
+
+def test_case_insensitive_keyword():
+    c = _client()
+    assert c._extract_logical_table("SeLeCt 1 FrOm ACCOUNT") == "account"
+
+def test_missing_from_raises():
+    c = _client()
+    with pytest.raises(ValueError):
+        c._extract_logical_table("SELECT 1")
+
+def test_from_as_value_not_table():
+    c = _client()
+    # Table should still be 'incident'; word 'from' earlier shouldn't interfere
+    sql = "SELECT 'from something', col FROM incident"
+    assert c._extract_logical_table(sql) == "incident"