Drizzle против Prisma

Время на прочтение статьи
На чтение13 мин
Дата обновления статьи
Обновлено4 недели назад
Просмотров статьи
Просмотров

Drizzle и Prisma - это две ORM системы, которые вам рекомендуется использовать при работе с доступом к данным и миграциями в вашем проекте.

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

Уровень абстракции

Уровень абстракции, на котором работает Prisma, отличается от Drizzle. Prisma обеспечивает высокий уровень абстракции, помогает упростить процесс получения данных и манипулирования ими, а также имеет API, который действительно прост для понимания.

Prisma абстрагируется от деталей базовой базы данных. В ней представлен язык, зависящий от предметной области (DSL), который менее сложен, чем базовый SQL.

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

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

Ниже приведен пример того, как Prisma запрашивает данные:

const userData = await prisma.user.findMany({
  where: { isActive: true },
  select: { id: true, name: true, email: true }
});

Prisma генерирует запросы, которые работают в большинстве случаев, но могут быть менее предсказуемыми для оптимизации производительности, поскольку они абстрагированы от SQL.

Drizzle, с другой стороны, следует в SQL-первый подход. Согласно его документации, вы знаете SQL, то вы знаете, Drizzle

Drizzle предлагает более детальный контроль над SQL-запросами и более тесную связь с базовой схемой базы данных, поскольку он разработан таким образом, чтобы избежать ощущения "черной коробки" Prisma. В Drizzle вы знаете, какой SQL выполняется, что облегчает прогнозирование поведения производительности.

Ниже приведен пример того, как Drizzle запрашивает данные:

const userData = await drizzle.execute(`
  SELECT id, name, email 
  FROM users 
  WHERE is_active = true;
`);

Поддержка баз данных

Что касается поддержки баз данных, Prisma поддерживает различные базы данных, такие как PostgreSQL, MySQL, SQLite, MongoDB и SQL Server. У нее есть функция автоматической миграции, которая упрощает процесс обновления схем баз данных. С помощью этой функции вы можете быстро адаптироваться к любым необходимым вам требованиям к данным без необходимости управлять миграциями вручную.

Drizzle, с другой стороны, не поддерживает столько баз данных, сколько Prisma, но поддерживает все основные базы данных SQL, такие как драйверы PostgreSQL, MySQL или SQLite. Его рабочие процессы, управляемые SQL, обеспечивают более практичный опыт и созданы для разработчиков, которые предпочитают прямое управление SQL на абстрактных уровнях ORM.

Соотношение гибкости и скорости

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

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

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

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

Интеграция с интерфейсом

Prisma прекрасно интегрируется с такими интерфейсными платформами, как Next.js и Remix, и к тому же обладает гибкостью. Она хорошо работает с маршрутами API, getServerSideProps, getStaticProps и другими серверными функциями. Благодаря встроенной поддержке TypeScript Prisma автоматически генерирует типы из сквозного типа схемы, что гарантирует безопасность, что помогает выявлять ошибки во время разработки.

Prisma также автоматически генерирует запросы и изменения, упрощая CRUD-операции.

Ниже приведен пример использования Prisma’s не сформирован автоматически схемы Next.js приложение:

import { prisma } from '../../../lib/prisma';
import type { NextApiRequest, NextApiResponse } from 'next';

export default async function handler(req: NextApiRequest, res: NextApiResponse) {
  const { id } = req.query;

  if (req.method === 'GET' && typeof id === 'string') {
    const user = await prisma.user.findUnique({
      where: { id },
    });
    return user ? res.status(200).json(user) : res.status(404).json({ error: 'User not found' });
  }

  res.status(405).json({ error: 'Method not allowed' });
}

В данном примере Prisma’с findUnique запрос, сгенерированный автоматически из схемы, выбирает пользователя по идентификатору в Next.js маршрут по API. Такая типобезопасная интеграция сокращает использование ручного кода API и делает взаимодействие между интерфейсом и серверной частью более простым и продуктивным.

Drizzle также поддерживает интеграцию с платформами на основе TypeScript, такими как Next.js и Remix. Он предоставляет API, который отражает синтаксис SQL и позволяет создавать запросы, безопасные для ввода. Drizzle генерирует типы TypeScript на основе схемы базы данных, которая не только облегчает совместное использование типов между интерфейсом и серверной частью, но и упрощает обработку данных.

В отличие от Prisma, Drizzle не генерирует специфичный для интерфейса код, но оптимизирован для использования в серверных функциях, маршрутах API и фреймворках с полным стеком. Это делает Drizzle более удобным, но точным выбором, идеально подходящим для тех, кто предпочитает тесно сотрудничать с SQL.

Ниже приведен пример морось интеграции в Next.js маршрут АПИ :

import { pgTable, serial, text, varchar } from 'drizzle-orm/pg-core';
import { drizzle } from 'drizzle-orm/node-postgres';

export const users = pgTable('users', {
  id: serial('id').primaryKey(),
  name: text('name'),
  email: varchar('email', { length: 255 }).unique(),
});

type User = typeof users.$inferSelect;

import { eq } from 'drizzle-orm';
import type { NextApiRequest, NextApiResponse } from 'next';

export default async function handler(
  req: NextApiRequest, 
  res: NextApiResponse<User | { error: string }>
) {
  const { id } = req.query;

  if (req.method === 'GET' && typeof id === 'string') {
    try {
      const user = await db.select()
        .from(users)
        .where(eq(users.id, parseInt(id)))
        .limit(1);

      if (user.length > 0) {
        res.status(200).json(user[0]); 
      } else {
        res.status(404).json({ error: 'User not found' });
      }
    } catch (error) {
      res.status(500).json({ error: 'Internal Server Error' });
    }
    return;
  }

  res.status(405).json({ error: 'Method not allowed' });
}

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

Скорость выполнения запросов и производительность

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

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

Ниже приведено сравнительное сравнение типичных интерфейсных запросов, которое показывает, как Prisma и Drizzle справляются с общими задачами:

В целом, Prisma - отличный выбор, если вам нужна гибкость при обработке сложных запросов, в то время как Drizzle был бы отличным выбором для более быстрого выполнения простых запросов, но требовал бы большей ручной обработки.

Безопасность ввода и опыт разработчика

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

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

Drizzle, напротив, не генерирует типы автоматически из абстрактной схемы. Вместо этого он определяет модели данных в SQL-подобных схемах, а TypeScript выводит типы из этих определений. Это обеспечивает вам гибкость и точность, если вы предпочитаете детальный контроль над SQL-запросами без добавления абстракций ORM.

Несмотря на то, что подход Drizzle требует большего количества обновлений вручную, он по-прежнему выигрывает от проверки TypeScript во время компиляции для предотвращения ошибок во время выполнения.

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

Выборка данных

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

import { prisma } from '../../lib/prisma';

const resolvers = {
  Query: {
    user: async (_: unknown, { id }: { id: string }) => {
      return prisma.user.findUnique({
        where: { id },
        select: {
          id: true,
          name: true,
          email: true,
          posts: { select: { id: true, title: true } }
        },
      });
    },
    users: async (_: unknown, { ids }: { ids: string[] }) => {
      return prisma.user.findMany({
        where: { id: { in: ids } },
        select: { id: true, name: true, email: true }
      });
    }
  },
};

export default resolvers;

В этом примере распознаватели Prisma обрабатывают однократную и пакетную выборку данных пользователем. Он использует select для извлечения только необходимых полей. Prisma также поддерживает RESTful API, которые позволяют извлекать данные как из GraphQL, так и из REST-систем с оптимизацией, такой как настройка конечной точки, пакетная обработка запросов и кэширование.

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

import { drizzle } from '../../../lib/drizzle';
import type { NextApiRequest, NextApiResponse } from 'next';
import { sql } from 'drizzle-orm';

export default async function handler(req: NextApiRequest, res: NextApiResponse) {
  const { id } = req.query;
  if (req.method === 'GET' && typeof id === 'string') {
    const user = await drizzle.query(sql`
      SELECT id, name, email FROM users WHERE id = ${id}
    `);

    if (user.length > 0) {
      res.status(200).json(user[0]);
    } else {
      res.status(404).json({ error: 'User not found' });
    }
    return;
  }
  res.status(405).json({ error: 'Method not allowed' });
}

В приведенном выше примере вы можете увидеть, как Drizzle позволяет выполнять точные SQL-запросы, извлекая только необходимые поля (id, имя, адрес электронной почты), чтобы предотвратить повторную выборку.

Drizzle также поддерживает GraphQL через свой пакет drizzle-graphql, который позволяет создавать сервер GraphQL на основе схемы с минимальными настройками:

import { createGraphQLServer } from 'drizzle-graphql';
import { schema } from './drizzleSchema';

const server = createGraphQLServer(schema);

Несмотря на то, что настройка GraphQL в Drizzle проста, вам все равно придется вручную обрабатывать сложную выборку данных:

import { createGraphQLServer } from 'drizzle-graphql';
import { schema } from './drizzleSchema';

const customResolvers = {
  Query: {
    optimizedDataFetch: async (_, args, context) => {
      const result = await context.db.query('SELECT ...');
      return result;
    }
  }
};

const server = createGraphQLServer(schema, { resolvers: customResolvers });

Это управляемое SQL управление в Drizzle обеспечивает гибкость при тонкой настройке, хотя для достижения оптимальной производительности интерфейса требуется больше практических настроек.

Инструменты и поддержка IDE

Prisma обеспечивает поддержку интерфейсных сред разработки многими способами, одним из которых является официальное расширение VS Code. Это расширение улучшает подсветку синтаксиса и проверку ошибок в файлах схемы .prisma, а также обеспечивает автозавершение и безопасность типов для моделей Prisma.

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

const user = await prisma.user.findUnique({ 
  where: { id: userId }, 
});

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

В отличие от этого, Drizzle использует более простой рабочий процесс без специального расширения, что может быть сложной задачей для тех, кто плохо знаком с SQL. Однако Drizzle использует интеграцию TypeScript в VS Code, которая позволяет автоматически заполнять поля SQL (например, users.id).

Этот подход, ориентированный на SQL, может понравиться тем, кто предпочитает работать непосредственно с необработанным SQL:

const user = await db.select().from(users).where(users.id.equals(userId));

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

Миграции

И Drizzle, и Prisma поддерживают миграцию, генерируя файлы миграции SQL на основе спецификаций модели, выполняемых через интерфейс командной строки, но их подходы к управлению миграцией различаются.

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

Такая автоматизация помогает поддерживать стабильность API, поскольку Prisma обновляет типы TypeScript всякий раз, когда меняется схема, и это будет указывать на любые несоответствия кода в вашем интерфейсе во время компиляции.

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

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

Безопасность и валидация

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

model User {
  id        Int      @id @default(autoincrement())
  email     String   @unique
  name      String   @db.VarChar(255)
  age       Int      @db.Int
}

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

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

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

Ниже приведена сравнительная таблица, в которой обобщено все, что мы обсуждали:

Варианты использования

Drizzle

  • Приложения, ориентированные на производительность: Поддерживает приложения, требующие максимальной скорости и минимальных затрат, такие как информационные панели в режиме реального времени, торговые платформы или API-интерфейсы с высоким трафиком Типобезопасная разработка: Предотвращает ошибки, связанные с данными, в крупных проектах на TypeScript, критически важных для финансовых систем или систем здравоохранения. Масштабирование инфраструктуры: подходит для микросервисов и бессерверных приложений в облачных средах с переменной нагрузкой и быстрым запуском Проекты, ориентированные на SQL: подходит для команд, использующих сложные SQL-запросы для хранилищ данных или аналитических платформ. Интеграция с современными веб-фреймворками: Эффективно интегрируется с Next.js, SvelteKit и другими современными фреймворками для серверных компонентов и маршрутов API Приложения реального времени: обеспечивает детальный контроль над запросами для приложений с низкой задержкой, требующих большого объема данных, таких как визуализация в реальном времени или инструменты для совместной работы

Prisma

  • Быстрое прототипирование: упрощает настройку базы данных для MVP и стартапов
  • Комплексная разработка: Синхронизирует интерфейс и серверную часть с автоматически генерируемыми типами и клиентами
  • Сложные отношения с данными: Управляет взаимосвязанными данными для таких приложений, как социальные сети или CMS
  • Абстрагирование баз данных: позволяет легко переключать базы данных или поддерживать несколько баз данных
  • Приложения реального времени: поддерживает синхронизацию данных для приложений, нуждающихся в оперативном обновлении, таких как инструменты для совместной работы или платформы социальных сетей.

Когда следует выбирать Prisma

Вы можете выбрать Prisma, когда:

  • Вам необходимо быстро разработать и апробировать свою идею
  • Успех вашего приложения в большей степени зависит от опыта пользователей, чем от производительности базы данных
  • Знания вашей команды в области SQL ограничены
  • Вашим приоритетом является своевременный вывод на рынок

Когда выбрать Drizzle

Выберите Drizzle, когда:

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

Вывод

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

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

#TypeScript