**Course Title:** Functional Programming with Haskell: From Fundamentals to Advanced Concepts **Section Title:** Working with Databases and Web Services in Haskell **Topic:** Introduction to Haskell database libraries: HDBC, Persistent ### Introduction In this topic, we will explore two popular Haskell database libraries: HDBC (Haskell Database Connectivity) and Persistent. These libraries provide a way to interact with relational databases, such as PostgreSQL and SQLite, from within Haskell applications. ### HDBC (Haskell Database Connectivity) HDBC is a database abstraction layer that provides a unified interface to various relational databases, including PostgreSQL, SQLite, and MySQL. It allows you to perform database operations, such as executing queries, retrieving data, and manipulating records, using a Haskell API. **Key Features:** * Database abstraction layer for multiple databases * Supports prepared statements for improved performance * Provides a simple and intuitive API **Example:** Here is an example of using HDBC to connect to a PostgreSQL database and execute a query: ```haskell import Database.HDBC import Database.HDBC.PostgreSQL main :: IO () main = do -- Connect to the database conn <- connectPG "host=localhost dbname=mydb" -- Execute a query results <- quickQuery conn "SELECT * FROM mytable" [] -- Print the results print results -- Disconnect from the database disconnect conn ``` This example demonstrates how to connect to a PostgreSQL database, execute a query, and retrieve the results. ### Persistent Persistent is a Haskell database library that provides a more advanced and sophisticated way of working with databases. It supports a wide range of databases, including PostgreSQL, SQLite, and MongoDB. **Key Features:** * Support for multiple databases, including NoSQL databases * Automatic table creation and migration * Type-safe database operations **Example:** Here is an example of using Persistent to define a Haskell data type and store it in a PostgreSQL database: ```haskell import Database.Persist import Database.Persist.Postgresql -- Define a Haskell data type data Person = Person { personName :: String , personAge :: Int } deriving (Eq, Show) -- Create a database table for the data type share [mkPersist sqlSettings, mkMigrate "migrateAll"] [persistLowerCase| Person name String age Int |] main :: IO () main = do -- Create a database connection pool <- createPostgresqlPool "host=localhost dbname=mydb" -- Run a database migration to create the table runMigration migrateAll pool -- Insert a record into the table person <- insert Person { personName = "John Doe", personAge = 30 } pool -- Retrieve the record from the table person' <- get person pool -- Print the retrieved record print person' ``` This example demonstrates how to define a Haskell data type, create a database table for it, and store a record in the table. ### Conclusion In this topic, we explored two Haskell database libraries: HDBC and Persistent. We saw how to use HDBC to connect to a PostgreSQL database and execute a query, and how to use Persistent to define a Haskell data type and store it in a PostgreSQL database. **External Resources:** * HDBC: [https://hackage.haskell.org/package/hdbc](https://hackage.haskell.org/package/hdbc) * Persistent: [https://hackage.haskell.org/package/persistent](https://hackage.haskell.org/package/persistent) **Next Steps:** In the next topic, we will explore how to connect to and query relational databases using HDBC and Persistent. **Leave a comment/ask for help:** If you have any questions or need further clarification on this topic, please leave a comment below.