TypeScript中将SQLite数据反序列化为对象：异步处理与数据映射指南

export const GetAllObjs = (): Obj[] => {
  const query = db.prepare("SELECT * FROM ObjTable");
  const rows= query.all(); // 这里的query.all()不会直接返回数据，而是返回Statement对象
  // ... 后续代码会因为rows不包含实际数据而失败
};

import * as sqlite3 from 'sqlite3'; // 假设db是一个sqlite3.Database实例

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

// 假设db已经初始化
const db = new sqlite3.Database(':memory:'); 

// 示例：创建表
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 {
        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], (err) => {
      if (err) {
        reject(err);
      } else {
        resolve();
      }
    });
  });
};

  // ...
  let objs = [] as Obj[];
  for(const row in rows as Obj[]){ // 错误：for...in 迭代的是索引
    // This object only contains the index number...
    // ...
    // id: row.id, // 错误：row此时是索引，不是数据对象
  }

export const GetAllObjs = (): Promise<Obj[]> => {
    const query = db.prepare("SELECT * FROM ObjTable");

    return new Promise((resolve, reject) => {
        let objs: Obj[] = []; // 明确类型

        query.all((err, rows: any[]) => { // `rows` 参数在回调中可用
            if (err) {
                return reject(err); // 发生错误时拒绝Promise
            }

            // 使用 for...of 循环迭代数组中的每个数据行对象
            for (const row of rows) { 
                objs.push(
                    {
                        id: row.id, 
                        name: row.name, 
                        amount: row.amount, 
                    } as Obj // 类型断言确保结构匹配
                );
            }
            resolve(objs); // 成功时解析Promise
        });
    });
};

import * as sqlite3 from 'sqlite3';

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

// 初始化数据库实例 (这里使用内存数据库作为示例)
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 表
 * @returns {Promise<void>} 一个Promise，表示表创建操作的完成
 */
export const CreateObjTable = (): Promise<void> => {
  return new Promise((resolve, reject) => {
    const query = `
      CREATE TABLE IF NOT EXISTS ObjTable
      (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        name TEXT,
        amount INTEGER
      )
    `;
    db.run(query, (err) => {
      if (err) {
        console.error('Error creating table:', err.message);
        reject(err);
      } else {
        console.log('ObjTable created or already exists.');
        resolve();
      }
    });
  });
};

/**
 * 插入一个新对象到 ObjTable
 * @param {string} name 对象的名称
 * @param {number} amount 对象的数量
 * @returns {Promise<void>} 一个Promise，表示插入操作的完成
 */
export const InsertObj = (name: string, amount: number): Promise<void> => {
  return new Promise((resolve, reject) => {
    const query = `INSERT INTO ObjTable (name, amount) VALUES (?, ?)`;
    db.run(query, [name, amount], function(err) { // 注意这里使用function而不是箭头函数，以便访问this.lastID
      if (err) {
        console.error('Error inserting data:', err.message);
        reject(err);
      } else {
        console.log(`A row has been inserted with rowid ${this.lastID}`);
        resolve();
      }
    });
  });
};

/**
 * 从 ObjTable 获取所有对象并反序列化为 Obj 数组
 * @returns {Promise<Obj[]>} 一个Promise，解析为一个 Obj 数组
 */
export const GetAllObjs = (): Promise<Obj[]> => {
    return new Promise((resolve, reject) => {
        const query = db.prepare("SELECT id, name, amount FROM ObjTable");
        let objs: Obj[] = [];

        query.all((err, rows: any[]) => { // `rows` 是一个包含数据行的数组
            if (err) {
                console.error('Error fetching data:', err.message);
                // 确保在错误时调用 reject
                return reject(err); 
            }

            // 遍历每一行数据，并将其映射到 Obj 接口
            for (const row of rows) {
                objs.push({
                    id: row.id,
                    name: row.name,
                    amount: row.amount,
                } as Obj); // 使用类型断言明确类型
            }
            // 成功获取并映射数据后，解析 Promise
            resolve(objs);
        });
        query.finalize(); // 释放statement资源
    });
};

// 示例用法
(async () => {
  try {
    await CreateObjTable();
    await InsertObj('Item A', 100);
    await InsertObj('Item B', 250);
    await InsertObj('Item C', 75);

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

    // 验证数据类型
    allObjs.forEach(obj => {
      console.log(`ID: ${obj.id}, Name: ${obj.name}, Amount: ${obj.amount}`);
      // obj.id 是 number 类型，obj.name 是 string 类型，obj.amount 是 number 类型
      // 可以在这里进行类型安全的进一步操作
    });

  } catch (error) {
    console.error('An error occurred during the operation:', error);
  } finally {
    // 关闭数据库连接
    db.close((err) => {
      if (err) {
        console.error('Error closing database:', err.message);
      } else {
        console.log('Database connection closed.');
      }
    });
  }
})();