FIX: Segmentation Fault when interleaving fetchmany and fetchone calls #427 (#441)

### Work Item / Issue Reference  
<!-- 
IMPORTANT: Please follow the PR template guidelines below.
For mssql-python maintainers: Insert your ADO Work Item ID below 
For external contributors: Insert Github Issue number below
Only one reference is required - either GitHub issue OR ADO Work Item.
-->

<!-- mssql-python maintainers: ADO Work Item -->
>
[AB#42605](https://sqlclientdrivers.visualstudio.com/c6d89619-62de-46a0-8b46-70b92a84d85e/_workitems/edit/42605)

<!-- External contributors: GitHub Issue -->
> GitHub Issue: #427 

-------------------------------------------------------------------
### Summary   
<!-- Insert your summary of changes below. Minimum 10 characters
required. -->
This pull request addresses a segmentation fault issue that occurred
when interleaving `fetchmany()` and `fetchone()` calls on a database
cursor, as reported in GitHub Issue #427. The main improvements include
unbinding columns after fetch operations to prevent conflicts with
`SQLGetData`, and adding comprehensive tests to ensure correct
interleaved fetch behavior.

Fixes for fetch interleaving bug:

* Added calls to `SQLFreeStmt_ptr(hStmt, SQL_UNBIND)` after
`fetchmany()` and `fetchall()` operations in `ddbc_bindings.cpp` to
unbind columns, allowing subsequent `fetchone()` calls to use
`SQLGetData` without causing segmentation faults.
[[1]](diffhunk://#diff-dde2297345718ec449a14e7dff91b7bb2342b008ecc071f562233646d71144a1R4097-R4100)
[[2]](diffhunk://#diff-dde2297345718ec449a14e7dff91b7bb2342b008ecc071f562233646d71144a1R4236-R4238)
* Added column unbinding at the start of `FetchOne_wrap` to avoid
conflicts from previous fetch operations, and improved error handling
for `SQLGetData` failures.

Testing improvements:

* Introduced a new test file `test_017_fetchmany_fetchone_interleave.py`
with multiple test cases to verify that interleaving `fetchmany()` and
`fetchone()` calls works correctly and no longer causes segmentation
faults.

<!-- 
### PR Title Guide

> For feature requests
FEAT: (short-description)

> For non-feature requests like test case updates, config updates ,
dependency updates etc
CHORE: (short-description) 

> For Fix requests
FIX: (short-description)

> For doc update requests 
DOC: (short-description)

> For Formatting, indentation, or styling update
STYLE: (short-description)

> For Refactor, without any feature changes
REFACTOR: (short-description)

> For release related changes, without any feature changes
RELEASE: #<RELEASE_VERSION> (short-description) 

### Contribution Guidelines

External contributors:
- Create a GitHub issue first:
https://github.com/microsoft/mssql-python/issues/new
- Link the GitHub issue in the "GitHub Issue" section above
- Follow the PR title format and provide a meaningful summary

mssql-python maintainers:
- Create an ADO Work Item following internal processes
- Link the ADO Work Item in the "ADO Work Item" section above  
- Follow the PR title format and provide a meaningful summary
-->

Author: gargsaumya

mssql_python/pybind/ddbc_bindings.cpp

@@ -4094,6 +4094,10 @@ SQLRETURN FetchMany_wrap(SqlHandlePtr StatementHandle, py::list& rows, int fetch
     // Reset attributes before returning to avoid using stack pointers later
     SQLSetStmtAttr_ptr(hStmt, SQL_ATTR_ROW_ARRAY_SIZE, (SQLPOINTER)1, 0);
     SQLSetStmtAttr_ptr(hStmt, SQL_ATTR_ROWS_FETCHED_PTR, NULL, 0);
+    
+    // Unbind columns to allow subsequent fetchone() calls to use SQLGetData
+    SQLFreeStmt_ptr(hStmt, SQL_UNBIND);
+    
     return ret;
 }
 
@@ -4228,6 +4232,9 @@ SQLRETURN FetchAll_wrap(SqlHandlePtr StatementHandle, py::list& rows,
     // Reset attributes before returning to avoid using stack pointers later
     SQLSetStmtAttr_ptr(hStmt, SQL_ATTR_ROW_ARRAY_SIZE, (SQLPOINTER)1, 0);
     SQLSetStmtAttr_ptr(hStmt, SQL_ATTR_ROWS_FETCHED_PTR, NULL, 0);
+    
+    // Unbind columns to allow subsequent fetchone() calls to use SQLGetData
+    SQLFreeStmt_ptr(hStmt, SQL_UNBIND);
 
     return ret;
 }
@@ -4254,12 +4261,21 @@ SQLRETURN FetchOne_wrap(SqlHandlePtr StatementHandle, py::list& row,
     SQLRETURN ret;
     SQLHSTMT hStmt = StatementHandle->get();
 
+    // Unbind any columns from previous fetch operations (e.g., fetchmany)
+    // to avoid conflicts with SQLGetData. SQLGetData cannot be used on
+    // columns that are already bound.
+    SQLFreeStmt_ptr(hStmt, SQL_UNBIND);
+
     // Assume hStmt is already allocated and a query has been executed
     ret = SQLFetch_ptr(hStmt);
     if (SQL_SUCCEEDED(ret)) {
         // Retrieve column count
         SQLSMALLINT colCount = SQLNumResultCols_wrap(StatementHandle);
         ret = SQLGetData_wrap(StatementHandle, colCount, row, charEncoding, wcharEncoding);
+        if (!SQL_SUCCEEDED(ret)) {
+            LOG("FetchOne_wrap: Error retrieving data with SQLGetData - SQLRETURN=%d", ret);
+            return ret;
+        }
     } else if (ret != SQL_NO_DATA) {
         LOG("FetchOne_wrap: Error when fetching data - SQLRETURN=%d", ret);
     }

tests/test_017_fetchmany_fetchone_interleave.py

@@ -0,0 +1,53 @@
+"""
+Test for GitHub Issue #427: Segmentation fault when interleaving fetchmany() and fetchone()
+https://github.com/microsoft/mssql-python/issues/427
+"""
+
+import pytest
+
+
+def test_fetchmany_then_fetchone_interleave(cursor):
+    """
+    Test that fetchmany() followed by fetchone() doesn't cause segfault.
+    This was the original failing case from issue #427.
+    """
+    cursor.execute("SELECT 1 UNION SELECT 2")
+
+    result1 = cursor.fetchmany(1)
+    assert len(result1) == 1
+    assert result1[0][0] == 1
+
+    # This used to cause segfault on Linux, return None on Windows
+    result2 = cursor.fetchone()
+    assert result2 is not None
+    assert result2[0] == 2
+
+
+def test_fetchone_then_fetchmany_interleave(cursor):
+    """Test that fetchone() followed by fetchmany() works correctly."""
+    cursor.execute("SELECT 1 UNION SELECT 2 UNION SELECT 3")
+
+    result1 = cursor.fetchone()
+    assert result1[0] == 1
+
+    result2 = cursor.fetchmany(2)
+    assert len(result2) == 2
+    assert result2[0][0] == 2
+    assert result2[1][0] == 3
+
+
+def test_multiple_interleaved_fetches(cursor):
+    """Test multiple alternating fetchmany() and fetchone() calls."""
+    cursor.execute("SELECT 1 UNION SELECT 2 UNION SELECT 3 UNION SELECT 4")
+
+    result = cursor.fetchmany(1)
+    assert result[0][0] == 1
+
+    result = cursor.fetchone()
+    assert result[0] == 2
+
+    result = cursor.fetchmany(1)
+    assert result[0][0] == 3
+
+    result = cursor.fetchone()
+    assert result[0] == 4