FIX: Handle empty data + tests (#212)

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

<!-- mssql-python maintainers: ADO Work Item -->
> AB#<WORK_ITEM_ID>

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

-------------------------------------------------------------------
### Summary   
<!-- Insert your summary of changes below. Minimum 10 characters
required. -->
This pull request improves the handling of empty string and binary
values in the MSSQL Python bindings, ensuring that empty data is
correctly distinguished from NULL values and does not cause assertion
failures. It also adds comprehensive tests to verify correct behavior
for these edge cases.

**Improvements to empty value handling:**

* Updated `SQLGetData_wrap` in `ddbc_bindings.cpp` to append an empty
string (`""`) or empty bytes (`b""`) when the returned data length is
zero, instead of causing assertion failures or misinterpreting the value
as NULL. This change applies to both string and binary column types.
[[1]](diffhunk://#diff-dde2297345718ec449a14e7dff91b7bb2342b008ecc071f562233646d71144a1R1703-R1705)
[[2]](diffhunk://#diff-dde2297345718ec449a14e7dff91b7bb2342b008ecc071f562233646d71144a1R1762-R1764)
[[3]](diffhunk://#diff-dde2297345718ec449a14e7dff91b7bb2342b008ecc071f562233646d71144a1R1961-R1963)
* Changed assertions in `FetchBatchData` to allow zero-length data,
ensuring that empty values are handled gracefully instead of triggering
errors.

**Testing improvements:**

* Added new tests in `tests/test_004_cursor.py` to verify correct
handling of empty strings and binary data, including distinguishing
empty values from NULLs, batch fetching, and various edge cases for
empty strings. These tests ensure that the fixes work as intended and
prevent regressions.

**Minor code cleanup:**

* Minor formatting and comment improvements in `ddbc_bindings.cpp` for
better code clarity.

<!-- 
### 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: bewithgaurav

mssql_python/pybind/ddbc_bindings.cpp

@@ -1778,11 +1778,19 @@ SQLRETURN SQLGetData_wrap(SqlHandlePtr StatementHandle, SQLUSMALLINT colCount, p
                         }
 				    } else if (dataLen == SQL_NULL_DATA) {
 					    row.append(py::none());
-                    } else {
-                        assert(dataLen == SQL_NO_TOTAL);
+                    } else if (dataLen == 0) {
+                        // Handle zero-length (non-NULL) data
+                        row.append(std::string(""));
+                    } else if (dataLen == SQL_NO_TOTAL) {
+                        // This means the length of the data couldn't be determined
                         LOG("SQLGetData couldn't determine the length of the data. "
-                            "Returning NULL value instead. Column ID - {}", i);
-					    row.append(py::none());
+                            "Returning NULL value instead. Column ID - {}, Data Type - {}", i, dataType);
+                    } else if (dataLen < 0) {
+                        // This is unexpected
+                        LOG("SQLGetData returned an unexpected negative data length. "
+                            "Raising exception. Column ID - {}, Data Type - {}, Data Length - {}",
+                            i, dataType, dataLen);
+                        ThrowStdException("SQLGetData returned an unexpected negative data length");
                     }
 				} else {
 					LOG("Error retrieving data for column - {}, data type - {}, SQLGetData return "
@@ -1834,11 +1842,15 @@ SQLRETURN SQLGetData_wrap(SqlHandlePtr StatementHandle, SQLUSMALLINT colCount, p
                         }
 				    } else if (dataLen == SQL_NULL_DATA) {
 					    row.append(py::none());
-                    } else {
-                        assert(dataLen == SQL_NO_TOTAL);
-                        LOG("SQLGetData couldn't determine the length of the data. "
-                            "Returning NULL value instead. Column ID - {}", i);
-					    row.append(py::none());
+                    } else if (dataLen == 0) {
+                        // Handle zero-length (non-NULL) data
+                        row.append(py::str(""));
+                    } else if (dataLen < 0) {
+                        // This is unexpected
+                        LOG("SQLGetData returned an unexpected negative data length. "
+                            "Raising exception. Column ID - {}, Data Type - {}, Data Length - {}",
+                            i, dataType, dataLen);
+                        ThrowStdException("SQLGetData returned an unexpected negative data length");
                     }
 				} else {
 					LOG("Error retrieving data for column - {}, data type - {}, SQLGetData return "
@@ -2030,11 +2042,15 @@ SQLRETURN SQLGetData_wrap(SqlHandlePtr StatementHandle, SQLUSMALLINT colCount, p
                         }
 				    } else if (dataLen == SQL_NULL_DATA) {
 					    row.append(py::none());
-                    } else {
-                        assert(dataLen == SQL_NO_TOTAL);
-                        LOG("SQLGetData couldn't determine the length of the data. "
-                            "Returning NULL value instead. Column ID - {}", i);
-					    row.append(py::none());
+                    } else if (dataLen == 0) {
+                        // Empty bytes
+                        row.append(py::bytes(""));
+                    } else if (dataLen < 0) {
+                        // This is unexpected
+                        LOG("SQLGetData returned an unexpected negative data length. "
+                            "Raising exception. Column ID - {}, Data Type - {}, Data Length - {}",
+                            i, dataType, dataLen);
+                        ThrowStdException("SQLGetData returned an unexpected negative data length");
                     }
 				} else {
 					LOG("Error retrieving data for column - {}, data type - {}, SQLGetData return "
@@ -2317,8 +2333,30 @@ SQLRETURN FetchBatchData(SQLHSTMT hStmt, ColumnBuffers& buffers, py::list& colum
                     "Column ID - {}", col);
                 row.append(py::none());
                 continue;
+            } else if (dataLen == SQL_NULL_DATA) {
+                LOG("Column data is NULL. Appending None to the result row. Column ID - {}", col);
+                row.append(py::none());
+                continue;
+            } else if (dataLen == 0) {
+                // Handle zero-length (non-NULL) data
+                if (dataType == SQL_CHAR || dataType == SQL_VARCHAR || dataType == SQL_LONGVARCHAR) {
+                    row.append(std::string(""));
+                } else if (dataType == SQL_WCHAR || dataType == SQL_WVARCHAR || dataType == SQL_WLONGVARCHAR) {
+                    row.append(std::wstring(L""));
+                } else if (dataType == SQL_BINARY || dataType == SQL_VARBINARY || dataType == SQL_LONGVARBINARY) {
+                    row.append(py::bytes(""));
+                } else {
+                    // For other datatypes, 0 length is unexpected. Log & append None
+                    LOG("Column data length is 0 for non-string/binary datatype. Appending None to the result row. Column ID - {}", col);
+                    row.append(py::none());
+                }
+                continue;
+            } else if (dataLen < 0) {
+                // Negative value is unexpected, log column index, SQL type & raise exception
+                LOG("Unexpected negative data length. Column ID - {}, SQL Type - {}, Data Length - {}", col, dataType, dataLen);
+                ThrowStdException("Unexpected negative data length, check logs for details");
             }
-            assert(dataLen > 0 && "Must be > 0 since SQL_NULL_DATA & SQL_NO_DATA is already handled");
+            assert(dataLen > 0 && "Data length must be > 0");
 
             switch (dataType) {
                 case SQL_CHAR: