mssql-python 0.1.6__cp313-cp313-win_arm64.whl

mssql_python/testing_ddbc_bindings.py

@@ -0,0 +1,463 @@
+"""
+Copyright (c) Microsoft Corporation.
+Licensed under the MIT license.
+This module provides functions to test DDBC bindings.
+"""
+import ctypes
+import datetime
+import os
+from mssql_python import ddbc_bindings
+from mssql_python.logging_config import setup_logging
+
+setup_logging()
+
+# Constants
+SQL_HANDLE_ENV = 1
+SQL_HANDLE_DBC = 2
+SQL_HANDLE_STMT = 3
+SQL_ATTR_DDBC_VERSION = 200
+SQL_OV_DDBC3_80 = 380
+SQL_DRIVER_NOPROMPT = 0
+SQL_NTS = -3  # SQL_NULL_TERMINATED for indicating string length in SQLDriverConnect
+SQL_NO_DATA = 100  # This is the value to indicate that there is no more data
+
+
+def alloc_handle(handle_type, input_handle):
+    """
+    Allocate a handle for the given handle type and input handle.
+    """
+    result_alloc, handle = ddbc_bindings.DDBCSQLAllocHandle(
+        handle_type,
+        input_handle
+    )
+    if result_alloc < 0:
+        print(
+            "Error:", ddbc_bindings.DDBCSQLCheckError(handle_type, handle, result_alloc)
+        )
+        raise RuntimeError(f"Failed to allocate handle. Error code: {result_alloc}")
+    return handle
+
+
+def free_handle(handle_type, handle):
+    """
+    Free the handle for the given handle type and handle.
+    """
+    result_free = ddbc_bindings.DDBCSQLFreeHandle(handle_type, handle)
+    if result_free < 0:
+        print(
+            "Error:", ddbc_bindings.DDBCSQLCheckError(handle_type, handle, result_free)
+        )
+        raise RuntimeError(f"Failed to free handle. Error code: {result_free}")
+
+
+def ddbc_sql_execute(
+    stmt_handle, query, params, param_info_list, is_stmt_prepared, use_prepare=True
+):
+    """
+    Execute an SQL statement using DDBC bindings.
+    """
+    result_execute = ddbc_bindings.DDBCSQLExecute(
+        stmt_handle, query, params, param_info_list, is_stmt_prepared, use_prepare
+    )
+    if result_execute < 0:
+        print(
+            "Error: ",
+            ddbc_bindings.DDBCSQLCheckError(SQL_HANDLE_STMT, stmt_handle, result_execute),
+        )
+        raise RuntimeError(f"Failed to execute query. Error code: {result_execute}")
+    return result_execute
+
+
+def fetch_data_onebyone(stmt_handle):
+    """
+    Fetch data one by one using DDBC bindings.
+    """
+    rows = []
+    ret_fetch = 1
+    while ret_fetch != SQL_NO_DATA:
+        row = []
+        ret_fetch = ddbc_bindings.DDBCSQLFetchOne(stmt_handle, row)
+        if ret_fetch < 0:
+            print(
+                "Error: ",
+                ddbc_bindings.DDBCSQLCheckError(
+                    SQL_HANDLE_STMT, stmt_handle, ret_fetch
+                ),
+            )
+            raise RuntimeError(f"Failed to fetch data. Error code: {ret_fetch}")
+        print(row)
+        rows.append(row)
+    return rows
+
+
+def fetch_data_many(stmt_handle):
+    """
+    Fetch data in batches using DDBC bindings.
+    """
+    rows = []
+    ret_fetch = 1
+    while ret_fetch != SQL_NO_DATA:
+        ret_fetch = ddbc_bindings.DDBCSQLFetchMany(stmt_handle, rows, 10)
+        if ret_fetch < 0:
+            print(
+                "Error: ",
+                ddbc_bindings.DDBCSQLCheckError(
+                    SQL_HANDLE_STMT, stmt_handle, ret_fetch
+                ),
+            )
+            raise RuntimeError(f"Failed to fetch data. Error code: {ret_fetch}")
+    return rows
+
+
+def fetch_data_all(stmt_handle):
+    """
+    Fetch all data using DDBC bindings.
+    """
+    rows = []
+    ret_fetch = ddbc_bindings.DDBCSQLFetchAll(stmt_handle, rows)
+    if ret_fetch != SQL_NO_DATA:
+        print(
+            "Error: ",
+            ddbc_bindings.DDBCSQLCheckError(SQL_HANDLE_STMT, stmt_handle, ret_fetch),
+        )
+        raise RuntimeError(f"Failed to fetch data. Error code: {ret_fetch}")
+    return rows
+
+
+def fetch_data(stmt_handle):
+    """
+    Fetch data using DDBC bindings.
+    """
+    rows = []
+    column_count = ddbc_bindings.DDBCSQLNumResultCols(stmt_handle)
+    print("Number of columns = " + str(column_count))
+    while True:
+        result_fetch = ddbc_bindings.DDBCSQLFetch(stmt_handle)
+        if result_fetch == SQL_NO_DATA:
+            break
+        if result_fetch < 0:
+            print(
+                "Error: ",
+                ddbc_bindings.DDBCSQLCheckError(
+                    SQL_HANDLE_STMT, stmt_handle, result_fetch
+                ),
+            )
+            raise RuntimeError(f"Failed to fetch data. Error code: {result_fetch}")
+        if column_count > 0:
+            row = []
+            result_get_data = ddbc_bindings.DDBCSQLGetData(stmt_handle, column_count, row)
+            if result_get_data < 0:
+                print(
+                    "Error: ",
+                    ddbc_bindings.DDBCSQLCheckError(
+                        SQL_HANDLE_STMT, stmt_handle, result_get_data
+                    ),
+                )
+                raise RuntimeError(f"Failed to get data. Error code: {result_get_data}")
+            rows.append(row)
+    return rows
+
+
+def describe_columns(stmt_handle):
+    """
+    Describe columns using DDBC bindings.
+    """
+    column_names = []
+    result_describe = ddbc_bindings.DDBCSQLDescribeCol(stmt_handle, column_names)
+    if result_describe < 0:
+        print(
+            "Error: ",
+            ddbc_bindings.DDBCSQLCheckError(SQL_HANDLE_STMT, stmt_handle, result_describe),
+        )
+        raise RuntimeError(f"Failed to describe columns. Error code: {result_describe}")
+    return column_names
+
+
+def connect_to_db(dbc_handle, connection_string):
+    """
+    Connect to the database using DDBC bindings.
+    """
+    result_connect = ddbc_bindings.DDBCSQLDriverConnect(dbc_handle, 0, connection_string)
+    if result_connect < 0:
+        print(
+            "Error: ",
+            ddbc_bindings.DDBCSQLCheckError(SQL_HANDLE_DBC, dbc_handle, result_connect),
+        )
+        raise RuntimeError(f"SQLDriverConnect failed. Error code: {result_connect}")
+
+
+def add_string_param(params, param_infos, data_string):
+    """
+    Add a string parameter to the parameter list.
+    """
+    params.append(data_string)
+    param_info = ddbc_bindings.ParamInfo()
+    param_info.paramCType = 1  # SQL_C_CHAR
+    param_info.paramSQLType = 12  # SQL_VARCHAR
+    param_info.columnSize = len(data_string)
+    param_info.inputOutputType = 1  # SQL_PARAM_INPUT
+    param_infos.append(param_info)
+
+
+def add_wstring_param(params, param_infos, wide_string):
+    """
+    Add a wide string parameter to the parameter list.
+    """
+    params.append(wide_string)
+    param_info = ddbc_bindings.ParamInfo()
+    param_info.paramCType = -8  # SQL_C_WCHAR
+    param_info.paramSQLType = -9  # SQL_WVARCHAR
+    param_info.columnSize = len(wide_string)
+    param_info.inputOutputType = 1  # SQL_PARAM_INPUT
+    param_infos.append(param_info)
+
+
+def add_date_param(params, param_infos):
+    """
+    Add a date parameter to the parameter list.
+    """
+    date_obj = datetime.date(2025, 1, 28)  # 28th Jan 2025
+    params.append(date_obj)
+    param_info = ddbc_bindings.ParamInfo()
+    param_info.paramCType = 91  # SQL_C_TYPE_DATE
+    param_info.paramSQLType = 91  # SQL_TYPE_DATE
+    param_info.inputOutputType = 1  # SQL_PARAM_INPUT
+    param_infos.append(param_info)
+
+
+def add_time_param(params, param_infos):
+    """
+    Add a time parameter to the parameter list.
+    """
+    time_obj = datetime.time(5, 15, 30)  # 5:15 AM + 30 secs
+    params.append(time_obj)
+    param_info = ddbc_bindings.ParamInfo()
+    param_info.paramCType = 92  # SQL_C_TYPE_TIME
+    param_info.paramSQLType = 92  # SQL_TYPE_TIME
+    param_info.inputOutputType = 1  # SQL_PARAM_INPUT
+    param_infos.append(param_info)
+
+
+def add_datetime_param(params, param_infos, add_none):
+    """
+    Add a datetime parameter to the parameter list.
+    """
+    param_info = ddbc_bindings.ParamInfo()
+    if add_none:
+        params.append(None)
+        param_info.paramCType = 99  # SQL_C_DEFAULT
+    else:
+        datetime_obj = datetime.datetime(2025, 1, 28, 5, 15, 30)
+        params.append(datetime_obj)
+        param_info.paramCType = 93  # SQL_C_TYPE_TIMESTAMP
+    param_info.paramSQLType = 93  # SQL_TYPE_TIMESTAMP
+    param_info.inputOutputType = 1  # SQL_PARAM_INPUT
+    param_infos.append(param_info)
+
+
+def add_bool_param(params, param_infos, bool_val):
+    """
+    Add a boolean parameter to the parameter list.
+    """
+    params.append(bool_val)
+    param_info = ddbc_bindings.ParamInfo()
+    param_info.paramCType = -7  # SQL_C_BIT
+    param_info.paramSQLType = -7  # SQL_BIT
+    param_info.inputOutputType = 1  # SQL_PARAM_INPUT
+    param_infos.append(param_info)
+
+
+def add_tinyint_param(params, param_infos, val):
+    """
+    Add a tinyint parameter to the parameter list.
+    """
+    params.append(val)
+    param_info = ddbc_bindings.ParamInfo()
+    param_info.paramCType = -6  # SQL_C_TINYINT
+    param_info.paramSQLType = -6  # SQL_TINYINT
+    param_info.inputOutputType = 1  # SQL_PARAM_INPUT
+    param_infos.append(param_info)
+
+
+def add_bigint_param(params, param_infos, val):
+    """
+    Add a bigint parameter to the parameter list.
+    """
+    params.append(val)
+    param_info = ddbc_bindings.ParamInfo()
+    param_info.paramCType = -25  # SQL_C_SBIGINT
+    param_info.paramSQLType = -5  # SQL_BIGINT
+    param_info.inputOutputType = 1  # SQL_PARAM_INPUT
+    param_infos.append(param_info)
+
+
+def add_float_param(params, param_infos, val):
+    """
+    Add a float parameter to the parameter list.
+    """
+    params.append(val)
+    param_info = ddbc_bindings.ParamInfo()
+    param_info.paramCType = 7  # SQL_C_FLOAT
+    param_info.paramSQLType = 7  # SQL_REAL
+    param_info.inputOutputType = 1  # SQL_PARAM_INPUT
+    param_info.columnSize = 15  # Precision
+    param_infos.append(param_info)
+
+
+def add_double_param(params, param_infos, val):
+    """
+    Add a double parameter to the parameter list.
+    """
+    params.append(val)
+    param_info = ddbc_bindings.ParamInfo()
+    param_info.paramCType = 8  # SQL_C_DOUBLE
+    param_info.paramSQLType = 8  # SQL_DOUBLE
+    param_info.inputOutputType = 1  # SQL_PARAM_INPUT
+    param_info.columnSize = 15  # Precision
+    param_infos.append(param_info)
+
+
+def add_numeric_param(params, param_infos, param):
+    """
+    Add a numeric parameter to the parameter list.
+    """
+    numeric_data = ddbc_bindings.NumericData()
+    numeric_data.precision = len(param.as_tuple().digits)
+    numeric_data.scale = param.as_tuple().exponent * -1
+    numeric_data.sign = param.as_tuple().sign
+    numeric_data.val = str(param)
+    print(
+        type(numeric_data.precision),
+        type(numeric_data.scale),
+        type(numeric_data.sign),
+        type(numeric_data.val),
+        type(numeric_data),
+    )
+    params.append(numeric_data)
+
+    param_info = ddbc_bindings.ParamInfo()
+    param_info.paramCType = 2  # SQL_C_NUMERIC
+    param_info.paramSQLType = 2  # SQL_NUMERIC
+    param_info.inputOutputType = 1  # SQL_PARAM_INPUT
+    param_info.columnSize = 10  # Precision
+    param_infos.append(param_info)
+
+
+if __name__ == "__main__":
+    # Allocate environment handle
+    env_handle = alloc_handle(SQL_HANDLE_ENV, None)
+    
+    # Set the DDBC version environment attribute
+    result_set_env = ddbc_bindings.DDBCSQLSetEnvAttr(
+        env_handle, SQL_ATTR_DDBC_VERSION, SQL_OV_DDBC3_80, 0
+    )
+    if result_set_env < 0:
+        print(
+            "Error: ",
+            ddbc_bindings.DDBCSQLCheckError(SQL_HANDLE_ENV, env_handle, result_set_env),
+        )
+        raise RuntimeError(
+            f"Failed to set DDBC version attribute. Error code: {result_set_env}"
+        )
+
+    # Allocate connection handle
+    dbc_handle = alloc_handle(SQL_HANDLE_DBC, env_handle)
+
+    # Fetch the connection string from environment variables
+    connection_string = os.getenv("DB_CONNECTION_STRING")
+
+    if not connection_string:
+        raise EnvironmentError(
+            "Environment variable 'DB_CONNECTION_STRING' is not set or is empty."
+        )
+
+    print("Connecting!")
+    connect_to_db(dbc_handle, connection_string)
+    print("Connection successful!")
+
+    # Allocate connection statement handle
+    stmt_handle = alloc_handle(SQL_HANDLE_STMT, dbc_handle)
+
+    ParamInfo = ddbc_bindings.ParamInfo
+    """
+    Table schema:
+    CREATE TABLE customers (
+        id INT IDENTITY(1,1) PRIMARY KEY,
+        name NVARCHAR(100),
+        email NVARCHAR(100)
+    );
+    """
+    # Test DDBCSQLExecute for INSERT query
+    print("Test DDBCSQLExecute insert")
+    insert_sql_query = (
+        "INSERT INTO [Employees].[dbo].[EmployeeFullNames] "
+        "(FirstName, LastName, date_, time_, wchar_, bool_, tinyint_, bigint_, float_, double_) "
+        "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?);"
+    )
+    params_insert = []
+    param_info_list_insert = []
+    add_string_param(params_insert, param_info_list_insert, "test")
+    add_string_param(params_insert, param_info_list_insert, "inner file")
+    add_date_param(params_insert, param_info_list_insert)
+    add_time_param(params_insert, param_info_list_insert)
+    # add_datetime_param(params_insert, param_info_list_insert, addNone=True) - Cannot insert an explicit value into a timestamp column. Use INSERT with a column list to exclude the timestamp column, or insert a DEFAULT into the timestamp column. Traceback (most recent call last):
+    add_wstring_param(params_insert, param_info_list_insert, "Wide str3")
+    add_bool_param(params_insert, param_info_list_insert, True)
+    add_tinyint_param(params_insert, param_info_list_insert, 127)
+    add_bigint_param(params_insert, param_info_list_insert, 123456789)
+    add_float_param(params_insert, param_info_list_insert, 12.34)
+    add_double_param(params_insert, param_info_list_insert, 12.34)
+    # add_numeric_param(params_insert, param_info_list_insert, decimal.Decimal('12'))
+    is_stmt_prepared_insert = [False]
+    result_insert = ddbc_sql_execute(
+        stmt_handle, insert_sql_query, params_insert, param_info_list_insert, is_stmt_prepared_insert, True
+    )
+    print("DDBCSQLExecute result:", result_insert)
+
+    # Test DDBCSQLExecute for SELECT query
+    print("Test DDBCSQLExecute select")
+    is_stmt_prepared_select = [False]
+    select_sql_query = (
+        "SELECT bool_, float_, wchar_, date_, time_, datetime_, wchar_, FirstName, LastName "
+        "FROM [Employees].[dbo].[EmployeeFullNames];"
+    )
+    params_select = []
+    param_info_list_select = []
+    result_select = ddbc_sql_execute(
+        stmt_handle, select_sql_query, params_select, param_info_list_select, is_stmt_prepared_select, False
+    )
+    print("DDBCSQLExecute result:", result_select)
+
+    print("Fetching Data for DDBCSQLExecute!")
+    column_names = describe_columns(stmt_handle)
+    print(column_names)
+    ret_fetch = 1
+    while ret_fetch != SQL_NO_DATA:
+        if column_names:
+            rows = fetch_data_all(stmt_handle)
+            for row in rows:
+                print(row)
+        else:
+            print("No columns to fetch data from.")
+        ret_fetch = ddbc_bindings.DDBCSQLMoreResults(stmt_handle)
+
+    # Free the statement handle
+    free_handle(SQL_HANDLE_STMT, stmt_handle)
+    # Disconnect from the data source
+    result_disconnect = ddbc_bindings.DDBCSQLDisconnect(dbc_handle)
+    if result_disconnect < 0:
+        print(
+            "Error: ",
+            ddbc_bindings.DDBCSQLCheckError(SQL_HANDLE_DBC, dbc_handle, result_disconnect),
+        )
+        raise RuntimeError(
+            f"Failed to disconnect from the data source. Error code: {result_disconnect}"
+        )
+
+    # Free the connection handle
+    free_handle(SQL_HANDLE_DBC, dbc_handle)
+
+    # Free the environment handle
+    free_handle(SQL_HANDLE_ENV, env_handle)
+
+    print("Done!")

mssql_python/type.py

@@ -0,0 +1,107 @@
+"""
+Copyright (c) Microsoft Corporation.
+Licensed under the MIT license.
+This module contains type objects and constructors for the mssql_python package.
+"""
+
+import datetime
+import time
+
+
+# Type Objects
+class STRING:
+    """
+    This type object is used to describe columns in a database that are string-based (e.g. CHAR).
+    """
+
+    def __init__(self) -> None:
+        self.type = "STRING"
+
+
+class BINARY:
+    """
+    This type object is used to describe (long)
+    binary columns in a database (e.g. LONG, RAW, BLOBs).
+    """
+
+    def __init__(self) -> None:
+        self.type = "BINARY"
+
+
+class NUMBER:
+    """
+    This type object is used to describe numeric columns in a database.
+    """
+
+    def __init__(self) -> None:
+        self.type = "NUMBER"
+
+
+class DATETIME:
+    """
+    This type object is used to describe date/time columns in a database.
+    """
+
+    def __init__(self) -> None:
+        self.type = "DATETIME"
+
+
+class ROWID:
+    """
+    This type object is used to describe the “Row ID” column in a database.
+    """
+
+    def __init__(self) -> None:
+        self.type = "ROWID"
+
+
+# Type Constructors
+def Date(year: int, month: int, day: int) -> datetime.date:
+    """
+    Generates a date object.
+    """
+    return datetime.date(year, month, day)
+
+
+def Time(hour: int, minute: int, second: int) -> datetime.time:
+    """
+    Generates a time object.
+    """
+    return datetime.time(hour, minute, second)
+
+
+def Timestamp(
+    year: int, month: int, day: int, hour: int, minute: int, second: int, microsecond: int
+) -> datetime.datetime:
+    """
+    Generates a timestamp object.
+    """
+    return datetime.datetime(year, month, day, hour, minute, second, microsecond)
+
+
+def DateFromTicks(ticks: int) -> datetime.date:
+    """
+    Generates a date object from ticks.
+    """
+    return datetime.date.fromtimestamp(ticks)
+
+
+def TimeFromTicks(ticks: int) -> datetime.time:
+    """
+    Generates a time object from ticks.
+    """
+    return datetime.time(*time.gmtime(ticks)[3:6])
+
+
+def TimestampFromTicks(ticks: int) -> datetime.datetime:
+    """
+    Generates a timestamp object from ticks.
+    """
+    return datetime.datetime.fromtimestamp(ticks, datetime.timezone.utc)
+
+
+def Binary(string: str) -> bytes:
+    """
+    Converts a string to bytes using UTF-8 encoding.
+    """
+    return bytes(string, "utf-8")

mssql_python-0.1.6.dist-info/METADATA

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: mssql-python
+Version: 0.1.6
+Summary: A Python library for interacting with Microsoft SQL Server
+Home-page: https://github.com/microsoft/mssql-python
+Author: Microsoft Corporation
+Author-email: pysqldriver@microsoft.com
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
+
+# mssql-python
+
+This is a new Python driver for Microsoft SQL Server currently in Alpha phase.
+
+## Alpha Version Release
+
+We are excited to announce the release of the alpha version of our driver. This marks a significant milestone in our development journey. While this version is still in the early stages, it includes the foundational code and initial logic that will drive future enhancements.
+
+### What's Included:
+
+- Basic functionality to get you started.
+- Initial implementation of core features.
+- Placeholder for future improvements and updates.
+
+For more information, please visit the project link on Github: https://github.com/microsoft/mssql-python
+
+### What's Next:
+
+As we continue to develop and refine the driver, you can expect regular updates that will introduce new features, optimizations, and bug fixes. We encourage you to provide feedback and report any issues you encounter, as this will help us improve the driver for the final release.
+
+### Stay Tuned:
+
+We appreciate your interest and support in this project. Stay tuned for more updates and enhancements as we work towards delivering a robust and fully-featured driver in coming months.
+Thank you for being a part of our journey!

mssql_python-0.1.6.dist-info/RECORD

@@ -0,0 +1,24 @@
+mssql_python/__init__.py,sha256=jM9MZ7_cyxbakvERtnUEtxXpuFS0Gfl7f87ebEPFl4M,1015
+mssql_python/connection.py,sha256=nAbk2SbwJV-fZrQOLdr0CkGnq3LHcXH7DioyVle604I,17409
+mssql_python/constants.py,sha256=0whntqgBnrpijXyG5ugyuMfqOZ6SemGFlny-hS4czOE,3010
+mssql_python/cursor.py,sha256=kpoEq25_OznkwotBey5lsPYg8DMsQAqqItxm4GXOZ9E,26162
+mssql_python/db_connection.py,sha256=bVzIMSOirQFhRP0DwcQtIoXNpzRmabzeq155RsZ7HzQ,1806
+mssql_python/ddbc_bindings.cp313-arm64.pyd,sha256=fzOhi1FbujIYtT7qAVgaX_zBzYVBIl6WD8gCmjf6drM,358912
+mssql_python/ddbc_bindings.py,sha256=EKuIMFeR-fTxFLcrtAlsD1cy7KUs_aOIzoVppRtDCqA,1571
+mssql_python/exceptions.py,sha256=QXtyaIflyCCeXT8l1ZlEMahRqN5RtMsJGZGfQ5bU4dc,26288
+mssql_python/helpers.py,sha256=3U_OO4_Gug3xeuv9wOFQDJfXBe4Nnk9Lw0aZykfgBsk,3821
+mssql_python/logging_config.py,sha256=d8HwLUlbMqHud568OS9d2ktqUNA54g-BZBD_A-mn40A,2186
+mssql_python/mssql_python.pyi,sha256=v_62ciVgf4UMAgbd4xCmQzy2WPjomshscY76x3zIndg,4979
+mssql_python/msvcp140.dll,sha256=Xxxd0xkWmQ2UGB4HvDr7Mr49tY8EO5-NZJ4kFYYvZr8,1387552
+mssql_python/testing_ddbc_bindings.py,sha256=q45U9kAZVGnCRXZSR8z533eKV1YF1cc8BfLUGbhiZO4,15967
+mssql_python/type.py,sha256=o2YKr71kM6TrwAaFVuW-TIWthsX29chb5Q7VYlLE6Ts,2444
+mssql_python/libs/LICENSING,sha256=tKc4unjxUNI_4GLJFk3f4uhtqxSQKWfDllM4M3Xj2VI,1287
+mssql_python/libs/arm64/msodbcdiag18.dll,sha256=f50K93e9YISsZCeQdejmRn9EPAW4XcFAFur3rGfsH3E,112168
+mssql_python/libs/arm64/msodbcsql18.dll,sha256=o_fpN9ty56Zxzg3P26G4hfalF5UZSPUyxnPUMRgLCXY,3889208
+mssql_python/libs/arm64/mssql-auth.dll,sha256=EfKOOxI_GU2qazXBhLzVmzOuXqNfyGdVyFzPO7ivxxI,12996128
+mssql_python/libs/arm64/1033/msodbcsqlr18.rll,sha256=LSp2aRjl5RD_yHRUkQR0k1XWXSNGmn7tmvFD7axddxU,200240
+mssql_python-0.1.6.dist-info/licenses/LICENSE,sha256=tMWsxLSz13xS8IQOwtLLNnrtInvjvKds2j5xmJAVsZA,2694
+mssql_python-0.1.6.dist-info/METADATA,sha256=9H6fMZipAv7SPrqPrEyq2qSu8HznHKKRKtFuX3_pq-U,1837
+mssql_python-0.1.6.dist-info/WHEEL,sha256=NSi-TvKb_JiwBrIuOvKq2JP6ukyjAAsPVdQr8ADvoR8,101
+mssql_python-0.1.6.dist-info/top_level.txt,sha256=6fwQBaoJlf_jkq0h4o3PZnvrg4LqyryK7_d6hLHYtaE,13
+mssql_python-0.1.6.dist-info/RECORD,,

mssql_python-0.1.6.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.7.1)
+Root-Is-Purelib: false
+Tag: cp313-cp313-win_arm64
+

mssql_python-0.1.6.dist-info/licenses/LICENSE

@@ -0,0 +1,47 @@
+MIT License
+All files licensed under the MIT license except the dynamic-link libraries (DLLs) in the mssql_python\libs\win folder, 
+which are subject to different licensing terms. Please review the licensing details for each component below.
+
+A. MIT License
+==================================================================
+Copyright (c) Microsoft Corporation.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE
+
+
+B. MICROSOFT LICENSES
+==================================================================
+The following dynamic-link libraries (DLLs) in the mssql_python\libs\win folder fall under different Microsoft licenses. 
+Below is a breakdown of these components by their respective licenses.
+
+1. Microsoft ODBC Driver 18 End User License Agreement (EULA)
+These components are part of the Microsoft ODBC Driver 18 for SQL Server and are governed by the Microsoft ODBC Driver 18 EULA.
+
+- msodbcsqlr18.rll: Resource library containing localized error messages for the ODBC driver.
+- msodbcdiag18.dll: Diagnostic library for handling error reporting and troubleshooting.
+- msodbcsql18.dll: Core ODBC driver enabling connectivity between SQL Server and applications.
+
+For official licensing terms, refer to: mssql_python\libs\win\MICROSOFT_ODBC_DRIVER_FOR_SQL_SERVER_LICENSE.txt 
+
+2. Microsoft Visual C++ Redistributable EULA
+These components are part of the Microsoft Visual C++ Redistributable and are governed by the Microsoft Visual C++ Redistributable EULA.
+
+- msvcp140.dll: Microsoft C++ Standard Library runtime, required for running C++ applications.  
+
+For redistribution and usage terms, refer to: mssql_python\libs\win\libs\win\MICROSOFT_VISUAL_STUDIO_LICENSE.txt

mssql_python-0.1.6.dist-info/top_level.txt

@@ -0,0 +1 @@
+mssql_python