diff --git a/docs/StardustDocs/d.tree b/docs/StardustDocs/d.tree
index f2ef4fd112..95f4c84255 100644
--- a/docs/StardustDocs/d.tree
+++ b/docs/StardustDocs/d.tree
@@ -187,8 +187,23 @@
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/docs/StardustDocs/topics/Home.topic b/docs/StardustDocs/topics/Home.topic
index 27cec9353e..aad8c8f117 100644
--- a/docs/StardustDocs/topics/Home.topic
+++ b/docs/StardustDocs/topics/Home.topic
@@ -29,6 +29,7 @@
Featured topics
+
diff --git a/docs/StardustDocs/topics/dataSources/ApacheArrow.md b/docs/StardustDocs/topics/dataSources/ApacheArrow.md
new file mode 100644
index 0000000000..cf9deb045e
--- /dev/null
+++ b/docs/StardustDocs/topics/dataSources/ApacheArrow.md
@@ -0,0 +1,49 @@
+# Apache Arrow
+
+
+Read and write Apache Arrow files in Kotlin — efficient binary format support with Kotlin DataFrame.
+
+
+
+Work with Arrow files in Kotlin for fast I/O — supports both streaming and random access formats.
+
+
+
+Kotlin DataFrame provides full support for reading and writing Apache Arrow files in high-performance workflows.
+
+
+
+Kotlin DataFrame supports reading from and writing to Apache Arrow files.
+
+Requires the [`dataframe-arrow` module](Modules.md#dataframe-arrow), which is included by
+default in the general [`dataframe`](Modules.md#dataframe-general) artifact
+and in [`%use dataframe`](gettingStartedKotlinNotebook.md#integrate-kotlin-dataframe) for Kotlin Notebook.
+
+> Make sure to follow the
+> [Apache Arrow Java compatibility guide](https://arrow.apache.org/docs/java/install.html#java-compatibility)
+> when using Java 9+.
+> {style="warning"}
+
+## Read
+
+[`DataFrame`](DataFrame.md) supports both the
+[Arrow interprocess streaming format](https://arrow.apache.org/docs/java/ipc.html#writing-and-reading-streaming-format)
+and the [Arrow random access format](https://arrow.apache.org/docs/java/ipc.html#writing-and-reading-random-access-files).
+
+You can read a `DataFrame` from Apache Arrow data sources
+(via a file path, URL, or stream) using the [`readArrowFeather()`](read.md#read-apache-arrow-formats) method:
+
+```kotlin
+val df = DataFrame.readArrowFeather("example.feather")
+```
+
+```kotlin
+val df = DataFrame.readArrowFeather("https://kotlin.github.io/dataframe/resources/example.feather")
+```
+
+## Write
+
+A [`DataFrame`](DataFrame.md) can be written to Arrow format using the interprocess streaming or random access format.
+Output targets include `WritableByteChannel`, `OutputStream`, `File`, or `ByteArray`.
+
+See [](write.md#writing-to-apache-arrow-formats) for more details.
diff --git a/docs/StardustDocs/topics/dataSources/CSV-TSV.md b/docs/StardustDocs/topics/dataSources/CSV-TSV.md
new file mode 100644
index 0000000000..1061620d18
--- /dev/null
+++ b/docs/StardustDocs/topics/dataSources/CSV-TSV.md
@@ -0,0 +1,52 @@
+# CSV / TSV
+
+
+Work with CSV and TSV files — read, analyze, and export tabular data using Kotlin DataFrame.
+
+
+
+Seamlessly load and write CSV or TSV files in Kotlin — perfect for common tabular data workflows.
+
+
+
+Kotlin DataFrame support for reading and writing CSV and TSV files with simple, type-safe APIs.
+
+
+
+Kotlin DataFrame supports reading from and writing to CSV and TSV files.
+
+Requires the [`dataframe-csv` module](Modules.md#dataframe-csv),
+which is included by default in the general [`dataframe`](Modules.md#dataframe-general)
+artifact and in [`%use dataframe`](gettingStartedKotlinNotebook.md#integrate-kotlin-dataframe) for Kotlin Notebook.
+
+## Read
+
+You can read a [`DataFrame`](DataFrame.md) from a CSV or TSV file (via a file path or URL)
+using the [`readCsv()`](read.md#read-from-csv) or `readTsv()` methods:
+
+```kotlin
+val df = DataFrame.readCsv("example.csv")
+```
+
+```kotlin
+val df = DataFrame.readCsv("https://kotlin.github.io/dataframe/resources/example.csv")
+```
+
+## Write
+
+You can write a [`DataFrame`](DataFrame.md) to a CSV file using the [`writeCsv()`](write.md#writing-to-csv) method:
+
+```kotlin
+df.writeCsv("example.csv")
+```
+
+## Deephaven CSV
+
+The [`dataframe-csv`](Modules.md#dataframe-csv) module uses the high-performance
+[Deephaven CSV library](https://github.com/deephaven/deephaven-csv) under the hood
+for fast and efficient CSV reading and writing.
+
+If you're working with large CSV files, you can adjust the parser manually
+by [configuring Deephaven-specific parameters](https://kotlin.github.io/dataframe/read.html#unlocking-deephaven-csv-features)
+to get the best performance for your use case.
+
diff --git a/docs/StardustDocs/topics/dataSources/Data-Sources.md b/docs/StardustDocs/topics/dataSources/Data-Sources.md
index 8d23903e1d..1e83f48821 100644
--- a/docs/StardustDocs/topics/dataSources/Data-Sources.md
+++ b/docs/StardustDocs/topics/dataSources/Data-Sources.md
@@ -1,3 +1,33 @@
# Data Sources
-> This topic is not ready yet.
+
+Discover all the data formats Kotlin DataFrame can work with — including JSON, CSV, Excel, SQL databases, and more.
+
+
+
+Explore supported data sources in Kotlin DataFrame and how to integrate them into your data processing workflow.
+
+
+
+Explore supported data sources in Kotlin DataFrame and how to integrate them into your data processing workflow.
+
+
+One of the key aspects of working with data is being able to read from and write to various data sources.
+Kotlin DataFrame provides seamless support for a wide range of formats to integrate into your data workflows.
+Below you'll find a list of supported sources along with instructions on how to read and write data using them.
+
+- [JSON](JSON.md)
+ - [OpenAPI](OpenAPI.md)
+- [CSV / TSV](CSV-TSV.md)
+- [Excel](Excel.md)
+- [Apache Arrow](ApacheArrow.md)
+- [SQL](SQL.md):
+ - [PostgreSQL](PostgreSQL.md)
+ - [MySQL](MySQL.md)
+ - [Microsoft SQL Server](Microsoft-SQL-Server.md)
+ - [SQLite](SQLite.md)
+ - [H2](H2.md)
+ - [MariaDB](MariaDB.md)
+ - [Custom SQL Source](Custom-SQL-Source.md)
+- [Custom integrations with unsupported data sources](Integrations.md)
+
diff --git a/docs/StardustDocs/topics/dataSources/Excel.md b/docs/StardustDocs/topics/dataSources/Excel.md
new file mode 100644
index 0000000000..349cc81eee
--- /dev/null
+++ b/docs/StardustDocs/topics/dataSources/Excel.md
@@ -0,0 +1,42 @@
+# Excel
+
+
+Read from and write to Excel files in `.xls` or `.xlsx` formats with Kotlin DataFrame for seamless spreadsheet integration.
+
+
+
+Kotlin DataFrame makes it easy to load and save data from Excel files — perfect for working with spreadsheet-based workflows.
+
+
+
+Learn how to read and write Excel files using Kotlin DataFrame with just a single line of code.
+
+
+
+Kotlin DataFrame supports reading from and writing to Excel files in both `.xls` and `.xlsx` formats.
+
+Requires the [`dataframe-excel` module](Modules.md#dataframe-excel),
+which is included by default in the general [`dataframe`](Modules.md#dataframe-general)
+artifact and in [`%use dataframe`](gettingStartedKotlinNotebook.md#integrate-kotlin-dataframe) for Kotlin Notebook.
+
+## Read
+
+You can read a [`DataFrame`](DataFrame.md) from an Excel file (via a file path or URL)
+using the [`readExcel()`](read.md#read-from-excel) method:
+
+```kotlin
+val df = DataFrame.readExcel("example.xlsx")
+```
+
+```kotlin
+val df = DataFrame.readExcel("https://kotlin.github.io/dataframe/resources/example.xlsx")
+```
+
+## Write
+
+You can write a [`DataFrame`](DataFrame.md) to an Excel file using the
+[`writeExcel()`](write.md#writing-to-csv) method:
+
+```kotlin
+df.writeExcel("example.xlsx")
+```
diff --git a/docs/StardustDocs/topics/dataSources/Integrations.md b/docs/StardustDocs/topics/dataSources/Integrations.md
index a1db9ca30c..438e12c163 100644
--- a/docs/StardustDocs/topics/dataSources/Integrations.md
+++ b/docs/StardustDocs/topics/dataSources/Integrations.md
@@ -1,3 +1,27 @@
-# Integrations
+# Custom integrations with unsupported data sources
-> This topic is not ready yet.
+
+Examples of how to integrate Kotlin DataFrame with other data frameworks like Exposed, Spark, or Multik.
+
+
+
+Integrate Kotlin DataFrame with unsupported sources — see practical examples with Exposed, Spark, and more.
+
+
+
+How to connect Kotlin DataFrame with data sources like Exposed, Apache Spark, or Multik.
+
+
+Some data sources are not officially supported in the Kotlin DataFrame API yet —
+but you can still integrate them easily using custom code.
+
+Below is a list of example integrations with other data frameworks.
+These examples demonstrate how to bridge Kotlin DataFrame with external libraries or APIs.
+
+- [Kotlin Exposed](https://github.com/Kotlin/dataframe/tree/master/examples/idea-examples/unsupported-data-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/exposed)
+- [Apache Spark](https://github.com/Kotlin/dataframe/tree/master/examples/idea-examples/unsupported-data-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/spark)
+- [Apache Spark (with Kotlin Spark API)](https://github.com/Kotlin/dataframe/tree/master/examples/idea-examples/unsupported-data-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/kotlinSpark)
+- [Multik](https://github.com/Kotlin/dataframe/tree/master/examples/idea-examples/unsupported-data-sources/src/main/kotlin/org/jetbrains/kotlinx/dataframe/examples/multik)
+
+You can use these examples as templates to create your own integrations
+with any data processing library that produces structured tabular data.
diff --git a/docs/StardustDocs/topics/dataSources/JSON.md b/docs/StardustDocs/topics/dataSources/JSON.md
new file mode 100644
index 0000000000..96a926c1a7
--- /dev/null
+++ b/docs/StardustDocs/topics/dataSources/JSON.md
@@ -0,0 +1,47 @@
+# JSON
+
+
+Support for working with JSON data — load, explore, and save structured JSON using Kotlin DataFrame.
+
+
+
+Easily handle JSON data in Kotlin — read from files or URLs, and export your data back to JSON format.
+
+
+
+Kotlin DataFrame support for reading and writing JSON files in a structured and type-safe way.
+
+
+Kotlin DataFrame supports reading from and writing to JSON files.
+
+Requires the [`dataframe-json` module](Modules.md#dataframe-json),
+which is included by default in the general [`dataframe`](Modules.md#dataframe-general)
+artifact and in [`%use dataframe`](gettingStartedKotlinNotebook.md#integrate-kotlin-dataframe)
+for Kotlin Notebook.
+
+> Kotlin DataFrame is suitable only for working with table-like structured JSON —
+> a list of objects where each object represents a row and all objects share the same structure.
+>
+> Experimental support for [OpenAPI JSON schemas](OpenAPI.md) is also available.
+> {style="note"}
+
+## Read
+
+You can read a [`DataFrame`](DataFrame.md) or [`DataRow`](DataRow.md)
+from a JSON file (via a file path or URL) using the [`readJson()`](read.md#read-from-json) method:
+
+```kotlin
+val df = DataFrame.readJson("example.json")
+```
+
+```kotlin
+val df = DataFrame.readJson("https://kotlin.github.io/dataframe/resources/example.json")
+```
+
+## Write
+
+You can write a [`DataFrame`](DataFrame.md) to a JSON file using the [`writeJson()`](write.md#writing-to-json) method:
+
+```kotlin
+df.writeJson("example.json")
+```
diff --git a/docs/StardustDocs/topics/dataSources/OpenAPI.md b/docs/StardustDocs/topics/dataSources/OpenAPI.md
new file mode 100644
index 0000000000..c8db295c66
--- /dev/null
+++ b/docs/StardustDocs/topics/dataSources/OpenAPI.md
@@ -0,0 +1,34 @@
+# OpenAPI
+
+
+Work with JSON data based on OpenAPI 3.0 schemas using Kotlin DataFrame — helpful for consuming structured API responses.
+
+
+
+Use Kotlin DataFrame to read and write data that conforms to OpenAPI specifications. Great for API-driven data workflows.
+
+
+
+Learn how to use OpenAPI 3.0 JSON schemas with Kotlin DataFrame to load and manipulate API-defined data.
+
+
+
+> **Experimental**: Support for OpenAPI 3.0.0 schemas is currently experimental
+> and may change or be removed in future releases.
+> {style="warning"}
+
+Kotlin DataFrame provides support for reading and writing JSON data
+that conforms to [OpenAPI 3.0 specifications](https://www.openapis.org).
+This feature is useful when working with APIs that expose structured data defined via OpenAPI schemas.
+
+Requires the [`dataframe-openapi` module](Modules.md#dataframe-openapi),
+which **is not included** in the general [`dataframe`](Modules.md#dataframe-general) artifact.
+
+To enable it in Kotlin Notebook, use:
+
+```kotlin
+%use dataframe(enableExperimentalOpenApi=true)
+```
+
+See [the OpenAPI guide notebook](https://github.com/Kotlin/dataframe/blob/master/examples/notebooks/json/KeyValueAndOpenApi.ipynb)
+for details on how to work with OpenAPI-based data.
diff --git a/docs/StardustDocs/topics/dataSources/sql/Custom-SQL-Source.md b/docs/StardustDocs/topics/dataSources/sql/Custom-SQL-Source.md
new file mode 100644
index 0000000000..d573e381b8
--- /dev/null
+++ b/docs/StardustDocs/topics/dataSources/sql/Custom-SQL-Source.md
@@ -0,0 +1,22 @@
+# Custom SQL Source
+
+
+Connect Kotlin DataFrame to any JDBC-compatible database using a custom SQL source configuration.
+
+
+
+Easily integrate unsupported SQL databases in Kotlin DataFrame using a flexible custom source setup.
+
+
+
+Define a custom SQL source in Kotlin DataFrame to work with any JDBC-based database.
+
+
+
+If your SQL database is not officially supported, you can either
+[create an issue](https://github.com/Kotlin/dataframe/issues)
+or define a simple, configurable custom SQL source.
+
+See the [How to Extend DataFrame Library for Custom SQL Database Support guide](readSqlFromCustomDatabase.md)
+for detailed instructions and an example with HSQLDB.
+
diff --git a/docs/StardustDocs/topics/dataSources/sql/H2.md b/docs/StardustDocs/topics/dataSources/sql/H2.md
new file mode 100644
index 0000000000..fc266dce36
--- /dev/null
+++ b/docs/StardustDocs/topics/dataSources/sql/H2.md
@@ -0,0 +1,73 @@
+# H2
+
+
+Use Kotlin DataFrame to query H2 databases via JDBC — read tables, run SQL queries, or fetch result sets directly.
+
+
+
+Connect to H2 databases in Kotlin DataFrame and load data using simple JDBC configurations.
+
+
+
+Read from H2 databases in Kotlin DataFrame using built-in SQL reading methods.
+
+
+
+Kotlin DataFrame supports reading from an [H2](https://www.h2database.com/html/main.html) database using JDBC.
+
+Requires the [`dataframe-jdbc` module](Modules.md#dataframe-jdbc),
+which is included by default in the general [`dataframe` artifact](Modules.md#dataframe-general)
+and in [`%use dataframe`](gettingStartedKotlinNotebook.md#integrate-kotlin-dataframe) for Kotlin Notebook.
+
+You’ll also need [the official H2 JDBC driver](https://www.h2database.com/html/main.html):
+
+
+
+
+```kotlin
+dependencies {
+ implementation("com.h2database:h2:$version")
+}
+```
+
+
+
+
+
+```kotlin
+USE {
+ dependencies("com.h2database:h2:$version")
+}
+```
+
+
+
+
+The actual Maven Central driver version could be found
+[here](https://mvnrepository.com/artifact/com.h2database/h2).
+
+## Read
+
+[`DataFrame`](DataFrame.md) can be loaded from a database in several ways:
+a user can read data from a SQL table by given name ([`readSqlTable`](readSqlDatabases.md)),
+as a result of a user-defined SQL query ([`readSqlQuery`](readSqlDatabases.md)),
+or from a given `ResultSet` ([`readResultSet`](readSqlDatabases.md)).
+It is also possible to load all data from non-system tables, each into a separate `DataFrame` ([`readAllSqlTables`](readSqlDatabases.md)).
+
+See [](readSqlDatabases.md) for more details.
+
+```kotlin
+import org.jetbrains.kotlinx.dataframe.io.DbConnectionConfig
+import org.jetbrains.kotlinx.dataframe.api.*
+
+val url = "jdbc:h2:mem:testDatabase"
+val username = "sa"
+val password = ""
+
+val dbConfig = DbConnectionConfig(url, username, password)
+
+val tableName = "Customer"
+
+val df = DataFrame.readSqlTable(dbConfig, tableName)
+```
+
diff --git a/docs/StardustDocs/topics/dataSources/sql/MariaDB.md b/docs/StardustDocs/topics/dataSources/sql/MariaDB.md
new file mode 100644
index 0000000000..41d09f58fb
--- /dev/null
+++ b/docs/StardustDocs/topics/dataSources/sql/MariaDB.md
@@ -0,0 +1,72 @@
+# MariaDB
+
+
+Access MariaDB databases using Kotlin DataFrame and JDBC — fetch data from tables or custom SQL queries with ease.
+
+
+
+Seamlessly integrate MariaDB with Kotlin DataFrame — load data using JDBC and analyze it in Kotlin.
+
+
+
+Read data from MariaDB into Kotlin DataFrame using standard JDBC configurations.
+
+
+
+Kotlin DataFrame supports reading from [MariaDB](https://mariadb.org) database using JDBC.
+
+Requires the [`dataframe-jdbc` module](Modules.md#dataframe-jdbc),
+which is included by default in the general [`dataframe` artifact](Modules.md#dataframe-general)
+and in [`%use dataframe`](gettingStartedKotlinNotebook.md#integrate-kotlin-dataframe) for Kotlin Notebook.
+
+You’ll also need [the official MariaDB JDBC driver](https://mariadb.com/docs/connectors/mariadb-connector-j):
+
+
+
+
+```kotlin
+dependencies {
+ implementation("org.mariadb.jdbc:mariadb-java-client:$version")
+}
+```
+
+
+
+
+
+```kotlin
+USE {
+ dependencies("org.mariadb.jdbc:mariadb-java-client:$version")
+}
+```
+
+
+
+
+The actual Maven Central driver version could be found
+[here](https://mvnrepository.com/artifact/org.mariadb.jdbc/mariadb-java-client).
+
+## Read
+
+[`DataFrame`](DataFrame.md) can be loaded from a database in several ways:
+a user can read data from a SQL table by given name ([`readSqlTable`](readSqlDatabases.md)),
+as a result of a user-defined SQL query ([`readSqlQuery`](readSqlDatabases.md)),
+or from a given `ResultSet` ([`readResultSet`](readSqlDatabases.md)).
+It is also possible to load all data from non-system tables, each into a separate `DataFrame` ([`readAllSqlTables`](readSqlDatabases.md)).
+
+See [](readSqlDatabases.md) for more details.
+
+```kotlin
+import org.jetbrains.kotlinx.dataframe.io.DbConnectionConfig
+import org.jetbrains.kotlinx.dataframe.api.*
+
+val url = "jdbc:mariadb://localhost:3306/testDatabase"
+val username = "root"
+val password = "password"
+
+val dbConfig = DbConnectionConfig(url, username, password)
+
+val tableName = "Customer"
+
+val df = DataFrame.readSqlTable(dbConfig, tableName)
+```
diff --git a/docs/StardustDocs/topics/dataSources/sql/Microsoft-SQL-Server.md b/docs/StardustDocs/topics/dataSources/sql/Microsoft-SQL-Server.md
new file mode 100644
index 0000000000..e42b3bd857
--- /dev/null
+++ b/docs/StardustDocs/topics/dataSources/sql/Microsoft-SQL-Server.md
@@ -0,0 +1,74 @@
+# Microsoft SQL Server (MS SQL)
+
+
+Connect to Microsoft SQL Server using Kotlin DataFrame and JDBC — load structured data directly into your Kotlin workflow.
+
+
+
+Use Kotlin DataFrame to read from Microsoft SQL Server — run queries or load entire tables via JDBC.
+
+
+
+Fetch data from Microsoft SQL Server into Kotlin DataFrame using JDBC configuration.
+
+
+
+Kotlin DataFrame supports reading from [Microsoft SQL Server (MS SQL)](https://www.microsoft.com/en-us/sql-server)
+database using JDBC.
+
+Requires the [`dataframe-jdbc` module](Modules.md#dataframe-jdbc),
+which is included by default in the general [`dataframe` artifact](Modules.md#dataframe-general)
+and in [`%use dataframe`](gettingStartedKotlinNotebook.md#integrate-kotlin-dataframe) for Kotlin Notebook.
+
+You’ll also need
+[the official MS SQL JDBC driver](https://learn.microsoft.com/en-us/sql/connect/jdbc/download-microsoft-jdbc-driver-for-sql-server?view=sql-server-ver17):
+
+
+
+
+```kotlin
+dependencies {
+ implementation("com.microsoft.sqlserver:mssql-jdbc:$version")
+}
+```
+
+
+
+
+
+```kotlin
+USE {
+ dependencies("com.microsoft.sqlserver:mssql-jdbc:$version")
+}
+```
+
+
+
+
+The actual Maven Central driver version could be found
+[here](https://mvnrepository.com/artifact/com.microsoft.sqlserver/mssql-jdbc).
+
+## Read
+
+[`DataFrame`](DataFrame.md) can be loaded from a database in several ways:
+a user can read data from a SQL table by given name ([`readSqlTable`](readSqlDatabases.md)),
+as a result of a user-defined SQL query ([`readSqlQuery`](readSqlDatabases.md)),
+or from a given `ResultSet` ([`readResultSet`](readSqlDatabases.md)).
+It is also possible to load all data from non-system tables, each into a separate `DataFrame` ([`readAllSqlTables`](readSqlDatabases.md)).
+
+See [](readSqlDatabases.md) for more details.
+
+```kotlin
+import org.jetbrains.kotlinx.dataframe.io.DbConnectionConfig
+import org.jetbrains.kotlinx.dataframe.api.*
+
+val url = "jdbc:sqlserver://localhost:1433;databaseName=testDatabase"
+val username = "sa"
+val password = "password"
+
+val dbConfig = DbConnectionConfig(url, username, password)
+
+val tableName = "Customer"
+
+val df = DataFrame.readSqlTable(dbConfig, tableName)
+```
diff --git a/docs/StardustDocs/topics/dataSources/sql/MySQL.md b/docs/StardustDocs/topics/dataSources/sql/MySQL.md
new file mode 100644
index 0000000000..2ed3dbc5d6
--- /dev/null
+++ b/docs/StardustDocs/topics/dataSources/sql/MySQL.md
@@ -0,0 +1,72 @@
+# MySQL
+
+
+Connect to MySQL databases and load data into Kotlin DataFrame using JDBC — query, analyze, and transform SQL data in Kotlin.
+
+
+
+Use Kotlin DataFrame with MySQL — easily read tables and queries over JDBC into powerful data structures.
+
+
+
+Read data from MySQL into Kotlin DataFrame using JDBC configuration.
+
+
+
+Kotlin DataFrame supports reading from [MySQL](https://www.mysql.com) database using JDBC.
+
+Requires the [`dataframe-jdbc` module](Modules.md#dataframe-jdbc),
+which is included by default in the general [`dataframe` artifact](Modules.md#dataframe-general)
+and in [`%use dataframe`](gettingStartedKotlinNotebook.md#integrate-kotlin-dataframe) for Kotlin Notebook.
+
+You’ll also need [the official MySQL JDBC driver](https://dev.mysql.com/downloads/connector/j/):
+
+
+
+
+```kotlin
+dependencies {
+ implementation("com.mysql:mysql-connector-j:$version")
+}
+```
+
+
+
+
+
+```kotlin
+USE {
+ dependencies("com.mysql:mysql-connector-j:$version")
+}
+```
+
+
+
+
+The actual Maven Central driver version could be found
+[here](https://mvnrepository.com/artifact/org.xerial/sqlite-jdbc).
+
+## Read
+
+[`DataFrame`](DataFrame.md) can be loaded from a database in several ways:
+a user can read data from a SQL table by given name ([`readSqlTable`](readSqlDatabases.md)),
+as a result of a user-defined SQL query ([`readSqlQuery`](readSqlDatabases.md)),
+or from a given `ResultSet` ([`readResultSet`](readSqlDatabases.md)).
+It is also possible to load all data from non-system tables, each into a separate `DataFrame` ([`readAllSqlTables`](readSqlDatabases.md)).
+
+See [](readSqlDatabases.md) for more details.
+
+```kotlin
+import org.jetbrains.kotlinx.dataframe.io.DbConnectionConfig
+import org.jetbrains.kotlinx.dataframe.api.*
+
+val url = "jdbc:mysql://localhost:3306/testDatabase"
+val username = "root"
+val password = "password"
+
+val dbConfig = DbConnectionConfig(url, username, password)
+
+val tableName = "Customer"
+
+val df = DataFrame.readSqlTable(dbConfig, tableName)
+```
diff --git a/docs/StardustDocs/topics/dataSources/sql/PostgreSQL.md b/docs/StardustDocs/topics/dataSources/sql/PostgreSQL.md
new file mode 100644
index 0000000000..c62cd71fca
--- /dev/null
+++ b/docs/StardustDocs/topics/dataSources/sql/PostgreSQL.md
@@ -0,0 +1,71 @@
+# PostgreSQL
+
+
+Work with PostgreSQL databases in Kotlin — read tables and queries into DataFrames using JDBC.
+
+
+
+Use Kotlin DataFrame to query and transform PostgreSQL data directly via JDBC.
+
+
+
+Read PostgreSQL data into Kotlin DataFrame with JDBC support.
+
+
+
+Kotlin DataFrame supports reading from [PostgreSQL](https://www.postgresql.org) database using JDBC.
+
+Requires the [`dataframe-jdbc` module](Modules.md#dataframe-jdbc),
+which is included by default in the general [`dataframe` artifact](Modules.md#dataframe-general)
+and in [`%use dataframe`](gettingStartedKotlinNotebook.md#integrate-kotlin-dataframe) for Kotlin Notebook.
+
+You’ll also need [the official PostgreSQL JDBC driver](https://jdbc.postgresql.org):
+
+
+
+
+```kotlin
+dependencies {
+ implementation("org.postgresql:postgresql:$version")
+}
+```
+
+
+
+
+
+```kotlin
+USE {
+ dependencies("org.postgresql:postgresql:$version")
+}
+```
+
+
+
+
+The actual Maven Central driver version could be found
+[here](https://mvnrepository.com/artifact/org.postgresql/postgresql).
+
+## Read
+
+[`DataFrame`](DataFrame.md) can be loaded from a database in several ways:
+a user can read data from a SQL table by given name ([`readSqlTable`](readSqlDatabases.md)),
+as a result of a user-defined SQL query ([`readSqlQuery`](readSqlDatabases.md)),
+or from a given `ResultSet` ([`readResultSet`](readSqlDatabases.md)).
+It is also possible to load all data from non-system tables, each into a separate `DataFrame` ([`readAllSqlTables`](readSqlDatabases.md)).
+
+See [](readSqlDatabases.md) for more details.
+
+```kotlin
+import org.jetbrains.kotlinx.dataframe.io.DbConnectionConfig
+
+val url = "jdbc:postgresql://localhost:5432/testDatabase"
+val username = "postgres"
+val password = "password"
+
+val dbConfig = DbConnectionConfig(url, username, password)
+
+val tableName = "Customer"
+
+val df = DataFrame.readSqlTable(dbConfig, tableName)
+```
diff --git a/docs/StardustDocs/topics/dataSources/sql/SQL.md b/docs/StardustDocs/topics/dataSources/sql/SQL.md
new file mode 100644
index 0000000000..5337903285
--- /dev/null
+++ b/docs/StardustDocs/topics/dataSources/sql/SQL.md
@@ -0,0 +1,45 @@
+# SQL
+
+
+Work with SQL databases in Kotlin using DataFrame and JDBC — read tables and queries with ease.
+
+
+
+Connect to PostgreSQL, MySQL, SQLite, and other SQL databases using Kotlin DataFrame's JDBC support.
+
+
+
+Load data from SQL databases into Kotlin DataFrame using JDBC and built-in reading functions.
+
+
+Kotlin DataFrame supports reading from SQL databases using JDBC.
+
+Requires the [`dataframe-jdbc` module](Modules.md#dataframe-jdbc),
+which is included by default in the general [`dataframe` artifact](Modules.md#dataframe-general)
+and in [`%use dataframe`](gettingStartedKotlinNotebook.md#integrate-kotlin-dataframe) for Kotlin Notebook.
+You’ll also need a JDBC driver for the specific database.
+
+## Supported databases
+
+Kotlin DataFrame provides out-of-the-box support for the most common SQL databases:
+
+- [PostgreSQL](PostgreSQL.md)
+- [MySQL](MySQL.md)
+- [Microsoft SQL Server](Microsoft-SQL-Server.md)
+- [SQLite](SQLite.md)
+- [H2](H2.md)
+- [MariaDB](MariaDB.md)
+
+You can also define a [Custom SQL Source](Custom-SQL-Source.md)
+to work with any other JDBC-compatible database.
+
+## Read
+
+[`DataFrame`](DataFrame.md) can be loaded from a database in several ways:
+a user can read data from a SQL table by given name ([`readSqlTable`](readSqlDatabases.md)),
+as a result of a user-defined SQL query ([`readSqlQuery`](readSqlDatabases.md)),
+or from a given `ResultSet` ([`readResultSet`](readSqlDatabases.md)).
+It is also possible to load all data from non-system tables, each into a separate `DataFrame`
+([`readAllSqlTables`](readSqlDatabases.md)).
+
+See [](readSqlDatabases.md) for more details.
diff --git a/docs/StardustDocs/topics/dataSources/sql/SQLite.md b/docs/StardustDocs/topics/dataSources/sql/SQLite.md
new file mode 100644
index 0000000000..0d4956dd46
--- /dev/null
+++ b/docs/StardustDocs/topics/dataSources/sql/SQLite.md
@@ -0,0 +1,70 @@
+# SQLite
+
+
+Use Kotlin DataFrame to read data from SQLite databases with minimal setup via JDBC.
+
+
+
+Query and transform SQLite data directly in Kotlin using DataFrame and JDBC.
+
+
+
+Read SQLite tables into Kotlin DataFrame using the built-in JDBC integration.
+
+
+
+Kotlin DataFrame supports reading from [SQLite](https://www.sqlite.org) database using JDBC.
+
+Requires the [`dataframe-jdbc` module](Modules.md#dataframe-jdbc),
+which is included by default in the general [`dataframe` artifact](Modules.md#dataframe-general)
+and in [`%use dataframe`](gettingStartedKotlinNotebook.md#integrate-kotlin-dataframe) for Kotlin Notebook.
+
+You’ll also need [SQLite JDBC driver](https://github.com/xerial/sqlite-jdbc):
+
+
+
+
+```kotlin
+dependencies {
+ implementation("org.xerial:sqlite-jdbc:$version")
+}
+```
+
+
+
+
+
+```kotlin
+USE {
+ dependencies("org.xerial:sqlite-jdbc:$version")
+}
+```
+
+
+
+
+The actual Maven Central driver version could be found
+[here](https://mvnrepository.com/artifact/com.mysql/mysql-connector-j).
+
+## Read
+
+[`DataFrame`](DataFrame.md) can be loaded from a database in several ways:
+a user can read data from a SQL table by given name ([`readSqlTable`](readSqlDatabases.md)),
+as a result of a user-defined SQL query ([`readSqlQuery`](readSqlDatabases.md)),
+or from a given `ResultSet` ([`readResultSet`](readSqlDatabases.md)).
+It is also possible to load all data from non-system tables, each into a separate `DataFrame` ([`readAllSqlTables`](readSqlDatabases.md)).
+
+See [](readSqlDatabases.md) for more details.
+
+```kotlin
+import org.jetbrains.kotlinx.dataframe.io.DbConnectionConfig
+import org.jetbrains.kotlinx.dataframe.api.*
+
+val url = "jdbc:sqlite:testDatabase.db"
+
+val dbConfig = DbConnectionConfig(url)
+
+val tableName = "Customer"
+
+val df = DataFrame.readSqlTable(dbConfig, tableName)
+```
diff --git a/docs/StardustDocs/topics/write.md b/docs/StardustDocs/topics/write.md
index 74895026c2..7a1df9afde 100644
--- a/docs/StardustDocs/topics/write.md
+++ b/docs/StardustDocs/topics/write.md
@@ -144,9 +144,10 @@ Add dependency:
implementation("org.jetbrains.kotlinx:dataframe-arrow:$dataframe_version")
```
-
-Make sure to follow [Apache Arrow Java compatibility](https://arrow.apache.org/docs/java/install.html#java-compatibility) guide when using Java 9+
-
+> Make sure to follow an
+> [Apache Arrow Java compatibility](https://arrow.apache.org/docs/java/install.html#java-compatibility)
+> guide when using Java 9+
+> {style = "warning"}
[`DataFrame`](DataFrame.md) supports writing [Arrow interprocess streaming format](https://arrow.apache.org/docs/java/ipc.html#writing-and-reading-streaming-format)
and [Arrow random access format](https://arrow.apache.org/docs/java/ipc.html#writing-and-reading-random-access-files)