TypeScript中将SQLite查询结果反序列化为类型化对象的教程

interface Obj {
  id: number;
  name: string;
  amount: number;
}

import * as sqlite3 from 'sqlite3';

// 假设 db 是已初始化的 sqlite3 数据库实例
const db = new sqlite3.Database(':memory:'); // 示例：使用内存数据库

// 创建表（为完整示例提供）
export const CreateObjTable = (): Promise<void> => {
  return new Promise((resolve, reject) => {
    const query = db.prepare(`
      CREATE TABLE IF NOT EXISTS ObjTable
      (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        name TEXT,
        amount INTEGER
      )
    `);
    query.run((err) => {
      if (err) {
        reject(err);
      } else {
        resolve();
      }
    });
  });
};

// 获取所有 Obj 对象的函数
export const GetAllObjs = (): Promise<Obj[]> => {
  const query = db.prepare("SELECT * FROM ObjTable");

  return new Promise((resolve, reject) => {
    let objs: Obj[] = []; // 初始化一个空数组来存储类型化的对象

    // 调用 query.all()，并传入回调函数
    query.all((err, rows) => {
      if (err) {
        // 如果发生错误，拒绝 Promise
        return reject(err);
      }

      // 确保 rows 是一个数组，并正确迭代
      // rows 的类型通常是 any[]，我们需要将其断言为 Obj[] 或在内部手动映射
      for (const row of rows as any[]) { // 使用 for...of 迭代数组元素
        objs.push({
          id: row.id,
          name: row.name,
          amount: row.amount,
        } as Obj); // 将原始行数据映射到 Obj 类型
      }

      // 查询成功且数据映射完成，解决 Promise 并返回类型化数组
      resolve(objs);
    });
  });
};

import * as sqlite3 from 'sqlite3';

// 定义数据模型
interface Obj {
  id: number;
  name: string;
  amount: number;
}

// 假设 db 是已初始化的 sqlite3 数据库实例
// 实际应用中，你可能从外部配置或单例模式获取 db 实例
const db = new sqlite3.Database(':memory:', (err) => {
  if (err) {
    console.error('Error opening database', err.message);
  } else {
    console.log('Connected to the SQLite database.');
  }
});

// 创建 ObjTable 表
export const CreateObjTable = (): Promise<void> => {
  return new Promise((resolve, reject) => {
    db.run(`
      CREATE TABLE IF NOT EXISTS ObjTable
      (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        name TEXT,
        amount INTEGER
      )
    `, (err) => {
      if (err) {
        reject(err);
      } else {
        console.log('ObjTable created or already exists.');
        resolve();
      }
    });
  });
};

// 插入示例数据
export const InsertObj = (name: string, amount: number): Promise<void> => {
  return new Promise((resolve, reject) => {
    db.run(`INSERT INTO ObjTable (name, amount) VALUES (?, ?)`, [name, amount], function(err) {
      if (err) {
        reject(err);
      } else {
        console.log(`A row has been inserted with rowid ${this.lastID}`);
        resolve();
      }
    });
  });
};

// 获取所有 Obj 对象的函数
export const GetAllObjs = (): Promise<Obj[]> => {
  return new Promise((resolve, reject) => {
    const objs: Obj[] = []; // 初始化一个空数组来存储类型化的对象

    db.all("SELECT id, name, amount FROM ObjTable", (err, rows: any[]) => {
      if (err) {
        return reject(err); // 如果发生错误，拒绝 Promise
      }

      // 迭代查询结果，将原始行数据映射到 Obj 类型
      for (const row of rows) {
        objs.push({
          id: row.id,
          name: row.name,
          amount: row.amount,
        });
      }

      resolve(objs); // 查询成功且数据映射完成，解决 Promise
    });
  });
};

// 示例使用
async function main() {
  try {
    await CreateObjTable();
    await InsertObj('Item A', 100);
    await InsertObj('Item B', 250);
    await InsertObj('Item C', 75);

    const allObjs = await GetAllObjs();
    console.log('Retrieved Objects:', allObjs);

    // 验证类型安全
    allObjs.forEach(obj => {
      console.log(`ID: ${obj.id}, Name: ${obj.name}, Amount: ${obj.amount}`);
      // obj.nonExistentProperty = 'error'; // 这会在编译时报错，体现了类型安全
    });

  } catch (error) {
    console.error('An error occurred:', error);
  } finally {
    db.close((err) => {
      if (err) {
        console.error('Error closing database', err.message);
      } else {
        console.log('Database connection closed.');
      }
    });
  }
}

main();