Node.js 节点SQLite查询返回未定义的

我的问题很简单：我有3种方法：

• 导出函数F\u SetupDatabase（\u logger:any）：void

• 导出函数Q\u RunQuery（查询：字符串，db:“session”|“global”）：any

• 导出函数Q_RunQueryWithParams（查询：string，参数：string[]，db:“session”|“global”）：any

访问数据库文件（SQLite3）。 （调用顺序：

F\u SetupDatabase（…）

->

Q\u RunQuery（…）

）

F_SetupDatabase（…）

用于打开数据库文件

global Database.db

，并创建另一个内存数据库

会话。我的主要问题是，在我的应用程序的主功能中，来自
Q_RunQuery
的日志显示在
F_SetupDatabase
之前。查询也不起作用，总是返回未定义的
。所以我想这与异步/同步调用或类似的东西有关。
我试图完全避免异步调用/方法，因为我缺乏经验，总是挂断自己的电话。
SQL查询是正确的

数据库.ts的完整源代码

/**
*文件：database/database.ts
*描述：数据库管理器
*作者：奥利弗·卡格
*/
从“sqlite3”导入*作为sqlite；
从“粉笔”导入粉笔；
//可用于此文件之外的其他方法
导出var sessionDatabase:sqlite.Database；
导出var数据库：sqlite.database；
//信号记录器
var记录器：任何；
/**
*@description创建/连接数据库并在内存中设置会话数据库`
*@作者奥利弗·卡格
*@param{any}\u记录器信号记录器
*/
导出函数F_SetupDatabase（_logger:any）：void{
logger=_logger.scope（'Database'）；
//在内存中打开数据库
sessionDatabase=new sqlite.Database(
“：内存：”，
函数（err:any）：void{
如果（错误）{
logger.fatal（新错误（err））；
} 
logger.success（'在内存中打开会话数据库！'）；
}
);
//内存数据库中的设置
//注意：不需要自动递增，列：int主键将自动递增
// https://stackoverflow.com/questions/24600375/syntax-error-near-autoincrement-with-sqlite-database-creation
常量setupSessionDatabaseQuery:字符串=`
创建表会话(
sessionID int unique，
clientID varchar（25）不为空，
主键（sessionID）
);`
run（setupSessionDatabaseQuery，[]，函数（err:any）{
if（err）logger.fatal（新错误（err））；
logger.success（“内存会话数据库设置完成！”）
});
//打开数据库文件
database=new sqlite.database(
“./database/global database.db”，sqlite.OPEN\u READWRITE，
函数（err:any）：void{
如果（错误）{
logger.fatal（新错误（err））；
}
logger.success（'打开的数据库文件！'）；
}
);
}
/**
*@description不带参数运行查询
*@作者奥利弗·卡格
*@param{string}query SQL查询
*@param{“session”|“database”}db在哪个数据库上执行查询
*/
导出函数Q|u RunQuery（查询：字符串，db:“session”|“global”）：任意{
logger.info（“SQL查询：用于：“+chalk.bold（db））
如果（db==“全局”）{
database.serialize（函数（）{
database.all（查询，[]，函数（err:any，rows:any）{
如果（错误）{
logger.fatal（新错误（err））；
}
返回行；
});
});
}else if（db==“会话”）{
sessionDatabase.serialize（函数（）{
sessionDatabase.all（查询，[]，函数（err:any，rows:any）{
如果（错误）{
logger.fatal（新错误（err））；
}
返回行；
});
});
}
}
/**
*@description使用参数运行查询
*@作者奥利弗·卡格
*@param{string}query SQL查询
*@param{string[]}params SQL查询参数
*@param{“session”|“database”}db在哪个数据库上执行查询
*/
导出函数Q_RunQueryWithParams（查询：字符串，参数：字符串[]，db:“会话”|“全局”）：任意{
logger.info（“SQL查询：用于：“+chalk.bold（db））
如果（db==“全局”）{
const data=database.serialize（函数（）{
database.all（查询、参数、函数（err:any、rows:any）{
如果（错误）{
logger.fatal（新错误（err））；
}
返回行；
});
});
}else if（db==“会话”）{
返回sessionDatabase.serialize（函数（）{
sessionDatabase.all（查询、参数、函数（err:any、rows:any）{
如果（错误）{
logger.fatal（新错误（err））；
}
返回行；
});
});
}
} 

main.ts

导出函数F_Start（enableLogger？：布尔）：http.Server{
如果（启用记录器===真）{
logger.enable（）；
}else if（enableLogger==false）{
logger.disable（）；
}否则{
logger.enable（）；
}
console.clear（）；
F_SkynetLogo（）；
F_EnableMiddleware（skynetApi、记录器）；
F_设置路由（skynetApi、记录器）；
F_设置数据库（记录器）；
skynetServer=F_ServerListener（skynetApi，记录器）；
Q_RunQuery（`INSERT-INTO-sessions（clientID）值（“client-1-0-0”）`，“session”）；
//获取会话（clientID）
const session=Q_RunQuery（`SELECT*FROM sessions`，“session”）；
console.log（会话）；
返回skynetServer；
}

从控制台记录

[Database] › ℹ  info      SQL Query: <INSERT INTO sessions (clientID) VALUES ("client-1-0-0")> for: session
[Database] › ℹ  info      SQL Query: <SELECT * FROM sessions> for: session
undefined
[Server] › ▶  start     Instance available on: 127.0.0.1:3000
[Database] › ✔  success   Opened in-Memory Session Database!
[Database] › ✔  success   Opened Database File!
[Database] › ✔  success   Setup of in-Memory Session Database complete!

[数据库]›ℹ  信息SQL查询：用于：会话
[数据库]›ℹ  信息SQL查询：用于：会话
未定义
[服务器]›▶  开始实例的可用时间：127.0.0.1:3000
[数据库]›✔  成功打开内存会话数据库！
[数据库]›✔  成功打开数据
/**
 * @description Run Query without Params
 * @author Oliver Karger <kmaster@oliver-karger.de>
 * @param {string} query SQL Query 
 * @param {"session" | "database"} db On which Database to execute the Query 
 */
export function Q_RunQuery(query: string, db: "session" | "global", callback: CallableFunction): any {
    logger.info("SQL Query: <" + chalk.bold(query) + "> for: " + chalk.bold(db))
    if(db === "global") {
        database.serialize(function() {
             database.all(query, [], function(err: any, rows: any) {
                if(err){
                    callback(err);
                }
                callback(null, rows);
            });
        });
    } else if(db === "session"){
        sessionDatabase.serialize(function() {
            sessionDatabase.all(query, [], function(err: any, rows: any) {
                if(err){
                    callback(err);
                }
                callback(null, rows);
            });
        });
    }
}

Q_RunQuery(`SELECT * FROM sessions`, "session", (err, data) => {
    if (err) {
       console.error(err); 
       return;
    }

    console.log('Result, - ', data);
});

export function Q_RunQuery<T>(query: string, db: "session" | "global"): Promise<T> {
    logger.info("SQL Query: <" + chalk.bold(query) + "> for: " + chalk.bold(db))
    if(db === "global") {
        return new Promise((res, rej) => {
         database.serialize(function() {
             database.all(query, [], function(err: any, rows: any) {
                if(err){
                    rej(err);
                }
                res(rows);
            });
         });
        })
    } else if(db === "session"){
        // Some thing here...
    }
}