Стойкой: Недопустимое название — Викисловарь

Это может быть компания, которая помогает расширить свои возможности или географическое присутствие или усилить свои сильные стороны в существующей вертикали.

Нравится эта история?

Получите одно письмо, содержащее самые важные технические новости дня менее чем за 5 минут!

Спасибо за подписку на Tech Top 5

Подождите …

В центре внимания будут банковское дело, финансовые услуги и страхование (BFSI), здравоохранение и науки о жизни, а также высокие технологии.

Persistent имеет на балансе около 268 миллионов долларов наличными, и будет использовать их для приобретений, которые соответствуют стратегическим бизнес-целям или финансовым критериям, таким как рост доходов и рентабельность капитала.

«Наша золотая середина составляет от 10 до 50 миллионов долларов с точки зрения выручки целевой компании, хотя иногда мы можем рассматривать цели за пределами этого диапазона», — сказал Калра.

Он намерен в будущем увеличить долю выручки в Европе.

В Индии компания работает с небанковскими организациями, и вклад страны в выручку составляет около 9%.

Калра сказал, что этот показатель, вероятно, останется на том же уровне и будет расти вместе с ростом компании.

Компания со штаб-квартирой в Пуне на прошлой неделе сообщила о росте чистой прибыли на 32,4% до 340 рупий. На 28 крор и на 17,4% больше доходов в 3 565,80 крор за предыдущий финансовый год.

Kalra заявила, что ее ключевые вертикали — BFSI, здравоохранение и технологические услуги — хорошо растут, и в 2022 году у компании будет хороший портфель заказов и портфель сделок.

«Даже несмотря на то, что существует такая большая неопределенность, люди достаточно уверены в долгосрочном будущем своего бизнеса, поэтому они инвестируют в него», — сказал Сунил Сапре, финансовый директор Persistent Systems.

Отрасли, которые пострадали, — это отрасли, затронутые недостатком передвижения людей, и для их восстановления потребуется время.

Банки инвестируют в более цифровые технологии, в модернизацию приложений и переход в облако, в то время как в сфере здравоохранения основное внимание уделяется улучшению взаимодействия с пациентами в цифровом формате, и все это приводит к более крупным сделкам для Persistent.

«Persistent сообщил об устойчивых показателях прибыли за 4 квартал 21 финансового года, а его стратегия крупных сделок продолжает стимулировать рост бизнеса в сфере услуг, несмотря на слабую сезонность альянсов», — сказал Харит Шах, старший аналитик KRChoksey Shares & Securities.

«Комментарий руководства по поддержанию сделки TCV в диапазоне от 200 до 250 миллионов долларов дополнительно укрепляет уверенность в динамике основного бизнеса, поскольку бизнес альянсов, вероятно, будет и дальше способствовать росту, помимо услуг», — сказал он.

Компания объявила о повышении заработной платы в ноябре 2020 года и будет придерживаться обычного цикла аттестации с июля 2021 года.

Persistent продолжит нанимать в течение следующих нескольких кварталов, говорится в сообщении.

постоянный · PyPI

Скачать файлы

Загрузите файл для своей платформы.Если вы не уверены, что выбрать, узнайте больше об установке пакетов.

Файлы для постоянного хранения, версия 4.7.0

Имя файла, размер	Тип файла	Версия Python	Дата загрузки	Хеши
Имя файла, размер постоянный-4. 7.0-cp27-cp27m-macosx_10_14_x86_64.whl (146,7 кБ)	Тип файла Колесо	Версия Python cp27	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0-cp27-cp27m-manylinux1_i686.whl (237,3 КБ)	Тип файла Колесо	Версия Python cp27	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0-cp27-cp27m-manylinux1_x86_64.whl (243,8 кБ)	Тип файла Колесо	Версия Python cp27	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4. 7.0-cp27-cp27m-manylinux2010_i686.whl (237,3 КБ)	Тип файла Колесо	Версия Python cp27	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0-cp27-cp27m-manylinux2010_x86_64.whl (243,8 кБ)	Тип файла Колесо	Версия Python cp27	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0-cp27-cp27mu-manylinux1_i686.whl (237,3 КБ)	Тип файла Колесо	Версия Python cp27	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4. 7.0-cp27-cp27mu-manylinux1_x86_64.whl (243,8 кБ)	Тип файла Колесо	Версия Python cp27	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0-cp27-cp27mu-manylinux2010_i686.whl (237,3 КБ)	Тип файла Колесо	Версия Python cp27	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0-cp27-cp27mu-manylinux2010_x86_64.whl (243,8 кБ)	Тип файла Колесо	Версия Python cp27	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4. 7.0-cp27-cp27m-win32.whl (147.9 КБ)	Тип файла Колесо	Версия Python cp27	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0-cp27-cp27m-win_amd64.whl (148,7 кБ)	Тип файла Колесо	Версия Python cp27	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0-cp35-cp35m-manylinux1_i686.whl (242,2 КБ)	Тип файла Колесо	Версия Python cp35	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4. 7.0-cp35-cp35m-manylinux1_x86_64.whl (248,4 кБ)	Тип файла Колесо	Версия Python cp35	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0-cp35-cp35m-manylinux2010_i686.whl (242,2 КБ)	Тип файла Колесо	Версия Python cp35	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0-cp35-cp35m-manylinux2010_x86_64.whl (248,4 кБ)	Тип файла Колесо	Версия Python cp35	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4. 7.0-cp35-cp35m-manylinux2014_aarch64.whl (253,0 кБ)	Тип файла Колесо	Версия Python cp35	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0-cp35-cp35m-win32.whl (154,2 КБ)	Тип файла Колесо	Версия Python cp35	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0-cp35-cp35m-win_amd64.whl (158,5 кБ)	Тип файла Колесо	Версия Python cp35	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4. 7.0-cp36-cp36m-macosx_10_14_x86_64.whl (147,2 КБ)	Тип файла Колесо	Версия Python cp36	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0-cp36-cp36m-manylinux1_i686.whl (242,9 кБ)	Тип файла Колесо	Версия Python cp36	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0-cp36-cp36m-manylinux1_x86_64.whl (249,1 кБ)	Тип файла Колесо	Версия Python cp36	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4. 7.0-cp36-cp36m-manylinux2010_i686.whl (242,9 кБ)	Тип файла Колесо	Версия Python cp36	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0-cp36-cp36m-manylinux2010_x86_64.whl (249,1 кБ)	Тип файла Колесо	Версия Python cp36	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0-cp36-cp36m-manylinux2014_aarch64.whl (253,6 кБ)	Тип файла Колесо	Версия Python cp36	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4. 7.0-cp36-cp36m-win32.whl (154,2 КБ)	Тип файла Колесо	Версия Python cp36	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0-cp36-cp36m-win_amd64.whl (158,5 кБ)	Тип файла Колесо	Версия Python cp36	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0-cp37-cp37m-macosx_10_14_x86_64.whl (147,2 КБ)	Тип файла Колесо	Версия Python cp37	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4. 7.0-cp37-cp37m-manylinux1_i686.whl (246.9 КБ)	Тип файла Колесо	Версия Python cp37	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0-cp37-cp37m-manylinux1_x86_64.whl (253,0 кБ)	Тип файла Колесо	Версия Python cp37	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0-cp37-cp37m-manylinux2010_i686.whl (246.9 КБ)	Тип файла Колесо	Версия Python cp37	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4. 7.0-cp37-cp37m-manylinux2010_x86_64.whl (253,0 кБ)	Тип файла Колесо	Версия Python cp37	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0-cp37-cp37m-manylinux2014_aarch64.whl (257,5 кБ)	Тип файла Колесо	Версия Python cp37	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0-cp37-cp37m-win32.whl (154,2 КБ)	Тип файла Колесо	Версия Python cp37	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4. 7.0-cp37-cp37m-win_amd64.whl (158,5 кБ)	Тип файла Колесо	Версия Python cp37	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0-cp38-cp38-macosx_10_14_x86_64.whl (147,3 кБ)	Тип файла Колесо	Версия Python cp38	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0-cp38-cp38-manylinux1_i686.whl (251,9 КБ)	Тип файла Колесо	Версия Python cp38	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4. 7.0-cp38-cp38-manylinux1_x86_64.whl (258,7 КБ)	Тип файла Колесо	Версия Python cp38	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0-cp38-cp38-manylinux2010_i686.whl (251,9 КБ)	Тип файла Колесо	Версия Python cp38	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0-cp38-cp38-manylinux2010_x86_64.whl (258,7 КБ)	Тип файла Колесо	Версия Python cp38	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4. 7.0-cp38-cp38-manylinux2014_aarch64.whl (263,3 кБ)	Тип файла Колесо	Версия Python cp38	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0-cp38-cp38-win32.whl (154.9 КБ)	Тип файла Колесо	Версия Python cp38	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0-cp38-cp38-win_amd64.whl (159.0 кБ)	Тип файла Колесо	Версия Python cp38	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4. 7.0-cp39-cp39-macosx_10_14_x86_64.whl (147,3 кБ)	Тип файла Колесо	Версия Python cp39	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0-cp39-cp39-manylinux1_i686.whl (249,7 КБ)	Тип файла Колесо	Версия Python cp39	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0-cp39-cp39-manylinux1_x86_64.whl (257,1 кБ)	Тип файла Колесо	Версия Python cp39	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4. 7.0-cp39-cp39-manylinux2010_i686.whl (249,7 КБ)	Тип файла Колесо	Версия Python cp39	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0-cp39-cp39-manylinux2010_x86_64.whl (257,1 кБ)	Тип файла Колесо	Версия Python cp39	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0-cp39-cp39-manylinux2014_aarch64.whl (261,7 КБ)	Тип файла Колесо	Версия Python cp39	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4. 7.0-cp39-cp39-win32.whl (154,7 кБ)	Тип файла Колесо	Версия Python cp39	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0-cp39-cp39-win_amd64.whl (158,8 кБ)	Тип файла Колесо	Версия Python cp39	Дата загрузки 13 апреля 2021 г.	Хеши Вид
Имя файла, размер постоянный-4.7.0.tar.gz (127,1 кБ)	Тип файла Источник	Версия Python Никто	Дата загрузки 13 апреля 2021 г.	Хеши Вид

Yesod Web Framework Book — версия 1.

Формы имеют дело с границей между пользователем и приложением. Другой Граница, с которой нам нужно иметь дело, находится между приложением и уровнем хранения. Будь то база данных SQL, файл YAML или двоичный BLOB-объект, скорее всего, вы уровень хранения изначально не понимает типы данных вашего приложения, и вам нужно будет выполнить маршалинг. Постоянство — это ответ Yesod на данные storage — типобезопасный универсальный интерфейс хранилища данных для Haskell.

Haskell имеет множество доступных привязок к базам данных.Однако большинство из них мало знакомы со схемой и поэтому не предоставляют полезных статических гарантии. Они также заставляют API-интерфейсы и типы данных, зависящие от базы данных, программист.

Некоторые хаскеллеры попытались найти более революционный путь: создание Haskell. специальные хранилища данных, которые позволяют легко хранить любой строго типизированный Haskell данные. Эти параметры отлично подходят для определенных случаев использования, но они ограничивают возможность методы хранения, предоставляемые библиотекой, и плохо взаимодействуют с Другие языки.

Напротив, Persistent позволяет нам выбирать среди существующих баз данных, которые отлично настроен для различных сценариев использования хранилищ данных, взаимодействует с другими языков программирования, а также использовать безопасный и производительный интерфейс запросов, в то время как все еще сохраняя безопасность типов данных Haskell.

Persistent следует руководящим принципам типовой безопасности и краткости, декларативный синтаксис. Некоторые другие приятные особенности:

• Независимость от базы данных. Первоклассная поддержка PostgreSQL, SQLite, MySQL. и MongoDB с экспериментальной поддержкой Redis.

• Удобное моделирование данных. Постоянный позволяет моделировать отношения и использовать их безопасным для типов способами. Постоянный типобезопасный API по умолчанию не поддерживает объединения, что позволяет поддерживать большее количество слоев хранения. Объединения и другие специфические функции SQL могут быть реализованы с помощью необработанный уровень SQL (с очень низкой типобезопасностью). Дополнительная библиотека Esqueleto, строится на основе постоянной модели данных, добавляя типобезопасные соединения и функциональность SQL.

• Автоматическая миграция баз данных в непроизводственных средах для ускорения разработка.

Persistent хорошо работает с Yesod, но вполне можно использовать как отдельную библиотеку. Большая часть этой главы будет посвящена Устойчив сам по себе.

Необходимые зависимости для перечисленных ниже: persistent, persistent-sqlite и persistent-template.

  {- # LANGUAGE EmptyDataDecls # -}
{- # LANGUAGE FlexibleContexts # -}
{- # LANGUAGE GADTs # -}
{- # LANGUAGE GeneralizedNewtypeDeriving # -}
{- # LANGUAGE MultiParamTypeClasses # -}
{- # LANGUAGE OverloadedStrings # -}
{- # ЯЗЫК QuasiQuotes # -}
{- # LANGUAGE TemplateHaskell # -}
{- # LANGUAGE TypeFamilies # -}
Контроль импорта.Монада.IO.Class (liftIO)
импортировать Database.Persist
импортировать Database. Persist.Sqlite
импортировать Database.Persist.TH

share [mkPersist sqlSettings, mkMigrate "migrateAll"] [persistLowerCase |
Человек
    имя Строка
    возраст Инт Может быть
    производное шоу
Сообщение блога
    заголовок Строка
    authorId PersonId
    производное шоу
|]

main :: IO ()
main = runSqlite ": memory:" $ do
    runMigration migrateAll

    johnId <- insert $ Person "John Doe" Всего 35 долларов
    janeId <- insert $ Person "Jane Doe" Ничего

    insert $ BlogPost "Мой первый p0st" johnId
    insert $ BlogPost "Еще одно на всякий случай" johnId

    oneJohnPost <- selectList [BlogPostAuthorId ==.johnId] [LimitTo 1]
    liftIO $ print (oneJohnPost :: [Entity BlogPost])

    john <- получить johnId
    liftIO $ print (john :: Может быть, человек)

    удалить janeId
    deleteWhere [BlogPostAuthorId ==. johnId]  

Аннотации типов в приведенном выше фрагменте: , а не , необходимые для получения вашего код для компиляции, но присутствуют, чтобы прояснить читателю типы каждого значение.

Предположим, вы храните информацию о людях в базе данных SQL. Ваш стол может выглядеть примерно так:

  CREATE TABLE person (id SERIAL PRIMARY KEY, имя VARCHAR NOT NULL, age INTEGER)  

И если вы используете такую ​​базу данных, как PostgreSQL, вы можете быть уверены, что база данных никогда не будет хранить произвольный текст в поле вашего возраста.(Тоже самое нельзя сказать о SQLite, но давайте пока забудем об этом.) таблицу базы данных, вы, вероятно, создадите тип данных Haskell, который выглядит как нравится:

  данные Человек = Человек
    {personName :: Text
    , personAge :: Int
    }  

Похоже, что все безопасно по типу: схема базы данных соответствует нашему Haskell типов данных, база данных гарантирует, что недопустимые данные никогда не попадут в нашу хранилище данных, и вообще все офигенно. Хорошо, пока:

• Вы хотите получить данные из базы данных, а уровень базы данных дает вам данные в нетипизированном формате.

• Вы хотите найти всех старше 32 лет и случайно пишете «тридцать два» в вашем операторе SQL. Угадайте, что: это будет хорошо скомпилировано, и вы не узнайте, что у вас есть проблема, до выполнения.

• Вы решаете, что хотите найти первых 10 человек по алфавиту. Без проблем… пока вы не сделаете опечатку в своем SQL. Еще раз, вы не узнаете, пока время выполнения.

Для динамических языков ответом на эти проблемы является модульное тестирование.Для все, что может пойти не так, обязательно напишите тестовый пример. Но как я конечно, вы уже знаете, что это плохо сочетается с подходом Йесод к вещи. Нам нравится использовать строгую типизацию Haskell, чтобы спасти нас везде, где это возможно, и хранение данных не исключение.

Итак, остается вопрос: как мы можем использовать систему типов Haskell, чтобы спасти положение?

Как и в случае с маршрутизацией, в типобезопасных данных нет ничего сложного. Использование PersistDbSpecific позволяет использовать типы - специфично для конкретного бэкэнда

PersistValue коррелирует со столбцом в базе данных SQL.В нашем личном примере выше имя и возраст будут нашими PersistValues ​​ s.

Каждый Persistent backend должен знать, как переводить соответствующие значения в что-то, что может понять база данных. Однако было бы неудобно просто выразить все наши данные в терминах этих основных типов. Следующий слой класс типов PersistField , который определяет, как произвольный тип данных Haskell можно маршалировать в и из PersistValue .

Чтобы связать пользовательскую сторону кода, наш последний класс типов — PersistEntity .An экземпляр PersistEntity коррелирует с таблицей в базе данных SQL. Этот typeclass определяет ряд функций и некоторые связанные типы. Чтобы просмотреть, у нас есть следующее соответствие между Persistent и SQL:

Чтобы гарантировать, что экземпляры PersistEntity правильно соответствуют вашему Типы данных Haskell, Persistent берет на себя ответственность за оба.Это тоже хорошо с точки зрения СУХОЙ (не повторяйся): вам нужно только определить свой сущности один раз. Давайте посмотрим на быстрый пример:

  {- # LANGUAGE GADTs # -}
{- # LANGUAGE GeneralizedNewtypeDeriving # -}
{- # LANGUAGE OverloadedStrings # -}
{- # ЯЗЫК QuasiQuotes # -}
{- # LANGUAGE TemplateHaskell # -}
{- # LANGUAGE TypeFamilies # -}
импортировать Database.Persist
импортировать Database.Persist.TH
импортировать Database. Persist.Sqlite
Контроль импорта.Монада.IO.Class (liftIO)

mkPersist sqlSettings [persistLowerCase |
Человек
    имя Строка
    возраст Int
    производное шоу
|]  

Мы используем комбинацию Template Haskell и Quasi-Quotation (например, когда определение маршрутов): persistLowerCase — это квазиквотер, который преобразует синтаксис, чувствительный к пробелам, в список определений сущностей. «Нижний регистр» относится к формату сгенерированных имен таблиц. На этой схеме такой объект, как SomeTable , станет таблицей SQL some_table .Вы также можете объявите свои объекты в отдельном файле, используя persistFileWith . мкПерсист берет этот список лиц и объявляет:

В приведенном выше примере создается код, который выглядит следующим образом:

  {- # LANGUAGE TypeFamilies, GeneralizedNewtypeDeriving, OverloadedStrings, GADT # -}
импортировать Database. Persist
импортировать Database.Persist.Sqlite
импортировать Control.Monad.IO.Class (liftIO)
Импорт Control.Applicative

data Person = Человек
    {personName ::! Строка
    , personAge ::! Int
    }
  производное шоу

type PersonId = Ключевое лицо

экземпляр PersistEntity Person, где
    newtype Key Person = PersonKey (BackendKey SqlBackend)
        извлечение (PersistField, Show, Eq, Read, Ord)
    - Обобщенный алгебраический тип данных (GADT).- Это дает нам типобезопасный подход к сопоставлению полей с
    - их типы данных.
    data EntityField Тип человека, где
        PersonId :: EntityField Person PersonId
        PersonName :: EntityField Person String
        PersonAge :: EntityField Person Int

    данные Уникальное лицо
    тип PersistEntityBackend Person = SqlBackend

    toPersistFields (возраст имени человека) =
        [SomePersistField имя
        , SomePersistField возраст
        ]

    fromPersistValues ​​[nameValue, ageValue] = Человек
        <$> fromPersistValue nameValue
        <*> fromPersistValue ageValue
    fromPersistValues ​​_ = Left «Недействительный ввод fromPersistValues»

    - Информация о каждом поле, используемое внутри для генерации операторов SQL. 
    persistFieldDef PersonId = FieldDef
        (HaskellName «Id»)
        (DBName "id")
        (FTTypeCon Nothing "PersonId")
        SqlInt64
        []
        Правда
        Нет ссылки
    persistFieldDef PersonName = FieldDef
        (HaskellName "имя")
        (DBName "имя")
        (FTTypeCon Ничего "Строка")
        SqlString
        []
        Правда
        Нет ссылки
    persistFieldDef PersonAge = FieldDef
        (HaskellName "возраст")
        (DBName "возраст")
        (FTTypeCon Nothing "Int")
        SqlInt64
        []
        Правда
        Номер ссылки  

Как и следовало ожидать, наш тип данных Person полностью соответствует определению, которое мы дал в оригинальной версии Template Haskell.У нас также есть обобщенный Алгебраический тип данных (GADT), который дает отдельный конструктор для каждого поля. Этот GADT кодирует как тип объекта, так и тип поля. Мы используем его конструкторы по всему Persistent, например, чтобы гарантировать, что когда мы применяем filter, типы значения фильтрации соответствуют полю. Есть еще один связанный newtype для первичного ключа базы данных этого объекта.

Мы можем использовать сгенерированный тип Person , как и любой другой тип Haskell, а затем передать его другим постоянным функциям.

  {- # LANGUAGE EmptyDataDecls # -}
{- # LANGUAGE FlexibleContexts # -}
{- # LANGUAGE GADTs # -}
{- # LANGUAGE GeneralizedNewtypeDeriving # -}
{- # LANGUAGE MultiParamTypeClasses # -}
{- # LANGUAGE OverloadedStrings # -}
{- # ЯЗЫК QuasiQuotes # -}
{- # LANGUAGE TemplateHaskell # -}
{- # LANGUAGE TypeFamilies # -}

импортировать Control.Monad.IO.Class (liftIO)
импортировать Database.Persist
База данных импорта.Persist.Sqlite
импортировать Database.Persist.TH
импортировать Control.Monad.IO.Unlift
импортировать Data.Text
импортировать Control.Monad.Reader
импортировать Control.Monad.Logger
импортный трубопровод

share [mkPersist sqlSettings, mkSave "entityDefs"] [persistLowerCase |
Человек
    имя Строка
    возраст Инт Может быть
    производное шоу
|]

runSqlite ':: (MonadUnliftIO m) => Текст -> ReaderT SqlBackend (NoLoggingT (ResourceT m)) a -> m a
runSqlite '= runSqlite

main :: IO ()
main = runSqlite '": memory:" $ do
    michaelId <- insert $ Person "Michael" $ Всего 26
    michael <- получить michaelId
    liftIO $ print майкл  

Этот код компилируется, но генерирует исключение во время выполнения об отсутствующем Таблица. Мы объясним и решим эту проблему ниже.

Начнем со стандартного кода подключения к базе данных. В этом случае мы использовали функции одинарного подключения. Постоянный также встроен с подключением функции пула, которые мы обычно хотим использовать в продакшене.

В этом примере мы видели две функции: insert создает новую запись в базу данных и возвращает ее идентификатор. Как и все остальное в Persistent, идентификаторы тип безопасный. Подробнее о том, как работают эти идентификаторы, мы поговорим позже.Итак, когда вы вызовите insert $ Person "Michael" 26 , он вернет вам значение типа Персональный идентификатор .

Следующая функция, которую мы видим, - это get , которая пытается загрузить значение из база данных с использованием идентификатора . В Persistent вам не нужно беспокоиться о том, что вы использование ключа из неправильной таблицы: попытка загрузить другую сущность (например, House ) с использованием персонального идентификатора никогда не будет компилироваться.

Последняя деталь, оставленная без объяснения из предыдущего примера: что именно выполняет ли runSqlite , и что это за монада, которую выполняют наши действия с базой данных вбегает?

Все действия с базой данных требуют параметра, который является экземпляром PersistStore .Как следует из названия, каждое хранилище данных (PostgreSQL, SQLite, MongoDB) имеет экземпляр PersistStore . Здесь все переводы от PersistValue до значений, специфичных для базы данных, где SQL-запрос происходит генерация и так далее.

Как вы понимаете, хотя PersistStore обеспечивает безопасную, хорошо типизированный интерфейс с внешним миром, есть много баз данных взаимодействия, которые могут пойти не так. Однако при автоматическом тестировании этого кода и полностью в одном месте, мы можем централизовать наш подверженный ошибкам код и убедитесь, что в нем как можно больше ошибок.

runSqlite создает одно соединение с базой данных, используя предоставленный строка подключения. Для наших тестовых случаев мы будем использовать : memory: , который использует база данных в памяти. Все серверные части SQL используют один и тот же экземпляр PersistStore : SqlBackend . runSqlite затем предоставляет значение SqlBackend в качестве параметра среды действия через runReaderT .

На самом деле существует несколько других классов типов: PersistUpdate и PersistQuery .Различные классы типов предоставляют разную функциональность, которая позволяет нам писать бэкенды, которые используют более простые хранилища данных (например, Redis), даже хотя они не могут предоставить нам все функции высокого уровня, доступные в Настойчивый.

Важно отметить, что все, что происходит внутри одного вызов runSqlite выполняется за одну транзакцию. Здесь есть два важных последствия:

• Для многих баз данных фиксация транзакции может быть дорогостоящим мероприятием. От помещая несколько шагов в одну транзакцию, вы можете ускорить код резко.

• Если исключение генерируется где-нибудь внутри одного вызова runSqlite , все действия будут отменены (при условии, что ваш сервер поддерживает откат).

  На самом деле это имеет более далеко идущие последствия, чем может показаться на первый взгляд. А количество функций короткого замыкания в Yesod, таких как перенаправления, реализовано с использованием исключений. Если вы используете такой вызов из постоянного block, он откатит всю транзакцию.

Мне жаль говорить вам, но пока я немного солгал вам: пример из предыдущий раздел на самом деле не работает. Если вы попытаетесь запустить его, вы получите сообщение об ошибке об отсутствующей таблице.

Для баз данных SQL одной из основных проблем может быть управление изменениями схемы. Вместо того, чтобы оставлять это на усмотрение пользователя, Постоянный вмешивается, чтобы помочь, но у вас есть to попросите помочь. Посмотрим, как это выглядит:

  {- # LANGUAGE EmptyDataDecls # -}
{- # LANGUAGE FlexibleContexts # -}
{- # LANGUAGE GADTs # -}
{- # LANGUAGE GeneralizedNewtypeDeriving # -}
{- # LANGUAGE MultiParamTypeClasses # -}
{- # LANGUAGE OverloadedStrings # -}
{- # ЯЗЫК QuasiQuotes # -}
{- # LANGUAGE TemplateHaskell # -}
{- # LANGUAGE TypeFamilies # -}

Контроль импорта.Монада.IO.Class (liftIO)
импортировать Database.Persist
импортировать Database.Persist.Sqlite
импортировать Database.Persist.TH
импортировать Control.Monad.IO.Unlift
импортировать Data.Text
импортировать Control.Monad.Reader
импортировать Control.Monad.Logger
импортный трубопровод

share [mkPersist sqlSettings, mkSave "entityDefs"] [persistLowerCase |
Человек
    имя Строка
    возраст Инт Может быть
    производное шоу
|]

main :: IO ()
main = runSqlite ": memory:" $ do
    runMigration $ migrate entityDefs $ entityDef (Ничего :: Может быть, человек)
    michaelId <- insert $ Person "Michael" $ Всего 26
    michael <- получить michaelId
    liftIO $ print майкл  

После этого небольшого изменения кода Persistent автоматически создаст ваш Персона стол для вас. Это разделение между runMigration и migrate позволяет вы можете переносить несколько таблиц одновременно.

Использование автоматической миграции базы данных рекомендуется только при разработке. среды. Разрешение вашему приложению изменять схему базы данных в производственная среда очень не рекомендуется . Автоматические миграции может использоваться для ускорения разработки, но не заменяет ручной обзор и тестирование, которые необходимо провести перед производственным развертыванием.

Это работает при работе с несколькими объектами, но может быстро утомить когда-то мы имеем дело с десятком сущностей. Вместо того, чтобы повторяться, Persistent предоставляет вспомогательную функцию, mkMigrate :

  {- # LANGUAGE EmptyDataDecls # -}
{- # LANGUAGE FlexibleContexts # -}
{- # LANGUAGE GADTs # -}
{- # LANGUAGE GeneralizedNewtypeDeriving # -}
{- # LANGUAGE MultiParamTypeClasses # -}
{- # LANGUAGE OverloadedStrings # -}
{- # ЯЗЫК QuasiQuotes # -}
{- # LANGUAGE TemplateHaskell # -}
{- # LANGUAGE TypeFamilies # -}
База данных импорта. Сопротивляться
импортировать Database.Persist.Sqlite
импортировать Database.Persist.TH

share [mkPersist sqlSettings, mkMigrate "migrateAll"] [persistLowerCase |
Человек
    имя Строка
    возраст Int
    производное шоу
Машина
    цвет Строка
    сделать строку
    модель String
    производное шоу
|]

main :: IO ()
main = runSqlite ": memory:" $ do runMigration migrateAll  

mkMigrate - это функция Template Haskell, которая создает новую функцию, которая автоматически вызовет migrate для всех сущностей, определенных в persist блокировать.Функция share - это всего лишь небольшой помощник, который передает информацию. из блока persist в каждую функцию Template Haskell и объединяет полученные результаты.

Persistent имеет очень консервативные правила относительно того, что он будет делать во время миграция. Он начинается с загрузки табличной информации из базы данных, в комплекте со всеми определенными типами данных SQL. Затем он сравнивает это с определение сущности дано в коде. В следующих случаях он будет автоматически изменить схему:

• Тип данных поля изменен.Однако база данных может возражать против этого. модификация, если данные не могут быть переведены.

• Добавлено поле. Однако, если поле не является нулевым, значение по умолчанию не предоставлен (мы обсудим значения по умолчанию позже), и уже есть данные в база данных, база данных не допустит этого.

• Поле преобразуется из ненулевого в нулевое. В противном случае Persistent попытается выполнить преобразование при условии одобрения базы данных.

• Добавлен новый объект.

Однако в некоторых случаях Persistent не обрабатывает:

• Переименование поля или объекта: Persistent не знает, что "name" теперь был переименован в "fullName": все, что он видит, - это старое поле с именем name и новое поле с именем fullName.

• Удаление полей: поскольку это может привести к потере данных, по умолчанию постоянный откажется выполнить действие (вы можете вызвать проблему, используя runMigrationUnsafe вместо runMigration , хотя это , а не рекомендуемые).

runMigration распечатает миграции, которые он выполняет на stderr (вы можете обойти это, используя runMigrationSilent ). По возможности используется ALTER. ТАБЛИЦА звонков. Однако в SQLite ALTER TABLE имеет очень ограниченные возможности и поэтому Persistent должен прибегать к копированию данных из одной таблицы в другую.

Наконец, если вместо выполняется миграция , вы хотите, чтобы Persistent дал вы намекаете, какие миграции необходимы, используйте printMigration функция.Эта функция распечатает миграции, которые выполняются Migration выступит для вас. Это может быть полезно для выполнения миграций, которые Persistent не поддерживает добавление произвольного SQL в миграцию или просто чтобы записать, какие миграции произошли.

Помимо объявления полей внутри сущности, вы также можете объявить ограничения уникальности. Типичный пример: требуется, чтобы имя пользователя было уникальный.

  Пользователь
    текст имени пользователя
    Уникальное имя пользователя  

Хотя каждое имя поля должно начинаться со строчной буквы, уникальность ограничения должны начинаться с заглавной буквы, так как они будут представлены в Haskell как конструктор данных.

  {- # LANGUAGE EmptyDataDecls # -}
{- # LANGUAGE FlexibleContexts # -}
{- # LANGUAGE GADTs # -}
{- # LANGUAGE GeneralizedNewtypeDeriving # -}
{- # LANGUAGE MultiParamTypeClasses # -}
{- # LANGUAGE OverloadedStrings # -}
{- # ЯЗЫК QuasiQuotes # -}
{- # LANGUAGE TemplateHaskell # -}
{- # LANGUAGE TypeFamilies # -}
импортировать Database.Persist
импортировать Database.Persist.Sqlite
импортировать Database.Persist.TH
импортировать данные.Время
импортировать Control.Monad.IO.Class (liftIO)

share [mkPersist sqlSettings, mkMigrate "migrateAll"] [persistLowerCase |
Человек
    firstName String
    lastName String
    возраст Int
    PersonName firstName lastName
    производное шоу
|]

main :: IO ()
main = runSqlite ": memory:" $ do
    runMigration migrateAll
    insert $ Person "Michael" "Snoyman" 26
    michael <- getBy $ PersonName "Майкл" "Снойман"
    liftIO $ print майкл  

Чтобы объявить уникальную комбинацию полей, мы добавляем дополнительную строку в наш декларация. Persistent знает, что он определяет уникальный конструктор, поскольку строка начинается с заглавной буквы. Каждое следующее слово должно быть полем в этот объект.

Основное ограничение уникальности заключается в том, что оно может применяться только к ненулевым поля. Причина этого в том, что стандарт SQL неоднозначно определяет, как уникальность должна быть применена к NULL (например, NULL = NULL истина или ложь?). Помимо этой двусмысленности, большинство механизмов SQL фактически реализуют правила, которые вопреки тому, что ожидают типы данных Haskell (например,g., PostgreSQL говорит, что NULL = NULL - ложь, тогда как Haskell говорит, что Nothing == Nothing - True ).

Помимо предоставления хороших гарантий на уровне базы данных о согласованность ваших данных, ограничения уникальности также могут использоваться для выполнения некоторые конкретные запросы в вашем коде Haskell, такие как getBy выше. Это происходит через связанный тип Unique . В приведенном выше примере мы получим новый конструктор:

  Имя человека :: Строка -> Строка -> Уникальное лицо  

С бэкэндом MongoDB ограничение уникальности не может быть создано: вы должен разместить уникальный индекс в поле.

В зависимости от вашей цели существуют разные подходы к запросам база данных. Некоторые команды запрашивают на основе числового идентификатора, а другие фильтруют. Запросы также различаются по количеству возвращаемых результатов: некоторые запросы должны возвращать не более одного результата (если ключ поиска уникален), в то время как другие могут вернуть много результатов.

Persistent предоставляет несколько различных функций запросов. Как обычно, мы стараемся чтобы закодировать как можно больше инвариантов в типах. Например, запрос который может возвращать только 0 или 1 результат, будет использовать оболочку Maybe , тогда как запрос при возврате большого количества результатов будет возвращен список.

Самый простой запрос, который вы можете выполнить в Persistent, - это получение на основе идентификатора. Поскольку это значение может существовать, а может и не существовать, его возвращаемый тип заключен в Maybe .

  personId <- вставить $ Person "Michael" "Snoyman" 26
mayPerson <- получить personId
случай, возможно, человек
    Ничего -> liftIO $ putStrLn "Шучу, не совсем там"
    Просто человек -> liftIO $ print person  

Это может быть очень полезно для сайтов, которые предоставляют URL-адреса типа / person / 5 .Тем не мение, в таком случае нас обычно не волнует обертка Может быть, , и мы просто хотим значение, возвращающее сообщение 404, если оно не найдено. К счастью, Здесь нам помогает функция get404 (предоставляется пакетом yesod-persistent). Мы углубимся в подробности, когда увидим интеграцию с Yesod.

getBy почти идентично get , за исключением:

1. требуется ограничение уникальности; то есть вместо идентификатора используется значение Уникальное значение .

2. он возвращает Entity вместо значения. Сущность - это комбинация идентификатора базы данных и значения.

  personId <- вставить $ Person "Michael" "Snoyman" 26
mayPerson <- getBy $ PersonName "Майкл" "Снойман"
случай, возможно, человек
    Ничего -> liftIO $ putStrLn "Шучу, не совсем там"
    Просто (Entity personId person) -> liftIO $ print person  

Как и get404 , есть также функция getBy404 .

Скорее всего, вам понадобятся более мощные запросы. Ты захочешь найти всем старше определенного возраста; все автомобили доступны в синем цвете; все пользователи без зарегистрированный адрес электронной почты. Для этого вам понадобится одна из функций select.

Все функции выбора используют аналогичный интерфейс с немного разными выходами:

selectList является наиболее часто используемым, поэтому мы рассмотрим его специально. После этого понимание других должно быть тривиальным.

selectList принимает два аргумента: список Filter s и список SelectOpt с. Первое - это то, что ограничивает ваши результаты на основе характеристики; он допускает равное, меньшее, является членом и т. д. SelectOpt s предоставляет три различных функции: сортировка, ограничение вывода на определенное количество строк и смещение результатов на определенное количество ряды.

Комбинация пределов и смещений очень важна; это позволяет эффективная разбивка на страницы в ваших веб-приложениях.

Давайте сразу перейдем к примеру фильтрации, а затем проанализируем его.

  человек <- selectList [PersonAge>. 25 лет, возраст <=. 30] []
liftIO $ печать человек  

Каким бы простым ни был этот пример, нам действительно нужно охватить три момента:

1. PersonAge - конструктор для связанного фантомного типа. Это может звучать страшно, но важно то, что он однозначно определяет столбец "возраст" таблица "person" и знает, что поле age - это Int . (Это фантомная часть.)

2. У нас есть несколько постоянных операторов фильтрации. Они все красивые прямолинейно: просто поставьте точку в конце того, что вы ожидаете. Есть три ошибки здесь, я объясню ниже.

3. Список фильтров состоит из И вместе, так что наше ограничение означает "возраст больше 25 И возраст меньше или равен 30 ".Мы опишем ORing позже.

Один оператор с неожиданным названием - «не равно». Мы используем ! =. , так как / =. используется для обновлений (для «разделяй и устанавливай», описанного ниже). Не волнуйтесь: если вы воспользуетесь не тем, компилятор поймает вас. Два других удивительных операторы - это «член» и «не член». Они, соответственно, <-. и / <-. (оба оканчиваются точкой).

А относительно OR s мы используем ||. оператор. Например:

  человек <- selectList
    ([PersonAge>. 25, PersonAge <=. 30]
        ||. [PersonFirstName / <-. ["Адам", "Бонни"]]
        ||. ([PersonAge ==. 50] ||. [PersonAge ==. 60])
    )
    []
liftIO $ печать человек  

Этот (совершенно бессмысленный) пример означает: найти людей от 26 до 30 лет, включительно, ИЛИ чье имя не Адам или Бонни, ИЛИ возраст 50 лет. или 60.

Все наши вызовов selectList включали пустой список в качестве второго параметр.Это не определяет никаких параметров, что означает: сортировать, как хочет база данных, вернуть все результаты и не пропустить ни одного результата. SelectOpt имеет четыре конструкторы, которые можно использовать, чтобы все это изменить.

По возрастанию

Сортировать по заданному столбцу в порядке возрастания. При этом используется тот же фантомный тип, что и при фильтрации, например PersonAge .

Desc

То же, что и Asc , в порядке убывания.

Ограничено до

Принимает аргумент Int .Возврат только до указанного количества результатов.

OffsetBy

Принимает аргумент Int . Пропустить указанное количество результатов.

Следующий код определяет функцию, которая разбивает результаты на страницы. Он возвращает всех людей в возрасте 18 лет и старше, а затем сортирует их по возрасту (самые старые человек в первую очередь). Для людей одного возраста они отсортированы в алфавитном порядке по фамилия, затем имя.

  resultsForPage pageNumber = do
    пусть resultsPerPage = 10
    selectList
        [PersonAge> =.18
        ]
        [Desc PersonAge
        , Asc PersonLastName
        , По возрастанию PersonFirstName
        , LimitTo resultsPerPage
        , OffsetBy $ (pageNumber - 1) * resultsPerPage
        ]  

Запросы - это только половина дела. Мы также должны иметь возможность добавлять данные и изменить существующие данные в базе данных.

Это нормально - иметь возможность поиграть с данными в базе данных, но как он вообще туда попадает? Ответ - вставить функцию .Ты просто дайте ему значение, и он вернет идентификатор.

На этом этапе имеет смысл немного объяснить философию, лежащую в основе Настойчивый. Во многих других решениях ORM для хранения данных используются следующие типы данных: непрозрачный: вам нужно пройти через их определенные интерфейсы, чтобы получить и изменить данные. В случае с Persistent дело обстоит иначе: мы используем старый добрый алгебраический Типы данных для всего. Это означает, что вы по-прежнему получаете все преимущества сопоставления с образцом, каррирования и всего остального, к чему вы привыкли.

Однако есть несколько вещей, которые не может сделать . Во-первых, нет возможности автоматически обновлять значения в базе данных каждый раз, когда запись обновляется в Haskell. Конечно, с нормальным отношением Haskell к чистоте и неизменности, в любом случае это не имело бы особого смысла, так что я не плачу по этому поводу.

Однако есть одна проблема, которая часто беспокоит новичков: почему идентификаторы а ценности полностью разделены? Вроде бы очень логично было бы встроить ID внутри значения.Другими словами, вместо того, чтобы иметь:

  данные Person = Person {name :: String}  

имеют

  данные Person = Person {personId :: PersonId, name :: String}  

Что ж, с этим сразу возникает одна проблема: как нам вставить ? Если у человека должен быть идентификатор, и мы получаем идентификатор путем вставки, а для вставки требуется человек, у нас возникает невозможный цикл. Мы могли бы решить эту проблему с помощью undefined , но это просто напрасно.

Хорошо, вы говорите, давайте попробуем что-нибудь более безопасное:

  data Person = Person {personId :: Maybe PersonId, name :: String}  

Я определенно предпочитаю вставить $ Person Ничего "Майкл" - вставить $ Person undefined "Майкл" . А теперь наши типы будут намного проще, не так ли? Для Например, selectList может вернуть простой [Person] вместо этого уродливого [Entity SqlPersist Person] .

Проблема в том, что "уродство" невероятно полезно.Имея Юридическое лицо делает очевидным на уровне типа, что мы имеем дело со значением, которое существует в базе данных. Допустим, мы хотим создать ссылку на другую страницу, требует PersonId (это не редкость, о чем мы поговорим позже). Форма Entity Person дает нам однозначный доступ к этой информации; встраивание PersonId в Person с оберткой Может быть, означает дополнительную проверка времени выполнения для Просто вместо более устойчивой к ошибкам проверки времени компиляции.

Наконец, существует семантическое несоответствие с встраиванием идентификатора в значение. Человек - это значение. Два человека идентичны (в контексте Haskell), если все их поля совпадают. Встраивая идентификатор в значение, мы больше не говорим о человеке, а о строке в базе данных. Равенство больше не является равенством, это идентичность: это то же самое person , а не эквивалентное лицо.

Другими словами, есть некоторые неудобства, связанные с выделением идентификатора, но в целом, это правильный подход , который, по большому счету, приводит к лучшему, менее ошибочному коду.

Теперь, в контексте этого обсуждения, давайте подумаем об обновлении. Самый простой способ обновить:

  let michael = Человек "Майкл" 26
    michaelAfterBirthday = michael {personAge = 27}  

Но на самом деле это ничего не меняет, это просто создает новый Person значение основано на старом. Когда мы говорим "обновить", мы имеем в виду , а не . модификации значений в Haskell. (Нам, конечно, лучше не быть, так как данные в Haskell неизменны.)

Вместо этого мы ищем способы изменения строк в таблице. И самое простое способ сделать это с помощью функции обновления .

  personId <- вставить $ Person "Michael" "Snoyman" 26
обновить personId [PersonAge =. 27]  

update принимает два аргумента: идентификатор и список Update s. Простейший обновление - это задание, но не всегда лучшее. Что, если ты хочешь увеличить чей-то возраст на 1, но у вас нет его нынешнего возраста? Настойчивый Вы покрыли:

  haveBirthday personId = обновить personId [PersonAge + =.1]  

И, как и следовало ожидать, у нас есть все основные математические операторы: + =. , - =. , * =. и / =. (точка). Это может быть удобно для обновление одной записи, но они также необходимы для правильной ACID гарантии. Представьте себе альтернативу: вытащите Person , увеличьте возраст, и обновите новое значение. Если у вас есть два потока / процесса, работающих над этим базы данных в то же время, вас ждет мир боли (подсказка: гонка условия).

Иногда вам нужно обновить сразу несколько строк (дайте всем своим сотрудникам Повышение заработной платы на 5%, например). update Где принимает два параметра: список фильтры и список применяемых обновлений.

  update Где [PersonFirstName ==. «Майкл»] [PersonAge * =. 2] - день был длинным  

Иногда вам просто нужно полностью заменить значение в базе данных с другим значением. Для этого вы используете (что удивительно) функцию replace .

  personId <- вставить $ Person "Michael" "Snoyman" 26
replace personId $ Person "John" "Doe" 20  

Как бы нам ни было больно, иногда мы вынуждены расстаться с нашими данными. Для этого у нас есть три функции:

Удалить

Удалить на основе идентификатора

deleteBy

Удалить на основе уникального ограничения

deleteWhere

Удалить на основе набора фильтров

  personId <- вставить $ Person "Michael" "Snoyman" 26
удалить personId
deleteBy $ PersonName "Майкл" "Снойман"
deleteWhere [PersonFirstName ==.«Михаил»]  

Мы даже можем использовать delete Где чтобы стереть все записи в таблице, мы просто нужно подсказать GHC, какая таблица нас интересует:

  deleteWhere ([] :: [Filter Person])  

До сих пор мы видели базовый синтаксис для наших блоков persistLowerCase : строка для названия наших сущностей, а затем строку с отступом для каждого поля с двумя слова: имя поля и тип данных поля.Постоянные ручки более того: вы можете назначить произвольный список атрибутов после первого два слова в строке.

Предположим, мы хотим иметь сущность Person с (необязательным) возрастом и отметка времени, когда он был добавлен в систему. Для организаций, уже находящихся в database, мы хотим просто использовать текущую дату и время для этой временной метки.

  {- # LANGUAGE EmptyDataDecls # -}
{- # LANGUAGE FlexibleContexts # -}
{- # LANGUAGE GADTs # -}
{- # LANGUAGE GeneralizedNewtypeDeriving # -}
{- # LANGUAGE MultiParamTypeClasses # -}
{- # LANGUAGE OverloadedStrings # -}
{- # ЯЗЫК QuasiQuotes # -}
{- # LANGUAGE TemplateHaskell # -}
{- # LANGUAGE TypeFamilies # -}
База данных импорта.Сопротивляться
импортировать Database.Persist.Sqlite
импортировать Database.Persist.TH
импортировать Data.Time
импортировать Control.Monad.IO.Class

share [mkPersist sqlSettings, mkMigrate "migrateAll"] [persistLowerCase |
Человек
    имя Строка
    возраст Инт Может быть
    создано UTCTime по умолчанию = CURRENT_TIME
    производное шоу
|]

main :: IO ()
main = runSqlite ": memory:" $ do
    время <- liftIO getCurrentTime
    runMigration migrateAll
    вставить $ Человек "Майкл" (Всего 26) раз
    insert $ Person "Greg" Ничего не раз
    возврат ()  

Может быть, - встроенный атрибут из одного слова.Это делает поле необязательным. В Haskell, это означает, что он заключен в . Может быть, . В SQL это делает столбец допускающий значение NULL.

Атрибут по умолчанию специфичен для серверной части и использует любой синтаксис понимается базой данных. В этом случае он использует встроенный в базу данных CURRENT_TIME функция. Предположим, теперь мы хотим добавить поле для любимый язык программирования:

  {- # LANGUAGE EmptyDataDecls # -}
{- # LANGUAGE FlexibleContexts # -}
{- # LANGUAGE GADTs # -}
{- # LANGUAGE GeneralizedNewtypeDeriving # -}
{- # LANGUAGE MultiParamTypeClasses # -}
{- # LANGUAGE OverloadedStrings # -}
{- # ЯЗЫК QuasiQuotes # -}
{- # LANGUAGE TemplateHaskell # -}
{- # LANGUAGE TypeFamilies # -}
База данных импорта.Сопротивляться
импортировать Database.Persist.Sqlite
импортировать Database.Persist.TH
импортировать Data.Time

share [mkPersist sqlSettings, mkMigrate "migrateAll"] [persistLowerCase |
Человек
    имя Строка
    возраст Инт Может быть
    создано UTCTime по умолчанию = CURRENT_TIME
    язык Строка по умолчанию = 'Haskell'
    производное шоу
|]

main :: IO ()
main = runSqlite ": memory:" $ do
    runMigration migrateAll  

Атрибут по умолчанию абсолютно не влияет на код Haskell сам; вам все равно нужно заполнить все значения.Это повлияет только на схема базы данных и автоматические миграции.

Нам нужно заключить строку в одинарные кавычки, чтобы база данных могла правильно интерпретировать это. Наконец, Persistent может использовать двойные кавычки для содержания пустое пространство, поэтому, если мы хотим установить чью-то родную страну по умолчанию как Эль Сальвадор:

  {- # LANGUAGE EmptyDataDecls # -}
{- # LANGUAGE FlexibleContexts # -}
{- # LANGUAGE GADTs # -}
{- # LANGUAGE GeneralizedNewtypeDeriving # -}
{- # LANGUAGE MultiParamTypeClasses # -}
{- # LANGUAGE OverloadedStrings # -}
{- # ЯЗЫК QuasiQuotes # -}
{- # LANGUAGE TemplateHaskell # -}
{- # LANGUAGE TypeFamilies # -}
База данных импорта.Сопротивляться
импортировать Database.Persist.Sqlite
импортировать Database.Persist.TH
импортировать Data.Time

share [mkPersist sqlSettings, mkMigrate "migrateAll"] [persistLowerCase |
Человек
    имя Строка
    возраст Инт Может быть
    создано UTCTime по умолчанию = CURRENT_TIME
    язык Строка по умолчанию = 'Haskell'
    страна Строка "default = 'Сальвадор'"
    производное шоу
|]

main :: IO ()
main = runSqlite ": memory:" $ do
    runMigration migrateAll  

Последний трюк, который вы можете сделать с атрибутами, - это указать имена, которые будут использоваться для таблиц и столбцов SQL.Это может быть удобно при взаимодействии с существующие базы данных.

  общий ресурс [mkPersist sqlSettings, mkMigrate "migrateAll"] [persistLowerCase |
Человек sql = идентификатор таблицы-лица = numeric_id
    firstName String sql = first_name
    lastName String sql = fldLastName
    age Int "sql = Возраст человека"
    PersonName firstName lastName
    производное шоу
|]  

Синтаксис определения сущности имеет ряд других особенностей. An актуальный список ведется в Постоянной документации.

Persistent позволяет ссылаться между вашими типами данных таким образом, чтобы совместим с поддержкой баз данных, отличных от SQL. Мы делаем это, вставляя идентификатор в связанный объект. Итак, если у человека много машин:

  {- # LANGUAGE EmptyDataDecls # -}
{- # LANGUAGE FlexibleContexts # -}
{- # LANGUAGE GADTs # -}
{- # LANGUAGE GeneralizedNewtypeDeriving # -}
{- # LANGUAGE MultiParamTypeClasses # -}
{- # LANGUAGE OverloadedStrings # -}
{- # ЯЗЫК QuasiQuotes # -}
{- # LANGUAGE TemplateHaskell # -}
{- # LANGUAGE TypeFamilies # -}
База данных импорта.Сопротивляться
импортировать Database.Persist.Sqlite
импортировать Database.Persist.TH
импортировать Control.Monad.IO.Class (liftIO)
импортировать Data.Time

share [mkPersist sqlSettings, mkMigrate "migrateAll"] [persistLowerCase |
Человек
    имя Строка
    производное шоу
Машина
    ownerId PersonId
    имя Строка
    производное шоу
|]

main :: IO ()
main = runSqlite ": memory:" $ do
    runMigration migrateAll
    bruce <- insert $ Person "Bruce Wayne"
    вставить $ Автомобиль Брюса "Bat Mobile"
    вставить $ Автомобиль Брюса "Порше"
    - это может продолжаться некоторое время
    автомобили <- selectList [CarOwnerId ==.Брюс] []
    liftIO $ распечатать автомобили  

Используя этот метод, вы можете определить отношения «один ко многим». Определить отношения "многие-ко-многим", нам нужна объединяющая сущность, которая имеет отношение "один ко многим" отношения с каждой из исходных таблиц. Также неплохо использовать ограничения на их уникальность. Например, чтобы смоделировать ситуацию, когда мы хотите отслеживать, какие люди делали покупки в каких магазинах:

  {- # LANGUAGE EmptyDataDecls # -}
{- # LANGUAGE FlexibleContexts # -}
{- # LANGUAGE GADTs # -}
{- # LANGUAGE GeneralizedNewtypeDeriving # -}
{- # LANGUAGE MultiParamTypeClasses # -}
{- # LANGUAGE OverloadedStrings # -}
{- # ЯЗЫК QuasiQuotes # -}
{- # LANGUAGE TemplateHaskell # -}
{- # LANGUAGE TypeFamilies # -}
База данных импорта.Сопротивляться
импортировать Database.Persist.Sqlite
импортировать Database.Persist.TH
импортировать Data.Time

share [mkPersist sqlSettings, mkMigrate "migrateAll"] [persistLowerCase |
Человек
    имя Строка
Магазин
    имя Строка
PersonStore
    personId PersonId
    storeId StoreId
    UniquePersonStore personId storeId
|]

main :: IO ()
main = runSqlite ": memory:" $ do
    runMigration migrateAll

    bruce <- insert $ Person "Bruce Wayne"
    michael <- вставить $ Person "Michael"

    target <- вставить $ Store "Target"
    gucci <- вставить $ Магазин "Gucci"
    sevenEleven <- вставить $ Store "7-11"

    вставить $ PersonStore Брюс Гуччи
    вставить $ PersonStore Брюс sevenEleven

    insert $ PersonStore michael target
    вставить $ PersonStore майкл sevenEleven

    возврат ()  

До сих пор мы говорили о Person и PersonId без подробных объяснений. что они.В простейшем смысле для системы только с SQL PersonId может быть просто типа PersonId = Int64 . Однако это означает, что нет ничего привязка PersonId на уровне типа к сущности Person . В результате вы мог случайно использовать PersonId и получить Car . Чтобы смоделировать это отношения, мы могли бы использовать фантомные типы. Итак, наш следующий наивный шаг:

  newtype Ключевой объект = Ключ Int64
тип PersonId = Ключевое лицо  

И это работает очень хорошо, пока вы не дойдете до серверной части, которая не использует Int64 для его идентификаторов.И это не только теоретический вопрос; MongoDB использует ByteString вместо этого. Итак, нам нужно ключевое значение, которое может содержать Int и ByteString . Похоже, отличное время для типа суммы:

  data Key entity = KeyInt Int64 | KeyByteString ByteString  

Но это просто напрашивается на неприятности. Далее у нас будет серверная часть, использующая timestamps, поэтому нам нужно добавить еще один конструктор в Key . Это могло продолжаться некоторое время.К счастью, у нас уже есть тип суммы, предназначенный для представления произвольные данные: PersistValue :

  newtype Ключевой объект = Key PersistValue  

И это (более или менее) то, что Persistent делал до версии 2.0. Однако это у него другая проблема: он выбрасывает данные. Например, при работе с База данных SQL, мы знаем, что тип ключа будет Int64 (при условии, что значения по умолчанию используются). Однако вы не можете утверждать, что на уровне типа с этим строительство.Поэтому вместо этого, начиная с Persistent 2.0, мы теперь используем связанный тип данных внутри класса PersistEntity :

  класс PersistEntity запись, где
    данные Ключевая запись
    ...  

Если вы работаете с серверной частью SQL и не используете специальный тип ключа, это становится оболочкой newtype вокруг Int64 , а toSqlKey / fromSqlKey Функции могут выполнять это типобезопасное преобразование для ты. С другой стороны, в MongoDB это оболочка вокруг байтовой строки .

По умолчанию Persistent жестко запрограммирует ваши типы данных для работы с определенным серверная часть базы данных. При использовании sqlSettings это тип SqlBackend . Но если вы хотите написать постоянный код, который можно использовать на нескольких серверах, вы можно включить более общие типы, заменив sqlSettings на sqlSettings { mpsGeneric = True} .

Чтобы понять, зачем это нужно, рассмотрим отношения. Допустим, мы хотим представляют блоги и сообщения в блогах.Мы бы использовали определение объекта:

 Блог
    заголовок Текст
Почта
    заголовок Текст
    blogId BlogId 

Мы знаем, что BlogId - это просто синоним типа для Key Blog , но как Key Блог определится? Мы не можем использовать Int64 , так как это не сработает для MongoDB. И мы не можем использовать ByteString , поскольку это не работает для баз данных SQL.

Для этого, если для mpsGeneric установлено значение True , результирующие типы данных будут иметь параметр типа, указывающий, какой сервер базы данных они используют, чтобы ключи могли быть правильно закодированы.Это выглядит так:

  data BlogGeneric backend = Блог {blogTitle :: Text}
data PostGeneric backend = Post
    {postTitle :: Text
    , postBlogId :: Key (базовая часть BlogGeneric)
    }  

Обратите внимание, что мы по-прежнему сохраняем короткие имена для конструкторов и записей. Наконец, чтобы дать простой интерфейс для обычного кода, мы определяем некоторый тип синонимы:

  type Blog = BlogGeneric SqlBackend
type BlogId = Ключевой блог
введите Post = PostGeneric SqlBackend
type PostId = Key Post  

И нет, SqlBackend нигде жестко не закодирован в Persistent.Что sqlSettings Параметр , который вы передали в mkPersist , говорит нам используйте SqlBackend . Код Mongo будет использовать вместо этого mongoSettings .

Это может быть довольно сложно на первый взгляд, но пользовательский код почти никогда не касается этого. Просмотрите всю эту главу: нам ни разу не нужно было иметь дело с Key или Generic напрямую. Самое обычное место для этого всплывающее окно находится в сообщениях об ошибках компилятора.Поэтому важно знать, что это существует, но не должно влиять на вас повседневно.

Иногда вам нужно определить настраиваемое поле, которое будет использоваться в вашем хранилище данных. Самый частый случай - это перечисление, например, статус занятости. Для этого Persistent предоставляет вспомогательную функцию Template Haskell:

  - @ Employment.hs
{- # LANGUAGE TemplateHaskell # -}
модуль Трудоустройство где

импортировать Database.Persist.TH

данные Занятость = Занятые | Безработные | На пенсии
    извлечение (показать, прочитать, уравнение)
derivePersistField "Занятость"  

  {- # LANGUAGE EmptyDataDecls # -}
{- # LANGUAGE FlexibleContexts # -}
{- # LANGUAGE GADTs # -}
{- # LANGUAGE GeneralizedNewtypeDeriving # -}
{- # LANGUAGE MultiParamTypeClasses # -}
{- # LANGUAGE OverloadedStrings # -}
{- # ЯЗЫК QuasiQuotes # -}
{- # LANGUAGE TemplateHaskell # -}
{- # LANGUAGE TypeFamilies # -}
База данных импорта.Persist.Sqlite
импортировать Database.Persist.TH
импортная занятость

share [mkPersist sqlSettings, mkMigrate "migrateAll"] [persistLowerCase |
Человек
    имя Строка
    занятость Занятость
|]

main :: IO ()
main = runSqlite ": memory:" $ do
    runMigration migrateAll

    вставить $ Человек "Брюс Уэйн" на пенсии
    вставить $ Человек "Питер Паркер" Безработный
    вставить $ Человек "Майкл" Занят

    возврат ()  

derivePersistField хранит данные в базе данных, используя строковое поле, и выполняет маршалинг с использованием экземпляров типа данных Show и Read .Этот может быть не так эффективно, как сохранение через целое число, но это гораздо больше в будущем доказательство: даже если вы добавите дополнительные конструкторы в будущем, ваши данные все равно будут быть действительным.

В этом случае мы разделили наше определение на два отдельных модуля. Это необходимо из-за ограничения стадии GHC, что по сути означает, что в во многих случаях код, сгенерированный Template Haskell, нельзя использовать в одном модуле. он был создан в.

Пакет Persistent обеспечивает типобезопасный интерфейс для хранилищ данных.Он пытается быть независимым от серверной части, например, не полагаться на реляционные функции SQL. Мой как показывает опыт, вы можете легко выполнить 95% того, что вам нужно, с высокоуровневый интерфейс. (Фактически, большинство моих веб-приложений используют высокий уровень только интерфейс.)

Но иногда вам может понадобиться использовать особенность серверной части. Раньше я пользовался функцией полнотекстового поиска. В этом случае мы будем использовать оператор SQL LIKE, который не смоделирован в Persistent. Мы соберем всех людей с фамилией «Снойман» и распечатаем записи.

На самом деле, вы можете выразить оператор LIKE непосредственно в обычном синтаксисе благодаря функции, добавленной в Persistent 0.6, которая позволяет операторы. Но это еще хороший пример, так что давайте ролл с ним.

  {- # LANGUAGE EmptyDataDecls # -}
{- # LANGUAGE FlexibleContexts # -}
{- # LANGUAGE GADTs # -}
{- # LANGUAGE GeneralizedNewtypeDeriving # -}
{- # LANGUAGE MultiParamTypeClasses # -}
{- # LANGUAGE OverloadedStrings # -}
{- # ЯЗЫК QuasiQuotes # -}
{- # LANGUAGE TemplateHaskell # -}
{- # LANGUAGE TypeFamilies # -}
База данных импорта.Persist.TH
импортировать Data.Text (текст)
импортировать Database.Persist.Sqlite
импортировать Control.Monad.IO.Class (liftIO)
импортировать Data.Conduit
импортировать квалифицированные Data.Conduit.List как CL

share [mkPersist sqlSettings, mkMigrate "migrateAll"] [persistLowerCase |
Человек
    имя Текст
|]

main :: IO ()
main = runSqlite ": memory:" $ do
    runMigration migrateAll
    вставить $ Человек "Майкл Снойман"
    вставить $ Человек "Мириам Снойман"
    вставить $ Человек "Элиэзер Снойман"
    вставить $ Персона "Гавриэлла Снойман"
    insert $ Person "Грег Вебер"
    вставить $ Person "Рик Ричардсон"

    - Persistent не предоставляет ключевое слово LIKE, но мы хотели бы получить
    - вся семья Сноймана...
    let sql = "ВЫБРАТЬ имя ОТ человека, ГДЕ имя LIKE '% Snoyman'"
    rawQuery sql [] $$ CL.mapM_ (liftIO. print)  

Существует также поддержка более высокого уровня, позволяющая автоматизировать маршалинг данных. Дополнительные сведения см. В документации по Haddock API.

Итак, вы убедились в силе Persistent. Как вы это интегрируете с вашим приложением Yesod? Если вы используете строительные леса, большая часть работы уже сделано для вас. Но как обычно, мы все создадим вручную. здесь, чтобы указать, как это работает под поверхностью.

Пакет yesod-persistent обеспечивает точку встречи между Persistent и Йесод. Он предоставляет класс типов YesodPersist , который стандартизирует доступ к базу данных с помощью метода runDB . Давайте посмотрим на это в действии.

  {- # LANGUAGE EmptyDataDecls # -}
{- # LANGUAGE FlexibleContexts # -}
{- # LANGUAGE GADTs # -}
{- # LANGUAGE GeneralizedNewtypeDeriving # -}
{- # LANGUAGE MultiParamTypeClasses # -}
{- # LANGUAGE OverloadedStrings # -}
{- # ЯЗЫК QuasiQuotes # -}
{- # LANGUAGE TemplateHaskell # -}
{- # LANGUAGE TypeFamilies # -}
{- # LANGUAGE ViewPatterns # -}
импорт Йесод
База данных импорта.Persist.Sqlite
импортировать Control.Monad.Trans.Resource (runResourceT)
импортировать Control.Monad.Logger (runStderrLoggingT)

- Определите наши сущности как обычно
share [mkPersist sqlSettings, mkMigrate "migrateAll"] [persistLowerCase |
Человек
    firstName String
    lastName String
    возраст Int
    производное шоу
|]

- Мы держим пул подключений в фундаменте. При инициализации программы мы
- создаем наш начальный пул, и каждый раз, когда нам нужно выполнить действие, мы проверяем
- вышло одно соединение из пула.данные PersistTest = PersistTest ConnectionPool

- Мы создадим единый маршрут для доступа к человеку. Это очень распространенный
- возможность использования типа Id в маршрутах.
mkYesod "PersistTest" [parseRoutes |
/ HomeR ПОЛУЧИТЬ
/ person / # PersonId PersonR GET
|]

- Здесь ничего особенного
экземпляр Yesod PersistTest

- Теперь нам нужно определить экземпляр YesodPersist, который будет отслеживать
- какой бэкэнд мы используем и как запускать действие.
instance YesodPersist PersistTest где
    тип YesodPersistBackend PersistTest = SqlBackend

    runDB действие = делать
        Пул PersistTest <- getYesod
        Пул действий runSqlPool

- Список всех людей в базе данных
getHomeR :: Handler Html
getHomeR = делать
    people <- runDB $ selectList [] [Asc PersonAge]
    defaultLayout
        [whamlet |
            

                $ forall Entity personid person <- люди
                    

                         # {personFirstName person}
        |]

- Мы просто вернем выставочную стоимость человека или 404, если человек этого не сделает.
-- существовать.getPersonR :: PersonId -> Строка обработчика
getPersonR personId = делать
    person <- runDB $ get404 personId
    вернуть $ показать человека

openConnectionCount :: Int
openConnectionCount = 10

main :: IO ()
main = runStderrLoggingT $ withSqlitePool "test.db3" openConnectionCount $ \ pool -> liftIO $ do
    runResourceT $ flip runSqlPool pool $ do
        runMigration migrateAll
        insert $ Person "Michael" "Snoyman" 26
    warp 3000 $ PersistTest pool  

Здесь есть две важные части для общего пользования. runDB используется для запуска Действие БД из обработчика . В пределах runDB вы можете использовать любой из функции, о которых мы уже говорили, такие как insert и selectList .

Тип runDB - YesodDB site a → HandlerT site IO a . YesodDB определяется как:

  type YesodDB site = ReaderT (YesodPersistBackend site) (HandlerT site IO)  

Поскольку он построен на основе ассоциированного типа YesodPersistBackend , он использует соответствующий сервер базы данных на основе текущего сайта.

Другая новая функция - get404 . Работает так же, как получить , но вместо возвращает Nothing , когда результат не может быть найден, возвращает сообщение 404 страница. Функция getPersonR - очень распространенный подход, используемый в реальном мире. Приложения Yesod: get404 значение, а затем возвращение ответа на его основе.

Persistent стремится быть независимым от серверной части. Преимущество такого подхода в том, что код, который легко перемещается с разных типов backend.Обратной стороной является то, что вы терять некоторые особенности, специфичные для серверной части. Наверное, самая большая жертва Поддержка присоединения к SQL.

К счастью, благодаря Фелипе Лесса и Крису Аллену вы можете съесть свой торт и съесть его. В Библиотека Esqueleto предоставляет поддержка написания безопасных по типу SQL-запросов с использованием существующих постоянных инфраструктура. Пикши для этого пакета дают хорошее введение в его использование. А поскольку он использует множество постоянных концепций, большинство ваших существующих Постоянные знания должны легко передаваться.

Простой пример использования Esqueleto см. В главе «Соединения SQL».

Чтобы примеры в этой главе были простыми, мы использовали серверную часть SQLite. В завершение, вот наш оригинальный синопсис, переписанный для работы с PostgreSQL:

  {- # LANGUAGE EmptyDataDecls # -}
{- # LANGUAGE FlexibleContexts # -}
{- # LANGUAGE GADTs # -}
{- # LANGUAGE GeneralizedNewtypeDeriving # -}
{- # LANGUAGE MultiParamTypeClasses # -}
{- # LANGUAGE OverloadedStrings # -}
{- # ЯЗЫК QuasiQuotes # -}
{- # LANGUAGE TemplateHaskell # -}
{- # LANGUAGE TypeFamilies # -}
Контроль импорта.Монада.IO.Class (liftIO)
импортировать Control.Monad.Logger (runStderrLoggingT)
импортировать Database.Persist
импортировать Database.Persist.Postgresql
импортировать Database.Persist.TH

share [mkPersist sqlSettings, mkMigrate "migrateAll"] [persistLowerCase |
Человек
    имя Строка
    возраст Инт Может быть
    производное шоу
Сообщение блога
    заголовок Строка
    authorId PersonId
    производное шоу
|]

connStr = "host = localhost dbname = test user = test password = test port = 5432"

main :: IO ()
main = runStderrLoggingT $ withPostgresqlPool connStr 10 $ \ pool -> liftIO $ do
    перевернуть пул runSqlPersistMPool $ do
        runMigration migrateAll

        johnId <- insert $ Person "John Doe" Всего 35 долларов
        janeId <- insert $ Person "Jane Doe" Ничего

        insert $ BlogPost "Мой первый p0st" johnId
        insert $ BlogPost "Еще одно на всякий случай" johnId

        oneJohnPost <- selectList [BlogPostAuthorId ==.johnId] [LimitTo 1]
        liftIO $ print (oneJohnPost :: [Entity BlogPost])

        john <- получить johnId
        liftIO $ print (john :: Может быть, человек)

        удалить janeId
        deleteWhere [BlogPostAuthorId ==. johnId]  

Persistent обеспечивает безопасность типов Haskell на уровне доступа к данным. Вместо написания подверженного ошибкам, нетипизированного доступа к данным или ручного написания шаблона Маршалинг кода, вы можете положиться на Persistent, который автоматизирует этот процесс за вас.

Цель состоит в том, чтобы предоставить все, что вам нужно, в большинстве случаев , .На время когда вам нужно что-то более мощное, Persistent дает вам прямой доступ в базовое хранилище данных, поэтому вы можете записать любые 5-сторонние соединения, которые захотите.

Persistent напрямую интегрируется в общий рабочий процесс Yesod. Не только делать вспомогательные пакеты, такие как yesod-persistent , предоставляют хороший уровень, но такие пакеты, как yesod-form и yesod-auth также используют функции Persistent.

Для получения дополнительной информации о синтаксисе объявлений сущностей, подключении к базе данных и т. Д.Оформить заказ https://github.com/yesodweb/persistent/tree/master/docs

Persistent Systems сообщает о доходе в 131 млн долларов с ростом на 3,1% кв / кв и 9,5% г / г за 1 квартал 21 финансового года

ПУНА, Индия и САНТА-КЛАРА, Калифорния, 25 июля 2020 г. / PRNewswire / -

Сводка новостей