/*
|
* Copyright (C) 2019 Rockchip Electronics Co., Ltd.
|
* author: Zhihua Wang, hogan.wang@rock-chips.com
|
*
|
* This software is available to you under a choice of one of two
|
* licenses. You may choose to be licensed under the terms of the GNU
|
* General Public License (GPL), available from the file
|
* COPYING in the main directory of this source tree, or the
|
* OpenIB.org BSD license below:
|
*
|
* Redistribution and use in source and binary forms, with or
|
* without modification, are permitted provided that the following
|
* conditions are met:
|
*
|
* - Redistributions of source code must retain the above
|
* copyright notice, this list of conditions and the following
|
* disclaimer.
|
*
|
* - Redistributions in binary form must reproduce the above
|
* copyright notice, this list of conditions and the following
|
* disclaimer in the documentation and/or other materials
|
* provided with the distribution.
|
*
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
* SOFTWARE.
|
*/
|
#include <sqlite3.h>
|
#include <stdio.h>
|
#include <string.h>
|
#include <stdlib.h>
|
#include <unistd.h>
|
#include <pthread.h>
|
|
#include "database.h"
|
#include "face_common.h"
|
|
#define DATABASE_TABLE "face_data"
|
#define DATABASE_VERSION "version_0"
|
|
static sqlite3 *g_db = NULL;
|
static pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER;
|
|
void database_bak(void)
|
{
|
char cmd[256];
|
snprintf(cmd, sizeof(cmd), "cp %s %s", DATABASE_PATH, BAK_DATABASE_PATH);
|
system(cmd);
|
}
|
|
int database_init(void)
|
{
|
char *err;
|
char cmd[256];
|
|
if (sqlite3_open(DATABASE_PATH, &g_db) != SQLITE_OK) {
|
printf("%s open database %s failed!\n", __func__, DATABASE_PATH);
|
return -1;
|
}
|
snprintf(cmd, sizeof(cmd),
|
"CREATE TABLE IF NOT EXISTS %s (data blob, name varchar(%d), id INTEGER PRIMARY KEY, mask blob, %s INTEGER)",
|
DATABASE_TABLE, NAME_LEN, DATABASE_VERSION);
|
if (sqlite3_exec(g_db, cmd, 0, 0, &err) != SQLITE_OK) {
|
sqlite3_close(g_db);
|
g_db = NULL;
|
printf("%s create table %s failed!\n", __func__, DATABASE_TABLE);
|
return -1;
|
}
|
|
snprintf(cmd, sizeof(cmd), "SELECT %s FROM %s;", DATABASE_VERSION, DATABASE_TABLE);
|
if (sqlite3_exec(g_db, cmd, 0, 0, &err) != SQLITE_OK) {
|
sqlite3_close(g_db);
|
g_db = NULL;
|
unlink(DATABASE_PATH);
|
printf("%s table %s %s mismatch!\n", __func__, DATABASE_TABLE, DATABASE_VERSION);
|
return database_init();
|
}
|
|
database_bak();
|
|
return 0;
|
}
|
|
void database_exit(void)
|
{
|
sqlite3_close(g_db);
|
database_bak();
|
}
|
|
void database_reset(void)
|
{
|
pthread_mutex_lock(&g_mutex);
|
database_exit();
|
unlink(DATABASE_PATH);
|
database_init();
|
pthread_mutex_unlock(&g_mutex);
|
}
|
|
int database_insert(void *data, size_t size, const char *name, size_t n_size, int id, bool sync_flag, void *mask, size_t mask_size)
|
{
|
char cmd[256];
|
sqlite3_stmt *stat = NULL;
|
|
if (n_size > NAME_LEN) {
|
printf("%s n_size error\n", __func__);
|
return -1;
|
}
|
pthread_mutex_lock(&g_mutex);
|
snprintf(cmd, sizeof(cmd), "REPLACE INTO %s VALUES(?, '%s', %d, ?, 0);", DATABASE_TABLE, name, id);
|
if (sqlite3_prepare(g_db, cmd, -1, &stat, 0) != SQLITE_OK) {
|
pthread_mutex_unlock(&g_mutex);
|
return -1;
|
}
|
sqlite3_exec(g_db, "begin transaction", NULL, NULL, NULL);
|
sqlite3_bind_blob(stat, 1, data, size, NULL);
|
sqlite3_bind_blob(stat, 2, mask, mask_size, NULL);
|
sqlite3_step(stat);
|
sqlite3_finalize(stat);
|
sqlite3_exec(g_db, "commit transaction", NULL, NULL, NULL);
|
if (sync_flag) {
|
sync();
|
database_bak();
|
}
|
pthread_mutex_unlock(&g_mutex);
|
|
return 0;
|
}
|
|
int database_record_count(void)
|
{
|
int ret = 0;
|
char cmd[256];
|
sqlite3_stmt *stat = NULL;
|
|
pthread_mutex_lock(&g_mutex);
|
snprintf(cmd, sizeof(cmd), "SELECT COUNT(*) FROM %s;", DATABASE_TABLE);
|
if (sqlite3_prepare(g_db, cmd, -1, &stat, 0) != SQLITE_OK) {
|
pthread_mutex_unlock(&g_mutex);
|
return 0;
|
}
|
if (sqlite3_step(stat) == SQLITE_ROW)
|
ret = sqlite3_column_int(stat, 0);
|
sqlite3_finalize(stat);
|
pthread_mutex_unlock(&g_mutex);
|
|
return ret;
|
}
|
|
int database_get_data(void *dst, const int cnt, size_t d_size, size_t d_off,
|
size_t i_size, size_t i_off, int mask)
|
{
|
int ret = 0;
|
char cmd[256];
|
sqlite3_stmt *stat = NULL;
|
int index = 0;
|
const void *data;
|
size_t size;
|
int id;
|
const size_t sum_size = d_size + i_size;
|
|
pthread_mutex_lock(&g_mutex);
|
snprintf(cmd, sizeof(cmd), "SELECT * FROM %s;", DATABASE_TABLE);
|
if (sqlite3_prepare(g_db, cmd, -1, &stat, 0) != SQLITE_OK) {
|
pthread_mutex_unlock(&g_mutex);
|
return 0;
|
}
|
while (1) {
|
ret = sqlite3_step(stat);
|
if (ret != SQLITE_ROW)
|
break;
|
if (mask) {
|
data = sqlite3_column_blob(stat, 3);
|
size = sqlite3_column_bytes(stat, 3);
|
} else {
|
data = sqlite3_column_blob(stat, 0);
|
size = sqlite3_column_bytes(stat, 0);
|
}
|
if (size <= d_size)
|
memcpy((char*)dst + index * sum_size + d_off, data, size);
|
id = sqlite3_column_int(stat, 2);
|
memcpy((char*)dst + index * sum_size + i_off, &id, i_size);
|
|
if (++index >= cnt)
|
break;
|
}
|
sqlite3_finalize(stat);
|
pthread_mutex_unlock(&g_mutex);
|
|
return index;
|
}
|
|
bool database_is_name_exist(const char *name)
|
{
|
bool exist = false;
|
int ret = 0;
|
char cmd[256];
|
sqlite3_stmt *stat = NULL;
|
|
pthread_mutex_lock(&g_mutex);
|
snprintf(cmd, sizeof(cmd), "SELECT * FROM %s WHERE name = '%s' LIMIT 1;", DATABASE_TABLE, name);
|
if (sqlite3_prepare(g_db, cmd, -1, &stat, 0) != SQLITE_OK) {
|
pthread_mutex_unlock(&g_mutex);
|
return false;
|
}
|
ret = sqlite3_step(stat);
|
if (ret == SQLITE_ROW)
|
exist = true;
|
else
|
exist = false;
|
sqlite3_finalize(stat);
|
pthread_mutex_unlock(&g_mutex);
|
|
return exist;
|
}
|
|
bool database_is_id_exist(int id, char *name, size_t size)
|
{
|
bool exist = false;
|
int ret = 0;
|
char cmd[256];
|
sqlite3_stmt *stat = NULL;
|
|
memset(name, 0, size);
|
snprintf(cmd, sizeof(cmd), "SELECT * FROM %s WHERE id = %d LIMIT 1;", DATABASE_TABLE, id);
|
pthread_mutex_lock(&g_mutex);
|
if (sqlite3_prepare(g_db, cmd, -1, &stat, 0) != SQLITE_OK) {
|
pthread_mutex_unlock(&g_mutex);
|
return false;
|
}
|
ret = sqlite3_step(stat);
|
if (ret == SQLITE_ROW) {
|
const char *n = sqlite3_column_text(stat, 1);
|
size_t s = sqlite3_column_bytes(stat, 1);
|
if (s <= size)
|
strncpy(name, n, size - 1);
|
exist = true;
|
} else {
|
exist = false;
|
}
|
sqlite3_finalize(stat);
|
pthread_mutex_unlock(&g_mutex);
|
|
return exist;
|
}
|
|
int database_get_user_name_id(void)
|
{
|
int ret = 0;
|
char cmd[256];
|
sqlite3_stmt *stat = NULL;
|
int id = 0;
|
int max_id = -1;
|
int *save_id = NULL;
|
int ret_id = 0;
|
|
pthread_mutex_lock(&g_mutex);
|
snprintf(cmd, sizeof(cmd), "SELECT * FROM %s where id=(select max(id) from %s);",
|
DATABASE_TABLE, DATABASE_TABLE);
|
if (sqlite3_prepare(g_db, cmd, -1, &stat, 0) != SQLITE_OK) {
|
pthread_mutex_unlock(&g_mutex);
|
return -1;
|
}
|
while (1) {
|
ret = sqlite3_step(stat);
|
if (ret != SQLITE_ROW)
|
break;
|
max_id = sqlite3_column_int(stat, 2);
|
}
|
sqlite3_finalize(stat);
|
|
if (max_id < 0) {
|
pthread_mutex_unlock(&g_mutex);
|
return 0;
|
}
|
|
#if 0
|
save_id = calloc(max_id + 1, sizeof(int));
|
if (!save_id) {
|
printf("%s: memory alloc fail!\n", __func__);
|
pthread_mutex_unlock(&g_mutex);
|
return -1;
|
}
|
|
snprintf(cmd, sizeof(cmd), "SELECT * FROM %s;",
|
DATABASE_TABLE);
|
if (sqlite3_prepare(g_db, cmd, -1, &stat, 0) != SQLITE_OK) {
|
ret_id = -1;
|
goto exit;
|
}
|
while (1) {
|
ret = sqlite3_step(stat);
|
if (ret != SQLITE_ROW)
|
break;
|
id = sqlite3_column_int(stat, 2);
|
save_id[id] = 1;
|
}
|
sqlite3_finalize(stat);
|
|
for (int i = 0; i < max_id + 1; i++) {
|
if (!save_id[i]) {
|
ret_id = i;
|
goto exit;
|
}
|
}
|
#endif
|
ret_id = max_id + 1;
|
|
exit:
|
if (save_id)
|
free(save_id);
|
pthread_mutex_unlock(&g_mutex);
|
return ret_id;
|
}
|
|
void database_delete(int id, bool sync_flag)
|
{
|
char cmd[256];
|
|
pthread_mutex_lock(&g_mutex);
|
snprintf(cmd, sizeof(cmd), "DELETE FROM %s WHERE id = %d;", DATABASE_TABLE, id);
|
sqlite3_exec(g_db, "begin transaction", NULL, NULL, NULL);
|
sqlite3_exec(g_db, cmd, NULL, NULL, NULL);
|
sqlite3_exec(g_db, "commit transaction", NULL, NULL, NULL);
|
if (sync_flag)
|
sync();
|
database_bak();
|
pthread_mutex_unlock(&g_mutex);
|
}
|
