diff --git a/.codeboarding/Common DBAPI Utilities.md b/.codeboarding/Common DBAPI Utilities.md
new file mode 100644
index 00000000..533ec61d
--- /dev/null
+++ b/.codeboarding/Common DBAPI Utilities.md
@@ -0,0 +1,141 @@
+```mermaid
+graph LR
+ DB_API_Cursor_Base["DB-API Cursor Base"]
+ Hive_Cursor["Hive Cursor"]
+ Presto_Cursor["Presto Cursor"]
+ Trino_Cursor["Trino Cursor"]
+ Parameter_Escaper["Parameter Escaper"]
+ Thrift_API_Client["Thrift API Client"]
+ HTTP_Client["HTTP Client"]
+ Exception_Management["Exception Management"]
+ Hive_Cursor -- "inherits from" --> DB_API_Cursor_Base
+ Hive_Cursor -- "calls methods of" --> DB_API_Cursor_Base
+ Presto_Cursor -- "inherits from" --> DB_API_Cursor_Base
+ Presto_Cursor -- "calls methods of" --> DB_API_Cursor_Base
+ Trino_Cursor -- "inherits from" --> Presto_Cursor
+ Trino_Cursor -- "calls methods of" --> Presto_Cursor
+ Hive_Cursor -- "interacts with" --> Thrift_API_Client
+ Hive_Cursor -- "sends requests to" --> Thrift_API_Client
+ Presto_Cursor -- "interacts with" --> HTTP_Client
+ Presto_Cursor -- "sends requests to" --> HTTP_Client
+ Trino_Cursor -- "interacts with" --> HTTP_Client
+ Trino_Cursor -- "sends requests to" --> HTTP_Client
+ Hive_Cursor -- "uses for parameter formatting" --> Parameter_Escaper
+ Presto_Cursor -- "uses for parameter formatting" --> Parameter_Escaper
+ Trino_Cursor -- "uses for parameter formatting" --> Parameter_Escaper
+ DB_API_Cursor_Base -- "raises" --> Exception_Management
+ Parameter_Escaper -- "raises" --> Exception_Management
+ Hive_Cursor -- "raises" --> Exception_Management
+ Presto_Cursor -- "raises" --> Exception_Management
+ Trino_Cursor -- "raises" --> Exception_Management
+```
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+## Component Details
+
+This system provides a set of DB-API compliant database cursors for various data sources like Hive, Presto, and Trino. It establishes a common base for cursor functionalities, handles SQL parameter escaping, manages interactions with specific database APIs (Thrift for Hive, HTTP for Presto/Trino), and incorporates a centralized exception management system to ensure robust database operations.
+
+### DB-API Cursor Base
+This component provides the fundamental interface and common logic for all database cursors in PyHive, adhering to the Python DB-API specification. It manages the cursor's internal state, handles generic fetching mechanisms like `fetchone` and `executemany`, and defines abstract methods that concrete cursor implementations must provide.
+
+
+**Related Classes/Methods**:
+
+- `pyhive.common.DBAPICursor` (27:192)
+- `pyhive.common.DBAPICursor:__init__` (34:37)
+- `pyhive.common.DBAPICursor:_fetch_while` (49:53)
+- `pyhive.common.DBAPICursor:executemany` (85:98)
+- `pyhive.common.DBAPICursor:fetchone` (100:117)
+- `pyhive.common.DBAPICursor:__next__` (177:186)
+- `pyhive.common.DBAPICursor._reset_state` (39:47)
+- `pyhive.common.DBAPICursor._fetch_more` (64:66)
+
+
+### Hive Cursor
+This component implements the DB-API cursor specifically for HiveServer2. It handles the execution of SQL queries, manages the Thrift operation handle, and retrieves results by interacting with the HiveServer2 Thrift API.
+
+
+**Related Classes/Methods**:
+
+- `pyhive.hive.Cursor` (361:570)
+- `pyhive.hive.Cursor:__init__` (369:373)
+- `pyhive.hive.Cursor:_reset_state` (375:385)
+- `pyhive.hive.Cursor:execute` (453:482)
+- `pyhive.hive._check_status` (607:611)
+
+
+### Presto Cursor
+This component implements the DB-API cursor for Presto. It manages HTTP-based query execution, sends requests to the Presto REST API, and processes the JSON responses to retrieve query results and metadata.
+
+
+**Related Classes/Methods**:
+
+- `pyhive.presto.Cursor` (91:355)
+- `pyhive.presto.Cursor:__init__` (99:206)
+- `pyhive.presto.Cursor:_reset_state` (208:212)
+- `pyhive.presto.Cursor:description` (215:242)
+- `pyhive.presto.Cursor:execute` (244:278)
+- `pyhive.presto.Cursor:_process_response` (325:355)
+
+
+### Trino Cursor
+This component extends the Presto cursor to provide specific functionalities for Trino. It primarily customizes the HTTP headers and response processing to align with Trino's API, while leveraging the core logic from the Presto cursor.
+
+
+**Related Classes/Methods**:
+
+- `pyhive.trino.Cursor` (58:132)
+- `pyhive.trino.Cursor:execute` (66:100)
+- `pyhive.trino.Cursor:_process_response` (102:132)
+
+
+### Parameter Escaper
+This component is responsible for safely formatting and escaping parameters for SQL queries. It provides methods to handle various data types such as numbers, strings, sequences, and datetime objects, with specialized implementations for Hive, Presto, and Trino to ensure correct syntax and prevent SQL injection.
+
+
+**Related Classes/Methods**:
+
+- `pyhive.common.ParamEscaper` (209:260)
+- `pyhive.common.ParamEscaper:escape_args` (214:220)
+- `pyhive.common.ParamEscaper:escape_item` (246:260)
+- `pyhive.common.ParamEscaper:escape_number` (222:223)
+- `pyhive.common.ParamEscaper:escape_string` (225:235)
+- `pyhive.common.ParamEscaper:escape_sequence` (237:239)
+- `pyhive.common.ParamEscaper:escape_datetime` (241:244)
+- `pyhive.presto.PrestoParamEscaper` (45:49)
+- `pyhive.presto.PrestoParamEscaper:escape_datetime` (46:49)
+- `pyhive.trino.TrinoParamEscaper` (33:34)
+- `pyhive.hive.HiveParamEscaper` (114:131)
+
+
+### Thrift API Client
+This component encapsulates the interactions with the HiveServer2 Thrift API. It is responsible for constructing and sending Thrift requests (e.g., for closing operations or executing statements) and processing the Thrift responses, ensuring proper communication with the Hive server.
+
+
+**Related Classes/Methods**:
+
+- `TCLIService.ttypes.TCloseOperationReq` (full file reference)
+- `TCLIService.ttypes.TExecuteStatementReq` (full file reference)
+
+
+### HTTP Client
+This component handles the underlying HTTP communication for Presto and Trino. It is responsible for sending HTTP requests (e.g., POST for query execution, GET for polling, DELETE for cancellation) and processing the HTTP responses, including status codes and JSON payloads.
+
+
+**Related Classes/Methods**: _None_
+
+### Exception Management
+This component defines and manages various database-related exceptions, such as ProgrammingError, OperationalError, DatabaseError, and NotSupportedError. It is responsible for raising appropriate exceptions based on error conditions encountered during database operations.
+
+
+**Related Classes/Methods**:
+
+- `pyhive.exc.ProgrammingError` (53:57)
+- `pyhive.exc.OperationalError` (44:50)
+- `pyhive.exc.DatabaseError` (33:35)
+- `pyhive.exc.NotSupportedError` (67:72)
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/Hive DBAPI Connector.md b/.codeboarding/Hive DBAPI Connector.md
new file mode 100644
index 00000000..7f81f127
--- /dev/null
+++ b/.codeboarding/Hive DBAPI Connector.md
@@ -0,0 +1,134 @@
+```mermaid
+graph LR
+ ConnectionManager["ConnectionManager"]
+ CursorManager["CursorManager"]
+ ThriftClient["ThriftClient"]
+ ThriftTypes["ThriftTypes"]
+ ErrorAndStatusHandler["ErrorAndStatusHandler"]
+ DataConverter["DataConverter"]
+ ConnectionManager -- "initializes" --> ThriftClient
+ ConnectionManager -- "creates" --> CursorManager
+ ConnectionManager -- "validates status with" --> ErrorAndStatusHandler
+ CursorManager -- "invokes operations on" --> ThriftClient
+ CursorManager -- "validates status with" --> ErrorAndStatusHandler
+ CursorManager -- "transforms data using" --> DataConverter
+ ThriftClient -- "sends/receives" --> ThriftTypes
+ ThriftTypes -- "defines structures for" --> ThriftClient
+ DataConverter -- "handles exceptions from" --> ErrorAndStatusHandler
+```
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+## Component Details
+
+This graph illustrates the core components of the Hive DBAPI Connector, focusing on how connections are managed, queries are executed, and data is handled. The main flow involves establishing a connection via the ConnectionManager, which then provides CursorManager instances for query execution. All low-level communication with HiveServer2 is handled by the ThriftClient, which relies on ThriftTypes for data structuring. Error handling and data conversion are centralized in ErrorAndStatusHandler and DataConverter, respectively, ensuring robust and compliant interactions with the Hive database.
+
+### ConnectionManager
+Manages the lifecycle of a connection to HiveServer2, including opening, closing, and setting up authentication. It serves as the primary entry point for users to establish a connection and obtain cursor objects.
+
+
+**Related Classes/Methods**:
+
+- `pyhive.hive.connect` (137:143)
+- `pyhive.hive.Connection` (146:358)
+- `pyhive.hive.Connection.__init__` (149:285)
+- `pyhive.hive.Connection.close` (334:339)
+- `pyhive.hive.Connection._set_authorization_header` (288:303)
+- `pyhive.hive.Connection._set_kerberos_header` (306:324)
+- `pyhive.sasl_compat.get_installed_sasl` (10:15)
+- `pyhive.sasl_compat.get_sasl_client` (18:23)
+- `pyhive.sasl_compat.get_pure_sasl_client` (26:31)
+
+
+### CursorManager
+Responsible for executing SQL queries, managing the operation handle, fetching results, handling query-related operations like cancellation, polling for status, and retrieving logs. It implements the DB-API cursor interface.
+
+
+**Related Classes/Methods**:
+
+- `pyhive.hive.Cursor` (361:570)
+- `pyhive.hive.Cursor.__init__` (369:373)
+- `pyhive.hive.Cursor.execute` (453:482)
+- `pyhive.hive.Cursor._fetch_more` (491:514)
+- `pyhive.hive.Cursor.poll` (516:533)
+- `pyhive.hive.Cursor.fetch_logs` (535:570)
+- `pyhive.hive.Cursor.cancel` (484:489)
+- `pyhive.hive.Cursor.close` (449:451)
+- `pyhive.hive.Cursor._reset_state` (375:385)
+- `pyhive.hive.Cursor.description` (401:441)
+
+
+### ThriftClient
+Provides the low-level interface for communicating with the HiveServer2 Thrift API. It encapsulates the methods for sending various Thrift requests and receiving their corresponding responses.
+
+
+**Related Classes/Methods**:
+
+- `TCLIService.TCLIService.Client` (174:861)
+- `TCLIService.TCLIService.Client.OpenSession` (181:187)
+- `TCLIService.TCLIService.Client.CloseSession` (212:218)
+- `TCLIService.TCLIService.Client.ExecuteStatement` (274:280)
+- `TCLIService.TCLIService.Client.GetOperationStatus` (584:590)
+- `TCLIService.TCLIService.Client.CancelOperation` (615:621)
+- `TCLIService.TCLIService.Client.CloseOperation` (646:652)
+- `TCLIService.TCLIService.Client.GetResultSetMetadata` (677:683)
+- `TCLIService.TCLIService.Client.FetchResults` (708:714)
+- `TCLIService.TCLIService.Client.GetLog` (832:838)
+
+
+### ThriftTypes
+Defines all the Thrift data structures, including request and response objects, session and operation handles, and status codes, which are fundamental for structured communication between the client and HiveServer2.
+
+
+**Related Classes/Methods**:
+
+- `TCLIService.ttypes` (full file reference)
+- `TCLIService.ttypes.TOpenSessionReq` (full file reference)
+- `TCLIService.ttypes.TCloseSessionReq` (full file reference)
+- `TCLIService.ttypes.TExecuteStatementReq` (full file reference)
+- `TCLIService.ttypes.TGetOperationStatusReq` (full file reference)
+- `TCLIService.ttypes.TCancelOperationReq` (full file reference)
+- `TCLIService.ttypes.TCloseOperationReq` (full file reference)
+- `TCLIService.ttypes.TGetResultSetMetadataReq` (full file reference)
+- `TCLIService.ttypes.TFetchResultsReq` (full file reference)
+- `TCLIService.ttypes.TGetLogReq` (full file reference)
+- `TCLIService.ttypes.TOpenSessionResp` (full file reference)
+- `TCLIService.ttypes.TCloseSessionResp` (full file reference)
+- `TCLIService.ttypes.TExecuteStatementResp` (full file reference)
+- `TCLIService.ttypes.TGetOperationStatusResp` (full file reference)
+- `TCLIService.ttypes.TCancelOperationResp` (full file reference)
+- `TCLIService.ttypes.TCloseOperationResp` (full file reference)
+- `TCLIService.ttypes.TGetResultSetMetadataResp` (full file reference)
+- `TCLIService.ttypes.TFetchResultsResp` (full file reference)
+- `TCLIService.ttypes.TGetLogResp` (full file reference)
+- `TCLIService.ttypes.TStatus` (full file reference)
+- `TCLIService.ttypes.TSessionHandle` (full file reference)
+- `TCLIService.ttypes.TOperationHandle` (full file reference)
+
+
+### ErrorAndStatusHandler
+Provides a centralized mechanism for validating the status of Thrift responses received from HiveServer2 and raising appropriate Python DB-API exceptions (e.g., OperationalError, ProgrammingError, DataError) based on the Thrift status codes.
+
+
+**Related Classes/Methods**:
+
+- `pyhive.hive._check_status` (607:611)
+- `pyhive.exc.OperationalError` (44:50)
+- `pyhive.exc.ProgrammingError` (53:57)
+- `pyhive.exc.DataError` (60:64)
+
+
+### DataConverter
+Handles the conversion of data types between Hive's Thrift representation and Python's native types, ensuring data integrity and usability. It also manages the escaping of parameters for SQL queries to prevent injection issues.
+
+
+**Related Classes/Methods**:
+
+- `pyhive.hive._unwrap_column` (588:604)
+- `pyhive.hive._parse_timestamp` (91:107)
+- `pyhive.hive.HiveParamEscaper` (114:131)
+- `pyhive.common.ParamEscaper.escape_args` (214:220)
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/Presto-Trino DBAPI Connector.md b/.codeboarding/Presto-Trino DBAPI Connector.md
new file mode 100644
index 00000000..cbcbc7ae
--- /dev/null
+++ b/.codeboarding/Presto-Trino DBAPI Connector.md
@@ -0,0 +1,132 @@
+```mermaid
+graph LR
+ Trino_API_Layer["Trino API Layer"]
+ Trino_Query_Execution["Trino Query Execution"]
+ Presto_API_Layer["Presto API Layer"]
+ Presto_Query_Execution["Presto Query Execution"]
+ Common_DB_API_Cursor_Base["Common DB-API Cursor Base"]
+ Parameter_Escaping_Utility["Parameter Escaping Utility"]
+ Exception_Management["Exception Management"]
+ Trino_API_Layer -- "creates" --> Trino_Query_Execution
+ Trino_API_Layer -- "extends" --> Presto_API_Layer
+ Trino_Query_Execution -- "extends" --> Presto_Query_Execution
+ Trino_Query_Execution -- "uses" --> Parameter_Escaping_Utility
+ Trino_Query_Execution -- "generates" --> Exception_Management
+ Presto_API_Layer -- "creates" --> Presto_Query_Execution
+ Presto_Query_Execution -- "extends" --> Common_DB_API_Cursor_Base
+ Presto_Query_Execution -- "uses" --> Parameter_Escaping_Utility
+ Presto_Query_Execution -- "generates" --> Exception_Management
+ Common_DB_API_Cursor_Base -- "generates" --> Exception_Management
+ Parameter_Escaping_Utility -- "generates" --> Exception_Management
+```
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+## Component Details
+
+The Presto/Trino DBAPI Connector provides DBAPI-compliant interfaces for connecting to and executing queries against Presto and Trino databases. It manages connection lifecycle, cursor operations, and response processing, with the Trino connector extending the functionalities of the Presto connector to ensure compatibility and specialized handling for each database.
+
+### Trino API Layer
+This component provides the high-level interface for establishing connections to a Trino database and obtaining cursor objects. It acts as an entry point for Trino-specific database interactions, inheriting core connection functionalities from the Presto API layer.
+
+
+**Related Classes/Methods**:
+
+- `pyhive.trino.connect` (40:46)
+- `pyhive.trino.Connection` (49:55)
+- `pyhive.trino.Connection:__init__` (50:51)
+- `pyhive.trino.Connection:cursor` (53:55)
+
+
+### Trino Query Execution
+Responsible for executing SQL queries against a Trino database and managing the lifecycle of query results. It handles parameter escaping, state management, and processing of responses received from the Trino server, including error handling.
+
+
+**Related Classes/Methods**:
+
+- `pyhive.trino.Cursor` (58:132)
+- `pyhive.trino.Cursor:execute` (66:100)
+- `pyhive.trino.Cursor:_process_response` (102:132)
+
+
+### Presto API Layer
+This component offers the foundational interface for connecting to a Presto database and creating cursor objects. It defines the basic connection and cursor creation mechanisms, serving as a base for Trino-specific implementations.
+
+
+**Related Classes/Methods**:
+
+- `pyhive.presto.connect` (55:61)
+- `pyhive.presto.Connection` (64:88)
+- `pyhive.presto.Connection:cursor` (83:85)
+- `pyhive.presto.Connection:rollback` (87:88)
+
+
+### Presto Query Execution
+Manages the execution of queries for Presto, including handling query parameters, resetting cursor state, fetching and processing data from the database, and managing query cancellation. It extends the common DB-API cursor functionality.
+
+
+**Related Classes/Methods**:
+
+- `pyhive.presto.Cursor` (91:355)
+- `pyhive.presto.Cursor:__init__` (99:206)
+- `pyhive.presto.Cursor:_reset_state` (208:212)
+- `pyhive.presto.Cursor:description` (215:242)
+- `pyhive.presto.Cursor:execute` (244:278)
+- `pyhive.presto.Cursor:cancel` (280:293)
+- `pyhive.presto.Cursor:poll` (295:311)
+- `pyhive.presto.Cursor:_fetch_more` (313:315)
+- `pyhive.presto.Cursor:_process_response` (325:355)
+
+
+### Common DB-API Cursor Base
+Provides a generic, abstract implementation of the DB-API cursor specification. It defines common behaviors for database cursors, such as state management, fetching multiple rows, and iteration, which are then specialized by database-specific cursors.
+
+
+**Related Classes/Methods**:
+
+- `pyhive.common.DBAPICursor` (27:192)
+- `pyhive.common.DBAPICursor:__init__` (34:37)
+- `pyhive.common.DBAPICursor:_reset_state` (39:47)
+- `pyhive.common.DBAPICursor:_fetch_while` (49:53)
+- `pyhive.common.DBAPICursor:executemany` (85:98)
+- `pyhive.common.DBAPICursor:fetchone` (100:117)
+- `pyhive.common.DBAPICursor:__next__` (177:186)
+- `pyhive.common.DBAPICursor._fetch_more` (64:66)
+
+
+### Parameter Escaping Utility
+This utility component is responsible for safely formatting and escaping various data types (numbers, strings, dates, sequences) to be used as parameters in SQL queries, preventing issues like SQL injection. It provides a base for database-specific escaping rules.
+
+
+**Related Classes/Methods**:
+
+- `pyhive.common.ParamEscaper` (209:260)
+- `pyhive.common.ParamEscaper:escape_args` (214:220)
+- `pyhive.common.ParamEscaper:escape_item` (246:260)
+- `pyhive.common.ParamEscaper:escape_number` (222:223)
+- `pyhive.common.ParamEscaper:escape_string` (225:235)
+- `pyhive.common.ParamEscaper:escape_sequence` (237:239)
+- `pyhive.common.ParamEscaper:escape_datetime` (241:244)
+- `pyhive.presto.PrestoParamEscaper:escape_datetime` (46:49)
+- `pyhive.trino.TrinoParamEscaper` (33:34)
+
+
+### Exception Management
+Defines a comprehensive set of custom exception classes that adhere to the DB-API specification. These exceptions are raised to signal various types of errors encountered during database operations, providing structured error handling.
+
+
+**Related Classes/Methods**:
+
+- `pyhive.exc.Error` (13:18)
+- `pyhive.exc.Warning` (21:23)
+- `pyhive.exc.InterfaceError` (26:30)
+- `pyhive.exc.DatabaseError` (33:35)
+- `pyhive.exc.InternalError` (38:41)
+- `pyhive.exc.OperationalError` (44:50)
+- `pyhive.exc.ProgrammingError` (53:57)
+- `pyhive.exc.DataError` (60:64)
+- `pyhive.exc.NotSupportedError` (67:72)
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/PyHive Exception Handling.md b/.codeboarding/PyHive Exception Handling.md
new file mode 100644
index 00000000..ddf55da6
--- /dev/null
+++ b/.codeboarding/PyHive Exception Handling.md
@@ -0,0 +1,107 @@
+```mermaid
+graph LR
+ Hive_Client["Hive Client"]
+ Presto_Trino_Client["Presto/Trino Client"]
+ DB_API_Abstraction["DB-API Abstraction"]
+ SQL_Parameter_Escaper["SQL Parameter Escaper"]
+ Thrift_API_Definitions["Thrift API Definitions"]
+ PyHive_Exceptions["PyHive Exceptions"]
+ Hive_Client -- "implements" --> DB_API_Abstraction
+ Hive_Client -- "communicates via" --> Thrift_API_Definitions
+ Hive_Client -- "uses" --> SQL_Parameter_Escaper
+ Hive_Client -- "raises" --> PyHive_Exceptions
+ Presto_Trino_Client -- "implements" --> DB_API_Abstraction
+ Presto_Trino_Client -- "uses" --> SQL_Parameter_Escaper
+ Presto_Trino_Client -- "raises" --> PyHive_Exceptions
+ SQL_Parameter_Escaper -- "raises" --> PyHive_Exceptions
+ DB_API_Abstraction -- "raises" --> PyHive_Exceptions
+```
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+## Component Details
+
+This graph illustrates the core components of the PyHive library, focusing on how different database clients (Hive, Presto/Trino) interact with common abstractions like the DB-API and SQL parameter escaping, and how a unified exception handling mechanism is utilized across the system. The main flow involves clients establishing connections, executing queries, and handling potential errors through a defined exception hierarchy.
+
+### Hive Client
+This component provides the core functionality for connecting to and interacting with HiveServer2. It manages the Thrift-based connection, handles session management, and facilitates query execution, result fetching, and log retrieval specific to Hive.
+
+
+**Related Classes/Methods**:
+
+- `PyHive.pyhive.hive.Connection` (146:358)
+- `PyHive.pyhive.hive.Connection:rollback` (357:358)
+- `PyHive.pyhive.hive.Cursor` (361:570)
+- `PyHive.pyhive.hive.Cursor:_fetch_more` (491:514)
+- `PyHive.pyhive.hive.Cursor:poll` (516:533)
+- `PyHive.pyhive.hive.Cursor:fetch_logs` (535:570)
+- `PyHive.pyhive.hive._check_status` (607:611)
+- `PyHive.pyhive.hive._unwrap_column` (588:604)
+
+
+### Presto/Trino Client
+This component is responsible for establishing connections and executing queries against Presto and Trino databases. It extends the common DB-API cursor functionality to handle the specific HTTP REST API interactions and data processing for these platforms.
+
+
+**Related Classes/Methods**:
+
+- `PyHive.pyhive.presto.Connection` (64:88)
+- `PyHive.pyhive.presto.Connection:rollback` (87:88)
+- `PyHive.pyhive.presto.Cursor` (91:355)
+- `PyHive.pyhive.presto.Cursor:cancel` (280:293)
+- `PyHive.pyhive.presto.Cursor:poll` (295:311)
+- `PyHive.pyhive.presto.Cursor:_process_response` (325:355)
+- `PyHive.pyhive.presto.Cursor:_process_data` (317:323)
+- `PyHive.pyhive.trino.Cursor` (58:132)
+- `PyHive.pyhive.trino.Cursor:_process_response` (102:132)
+
+
+### DB-API Abstraction
+This component defines the abstract base classes and common utilities that adhere to the Python DB-API 2.0 specification. It provides a standardized interface for database cursors, including methods for fetching rows and managing cursor state, which are then implemented by specific database clients.
+
+
+**Related Classes/Methods**:
+
+- `PyHive.pyhive.common.DBAPICursor` (27:192)
+- `PyHive.pyhive.common.DBAPICursor:fetchone` (100:117)
+- `PyHive.pyhive.common.DBAPICursor:_fetch_while` (49:53)
+
+
+### SQL Parameter Escaper
+This component handles the crucial task of safely formatting and escaping various Python data types (numbers, strings, dates, sequences) into SQL-compatible strings. This prevents SQL injection vulnerabilities and ensures correct query syntax.
+
+
+**Related Classes/Methods**:
+
+- `PyHive.pyhive.common.ParamEscaper` (209:260)
+- `PyHive.pyhive.common.ParamEscaper:escape_args` (214:220)
+- `PyHive.pyhive.common.ParamEscaper:escape_item` (246:260)
+
+
+### Thrift API Definitions
+This component encompasses the generated Thrift data types and service definitions used for communication with HiveServer2. It provides the structured messages and protocols necessary for the Hive client to interact with the Hive Thrift service.
+
+
+**Related Classes/Methods**:
+
+- `TCLIService.ttypes` (full file reference)
+
+
+### PyHive Exceptions
+This component defines a set of custom exception classes that are raised to indicate various database-related errors, such as unsupported operations, programming errors, operational issues, or data errors. These exceptions provide a structured way to handle errors within the PyHive library.
+
+
+**Related Classes/Methods**:
+
+- `pyhive.exc.Error` (13:18)
+- `pyhive.exc.InterfaceError` (26:30)
+- `pyhive.exc.DatabaseError` (33:35)
+- `pyhive.exc.InternalError` (38:41)
+- `pyhive.exc.OperationalError` (44:50)
+- `pyhive.exc.ProgrammingError` (53:57)
+- `pyhive.exc.DataError` (60:64)
+- `pyhive.exc.NotSupportedError` (67:72)
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/SASL Authentication Layer.md b/.codeboarding/SASL Authentication Layer.md
new file mode 100644
index 00000000..4d9cd62c
--- /dev/null
+++ b/.codeboarding/SASL Authentication Layer.md
@@ -0,0 +1,115 @@
+```mermaid
+graph LR
+ SASL_Compatibility_Layer["SASL Compatibility Layer"]
+ SASL_Client_Factory["SASL Client Factory"]
+ Hive_Connection_Initializer["Hive Connection Initializer"]
+ Thrift_SASL_Transport["Thrift SASL Transport"]
+ Thrift_Client_Interface["Thrift Client Interface"]
+ Thrift_Type_Definitions["Thrift Type Definitions"]
+ Status_Checker["Status Checker"]
+ Cursor_Management["Cursor Management"]
+ Hive_Connection_Initializer -- "initializes with" --> SASL_Client_Factory
+ SASL_Client_Factory -- "provides" --> SASL_Compatibility_Layer
+ Hive_Connection_Initializer -- "configures" --> Thrift_SASL_Transport
+ Thrift_SASL_Transport -- "utilizes" --> SASL_Client_Factory
+ Hive_Connection_Initializer -- "communicates via" --> Thrift_Client_Interface
+ Thrift_Client_Interface -- "exchanges data with" --> Thrift_Type_Definitions
+ Hive_Connection_Initializer -- "ensures status with" --> Status_Checker
+ Hive_Connection_Initializer -- "manages" --> Cursor_Management
+ Cursor_Management -- "executes operations via" --> Thrift_Client_Interface
+ Cursor_Management -- "validates status with" --> Status_Checker
+```
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+## Component Details
+
+The SASL Authentication Layer in PyHive provides a robust client-side implementation for various SASL mechanisms, primarily to secure connections with HiveServer2. It achieves this by offering a flexible compatibility layer that can utilize either the 'python-sasl' or 'pure-sasl' libraries, managed by a dedicated SASL Client Factory. This factory dynamically selects the appropriate SASL client, which is then integrated into the Thrift transport by the Hive Connection Initializer. This secure transport facilitates authenticated communication with the HiveServer2's Thrift Client Interface, ensuring that all data exchanges adhere to the defined Thrift Type Definitions and are validated for success by the Status Checker. The entire process enables secure and reliable database interactions, including cursor management for query execution.
+
+### SASL Compatibility Layer
+Provides a compatibility layer for SASL authentication within PyHive, allowing it to seamlessly integrate with either the 'python-sasl' or 'pure-sasl' libraries. It includes the `PureSASLClient` class, which wraps the 'pure-sasl' client's functionalities, and an `error_catcher` context manager for robust handling of SASL-related exceptions during authentication processes.
+
+
+**Related Classes/Methods**:
+
+- `pyhive.sasl_compat.PureSASLClient` (22:56)
+- `pyhive.sasl_compat.PureSASLClient:start` (27:35)
+- `pyhive.sasl_compat.PureSASLClient:encode` (37:41)
+- `pyhive.sasl_compat.PureSASLClient:decode` (43:47)
+- `pyhive.sasl_compat.PureSASLClient:step` (49:53)
+- `pyhive.sasl_compat.error_catcher` (14:19)
+
+
+### SASL Client Factory
+Responsible for dynamically providing the appropriate SASL client instance based on available libraries. It prioritizes the 'sasl' library (python-sasl) and gracefully falls back to using the 'pure-sasl' library, facilitated by the 'SASL Compatibility Layer', if the preferred 'sasl' library is not installed.
+
+
+**Related Classes/Methods**:
+
+- `pyhive.hive.get_sasl_client` (52:66)
+- `pyhive.hive.get_pure_sasl_client` (69:79)
+- `pyhive.hive.get_installed_sasl` (82:88)
+
+
+### Hive Connection Initializer
+Manages the establishment and configuration of connections to HiveServer2. This component is critical for setting up the Thrift transport, handling various authentication mechanisms (including SASL via the `SASL Client Factory`), and initializing the Thrift client for subsequent communication.
+
+
+**Related Classes/Methods**:
+
+- `pyhive.hive.Connection:__init__` (149:285)
+- `pyhive.hive.Connection._set_authorization_header` (288:303)
+- `pyhive.hive.Connection._set_kerberos_header` (306:324)
+
+
+### Thrift SASL Transport
+An external Thrift transport layer (`thrift_sasl.TSaslClientTransport`) that integrates with a SASL client to provide secure communication over Thrift. It wraps a standard Thrift socket transport and handles the SASL negotiation process.
+
+
+**Related Classes/Methods**:
+
+- `thrift_sasl.TSaslClientTransport` (full file reference)
+- `pyhive.hive.Connection:__init__` (149:285)
+
+
+### Thrift Client Interface
+Represents the primary interface for interacting with the HiveServer2's TCLIService. It utilizes the underlying Thrift transport (which can be SASL-enabled) to send requests and receive responses for operations like opening sessions, executing statements, and managing query operations.
+
+
+**Related Classes/Methods**:
+
+- `TCLIService.TCLIService.Client` (174:861)
+- `TCLIService.TCLIService.Client.OpenSession` (181:187)
+
+
+### Thrift Type Definitions
+Defines the structured data types (e.g., requests, responses, and their fields) used for communication within the Thrift protocol, ensuring proper serialization and deserialization of data exchanged between the PyHive client and HiveServer2.
+
+
+**Related Classes/Methods**:
+
+- `TCLIService.ttypes.TOpenSessionReq` (full file reference)
+- `TCLIService.ttypes.TStatusCode` (full file reference)
+
+
+### Status Checker
+A utility component responsible for validating the success status of responses received from HiveServer2 via the Thrift API. It raises an `OperationalError` if a response indicates a failure, ensuring that errors are propagated appropriately within the PyHive application.
+
+
+**Related Classes/Methods**:
+
+- `pyhive.hive._check_status` (607:611)
+
+
+### Cursor Management
+Handles the creation, lifecycle, and operations of database cursors, which are essential for managing the context of data fetching and query execution within PyHive. It provides methods for executing SQL, fetching results, and closing operations.
+
+
+**Related Classes/Methods**:
+
+- `pyhive.hive.Connection.cursor` (345:347)
+- `pyhive.hive.Cursor` (361:570)
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/SQLAlchemy Dialects.md b/.codeboarding/SQLAlchemy Dialects.md
new file mode 100644
index 00000000..1597da0c
--- /dev/null
+++ b/.codeboarding/SQLAlchemy Dialects.md
@@ -0,0 +1,76 @@
+```mermaid
+graph LR
+ PrestoDialect["PrestoDialect"]
+ HiveDialect["HiveDialect"]
+ TrinoDialect["TrinoDialect"]
+ TableColumnInspector["TableColumnInspector"]
+ PrestoDialect -- "uses" --> TableColumnInspector
+ HiveDialect -- "uses" --> TableColumnInspector
+ TrinoDialect -- "extends" --> PrestoDialect
+```
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+## Component Details
+
+This subsystem provides SQLAlchemy dialect implementations for Hive, Presto, and Trino databases. It enables Object Relational Mapping (ORM) functionalities and schema introspection for these databases. The core flow involves establishing connections, introspecting database schemas (tables, columns, indexes, views), and compiling SQL statements specific to each database. The Trino dialect extends the Presto dialect, inheriting and adapting its functionalities.
+
+### PrestoDialect
+The PrestoDialect component provides the core integration between SQLAlchemy and Presto. It handles connection arguments, schema and table introspection, and type mapping for Presto-specific data types. It also manages how SQL statements are compiled for Presto.
+
+
+**Related Classes/Methods**:
+
+- `pyhive.sqlalchemy_presto.PrestoDialect` (79:223)
+- `pyhive.sqlalchemy_presto.PrestoDialect.has_table` (151:156)
+- `pyhive.sqlalchemy_presto.PrestoDialect.get_columns` (158:174)
+- `pyhive.sqlalchemy_presto.PrestoDialect.get_indexes` (184:205)
+- `pyhive.sqlalchemy_presto.PrestoDialect._get_table_columns` (127:149)
+- `pyhive.sqlalchemy_presto.PrestoCompiler` (54:56)
+- `pyhive.sqlalchemy_presto.PrestoIdentifierPreparer` (34:36)
+- `pyhive.sqlalchemy_presto.PrestoTypeCompiler` (59:76)
+
+
+### HiveDialect
+The HiveDialect component provides the core integration between SQLAlchemy and Hive. It handles schema and table introspection, and manages how SQL statements are compiled for Hive. It also includes specific handling for view names.
+
+
+**Related Classes/Methods**:
+
+- `pyhive.sqlalchemy_hive.HiveDialect` (241:392)
+- `pyhive.sqlalchemy_hive.HiveDialect.get_view_names` (286:289)
+- `pyhive.sqlalchemy_hive.HiveDialect.has_table` (315:320)
+- `pyhive.sqlalchemy_hive.HiveDialect.get_columns` (322:348)
+- `pyhive.sqlalchemy_hive.HiveDialect.get_indexes` (358:374)
+- `pyhive.sqlalchemy_hive.HiveDialect._get_table_columns` (291:313)
+- `pyhive.sqlalchemy_hive.HiveDialect.get_table_names` (376:380)
+- `pyhive.sqlalchemy_hive.HiveCompiler` (155:180)
+- `pyhive.sqlalchemy_hive.HiveExecutionContext` (218:238)
+- `pyhive.sqlalchemy_hive.HiveIdentifierPreparer` (122:130)
+- `pyhive.sqlalchemy_hive.HiveTypeCompiler` (183:215)
+
+
+### TrinoDialect
+The TrinoDialect component extends the PrestoDialect, inheriting its core functionalities and providing specific adaptations for Trino databases. It leverages the existing Presto implementation for connection handling, introspection, and SQL compilation, with minor overrides for Trino-specific behaviors.
+
+
+**Related Classes/Methods**:
+
+- `pyhive.sqlalchemy_trino.TrinoDialect` (74:84)
+- `pyhive.sqlalchemy_trino.TrinoCompiler` (50:51)
+- `pyhive.sqlalchemy_trino.TrinoIdentifierPreparer` (31:32)
+- `pyhive.sqlalchemy_trino.TrinoTypeCompiler` (54:71)
+
+
+### TableColumnInspector
+The TableColumnInspector component is responsible for retrieving column information for a given table. It is a shared utility used by both PrestoDialect and HiveDialect to determine table existence, column details, and index information.
+
+
+**Related Classes/Methods**:
+
+- `pyhive.sqlalchemy_presto.PrestoDialect._get_table_columns` (127:149)
+- `pyhive.sqlalchemy_hive.HiveDialect._get_table_columns` (291:313)
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/TCLIService Thrift Layer.md b/.codeboarding/TCLIService Thrift Layer.md
new file mode 100644
index 00000000..53fda86f
--- /dev/null
+++ b/.codeboarding/TCLIService Thrift Layer.md
@@ -0,0 +1,77 @@
+```mermaid
+graph LR
+ Thrift_Data_Types_ttypes_["Thrift Data Types (ttypes)"]
+ TCLIService_Client["TCLIService Client"]
+ TCLIService_Processor["TCLIService Processor"]
+ RPC_Argument_Result_Structures["RPC Argument/Result Structures"]
+ Thrift_Data_Types_ttypes_ -- "defines" --> RPC_Argument_Result_Structures
+ RPC_Argument_Result_Structures -- "composed of" --> Thrift_Data_Types_ttypes_
+ TCLIService_Client -- "uses" --> RPC_Argument_Result_Structures
+ TCLIService_Client -- "sends/receives" --> Thrift_Data_Types_ttypes_
+ TCLIService_Processor -- "uses" --> RPC_Argument_Result_Structures
+ TCLIService_Processor -- "processes" --> Thrift_Data_Types_ttypes_
+```
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+## Component Details
+
+The TCLIService Thrift Layer in PyHive represents the auto-generated Thrift code for the HiveServer2 (TCLIService) API. It provides the foundational structures and interfaces for client-server communication. This layer includes the definitions for all data types exchanged (requests, responses, handles, schemas, row sets), the client-side interface for initiating RPC calls, and the server-side processor logic for handling incoming requests. Its purpose is to enable seamless serialization and deserialization of data, allowing Python applications to interact with HiveServer2 using the Thrift protocol.
+
+### Thrift Data Types (ttypes)
+This component encompasses all the auto-generated Thrift data structures and enums defined in `pyhive.TCLIService.ttypes`. These types are fundamental for serializing and deserializing data exchanged between the client and the HiveServer2. They define the format for requests, responses, session handles, operation handles, table schemas, row sets, and individual column values.
+
+
+**Related Classes/Methods**:
+
+- `pyhive.TCLIService.ttypes.TOpenSessionReq` (full file reference)
+- `pyhive.TCLIService.ttypes.TCloseSessionReq` (full file reference)
+- `pyhive.TCLIService.ttypes.TExecuteStatementReq` (full file reference)
+- `pyhive.TCLIService.ttypes.TFetchResultsReq` (full file reference)
+- `pyhive.TCLIService.ttypes.TGetResultSetMetadataReq` (full file reference)
+- `pyhive.TCLIService.ttypes.TTableSchema` (full file reference)
+- `pyhive.TCLIService.ttypes.TRowSet` (full file reference)
+
+
+### TCLIService Client
+The TCLIService Client component provides the client-side interface for interacting with the HiveServer2. It encapsulates the logic for sending various Thrift RPC requests (e.g., OpenSession, ExecuteStatement, FetchResults) and receiving their corresponding responses. This component is responsible for initiating communication and managing the client's interaction flow with the server.
+
+
+**Related Classes/Methods**:
+
+- `pyhive.TCLIService.TCLIService.Client` (174:861)
+- `pyhive.TCLIService.TCLIService.Client:OpenSession` (full file reference)
+- `pyhive.TCLIService.TCLIService.Client:ExecuteStatement` (full file reference)
+- `pyhive.TCLIService.TCLIService.Client:FetchResults` (full file reference)
+- `pyhive.TCLIService.TCLIService.Client:CloseSession` (full file reference)
+
+
+### TCLIService Processor
+The TCLIService Processor component acts as the server-side handler for incoming Thrift RPC calls. It is responsible for receiving requests, deserializing them, invoking the appropriate service methods, and serializing the results back to the client. This component effectively bridges the Thrift communication layer with the actual HiveServer2 logic.
+
+
+**Related Classes/Methods**:
+
+- `pyhive.TCLIService.TCLIService.Processor` (full file reference)
+- `pyhive.TCLIService.TCLIService.Processor:process_OpenSession` (full file reference)
+- `pyhive.TCLIService.TCLIService.Processor:process_ExecuteStatement` (full file reference)
+- `pyhive.TCLIService.TCLIService.Processor:process_FetchResults` (full file reference)
+- `pyhive.TCLIService.TCLIService.Processor:process_CloseSession` (full file reference)
+
+
+### RPC Argument/Result Structures
+This component represents the auto-generated Thrift classes that define the arguments and results for each specific RPC method in the TCLIService. These classes (e.g., OpenSession_args, OpenSession_result) are crucial for the serialization and deserialization of data during RPC calls, ensuring that the client and server can correctly interpret the parameters and return values of each operation.
+
+
+**Related Classes/Methods**:
+
+- `pyhive.TCLIService.TCLIService.OpenSession_args` (full file reference)
+- `pyhive.TCLIService.TCLIService.OpenSession_result` (full file reference)
+- `pyhive.TCLIService.TCLIService.ExecuteStatement_args` (full file reference)
+- `pyhive.TCLIService.TCLIService.ExecuteStatement_result` (full file reference)
+- `pyhive.TCLIService.TCLIService.FetchResults_args` (full file reference)
+- `pyhive.TCLIService.TCLIService.FetchResults_result` (full file reference)
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/on_boarding.md b/.codeboarding/on_boarding.md
new file mode 100644
index 00000000..edf63d42
--- /dev/null
+++ b/.codeboarding/on_boarding.md
@@ -0,0 +1,124 @@
+```mermaid
+graph LR
+ Hive_DBAPI_Connector["Hive DBAPI Connector"]
+ Presto_Trino_DBAPI_Connector["Presto-Trino DBAPI Connector"]
+ Common_DBAPI_Utilities["Common DBAPI Utilities"]
+ SASL_Authentication_Layer["SASL Authentication Layer"]
+ TCLIService_Thrift_Layer["TCLIService Thrift Layer"]
+ SQLAlchemy_Dialects["SQLAlchemy Dialects"]
+ PyHive_Exception_Handling["PyHive Exception Handling"]
+ Hive_DBAPI_Connector -- "communicates via" --> TCLIService_Thrift_Layer
+ Hive_DBAPI_Connector -- "uses" --> SASL_Authentication_Layer
+ Hive_DBAPI_Connector -- "builds upon" --> Common_DBAPI_Utilities
+ Hive_DBAPI_Connector -- "raises" --> PyHive_Exception_Handling
+ Presto_Trino_DBAPI_Connector -- "builds upon" --> Common_DBAPI_Utilities
+ Presto_Trino_DBAPI_Connector -- "raises" --> PyHive_Exception_Handling
+ Common_DBAPI_Utilities -- "raises" --> PyHive_Exception_Handling
+ SASL_Authentication_Layer -- "raises" --> PyHive_Exception_Handling
+ SQLAlchemy_Dialects -- "integrates with" --> Hive_DBAPI_Connector
+ SQLAlchemy_Dialects -- "integrates with" --> Presto_Trino_DBAPI_Connector
+ SQLAlchemy_Dialects -- "uses" --> Common_DBAPI_Utilities
+ click Hive_DBAPI_Connector href "https://github.com/CodeBoarding/GeneratedOnBoardings/blob/main/PyHive/Hive DBAPI Connector.md" "Details"
+ click Presto_Trino_DBAPI_Connector href "https://github.com/CodeBoarding/GeneratedOnBoardings/blob/main/PyHive/Presto-Trino DBAPI Connector.md" "Details"
+ click Common_DBAPI_Utilities href "https://github.com/CodeBoarding/GeneratedOnBoardings/blob/main/PyHive/Common DBAPI Utilities.md" "Details"
+ click SASL_Authentication_Layer href "https://github.com/CodeBoarding/GeneratedOnBoardings/blob/main/PyHive/SASL Authentication Layer.md" "Details"
+ click TCLIService_Thrift_Layer href "https://github.com/CodeBoarding/GeneratedOnBoardings/blob/main/PyHive/TCLIService Thrift Layer.md" "Details"
+ click SQLAlchemy_Dialects href "https://github.com/CodeBoarding/GeneratedOnBoardings/blob/main/PyHive/SQLAlchemy Dialects.md" "Details"
+ click PyHive_Exception_Handling href "https://github.com/CodeBoarding/GeneratedOnBoardings/blob/main/PyHive/PyHive Exception Handling.md" "Details"
+```
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+## Component Details
+
+PyHive is a Python DBAPI and SQLAlchemy dialect implementation for Hive, Presto, and Trino. It provides a standardized interface for connecting to these distributed SQL engines, enabling users to execute queries and retrieve results. The architecture is modular, separating concerns such as database-specific connectivity, common DBAPI utilities, authentication mechanisms, Thrift communication, and SQLAlchemy dialect implementations, all while providing a consistent exception handling framework.
+
+### Hive DBAPI Connector
+Provides the core DBAPI-compliant interface for connecting to and interacting with Hive databases, managing sessions, cursors, and query execution via the Thrift service.
+
+
+**Related Classes/Methods**:
+
+- `PyHive.pyhive.hive.Connection` (146:358)
+- `PyHive.pyhive.hive.Cursor` (361:570)
+- `PyHive.pyhive.hive.connect` (137:143)
+- `PyHive.pyhive.hive._check_status` (607:611)
+- `PyHive.pyhive.hive._unwrap_column` (588:604)
+
+
+### Presto-Trino DBAPI Connector
+Offers DBAPI-compliant interfaces for connecting to and executing queries against Presto and Trino databases, handling connection management, cursor operations, and response processing. The Trino connector extends the Presto connector.
+
+
+**Related Classes/Methods**:
+
+- `PyHive.pyhive.presto.Connection` (64:88)
+- `PyHive.pyhive.presto.Cursor` (91:355)
+- `PyHive.pyhive.presto.connect` (55:61)
+- `PyHive.pyhive.trino.Connection` (49:55)
+- `PyHive.pyhive.trino.Cursor` (58:132)
+- `PyHive.pyhive.trino.connect` (40:46)
+
+
+### Common DBAPI Utilities
+Encapsulates shared functionalities for DBAPI compliance, including base cursor behaviors and SQL parameter escaping, used across different database connectors.
+
+
+**Related Classes/Methods**:
+
+- `PyHive.pyhive.common.DBAPICursor` (27:192)
+- `PyHive.pyhive.common.ParamEscaper` (209:260)
+
+
+### SASL Authentication Layer
+Provides client-side implementation for SASL mechanisms, enabling secure authentication for connections, particularly with HiveServer2.
+
+
+**Related Classes/Methods**:
+
+- `PyHive.pyhive.sasl_compat.PureSASLClient` (22:56)
+
+
+### TCLIService Thrift Layer
+Represents the auto-generated Thrift code for the HiveServer2 (TCLIService) API, including client interface, data types for requests/responses, and server-side processor logic.
+
+
+**Related Classes/Methods**:
+
+- `PyHive.TCLIService.TCLIService.Client` (174:861)
+- `PyHive.TCLIService.ttypes.TOpenSessionReq` (full file reference)
+- `PyHive.TCLIService.ttypes.TCloseSessionReq` (full file reference)
+- `PyHive.TCLIService.ttypes.TExecuteStatementReq` (full file reference)
+- `PyHive.TCLIService.ttypes.TFetchResultsReq` (full file reference)
+- `PyHive.TCLIService.ttypes.TGetResultSetMetadataReq` (full file reference)
+
+
+### SQLAlchemy Dialects
+Provides SQLAlchemy dialect implementations for Hive, Presto, and Trino databases, enabling ORM functionalities and schema introspection. The Trino dialect extends the Presto dialect.
+
+
+**Related Classes/Methods**:
+
+- `PyHive.pyhive.sqlalchemy_hive.HiveDialect` (241:392)
+- `PyHive.pyhive.sqlalchemy_presto.PrestoDialect` (79:223)
+- `PyHive.pyhive.sqlalchemy_trino.TrinoDialect` (74:84)
+
+
+### PyHive Exception Handling
+Defines a hierarchy of custom exception classes for various database-related errors within PyHive.
+
+
+**Related Classes/Methods**:
+
+- `pyhive.exc.DataError` (60:64)
+- `pyhive.exc.DatabaseError` (33:35)
+- `pyhive.exc.InterfaceError` (26:30)
+- `pyhive.exc.InternalError` (38:41)
+- `pyhive.exc.NotSupportedError` (67:72)
+- `pyhive.exc.OperationalError` (44:50)
+- `pyhive.exc.ProgrammingError` (53:57)
+- `pyhive.exc.Error` (13:18)
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file