Drizzle ORM(expo-sqlite)

npx expo install expo-sqlite
npm i drizzle-orm
npm i -D drizzle-kit 迁移功能
官方基础用法
连接数据库

import * as SQLite from 'expo-sqlite';
import { drizzle } from 'drizzle-orm/expo-sqlite';
const expo = SQLite.openDatabaseSync('db.db');
const db = drizzle(expo);

定义模型表

import { sqliteTable, integer, text } from 'drizzle-orm/sqlite-core';

export const cards = sqliteTable('cards', {
  id: integer('id').primaryKey({ autoIncrement: true }),
  front: text('front').notNull(),
  back: text('back'),
});

项目根目录创建metro.config.js

const { getDefaultConfig } = require('expo/metro-config');
/** @type {import('expo/metro-config').MetroConfig} */
const config = getDefaultConfig(__dirname);
config.resolver.sourceExts.push('sql');
module.exports = config;

更新项目根目录的babel.config.js

module.exports = function(api) {
  api.cache(true);
  return {
    presets: ['babel-preset-expo'],
    plugins: [["inline-import", { "extensions": [".sql"] }]] // <-- add this
  };
};

app启动时自动创建表+增删改查

// App.tsx
import { Text, View } from 'react-native';
import * as SQLite from 'expo-sqlite';
import { drizzle, sql } from 'drizzle-orm/expo-sqlite';
import { cards } from './db/schema';
import { useEffect, useState } from 'react';
import { eq } from 'drizzle-orm/expressions';   // WHERE 条件辅助

const sqlite = SQLite.openDatabaseSync('cards.db');
const db = drizzle(sqlite);

export default function App() {
  const [list, setList] = useState<typeof cards.$inferSelect[]>();

  /** 第一次运行时自动建表（IF NOT EXISTS 保证幂等） */
  useEffect(() => {
    (async () => {
      await db.run(sql`
        CREATE TABLE IF NOT EXISTS cards (
          id    INTEGER PRIMARY KEY AUTOINCREMENT,
          front TEXT NOT NULL,
          back  TEXT
        );
      `);

      /** ----------------- 增 (Insert) ----------------- */
      await db.insert(cards).values({ front: 'Hello', back: '你好' });

      /** ----------------- 改 (Update) ----------------- */
      await db
        .update(cards)
        .set({ back: '您好！' })
        .where(eq(cards.id, 1));

      /** ----------------- 查单条 (Select one) ---------- */
      const single = await db
        .select()
        .from(cards)
        .where(eq(cards.id, 1))
        .get();                       // 只拿一条
      console.log('单条记录', single);

      /** ----------------- 查多条 (Select many) --------- */
      const rows = await db.select().from(cards);
      setList(rows);

      /** ----------------- 删 (Delete) ------------------ */
      // await db.delete(cards).where(eq(cards.id, 1));
    })();
  }, []);

  /* --------- UI 演示 --------- */
  if (!list) return <Text>Loading…</Text>;
  if (list.length === 0) return <Text>Empty</Text>;

  return (
    <View style={{ flex: 1, justifyContent: 'center', alignItems: 'center' }}>
      {list.map((c) => (
        <Text key={c.id}>{c.front} → {c.back}</Text>
      ))}
    </View>
  );
}

gpt给的示例

import * as SQLite from "expo-sqlite";
import { drizzle } from "drizzle-orm/expo-sqlite";

// 1. 打开 / 创建本地数据库
const sqlite = SQLite.openDatabaseSync("app.db");

// 2. 传给 Drizzle 得到 ORM 实例
export const db = drizzle(sqlite);

// 3. 定义 schema（最高效：单独放 schema.ts 并用 drizzle-kit 迁移）
import { int, text, sqliteTable } from "drizzle-orm/sqlite-core";

export const cards = sqliteTable("cards", {
  id: int("id").primaryKey({ autoIncrement: true }),
  front: text("front").notNull(),
  back: text("back"),
});

TypeORM

https://typeorm.io/docs/getting-started/
expo install expo-sqlite expo-sqlite 原生模块
npm install typeorm reflect-metadata --save TypeORM 主包 + 反射元数据
npm i expo-sqlite-storage expo-sqlite 封装

在第一个文件入口中导入例如App.ts
import "reflect-metadata"

初始化数据连接

import { createConnection } from 'typeorm/browser';
import { Card } from './entities/Card';

// expo-sqlite-storage 自动被 TypeORM 调用
import 'expo-sqlite';          // 仅确保模块存在，无需代码

// 初始化含糊，与逆行会自动创建表
export const initDB = async () => {
  return await createConnection({
    type: 'expo',
    database: 'app.db',
    driver: require('expo-sqlite'),   // 指向驱动
    synchronize: true,                // ★ 首次/修改实体时自动建表 & ALTER
    logging: false,
    entities: [Card],
  });
};

定义模型

import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';

@Entity('cards')
export class Card {
  @PrimaryGeneratedColumn()
  id!: number;

  @Column()
  front!: string;

  @Column({ nullable: true })
  back?: string;

  @Column({ default: 1 })              // 记忆等级
  lv!: number;
}

增删改查

const conn = await initDB();            // 自动建表
const repo = conn.getRepository(Card);

/** --------- 增 (Create) --------- */
await repo.save({ front: 'Hello', back: '你好' });

/** --------- 改 (Update) --------- */
await repo.update({ id: 1 }, { lv: 2 });

/** --------- 查单条 (Read one) ---- */
const one = await repo.findOne({ where: { id: 1 } });
console.log('单条', one);

/** --------- 查多条 (Read many) --- */
const all = await repo.find();          // 全表
setCards(all);

/** --------- 删 (Delete) ---------- */
await repo.delete({ id: 1 });