use std::{
    time,fs,
};
use rusqlite;
use dirs;
use crate::prelude::*;


pub static 全局_SQLITE数据库管理: OnceCell<数据库管理> = OnceCell::new(); 



#[gen_特征_derive(MOD特征_sqlite)]
impl 信令路由{
    async fn exec文本信令_sqlite(&self,函数名:&str, mut 参数数组:Vec<String>)-> anyhow_Result<(bool,Value,Vec<String>)>{
        let 信令路由ref = self;
        let 结果 = match 函数名{
            "sql_软件配置db总数"=>{   json!(信令路由ref.sql_软件配置db总数().await?)                 }
            "sql_软件配置db重置"=>{   json!(信令路由ref.sql_软件配置db重置().await?)                 }
            "sql_软件配置db打开"=>{
                if 参数数组.len() < 1 {   return Err(anyhow_err!("sql_软件配置db打开, 缺少参数::  <路径>"))  }
                json!(信令路由ref.sql_软件配置db打开(参数数组.remove(0)).await?)  
            }
            "sql_软件配置db保存"=>{
                if 参数数组.len() < 2 {   return Err(anyhow_err!("sql_软件配置db保存, 缺少参数:: <data对象>, <key>, <副key>"))  }
                let 副key = if 参数数组.len()>=3 && 参数数组[2] !="undefined"{  Some(参数数组.remove(2))  }else{ None };
                json!(信令路由ref.sql_软件配置db保存(参数数组.remove(0), 参数数组.remove(0), 副key ).await?)
            }
            "sql_软件配置db插入"=>{
                if 参数数组.len() < 2 {   return Err(anyhow_err!("sql_软件配置db插入, 缺少参数:: <data对象>, <key>, <副key>"))  }
                let 副key = if 参数数组.len()>=3 && 参数数组[2] !="undefined"{  Some(参数数组.remove(2))  }else{ None };
                json!(信令路由ref.sql_软件配置db插入(参数数组.remove(0), 参数数组.remove(0), 副key ).await?)
            }
            "sql_软件配置db查找单个"=>{
                if 参数数组.len() < 1 {   return Err(anyhow_err!("sql_软件配置db查找单个, 缺少参数:: <key>, <副key>"))  }
                let 副key = if 参数数组.len()>=2 && 参数数组[1] !="undefined"{  Some(参数数组.remove(1))  }else{ None };
                json!(信令路由ref.sql_软件配置db查找单个(参数数组.remove(0), 副key ).await?)
            }
            "sql_软件配置db查找"=>{
                if 参数数组.len() < 1 {   return Err(anyhow_err!("sql_软件配置db查找, 缺少参数:: <key>, <副key>"))  }
                let 副key = if 参数数组.len()>=2 && 参数数组[1] !="undefined"{  Some(参数数组.remove(1))  }else{ None };
                json!(信令路由ref.sql_软件配置db查找(参数数组.remove(0), 副key ).await?)
            }
            "sql_软件配置db删除"=>{
                if 参数数组.len() < 1 {   return Err(anyhow_err!("sql_软件配置db删除, 缺少参数:: <key>, <副key>"))  }
                let 副key = if 参数数组.len()>=2 && 参数数组[1] !="undefined"{  Some(参数数组.remove(1))  }else{ None };
                json!(信令路由ref.sql_软件配置db删除(参数数组.remove(0), 副key ).await?)
            }
            
            "sql_缩略图db总数"=>{   json!(信令路由ref.sql_缩略图db总数().await?)                 }
            "sql_缩略图db重置"=>{   json!(信令路由ref.sql_缩略图db重置().await?)                 }
            "sql_缩略图db打开"=>{
                if 参数数组.len() < 1 {   return Err(anyhow_err!("sql_缩略图db打开, 缺少参数::  <路径>"))  }
                json!(信令路由ref.sql_缩略图db打开(参数数组.remove(0)).await?)  
            }
            "sql_缩略图db保存"=>{
                if 参数数组.len() < 3 {   return Err(anyhow_err!("sql_缩略图db保存, 缺少参数:: <文件名>, <修改时间ms>, <图片dataurl>"))  }
                json!(信令路由ref.sql_缩略图db保存(参数数组.remove(0), 参数数组.remove(0),  参数数组.remove(0) ).await?)
            }
            "sql_缩略图db查找单个"=>{
                if 参数数组.len() < 2 {   return Err(anyhow_err!("sql_缩略图db查找单个, 缺少参数:: <文件名>, <修改时间ms>"))  }
                json!(信令路由ref.sql_缩略图db查找单个(参数数组.remove(0), 参数数组.remove(0) ).await?)
            }
            "sql_缩略图db删除"=>{
                if 参数数组.len() < 1 {   return Err(anyhow_err!("sql_缩略图db删除, 缺少参数:: <文件名>"))  }
                json!(信令路由ref.sql_缩略图db删除(参数数组.remove(0)).await?)
            }
    
            _=>{ return Ok((false, json!(""), 参数数组)); }
        };
        Ok((true, 结果, Vec::new()))
    }


    fn sql_软件配置db打开(&self,路径:impl AsRef<str>)-> impl 信令任务<原子ID>{
        core发布信令任务!(self, 信令表::sql_db打开 { 路径:路径.as_ref().to_string() , 数据库名:"软件配置db".to_string() },  信令表::sql_db打开_回复 => sql_id )
    }
    fn sql_软件配置db总数(&self)-> impl 信令任务<u64>{
        core发布信令任务!(self, 信令表::sql_db条目总数{ 数据库名:"软件配置db".to_string() },  信令表::sql_db条目总数_回复 => 总数 )
    }
    fn sql_软件配置db重置(&self)-> impl 信令任务<()>{
        core发布信令任务!(self, 信令表::sql_db重置数据库{ 数据库名:"软件配置db".to_string() },  信令表::sql_db重置数据库_回复 )
    }

    fn sql_软件配置db插入(&self,data字符串:impl AsRef<str>, key:impl AsRef<str>,副key:Option<String> )-> impl 信令任务<()>{
        core发布信令任务!(self, 信令表::sql_软件配置db保存_插入 { data字符串:data字符串.as_ref().to_string(), key:key.as_ref().to_string(), 副key , 插入:true },  信令表::sql_软件配置db保存_插入_回复 )
    }
    fn sql_软件配置db保存(&self,data字符串:impl AsRef<str>, key:impl AsRef<str>,副key:Option<String> )-> impl 信令任务<()>{
        core发布信令任务!(self, 信令表::sql_软件配置db保存_插入 { data字符串:data字符串.as_ref().to_string(), key:key.as_ref().to_string(), 副key , 插入:false },  信令表::sql_软件配置db保存_插入_回复 )
    }
    fn sql_软件配置db查找单个(&self,key:impl AsRef<str>, 副key:Option<String> )-> impl 信令任务<String>{
        信令表::sql_软件配置db查找或删除 { key:key.as_ref().to_string(), 副key, 查找单个:true ,删除:false }
            .task发布信令任务(self.clone(),
                |res|{
                    let mut 结果arr = match取出!(res? ,信令表::sql_软件配置db查找或删除_回复 => data数组)?;
                    if 结果arr.len() >=1 { Ok(结果arr.remove(0))  }else{ Err(anyhow_err!("sql_软件配置db查找单个 结果空 失败!!!")) }
            })
    }
    fn sql_软件配置db查找(&self,key:impl AsRef<str>,副key:Option<String> )-> impl 信令任务<Vec<String>>{
        core发布信令任务!(self, 信令表::sql_软件配置db查找或删除 { key:key.as_ref().to_string(), 副key, 查找单个:false ,删除:false },  信令表::sql_软件配置db查找或删除_回复 => data数组 )
    }
    fn sql_软件配置db删除(&self,key:impl AsRef<str>,副key:Option<String> )-> impl 信令任务<Vec<String>>{
        core发布信令任务!(self, 信令表::sql_软件配置db查找或删除 { key:key.as_ref().to_string(), 副key, 查找单个:false ,删除:true },  信令表::sql_软件配置db查找或删除_回复 => data数组 )
    }
    

    fn sql_缩略图db打开(&self,路径:impl AsRef<str>)-> impl 信令任务<原子ID>{
        core发布信令任务!(self, 信令表::sql_db打开 { 路径:路径.as_ref().to_string() , 数据库名:"缩略图db".to_string() },  信令表::sql_db打开_回复 => sql_id )
    }
    fn sql_缩略图db总数(&self)-> impl 信令任务<u64>{
        core发布信令任务!(self, 信令表::sql_db条目总数{ 数据库名:"缩略图db".to_string() },  信令表::sql_db条目总数_回复 => 总数 )
    }
    fn sql_缩略图db重置(&self)-> impl 信令任务<()>{
        core发布信令任务!(self, 信令表::sql_db重置数据库{ 数据库名:"缩略图db".to_string() },  信令表::sql_db重置数据库_回复 )
    }

    fn sql_缩略图db保存(&self,文件名:impl AsRef<str>, 修改时间ms:impl AsRef<str>, 图片dataurl:impl AsRef<str>)-> impl 信令任务<()>{
        core发布信令任务!(self, 信令表::sql_缩略图db保存_插入 { 文件名:文件名.as_ref().to_string(), 修改时间ms:Some(修改时间ms.as_ref().to_string()), 图片dataurl:图片dataurl.as_ref().to_string(),  插入:false },  信令表::sql_缩略图db保存_插入_回复 )
    }
    fn sql_缩略图db查找单个(&self,文件名:impl AsRef<str>, 修改时间ms:impl AsRef<str>)-> impl 信令任务<String>{
        信令表::sql_缩略图db查找或删除 { 文件名:文件名.as_ref().to_string(), 修改时间ms:Some(修改时间ms.as_ref().to_string()), 查找单个:true ,删除:false }
            .task发布信令任务(self.clone(),
                |res|{
                    let mut 结果arr = match取出!(res? ,信令表::sql_缩略图db查找或删除_回复 => 图片dataurl数组)?;
                    if 结果arr.len() >=1 { Ok(结果arr.remove(0))  }else{ Err(anyhow_err!("sql_缩略图db查找单个 结果空 失败!!!")) }
            })
    }
    fn sql_缩略图db删除(&self,文件名:impl AsRef<str> )-> impl 信令任务<Vec<String>>{
        core发布信令任务!(self, 信令表::sql_缩略图db查找或删除 { 文件名:文件名.as_ref().to_string(), 修改时间ms:None, 查找单个:false ,删除:true },  信令表::sql_缩略图db查找或删除_回复 => 图片dataurl数组  )
    }
    
}


#[derive(Clone, Serialize, Deserialize)]//可选特征
enum 信令表{
    sql_db打开{ 路径:String , 数据库名:String },
    sql_db打开_回复{   sql_id:原子ID   },
    sql_db条目总数{ 数据库名:String },
    sql_db条目总数_回复{ 总数:u64 },
    sql_db重置数据库{ 数据库名:String },
    sql_db重置数据库_回复,

    sql_软件配置db保存_插入{ data字符串:String, key:String, 副key:Option<String> ,  插入:bool },
    sql_软件配置db保存_插入_回复,
    sql_软件配置db查找或删除{ key:String,副key:Option<String>, 查找单个:bool ,删除:bool },
    sql_软件配置db查找或删除_回复{ data数组:Vec<String> },
    
    
    sql_缩略图db保存_插入{ 文件名:String, 修改时间ms:Option<String>, 图片dataurl:String ,  插入:bool },
    sql_缩略图db保存_插入_回复,
    sql_缩略图db查找或删除{ 文件名:String, 修改时间ms:Option<String>, 查找单个:bool ,删除:bool },
    sql_缩略图db查找或删除_回复{ 图片dataurl数组:Vec<String> },
 
}
impl信令特征!(信令表, 执行函数);



async fn 执行函数(信令路由:信令路由,id:信令ID,单个信令:信令表)->anyhow_Result<信令表>{
    let 数据库管理 = 全局_SQLITE数据库管理.get_or_init(||数据库管理::new(信令路由.clone()));
    
    match 单个信令{
        信令表::sql_db打开{ 路径 ,数据库名 }=>{
            let 结果 = 数据库管理.打开通用db(Some(路径), 数据库名) 
                                .map(|返回|{  信令表::sql_db打开_回复{ sql_id:返回  }  });
            anyhow_Ok信令!(结果?)
        }
        信令表::sql_db条目总数{ 数据库名 }=>{
            let 结果 = 数据库管理.通用db条目总数( 数据库名)
                                .map(|返回 |{  信令表::sql_db条目总数_回复 { 总数:返回 } });
            anyhow_Ok信令!(结果?)
        }
        信令表::sql_db重置数据库{ 数据库名 }=>{
            let 结果 = 数据库管理.通用db重置数据库( 数据库名) 
                                .map(|返回|{  信令表::sql_db重置数据库_回复 });
            anyhow_Ok信令!(结果?)
        }

        信令表::sql_软件配置db保存_插入{ data字符串, key, 副key ,  插入  }=>{
            let 结果 = 数据库管理.软件配置db保存_插入(data字符串, key, 副key, 插入) 
                                .map(|返回|{  信令表::sql_软件配置db保存_插入_回复 { }  });
            anyhow_Ok信令!(结果?)
        }
        信令表::sql_软件配置db查找或删除{ key, 副key, 查找单个, 删除  }=>{
            let 结果 = 数据库管理.软件配置db查找或删除(key, 副key, 查找单个, 删除) 
                                .map(|返回|{  信令表::sql_软件配置db查找或删除_回复 { data数组:返回 } });
            anyhow_Ok信令!(结果?)
        }
        
        
        信令表::sql_缩略图db保存_插入{ 文件名, 修改时间ms, 图片dataurl, 插入 }=>{
            let 结果 = 数据库管理.缩略图db保存_插入(文件名, 修改时间ms, 图片dataurl, 插入)
                        .map(|返回|{  信令表::sql_缩略图db保存_插入_回复  });
            anyhow_Ok信令!(结果?)
        }
        信令表::sql_缩略图db查找或删除{ 文件名, 修改时间ms, 查找单个, 删除  }=>{
            let 结果 = 数据库管理.缩略图db查找或删除(文件名, 修改时间ms, 查找单个, 删除) 
                                .map(|返回|{  信令表::sql_缩略图db查找或删除_回复 { 图片dataurl数组:返回 } });
            anyhow_Ok信令!(结果?)
        } 
        

        _ =>{ return Err(anyhow_err!("信令不存在")); }
    }
}




#[derive(Clone)]
pub struct  数据库管理{
    信令路由:信令路由,
    数据库conn表: Arc<DashMap<原子ID, Mutex<rusqlite::Connection>>>,
    唯一配置db_id:Arc<RwLock<原子ID>>,
    唯一缩略图db_id:Arc<RwLock<原子ID>>,
}

impl 数据库管理{
    pub fn new(信令路由:信令路由)->Self{
        Self {
            信令路由,
            数据库conn表: Default::default(),
            唯一配置db_id: Default::default(),
            唯一缩略图db_id: Default::default(),
        }
    }
    
    //默认目录 $HOME/lwleen-rust/软件配置.db
    pub fn 打开通用db(&self,路径: Option<String>, 数据库名:String)->anyhow_Result<原子ID>{
        let sql_id = 原子ID对象::next().0;
        let 可用路径 = if let Some(path) = 路径{ path }else{
            let config目录 = dirs::config_dir().ok_or(anyhow_err!("sqlite 无法获取 config目录"))?.display().to_string();
            let 路径 = format!("{config目录}/lwleen-sqlite3");
            fs::create_dir_all(&路径).ok();
            format!("{路径}/软件配置.db")
        };
        let conn = rusqlite::Connection::open(可用路径)?;
        
        if 数据库名 == "软件配置db" {
            conn.execute("CREATE TABLE IF NOT EXISTS 软件配置 (id INTEGER PRIMARY KEY AUTOINCREMENT, key TEXT, 副key TEXT, 数据 TEXT )", ())?;
            *self.唯一配置db_id.write() = sql_id; 
        }
        else if 数据库名 == "缩略图db" {
            conn.execute("CREATE TABLE IF NOT EXISTS  缩略图  (id INTEGER PRIMARY KEY AUTOINCREMENT, 文件名 TEXT, 修改时间ms INTEGER, 图片dataurl TEXT )", ())?;
            *self.唯一缩略图db_id.write() = sql_id; 
        }
        self.数据库conn表.insert(sql_id, Mutex::new(conn));
        Ok(sql_id)
    }
    pub fn 通用db条目总数(&self, 数据库名:String)->anyhow_Result<u64>{
        let sql_id;
        let 表单名称;
        if 数据库名 == "软件配置db"{ sql_id = *self.唯一配置db_id.read(); 表单名称 = "软件配置"; }
        else if 数据库名 == "缩略图db"{ sql_id = *self.唯一缩略图db_id.read(); 表单名称 = "缩略图";  }
        else{ return Err(anyhow_err!("通用db条目总数 错误  数据库名:{数据库名} 不存在!!!")); }
         
        let conn_mux = self.数据库conn表.get(&sql_id).ok_or(anyhow_err!("rust  {数据库名} 不存在!!!"))?;
        let conn = conn_mux.lock();
        let mut stmt = conn.prepare(&format!("SELECT COUNT(*) FROM {表单名称}"))?;
        let count: u64 = stmt.query_row([], |row| row.get(0) )?;   // 确定只返回一行的查询
        Ok(count)
    }
    pub fn 通用db重置数据库(&self, 数据库名:String)->anyhow_Result<()>{
        if 数据库名 == "软件配置db"{ 
            let sql_id = *self.唯一配置db_id.read(); let 表单名称 = "软件配置"; 
            let conn_mux = self.数据库conn表.get(&sql_id).ok_or(anyhow_err!("rust  {数据库名} 不存在!!!"))?;
            let conn = conn_mux.lock();
            conn.execute(&format!("DROP TABLE IF EXISTS {表单名称}"), ())?;
            conn.execute("CREATE TABLE IF NOT EXISTS 软件配置 (id INTEGER PRIMARY KEY AUTOINCREMENT, key TEXT, 副key TEXT, 数据 TEXT )", ())?;
        }
        else if 数据库名 == "缩略图db"{ 
            let sql_id = *self.唯一缩略图db_id.read(); let 表单名称 = "缩略图";
            let conn_mux = self.数据库conn表.get(&sql_id).ok_or(anyhow_err!("rust  {数据库名} 不存在!!!"))?;
            let conn = conn_mux.lock();
            conn.execute(&format!("DROP TABLE IF EXISTS {表单名称}"), ())?;
            conn.execute("CREATE TABLE IF NOT EXISTS  缩略图  (id INTEGER PRIMARY KEY AUTOINCREMENT, 文件名 TEXT, 修改时间ms INTEGER, 图片dataurl TEXT )", ())?;
        }
        else{ return Err(anyhow_err!("通用db条目总数 错误  数据库名:{数据库名} 不存在!!!")); }
        Ok(())
    }
    
    pub fn 软件配置db保存_插入(&self, data对象:String, key:String, 传入副key:Option<String>, 插入:bool)->anyhow_Result<()>{
        let sql_id = *self.唯一配置db_id.read();
        let conn_mux = self.数据库conn表.get(&sql_id).ok_or(anyhow_err!("rust  软件配置db 不存在!!!"))?;
        let conn = conn_mux.lock();
        //删除旧的 插入新的
        if let Some(副key) = 传入副key{
            if !插入{  conn.execute("DELETE FROM 软件配置 WHERE key = ?1 AND 副key = ?2", (key.clone(), 副key.clone())).ok();   }
            conn.execute("INSERT INTO 软件配置 (key, 副key, 数据) VALUES (?1, ?2, ?3)", (key, 副key, data对象))?;
        }else{
            if !插入{  conn.execute("DELETE FROM 软件配置 WHERE key = ?1", [key.clone()]).ok();   }
            conn.execute("INSERT INTO 软件配置 (key, 数据) VALUES (?1, ?2)", (key, data对象))?;
        }
        Ok(())
    }
    pub fn 软件配置db查找或删除(&self, key:String, 传入副key:Option<String>,查找单个:bool, 删除:bool)->anyhow_Result<Vec<String>>{
        let sql_id = *self.唯一配置db_id.read();
        let conn_mux = self.数据库conn表.get(&sql_id).ok_or(anyhow_err!("rust  软件配置db 不存在!!!"))?;
        let conn = conn_mux.lock();
        let mut 结果数组 = Vec::new();
        if let Some(副key) = 传入副key{
            if 删除{ conn.execute("DELETE FROM 软件配置 WHERE key = ?1 AND 副key = ?2", (key, 副key)).ok();  }
            else{
                let mut stmt = conn.prepare("SELECT 数据 FROM 软件配置 WHERE key = ?1 AND 副key = ?2")?;
                let mut rows = stmt.query_map((key, 副key), |row|{ row.get::<usize,String>(0)   })?;  // 处理多行结果
                while let Some(Ok(res)) = rows.next(){  结果数组.push(res); if 查找单个 {break;} }
            }
        }else{
            if 删除{ conn.execute("DELETE FROM 软件配置 WHERE key = ?1", [key]).ok();  }
            else{
                let mut stmt = conn.prepare("SELECT 数据 FROM 软件配置 WHERE key = ?1")?;
                let mut rows = stmt.query_map([key], |row|{ row.get::<usize,String>(0)   })?;  // 处理多行结果
                while let Some(Ok(res)) = rows.next(){  结果数组.push(res); if 查找单个 {break;} }
            }
        }
        Ok(结果数组)
    }
    
    pub fn 缩略图db保存_插入(&self, 文件名:String, 传入修改时间ms:Option<String>, 图片dataurl:String ,  插入:bool)->anyhow_Result<()>{
        let sql_id = *self.唯一缩略图db_id.read();
        let conn_mux = self.数据库conn表.get(&sql_id).ok_or(anyhow_err!("rust  缩略图db  不存在!!!"))?;
        let conn = conn_mux.lock();
        //删除旧的 插入新的
        if let Some(修改时间ms) = 传入修改时间ms.map(|time|time.parse::<i64>().unwrap_or_default()){
            if !插入{  conn.execute("DELETE FROM 缩略图 WHERE 文件名 = ?1 AND 修改时间ms <= ?2", (文件名.clone(), 修改时间ms)).ok();   }
            conn.execute("INSERT INTO 缩略图 (文件名, 修改时间ms, 图片dataurl ) VALUES (?1, ?2, ?3)", (文件名, 修改时间ms, 图片dataurl))?;
        }else{
            if !插入{  conn.execute("DELETE FROM 缩略图 WHERE 文件名 = ?1", [文件名.clone()]).ok();   }
            conn.execute("INSERT INTO 缩略图 (文件名, 图片dataurl) VALUES (?1, ?2)", (文件名, 图片dataurl))?;
        }
        Ok(())
    }
    pub fn 缩略图db查找或删除(&self,文件名:String, 传入修改时间ms:Option<String>, 查找单个:bool ,删除:bool)->anyhow_Result<Vec<String>>{
        let sql_id = *self.唯一缩略图db_id.read();
        let conn_mux = self.数据库conn表.get(&sql_id).ok_or(anyhow_err!("rust  缩略图db  不存在!!!"))?;
        let conn = conn_mux.lock();
        let mut 结果数组 = Vec::new();
        if let Some(修改时间ms) = 传入修改时间ms.map(|time|time.parse::<i64>().unwrap_or_default()){
            if 删除{ conn.execute("DELETE FROM 缩略图 WHERE 文件名 = ?1 AND 修改时间ms <= ?2", (文件名,修改时间ms)).ok();    }
            else {
                let mut stmt = conn.prepare("SELECT 图片dataurl FROM 缩略图 WHERE 文件名 = ?1 AND 修改时间ms = ?2")?;
                let mut rows = stmt.query_map((文件名,  修改时间ms), |row|{ row.get::<usize,String>(0)  })?; 
                while let Some(Ok(res)) = rows.next(){ 结果数组.push(res); if 查找单个 {break;} }
            }
        }else{
            if 删除{ conn.execute("DELETE FROM 缩略图 WHERE 文件名 = ?1", [文件名]).ok();    }
            else {
                let mut stmt = conn.prepare("SELECT 图片dataurl FROM 缩略图 WHERE 文件名 = ?1")?;
                let mut rows = stmt.query_map([文件名], |row|{ row.get::<usize,String>(0)  })?; 
                while let Some(Ok(res)) = rows.next(){ 结果数组.push(res); if 查找单个 {break;} }
            }
        }
        Ok(结果数组)
    }
   

}






#[cfg(all(test,feature = "mod_sqlite"))]
mod 测试 { 
    use crate::prelude::*;
    use super::*;
    #[cfg(all(test,feature = "mod_sqlite"))]
    #[test]
    fn 测试() {
        let 信令路由 =  信令路由::default();
        信令路由.clone().pool异步任务_block阻塞完成(async move{
            信令路由.sql_软件配置db保存("测试保持", "key_测试", None).await.unwrap();
            let 读取 = 信令路由.sql_软件配置db查找单个( "key_测试", None).await.unwrap();
            let 读取数组 = 信令路由.sql_软件配置db查找( "key_测试", None).await.unwrap();
            println!("sql_软件配置db查找 {读取:?} {读取数组:?}");
        }).ok();
    }
 
}