Beam：没有模板Haskell的数据库功能！

2023-10-26

作为Haskell Web系列的一部分，我们检查了Persistent和Esqueleto库。这些中的第一个允许您使用特殊语法创建数据库模式。然后，您可以使用Template Haskell生成所有必要的Haskell数据类型和类型的实例。更好的是，您可以编写Haskell代码以查询类似于SQL的代码。这些查询是类型安全的，这非常好。但是，需要使用模板Haskell指定我们的架构存在一些缺点。例如，代码花费更长的时间进行编译，而对于初学者而言则较难获得。

本周在博客上，我们将探索另一个名为Beam的数据库库。该库使我们无需使用Template Haskell即可指定数据库架构。涉及到一些样板，但这还不错！与Persistent一样，Beam也支持许多后端，例如SQLite和PostgresQL。与Persistent不同，Beam还支持将联接查询作为其系统的内置部分。

有关高级库的更多想法，请务必查看我们的生产清单！它包括几个其他数据库选项供您查看。

指定我们的类型

首先，虽然Beam不需要模板Haskell，但确实需要很多其他编译器扩展。您可以查看下面附录中的内容，也可以查看Github上的示例代码。现在让我们回想一下在使用Persistent时如何指定架构：

import qualified Database.Persist.TH as PTH

PTH.share [PTH.mkPersist PTH.sqlSettings, PTH.mkMigrate "migrateAll"] [PTH.persistLowerCase| 
 User sql=users 
 name Text 
 email Text 
 age Int 
 occupation Text 
 UniqueEmail email 
 deriving Show Read Eq

Article sql=articles 
 title Text 
 body Text 
 publishedTime UTCTime 
 authorId UserId 
 UniqueTitle title 
 deriving Show Read Eq

使用Beam，我们不会使用Template Haskell，因此实际上将创建普通的Haskell数据类型。但是仍然会有一些奇怪之处。首先，按照惯例，我们将在类型的最后加上额外的字符T 这是不必要的，但是约定可以帮助我们记住与表相关的类型。我们还必须提供一个额外的类型参数f ，稍后我们将进一步介绍它：

data UserT f = 
 …

data ArticleT f = 
 ...

我们的下一个约定是在字段名称前使用下划线。与持久性不同，我们还将在字段名称中指定类型名称。遵循这些约定，我遵循图书馆创建者Travis的建议。

data UserT f = 
 { _userId :: ... 
 , _userName :: … 
 , _userEmail :: … 
 , _userAge :: … 
 , _userOccupation :: … 
 }

data ArticleT f = 
 { _articleId :: … 
 , _articleTitle :: … 
 , _articleBody :: … 
 , _articlePublishedTime :: … 
 }

因此，当我们指定每个字段的实际类型时，我们只需放入相关的数据类型，例如Int ， Text或其他，对吗？好吧，不完全是。为了完成我们的类型，我们将用所需的类型填充每个字段，除非通过Columnar f指定。同样，我们将在这两种类型上派生Generic ，这将使Beam发挥其魔力：

data UserT f = 
 { _userId :: Columnar f Int64 
 , _userName :: Columnar f Text 
 , _userEmail :: Columnar f Text 
 , _userAge :: Columnar f Int 
 , _userOccupation :: Columnar f Text 
 } deriving (Generic)

data ArticleT f = 
 { _articleId :: Columnar f Int64 
 , _articleTitle :: Columnar f Text 
 , _articleBody :: Columnar f Text 
 , _articlePublishedTime :: Columnar f Int64 -- Unix Epoch 
 } deriving (Generic)

现在，此模式与我们之前的模式之间存在一些小差异。首先，我们将主键作为类型的显式字段。对于持久性，我们使用Entity抽象将其分离。我们将在下面看到如何处理未知密钥的情况。第二个区别是（目前），我们在文章上省略了userId字段。我们在处理主键时会添加它。

柱状

那么，这种Columnar业务到底是什么呢？在大多数情况下，我们希望使用原始字段类型指定一个User 。但是在某些情况下，我们必须为SQL表达式使用更复杂的类型。让我们先从简单的案例开始。

幸运的是， Columnar工作方式是，如果我们将Identity用作f ，则可以使用原始类型来填充字段值。我们将专门为此身份案例创建类型同义词。然后我们可以举一些例子：

type User = UserT Identity 
 type Article = ArticleT Identity

user1 :: User 
 user1 = User 1 "James" "james@example.com" 25 "programmer"

user2 :: User 
 user2 = User 2 "Katie" "katie@example.com " 25 "engineer"

users :: [User] 
 users = [ user1, user2 ]

请注意，如果您发现重复Columnar关键字比较麻烦，可以将其缩短为C ：

data UserT f = 
 { _userId :: C f Int64 
 , _userName :: C f Text 
 , _userEmail :: C f Text 
 , _userAge :: C f Int 
 , _userOccupation :: C f Text 
 } deriving (Generic)

现在，我们的初始示例将为我们的所有字段分配原始值。因此，除了Identity之外，我们最初不需要为f参数使用任何东西。不过，接下来，我们将讨论自动递增主键的情况。在这种情况下，我们将使用default_函数，该函数的类型实际上是SQL表达式的Beam形式。在这种情况下，我们将为f使用其他类型，但是灵活性将使我们能够继续使用User构造函数！

我们的类型的实例

既然我们已经指定了类型，我们就可以使用Beamable和Table类型类来告诉Beam有关我们类型的更多信息。在将任何这些类型设置为Table ，我们需要分配其主键类型。因此，让我们再加上几个类型同义词来表示这些：

type UserId = PrimaryKey UserT Identity 
 type ArticleId = PrimaryKey ArticleT Identity

在此过程中，让我们将外键添加到Article类型中：

data ArticleT f = 
 { _articleId :: Columnar f Int64 
 , _articleTitle :: Columnar f Text 
 , _articleBody :: Columnar f Text 
 , _articlePublishedTime :: Columnar f Int64 
 , _articleUserId :: PrimaryKey UserT f 
 } deriving (Generic)

现在，我们可以在主要类型和主键类型上为Beamable生成实例。我们还将导出Show和Eq实例：

data UserT f = 
 …

deriving instance Show User 
 deriving instance Eq User

instance Beamable UserT 
 instance Beamable (PrimaryKey UserT)

data ArticleT f = 
 …

deriving instance Show Article 
 deriving instance Eq Article

instance Beamable ArticleT 
 instance Beamable (PrimaryKey ArticleT)

现在，我们将为Table类创建一个实例。这将涉及一些类型族语法。我们将指定UserId和ArticleId作为我们的主键数据类型。然后，我们可以填写primaryKey函数以匹配右边的字段。

instance Table UserT where 
 data PrimaryKey UserT f = UserId (Columnar f Int64) deriving Generic 
 primaryKey = UserId . _userId

instance Table ArticleT where 
 data PrimaryKey ArticleT f = ArticleId (Columnar f Int64) deriving Generic 
 primaryKey = ArticleId . _articleId

隐形眼镜

我们将做另一件事来模仿持久性。模板Haskell为我们自动生成了镜头。我们可以在进行数据库查询时使用它们。下面，我们将使用类似的方法。但是，我们将使用特殊功能tableLenses而不是Template Haskell来制作这些。如果您还记得我们如何使用Servant Client库，我们可以通过使用client并将其与模式匹配来创建client函数。我们将使用tableLenses做类似的tableLenses 。我们将在表的每个字段上使用LensFor ，并创建构造项目的模式。

User 
 (LensFor userId) 
 (LensFor userName) 
 (LensFor userEmail) 
 (LensFor userAge) 
 (LensFor userOccupation) = tableLenses

Article 
 (LensFor articleId) 
 (LensFor articleTitle) 
 (LensFor articleBody) 
 (LensFor articlePublishedTime) 
 (UserId (LensFor articuleUserId)) = tableLenses

注意，我们必须将外键镜头包装在UserId 。

创建我们的数据库

现在，与持久性不同，我们将创建一个额外的类型来表示数据库。我们的两个表中的每个表在此数据库中都有一个字段：

data BlogDB f = BlogDB 
 { _blogUsers :: f (TableEntity UserT) 
 , _blogArticles :: f (TableEntity ArticleT) 
 } deriving (Generic)

我们需要使数据库类型成为Database类的实例。我们还将指定一组可在数据库上使用的默认设置。这两项都将包含参数be ，代表后端（例如，SQLite，Postgres）。我们暂时保留此参数的通用性。

instance Database be BlogDB

blogDb :: DatabaseSettings be BlogDB 
 blogDb = defaultDbSettings

插入我们的数据库

现在，使用Beam迁移我们的数据库要比使用Persistent迁移更为复杂。我们可能会在以后的文章中介绍。现在，我们将使事情变得简单，并使用SQLite数据库并自己进行迁移。因此，让我们首先创建表。我们必须在这里遵循Beam的约定，特别是在外键的user_id__id字段上：

CREATE TABLE users \ 
 ( id INTEGER PRIMARY KEY AUTOINCREMENT\ 
 , name VARCHAR NOT NULL \ 
 , email VARCHAR NOT NULL \ 
 , age INTEGER NOT NULL \ 
 , occupation VARCHAR NOT NULL \ 
 ); 
 CREATE TABLE articles \ 
 ( id INTEGER PRIMARY KEY AUTOINCREMENT \ 
 , title VARCHAR NOT NULL \ 
 , body VARCHAR NOT NULL \ 
 , published_time INTEGER NOT NULL \ 
 , user_id__id INTEGER NOT NULL \ 
 );

现在，我们要编写一些可以与数据库交互的查询。让我们从插入原始用户开始。我们首先打开一个SQLite连接，然后编写一个使用该连接的函数：

import Database.SQLite.Simple (open, Connection)

main :: IO () 
 main = do 
 conn <- open "blogdb1.db" 
 insertUsers conn

insertUsers :: Connection -> IO () 
 insertUsers = ...

我们通过使用runBeamSqlite并传递连接来开始表达式。然后，我们使用runInsert将希望创建插入语句的内容指定给Beam。

import Database.Beam 
 import Database.Beam.SQLite

insertUsers :: Connection -> IO () 
 insertUsers conn = runBeamSqlite conn $ runInsert $ 
 ...

现在，我们将使用insert函数，并从数据库中发出想要从哪个表中发出信号的信号：

insertUsers :: Connection -> IO () 
 insertUsers conn = runBeamSqlite conn $ runInsert $ 
 insert (_blogUsers blogDb) $ ...

最后，由于我们要插入原始值（ UserT Identity ），因此我们使用insertValues函数来完成此调用：

insertUsers :: Connection -> IO () 
 insertUsers conn = runBeamSqlite conn $ runInsert $ 
 insert (_blogUsers blogDb) $ insertValues users

现在，我们可以检查并验证我们的用户是否存在！

SELECT * FROM users; 
 1|James|james@example.com|25|programmer 
 2|Katie|katie@example.com|25|engineer

让我们对文章做同样的事情。我们将使用pk函数来访问特定User的主键：

article1 :: Article 
 article1 = Article 1 "First article" 
 "A great article" 1531193221 (pk user1)

article2 :: Article 
 article2 = Article 2 "Second article" 
 "A better article" 1531199221 (pk user2)

article3 :: Article 
 article3 = Article 3 "Third article" 
 "The best article" 1531200221 (pk user1)

articles :: [Article] 
 articles = [ article1, article2, article3]

insertArticles :: Connection -> IO () 
 insertArticles conn = runBeamSqlite conn $ runInsert $ 
 insert (_blogArticles blogDb) $ insertValues articles

选择查询

现在我们已经插入了几个元素，让我们运行一些基本的select语句。通常，对于select，我们需要runSelectReturningList函数。如果需要，我们还可以查询具有不同功能的单个元素：

findUsers :: Connection -> IO () 
 findUsers conn = runBeamSqlite conn $ do 
 users <- runSelectReturningList $ ...

现在，我们将使用select而不是从上一个查询insert 。我们还将在数据库的用户字段中使用all_函数，以表示我们希望他们全部获得。这就是我们所需要的！：

findUsers :: Connection -> IO () 
 findUsers conn = runBeamSqlite conn $ do 
 users <- runSelectReturningList $ select (all_ (_blogUsers blogDb)) 
 mapM_ (liftIO . putStrLn . show) users

为了进行过滤查询，我们将从相同的框架开始。但是现在我们需要将select语句增强为单子表达式。我们将从所有用户中选择一个user开始：

findUsers :: Connection -> IO () 
 findUsers conn = runBeamSqlite conn $ do 
 users <- runSelectReturningList $ select $ do 
 user <- (all_ (_blogUsers blogDb)) 
 ... 
 mapM_ (liftIO . putStrLn . show) users

现在，我们将使用guard_并应用其中一个镜头来guard_进行过滤。我们使用==. 像“持久性”中的平等运算符。我们还必须用val包装我们的原始比较值：

findUsers :: Connection -> IO () 
 findUsers conn = runBeamSqlite conn $ do 
 users <- runSelectReturningList $ select $ do 
 user <- (all_ (_blogUsers blogDb)) 
 guard_ (user ^. userName ==. (val_ "James")) 
 return user 
 mapM_ (liftIO . putStrLn . show) users

这就是我们所需要的！ Beam将为我们生成SQL！现在让我们尝试加入。在Beam中，这实际上比使用Persistent / Esqueleto简单得多。我们需要的是在文章的“选择”部分添加更多声明。我们将仅通过用户ID对其进行过滤！

findUsersAndArticles :: Connection -> IO () 
 findUsersAndArticles conn = runBeamSqlite conn $ do 
 users <- runSelectReturningList $ select $ do 
 user <- (all_ (_blogUsers blogDb)) 
 guard_ (user ^. userName ==. (val_ "James")) 
 articles <- (all_ (_blogArticles blogDb)) 
 guard_ (article ^. articleUserId ==. user ^. userId) 
 return user 
 mapM_ (liftIO . putStrLn . show) users

这里的所有都是它的！

自动递增主键

在上面的示例中，我们对所有ID进行了硬编码。但这通常不是您想要的。我们应该让数据库通过某些规则分配ID，在本例中为自动递增。在这种情况下，我们将创建一个“表达式”，而不是创建一个User “值”。这可以通过我们类型中的多态f参数来实现。我们将取消类型签名，因为它有点混乱。但是，我们将创建以下表达式：

user1' = User 
 default_ 
 (val_ "James") 
 (val_ "james@example.com") 
 (val_ 25) 
 (val_ "programmer")

我们使用default_表示将告诉SQL使用默认值的表达式。然后，我们使用val_提升所有其他值。最后，我们将在Haskell表达式中使用insertExpressions而不是insertValues 。

insertUsers :: Connection -> IO () 
 insertUsers conn = runBeamSqlite conn $ runInsert $ 
 insert (_blogUsers blogDb) $ insertExpressions [ user1' ]

然后，我们将获得我们的自动递增密钥！

结论

到此结束我们对Beam库的介绍。如我们所见，Beam是一个很棒的库，可让您无需使用任何模板Haskell即可指定数据库架构。有关更多详细信息，请确保签出文档！

要更深入地了解使用Haskell库制作Web应用程序，请务必阅读我们的Haskell Web系列。它介绍了一些数据库机制，以及创建API和测试。另一个挑战是，尝试重新编写该系列中的代码以使用Beam而不是Persistent。查看需要更改多少Servant代码以适应这种情况。

有关酷库的更多示例，请下载我们的生产清单！您还可以查看更多数据库和API库！

附录：编译器扩展

{-# LANGUAGE DeriveGeneric #-} 
 {-# LANGUAGE GADTs #-} 
 {-# LANGUAGE OverloadedStrings #-} 
 {-# LANGUAGE FlexibleContexts #-} 
 {-# LANGUAGE FlexibleInstances #-} 
 {-# LANGUAGE TypeFamilies #-} 
 {-# LANGUAGE TypeApplications #-} 
 {-# LANGUAGE StandaloneDeriving #-} 
 {-# LANGUAGE TypeSynonymInstances #-} 
 {-# LANGUAGE NoMonoMorphismRestriction #-}

From: https://hackernoon.com/beam-database-power-without-template-haskell-77a2df12fa24

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

数据库

后端